Start onewire interface. But probably won't finish it

stm-firmware/Makefile

@@ -49,7 +49,7 @@ CFILES += rotary-encoder.c
 
 CFILES += stack-check.c
 
-CFILES += onewire-if.c onewire-temp-sensors.c
+CFILES += onewire-temp-sensors.c
 
 DEFINES += -DDEBUGBUILD
 

stm-firmware/include/reflow-controller/onewire-if.h

@@ -1,34 +0,0 @@
-/* Reflow Oven Controller
-*
-* Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
-*
-* This file is part of the Reflow Oven Controller Project.
-*
-* The reflow oven controller is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with the reflow oven controller project.
-* If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef __ONEWIRE_IF_H__
-#define __ONEWIRE_IF_H__
-
-#include <stm-periph/uart.h>
-
-int onewire_if_init_uart(struct stm_uart *uart, uint32_t brr_val, USART_TypeDef *onewire_uart, volatile uint32_t *rcc_reg, uint8_t rcc_bit_num);
-
-void onewire_if_disable(struct stm_uart *uart);
-
-int onewire_if_send_byte(struct stm_uart *uart);
-
-int onewire_if_receive_byte(struct stm_uart *uart);
-
-#endif /* __ONEWIRE_IF_H__ */

stm-firmware/include/reflow-controller/onewire-temp-sensors.h

@@ -32,6 +32,8 @@
 
 #define ONEWIRE_UART_DEV USART3
 
+enum onewire_temp_resolution {RES_8BIT, RES_12BIT};
+
 void onewire_temp_sensors_setup_hw();
 
 /**
@@ -40,8 +42,10 @@ void onewire_temp_sensors_setup_hw();
  * @param list_len
  * @return Negative: error, >= 0: amount of discovered sensors
  */
-int onewire_temp_sensors_discover(uint32_t *id_list, size_t list_len);
+int onewire_temp_sensors_discover(uint64_t *id_list, size_t list_len);
 
-float onewire_temp_sensor_read_temp(uint32_t id);
+int onewire_temp_sensor_config(uint64_t id, enum onewire_temp_resolution resolution);
+
+float onewire_temp_sensor_read_temp(uint64_t id);
 
 #endif /* __ONEWIRE_TEMP_SENSORS_H__ */

stm-firmware/include/reflow-controller/systick.h

@@ -63,5 +63,6 @@ void systick_setup(void);
  */
 void systick_wait_ms(uint32_t ms);
 
+uint64_t systick_get_global_tick();
 
 #endif /* __SYSTICK_H__ */

stm-firmware/include/stm-periph/dma-ring-buffer.h

@@ -96,6 +96,14 @@ int dma_ring_buffer_periph_to_mem_get_data(struct dma_ring_buffer_to_mem *buff,
  */
 void dma_ring_buffer_periph_to_mem_stop(struct dma_ring_buffer_to_mem *buff);
 
+/**
+ * @brief Get fill level of peripheral to memory DMA ring buffer
+ * @param buff Buffer
+ * @param fill_level fill level to write data to
+ * @return 0 if success
+ */
+int dma_ring_buffer_periph_to_mem_fill_level(struct dma_ring_buffer_to_mem *buff, size_t *fill_level);
+
 /**
  * @brief Initialize ring buffer to streaming data from meory to a peripheral
  * @param[in,out] dma_buffer DMA ring buffer structure
@@ -138,6 +146,14 @@ void dma_ring_buffer_mem_to_periph_int_callback(struct dma_ring_buffer_to_periph
  */
 void dma_ring_buffer_mem_to_periph_stop(struct dma_ring_buffer_to_periph *buff);
 
+/**
+ * @brief Get fill level of mem to periph DMA ring buffer
+ * @param buff Buffer
+ * @param fill_level fill level to write data to
+ * @return 0 if success
+ */
+int dma_ring_buffer_mem_to_periph_fill_level(struct dma_ring_buffer_to_periph *buff, size_t *fill_level);
+
 /** @} */
 
 #endif /* __DMA_RING_BUFFER_H__ */

stm-firmware/include/stm-periph/uart.h

@@ -70,5 +70,8 @@ int uart_check_rx_avail(struct stm_uart *uart);
 
 void uart_tx_dma_complete_int_callback(struct stm_uart *uart);
 
+size_t uart_dma_tx_queue_avail(struct stm_uart *uart);
+
+size_t uart_dma_rx_queue_avail(struct stm_uart *uart);
 
 #endif /* UART_UART_H_ */

stm-firmware/onewire-if.c

@@ -1,56 +0,0 @@
-/* Reflow Oven Controller
-*
-* Copyright (C) 2020  Mario Hüttel <mario.huettel@gmx.net>
-*
-* This file is part of the Reflow Oven Controller Project.
-*
-* The reflow oven controller is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* The Reflow Oven Control Firmware is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with the reflow oven controller project.
-* If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include <reflow-controller/onewire-if.h>
-
-int onewire_if_init_uart(struct stm_uart *uart, uint32_t brr_val, USART_TypeDef *onewire_uart, volatile uint32_t *rcc_reg, uint8_t rcc_bit_num)
-{
-	if (!uart)
-		return -1000;
-
-	uart->rx = 1;
-	uart->tx = 1;
-	uart->brr_val = brr_val;
-	uart->rcc_reg = rcc_reg;
-	uart->uart_dev = onewire_uart;
-	uart->rcc_bit_no = rcc_bit_num;
-	uart->dma_rx_buff = NULL;
-	uart->dma_tx_buff = NULL;
-
-	return uart_init(uart);
-}
-
-void onewire_if_disable(struct stm_uart *uart)
-{
-	if (!uart)
-		return;
-
-	uart_disable(uart);
-}
-
-int onewire_if_send_byte(struct stm_uart *uart)
-{
-
-}
-
-int onewire_if_receive_byte(struct stm_uart *uart)
-{
-
-}

stm-firmware/onewire-temp-sensors.c

@@ -20,13 +20,20 @@
 
 #include <stm32/stm32f4xx.h>
 #include <stm-periph/uart.h>
-#include <reflow-controller/onewire-if.h>
 #include <reflow-controller/onewire-temp-sensors.h>
 #include <stm-periph/clock-enable-manager.h>
 #include <stm-periph/stm32-gpio-macros.h>
 
 static struct stm_uart if_uart;
 
+#define ONEWIRE_IF_RESET_BRR_VAL 0x1117UL
+
+/* UART_DIV is 45.5625 => 115200 @ 84 MHz */
+#define ONEWIRE_IF_COMM_DIV_FRACTION 9U /* Equals 9/16 = 0.5625 */
+#define ONEWIRE_IF_COMM_DIV_MANTISSA 45U /* Equals 45 */
+
+#define ONEWIRE_IF_COMM_BRR_VAL ((ONEWIRE_IF_COMM_DIV_MANTISSA<<4) | ONEWIRE_IF_COMM_DIV_FRACTION)
+
 void onewire_temp_sensors_setup_hw()
 {
 	rcc_manager_enable_clock(&RCC->AHB1ENR, BITMASK_TO_BITNO(ONEWIRE_TEMP_RCC_MASK));
@@ -37,6 +44,91 @@ void onewire_temp_sensors_setup_hw()
 	SETAF(ONEWIRE_TEMP_PORT, ONEWIRE_TEMP_RX_PIN, ONEWIRE_TEMP_AF_NUM);
 	SETAF(ONEWIRE_TEMP_PORT, ONEWIRE_TEMP_TX_PIN, ONEWIRE_TEMP_AF_NUM);
 
-	(void)onewire_if_init_uart(&if_uart, 1, ONEWIRE_UART_DEV, &RCC->APB1ENR, BITMASK_TO_BITNO(RCC_APB1ENR_USART3EN));
+	if_uart.rx = 1;
+	if_uart.tx = 1;
+	if_uart.brr_val = ONEWIRE_IF_RESET_BRR_VAL;
+	if_uart.rcc_reg = &RCC->AHB1ENR;
+	if_uart.rcc_bit_no = BITMASK_TO_BITNO(ONEWIRE_TEMP_RCC_MASK);
+	if_uart.uart_dev = ONEWIRE_UART_DEV;
+	if_uart.dma_rx_buff = NULL;
+	if_uart.dma_tx_buff = NULL;
+	if_uart.base_dma_num = 1;
+	if_uart.dma_rx_stream = NULL;
+	if_uart.dma_tx_stream = NULL;
+	if_uart.rx_buff_count = 0ULL;
+	if_uart.tx_buff_count = 0ULL;
+
+	(void)uart_init(&if_uart);
 }
 
+static void onewire_send_bit(uint8_t bit)
+{
+	uart_send_char(&if_uart, (bit ? 0xFF : 0x00));
+	(void)uart_get_char(&if_uart);
+}
+
+static uint8_t onewire_receive_bit()
+{
+	unsigned char recv;
+
+	uart_send_char(&if_uart, 0xFF);
+	recv = (unsigned char)uart_get_char(&if_uart);
+
+	if (recv <= 0xFE)
+		return 0;
+	else
+		return 1;
+}
+
+static void onewire_send_byte(uint8_t byte)
+{
+	int i;
+
+	for (i = 7; i >= 0; i--) {
+		onewire_send_bit(byte & 0x80);
+		byte <<= 1;
+	}
+}
+
+static uint8_t onewire_receive_byte()
+{
+	uint8_t byte = 0;
+	int i;
+
+	for (i = 0; i < 8; i++) {
+		byte <<= 1;
+		byte |= (onewire_receive_bit() ? 0x01 : 0x0);
+	}
+
+	return byte;
+}
+
+static int onewire_temp_init_presence()
+{
+	unsigned char recv;
+
+	uart_change_brr(&if_uart, ONEWIRE_IF_RESET_BRR_VAL);
+	uart_send_char(&if_uart, 0xF0);
+	recv = (unsigned char)uart_get_char(&if_uart);
+	uart_change_brr(&if_uart, ONEWIRE_IF_COMM_BRR_VAL);
+
+	if (recv >= 0x10 && recv <= 0x90)
+		return 1;
+	else
+		return 0;
+}
+
+int onewire_temp_sensors_discover(uint64_t *id_list, size_t list_len)
+{
+
+}
+
+int onewire_temp_sensor_config(uint64_t id, enum onewire_temp_resolution resolution)
+{
+
+}
+
+float onewire_temp_sensor_read_temp(uint64_t id)
+{
+
+}

stm-firmware/stm-periph/dma-ring-buffer.c

@@ -33,6 +33,19 @@
 #include <stdbool.h>
 #include <string.h>
 
+static size_t calculate_ring_buffer_fill_level(size_t buffer_size, size_t get_idx, size_t put_idx)
+{
+	size_t fill_level;
+
+	if (put_idx >= get_idx) {
+		fill_level = (put_idx - get_idx);
+	} else {
+		fill_level = buffer_size - get_idx + put_idx;
+	}
+
+	return fill_level;
+}
+
 static int dma_ring_buffer_switch_clock_enable(uint8_t base_dma, bool clk_en)
 {
 	int ret_val;
@@ -141,6 +154,19 @@ void dma_ring_buffer_periph_to_mem_stop(struct dma_ring_buffer_to_mem *buff)
 	memset(buff, 0, sizeof(struct dma_ring_buffer_to_mem));
 }
 
+int dma_ring_buffer_periph_to_mem_fill_level(struct dma_ring_buffer_to_mem *buff, size_t *fill_level)
+{
+	size_t put_idx;
+
+	if (!buff || !fill_level)
+		return -1000;
+
+	put_idx = buff->buffer_count - buff->dma->NDTR;
+	*fill_level = calculate_ring_buffer_fill_level(buff->buffer_count, buff->get_idx, put_idx);
+
+	return 0;
+}
+
 int dma_ring_buffer_mem_to_periph_initialize(struct dma_ring_buffer_to_periph *dma_buffer, uint8_t base_dma_id, DMA_Stream_TypeDef *dma_stream, size_t buffer_element_count, size_t element_size, volatile void *data_buffer, uint8_t dma_trigger_channel, void *dest_reg)
 {
 	if (!dma_buffer || !dma_stream || !data_buffer || !dest_reg)
@@ -163,19 +189,6 @@ int dma_ring_buffer_mem_to_periph_initialize(struct dma_ring_buffer_to_periph *d
 	return 0;
 }
 
-static size_t calculate_ring_buffer_fill_level(size_t buffer_size, size_t get_idx, size_t put_idx)
-{
-	size_t fill_level;
-
-	if (put_idx >= get_idx) {
-		fill_level = (put_idx - get_idx);
-	} else {
-		fill_level = buffer_size - get_idx + put_idx;
-	}
-
-	return fill_level;
-}
-
 static void queue_or_start_dma_transfer(struct dma_ring_buffer_to_periph *buff)
 {
 	uint32_t dma_transfer_cnt;
@@ -289,4 +302,14 @@ void dma_ring_buffer_mem_to_periph_stop(struct dma_ring_buffer_to_periph *buff)
 	memset(buff, 0, sizeof(struct dma_ring_buffer_to_periph));
 }
 
+int dma_ring_buffer_mem_to_periph_fill_level(struct dma_ring_buffer_to_periph *buff, size_t *fill_level)
+{
+	if (!buff || !fill_level)
+		return -1000;
+
+	*fill_level = calculate_ring_buffer_fill_level(buff->buffer_count, buff->dma_get_idx_current, buff->sw_put_idx);
+
+	return 0;
+}
+
 /** @} */

stm-firmware/stm-periph/uart.c

@@ -162,6 +162,16 @@ int uart_receive_data_with_dma(struct stm_uart *uart, const char **data, size_t
 	return dma_ring_buffer_periph_to_mem_get_data(&uart->rx_ring_buff, (const volatile void **)data, len);
 }
 
+char uart_get_char(struct stm_uart *uart)
+{
+	if (!uart)
+		return 0;
+	/* Wait for data to be available */
+	while (!(uart->uart_dev->SR & USART_SR_RXNE));
+
+	return (char)uart->uart_dev->DR;
+}
+
 int uart_check_rx_avail(struct stm_uart *uart)
 {
 	if (!uart)
@@ -181,3 +191,26 @@ void uart_tx_dma_complete_int_callback(struct stm_uart *uart)
 	dma_ring_buffer_mem_to_periph_int_callback(&uart->tx_ring_buff);
 }
 
+size_t uart_dma_tx_queue_avail(struct stm_uart *uart)
+{
+	size_t fill_level = 0UL;
+
+	if (!uart)
+		return 0UL;
+
+	(void)dma_ring_buffer_mem_to_periph_fill_level(&uart->tx_ring_buff, &fill_level);
+
+	return fill_level;
+}
+
+size_t uart_dma_rx_queue_avail(struct stm_uart *uart)
+{
+	size_t fill_level = 0UL;
+
+	if (!uart)
+		return 0UL;
+
+	(void)dma_ring_buffer_periph_to_mem_fill_level(&uart->rx_ring_buff, &fill_level);
+
+	return fill_level;
+}

stm-firmware/systick.c

@@ -41,6 +41,11 @@ void systick_wait_ms(uint32_t ms)
 	while (wait_tick_ms < ms);
 }
 
+uint64_t systick_get_global_tick()
+{
+	return global_tick_ms;
+}
+
 /**
  * @brief Interrupt Handler for SysTick
  *