veles_labs/iaq_sensor_wired
2
0
Fork 0
Code Issues 6 Pull Requests Projects Releases Wiki Activity

Added variable baudrates functionality. NOT TESTED.

Browse Source
This commit is contained in:
David Žaitlík 2021-10-02 18:02:09 +02:00
parent daaab07912
commit 36e2597539
3 changed files with 244 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
fw/Core/Inc/config.h
View File

@ -54,8 +54,10 @@ config_read(&config);
#define CONFIG_DEFAULT_LED_ALERT2_LIMIT 3000 #define CONFIG_DEFAULT_LED_ALERT2_LIMIT 3000
#define CONFIG_DEFAULT_LED_SMOOTH 0 #define CONFIG_DEFAULT_LED_SMOOTH 0
#define CONFIG_DEFAULT_SCD4x_T_OFFSET 0 #define CONFIG_DEFAULT_SCD4x_T_OFFSET 0
#define CONFIG_DEFAULT_BAUDRATE_INDEX 0
#define MODBUS_ADDR_LENGTH 2 #define CONFIG_MODBUS_ADDR_LENGTH 2
#define CONFIG_BAUDRATE_INDEX_LENGTH 2
#define CONFIG_LED_ON_LENGTH 2 #define CONFIG_LED_ON_LENGTH 2
#define CONFIG_LED_BRIGHTNESS_LENGTH 2 #define CONFIG_LED_BRIGHTNESS_LENGTH 2
#define CONFIG_LED_SMOOTH_LENGTH 2 #define CONFIG_LED_SMOOTH_LENGTH 2
@ -75,7 +77,8 @@ config_read(&config);
#define EEPROM_ADDR_END ((uint32_t)0x080801FF) #define EEPROM_ADDR_END ((uint32_t)0x080801FF)
#define CONFIG_EEPROM_ADDR_MODBUS_ADDR (EEPROM_ADDR_START) #define CONFIG_EEPROM_ADDR_MODBUS_ADDR (EEPROM_ADDR_START)
#define CONFIG_EEPROM_ADDR_LED_ON (CONFIG_EEPROM_ADDR_MODBUS_ADDR + MODBUS_ADDR_LENGTH) #define CONFIG_EEPROM_ADDR_BAUDRATE_INDEX (CONFIG_EEPROM_ADDR_MODBUS_ADDR + CONFIG_MODBUS_ADDR_LENGTH)
#define CONFIG_EEPROM_ADDR_LED_ON (CONFIG_EEPROM_ADDR_BAUDRATE_INDEX + CONFIG_BAUDRATE_INDEX_LENGTH)
#define CONFIG_EEPROM_ADDR_LED_BRIGHTNESS (CONFIG_EEPROM_ADDR_LED_ON + CONFIG_LED_ON_LENGTH) #define CONFIG_EEPROM_ADDR_LED_BRIGHTNESS (CONFIG_EEPROM_ADDR_LED_ON + CONFIG_LED_ON_LENGTH)
#define CONFIG_EEPROM_ADDR_LED_SMOOTH (CONFIG_EEPROM_ADDR_LED_BRIGHTNESS + CONFIG_LED_BRIGHTNESS_LENGTH) #define CONFIG_EEPROM_ADDR_LED_SMOOTH (CONFIG_EEPROM_ADDR_LED_BRIGHTNESS + CONFIG_LED_BRIGHTNESS_LENGTH)
#define CONFIG_EEPROM_ADDR_LED_ALERT1 (CONFIG_EEPROM_ADDR_LED_SMOOTH + CONFIG_LED_SMOOTH_LENGTH) #define CONFIG_EEPROM_ADDR_LED_ALERT1 (CONFIG_EEPROM_ADDR_LED_SMOOTH + CONFIG_LED_SMOOTH_LENGTH)
@ -118,8 +121,12 @@ typedef struct
/* MODBUS CONFIG */ /* MODBUS CONFIG */
uint16_t modbus_addr; uint16_t modbus_addr;
uint32_t baudrate_index;
} config_t; } config_t;
/* IMPORTANT: baudrates must be defined in main.c and the default value must be at index 0*/
/* const uint32_t baudrates [] = {19200, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, 76800, 115200}; */
int8_t config_read(config_t *config); int8_t config_read(config_t *config);
int8_t config_write(config_t *config); int8_t config_write(config_t *config);

39
fw/Core/Src/config.c
View File

@ -17,10 +17,14 @@ static int8_t eeprom_program_byte(uint32_t addr, uint8_t ee_data);
/* Function to write two bytes to the EEPROM */ /* Function to write two bytes to the EEPROM */
/* IMPORTANT: EEPROM must be unlocked first */ /* IMPORTANT: EEPROM must be unlocked first */
static int8_t eeprom_program_halfword(uint32_t addr, uint16_t ee_data); static int8_t eeprom_program_halfword(uint32_t addr, uint16_t ee_data);
/* Function to write four bytes to the EEPROM */
/* IMPORTANT: EEPROM must be unlocked first */
static int8_t eeprom_program_word(uint32_t addr, uint32_t ee_data);
int8_t config_read(config_t *config) int8_t config_read(config_t *config)
{ {
config->modbus_addr = *(uint16_t *) (CONFIG_EEPROM_ADDR_MODBUS_ADDR); config->modbus_addr = *(uint16_t *) (CONFIG_EEPROM_ADDR_MODBUS_ADDR);
config->baudrate_index = *(uint32_t *) (CONFIG_EEPROM_ADDR_BAUDRATE_INDEX);
config->led_on = *(uint16_t *) (CONFIG_EEPROM_ADDR_LED_ON); config->led_on = *(uint16_t *) (CONFIG_EEPROM_ADDR_LED_ON);
config->led_brightness = *(uint16_t *) (CONFIG_EEPROM_ADDR_LED_BRIGHTNESS); config->led_brightness = *(uint16_t *) (CONFIG_EEPROM_ADDR_LED_BRIGHTNESS);
config->led_smooth = *(uint16_t *) (CONFIG_EEPROM_ADDR_LED_SMOOTH); config->led_smooth = *(uint16_t *) (CONFIG_EEPROM_ADDR_LED_SMOOTH);
@ -28,10 +32,16 @@ int8_t config_read(config_t *config)
config->led_co2_alert_limit2 = *(uint16_t *) (CONFIG_EEPROM_ADDR_LED_ALERT2); config->led_co2_alert_limit2 = *(uint16_t *) (CONFIG_EEPROM_ADDR_LED_ALERT2);
config->scd4x_t_offset = *(int16_t *) (CONFIG_EEPROM_ADDR_SCD4x_T_OFFSET); config->scd4x_t_offset = *(int16_t *) (CONFIG_EEPROM_ADDR_SCD4x_T_OFFSET);
/* Check if the EEPROM is initialized - do not check LED ON, that is 1 or 0 */ /* Check if the EEPROM is initialized - do not check:
if ((config->modbus_addr == EEPROM_EMPTY_BYTE) || * LED ON
(config->led_co2_alert_limit1 == EEPROM_EMPTY_BYTE) || * LED SMOOTH
(config->led_co2_alert_limit2 == EEPROM_EMPTY_BYTE)) * SCD4x T OFFSET
* BAUDRATE INDEX
* those can be 0 */
if ((config->modbus_addr == EEPROM_EMPTY_BYTE) ||
(config->led_co2_alert_limit1 == EEPROM_EMPTY_BYTE) ||
(config->led_co2_alert_limit2 == EEPROM_EMPTY_BYTE) ||
(config->led_brightness == EEPROM_EMPTY_BYTE))
{ {
return CONFIG_ERROR; return CONFIG_ERROR;
} }
@ -53,6 +63,11 @@ int8_t config_write(config_t *config)
{ {
return EEPROM_WRITE_ERROR; return EEPROM_WRITE_ERROR;
} }
/* Write BAUDRATE */
if (eeprom_program_word(CONFIG_EEPROM_ADDR_BAUDRATE_INDEX, config->baudrate_index) != EEPROM_OK)
{
return EEPROM_WRITE_ERROR;
}
/* Write LED ON */ /* Write LED ON */
if (eeprom_program_byte(CONFIG_EEPROM_ADDR_LED_ON, config->led_on) != EEPROM_OK) if (eeprom_program_byte(CONFIG_EEPROM_ADDR_LED_ON, config->led_on) != EEPROM_OK)
@ -191,3 +206,19 @@ static int8_t eeprom_program_halfword(uint32_t addr, uint16_t ee_data)
return EEPROM_ADDR_ERROR; return EEPROM_ADDR_ERROR;
} }
} }
static int8_t eeprom_program_word(uint32_t addr, uint32_t ee_data)
{
if ((EEPROM_ADDR_START <= addr) && (addr <= EEPROM_ADDR_END - 4))
{
*(uint32_t *)(addr) = ee_data; /* write data to EEPROM */
if (*(uint32_t *)(addr) != ee_data)
{
return EEPROM_WRITE_ERROR;
}
return EEPROM_OK;
} else
{
return EEPROM_ADDR_ERROR;
}
}

356
fw/Core/Src/main.c
View File

@ -69,7 +69,8 @@ const uint16_t tim21_period = 1200-1; // 6s
* *
*/ */
/* Input registers memory map implementation */ /* Input registers memory map implementation */
enum { enum
{
REGISTER_NUM_CO2 = 30010, REGISTER_NUM_CO2 = 30010,
REGISTER_NUM_T_SHT4x = 30011, REGISTER_NUM_T_SHT4x = 30011,
REGISTER_NUM_RH_SHT4x = 30012, REGISTER_NUM_RH_SHT4x = 30012,
@ -79,7 +80,8 @@ enum {
REGISTER_NUM_T_SCD4x_SIGNED = 30016 REGISTER_NUM_T_SCD4x_SIGNED = 30016
} data_registers_numbers; } data_registers_numbers;
enum { enum
{
REGISTER_NUM_LED_ON = 40001, REGISTER_NUM_LED_ON = 40001,
REGISTER_NUM_LED_BRIGHTNESS = 40002, REGISTER_NUM_LED_BRIGHTNESS = 40002,
REGISTER_NUM_LED_SMOOTH = 40003, REGISTER_NUM_LED_SMOOTH = 40003,
@ -87,9 +89,11 @@ enum {
REGISTER_NUM_CO2_ALERT_LIMIT2 = 40005, REGISTER_NUM_CO2_ALERT_LIMIT2 = 40005,
REGISTER_NUM_SCD4x_T_OFFSET = 40006, REGISTER_NUM_SCD4x_T_OFFSET = 40006,
REGISTER_NUM_MODBUS_ADDR = 40007, REGISTER_NUM_MODBUS_ADDR = 40007,
REGISTER_NUM_BAUDRATE = 40008
} config_registers_numbers; } config_registers_numbers;
enum { enum
{
REGISTER_NUM_VENDOR_NAME = 30010, REGISTER_NUM_VENDOR_NAME = 30010,
REGISTER_NUM_PRODUCT_CODE = 30011, REGISTER_NUM_PRODUCT_CODE = 30011,
REGISTER_NUM_REVISION = 30012, REGISTER_NUM_REVISION = 30012,
@ -97,6 +101,9 @@ enum {
REGISTER_NUM_SERIAL_NUMBER = 30014 REGISTER_NUM_SERIAL_NUMBER = 30014
} identification_registers_numbers; } identification_registers_numbers;
/* Baudrates - STM32L0xx can do baudrates from 1200 to 115200 */
const uint32_t baudrates [] = {19200, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, 76800, 115200};
const uint8_t baudrates_length = 12;
/* Variables to store the measured data */ /* Variables to store the measured data */
int CO2, T_SCD4x, RH_SCD4x; int CO2, T_SCD4x, RH_SCD4x;
int T_SHT4x, RH_SHT4x; int T_SHT4x, RH_SHT4x;
@ -104,6 +111,8 @@ uint16_t sps30_measured_data[10];
/* Struct to store the sensor config */ /* Struct to store the sensor config */
config_t sensor_config; config_t sensor_config;
uint8_t baudrate_changed = 0;
/* USER CODE END PV */ /* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/ /* Private function prototypes -----------------------------------------------*/
@ -113,124 +122,13 @@ static void MX_I2C1_Init(void);
static void MX_LPUART1_UART_Init(void); static void MX_LPUART1_UART_Init(void);
static void MX_TIM21_Init(void); static void MX_TIM21_Init(void);
/* USER CODE BEGIN PFP */ /* USER CODE BEGIN PFP */
int8_t modbus_slave_callback(modbus_transaction_t *transaction);
int8_t modbus_transmit_function(uint8_t *buffer, int data_len);
void LPUART1_TX_Buffer(uint8_t* buffer_tx, uint8_t buffer_tx_len); void LPUART1_TX_Buffer(uint8_t* buffer_tx, uint8_t buffer_tx_len);
/* USER CODE END PFP */ /* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/ /* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */ /* USER CODE BEGIN 0 */
int8_t modbus_slave_callback(modbus_transaction_t *transaction)
{
uint16_t register_number = transaction->register_number;
switch (transaction->function_code)
{
case MODBUS_READ_INPUT_REGISTERS:
for (int i = 0; i < transaction->register_count; i++, register_number++)
{
switch (register_number)
{
case REGISTER_NUM_CO2:
transaction->input_registers[i] = (uint16_t)CO2;
break;
case REGISTER_NUM_T_SHT4x:
transaction->input_registers[i] = (uint16_t)T_SHT4x;
break;
case REGISTER_NUM_RH_SHT4x:
transaction->input_registers[i] = (uint16_t)RH_SHT4x;
break;
case REGISTER_NUM_T_SCD4x:
transaction->input_registers[i] = (uint16_t)T_SCD4x;
break;
case REGISTER_NUM_RH_SCD4x:
transaction->input_registers[i] = (uint16_t)RH_SCD4x;
break;
case REGISTER_NUM_T_SHT4x_SIGNED:
transaction->input_registers_signed[i] = (int16_t)T_SHT4x;
break;
case REGISTER_NUM_T_SCD4x_SIGNED:
transaction->input_registers_signed[i] = (int16_t)T_SCD4x;
break;
default:
return MODBUS_ERROR_FUNCTION_NOT_IMPLEMENTED;
}
}
return MODBUS_OK;
case MODBUS_READ_HOLDING_REGISTERS:
for (int i = 0; i < transaction->register_count; i++, register_number++)
{
switch (register_number)
{
case REGISTER_NUM_LED_ON:
transaction->holding_registers[i] = (uint16_t)(sensor_config.led_on);
break;
case REGISTER_NUM_CO2_ALERT_LIMIT1:
transaction->holding_registers[i] = (uint16_t)(sensor_config.led_co2_alert_limit1);
break;
case REGISTER_NUM_CO2_ALERT_LIMIT2:
transaction->holding_registers[i] = (uint16_t)(sensor_config.led_co2_alert_limit2);
break;
case REGISTER_NUM_MODBUS_ADDR:
transaction->holding_registers[i] = (uint16_t)(sensor_config.modbus_addr);
break;
default:
return MODBUS_ERROR_FUNCTION_NOT_IMPLEMENTED;
}
}
return MODBUS_OK;
case MODBUS_WRITE_SINGLE_REGISTER:
switch (register_number)
{
case REGISTER_NUM_LED_ON:
sensor_config.led_on = (uint8_t) transaction->holding_registers[0];
break;
case REGISTER_NUM_CO2_ALERT_LIMIT1:
sensor_config.led_co2_alert_limit1 = (uint16_t) transaction->holding_registers[0];
break;
case REGISTER_NUM_CO2_ALERT_LIMIT2:
sensor_config.led_co2_alert_limit2 = (uint16_t) transaction->holding_registers[0];
break;
case REGISTER_NUM_MODBUS_ADDR:
sensor_config.modbus_addr = (uint16_t) transaction->holding_registers[0];
break;
default:
return MODBUS_ERROR_FUNCTION_NOT_IMPLEMENTED;
}
return MODBUS_OK;
case MODBUS_WRITE_MULTIPLE_REGISTERS:
for (int i = 0; i < transaction->register_count; i++, register_number++)
{
switch (register_number)
{
case REGISTER_NUM_LED_ON:
sensor_config.led_on = (uint8_t) transaction->holding_registers[i];
break;
case REGISTER_NUM_CO2_ALERT_LIMIT1:
sensor_config.led_co2_alert_limit1 = (uint16_t) transaction->holding_registers[i];
break;
case REGISTER_NUM_CO2_ALERT_LIMIT2:
sensor_config.led_co2_alert_limit2 = (uint16_t) transaction->holding_registers[i];
break;
case REGISTER_NUM_MODBUS_ADDR:
sensor_config.modbus_addr = (uint16_t) transaction->holding_registers[i];
break;
default:
return MODBUS_ERROR_FUNCTION_NOT_IMPLEMENTED;
}
}
return MODBUS_OK;
default:
return MODBUS_ERROR_FUNCTION_NOT_IMPLEMENTED;
}
/* Catch-all error */
return MODBUS_ERROR_FUNCTION_NOT_IMPLEMENTED; /* nothing implemented yet! TODO */
}
int8_t modbus_transmit_function(uint8_t *buffer, int data_len)
{
/* TODO */
LPUART1_TX_Buffer(buffer, data_len);
return MODBUS_OK;
}
/* USER CODE END 0 */ /* USER CODE END 0 */
@ -261,7 +159,19 @@ int main(void)
SystemClock_Config(); SystemClock_Config();
/* USER CODE BEGIN SysInit */ /* USER CODE BEGIN SysInit */
/* Read config from EEPROM - if unsuccessful, set the default values*/
int8_t config_read_status = config_read(&sensor_config);
if (config_read_status != CONFIG_OK)
{
sensor_config.modbus_addr = MODBUS_DEFAULT_SLAVE_ADDRESS;
sensor_config.led_co2_alert_limit1 = CONFIG_DEFAULT_LED_ALERT1_LIMIT;
sensor_config.led_co2_alert_limit2 = CONFIG_DEFAULT_LED_ALERT2_LIMIT;
sensor_config.led_on = CONFIG_DEFAULT_LED_ON;
sensor_config.led_brightness = CONFIG_DEFAULT_LED_BRIGHTNESS;
sensor_config.led_smooth = CONFIG_DEFAULT_LED_SMOOTH;
sensor_config.scd4x_t_offset = CONFIG_DEFAULT_SCD4x_T_OFFSET;
sensor_config.baudrate_index = CONFIG_DEFAULT_BAUDRATE_INDEX;
}
/* USER CODE END SysInit */ /* USER CODE END SysInit */
/* Initialize all configured peripherals */ /* Initialize all configured peripherals */
@ -279,18 +189,6 @@ int main(void)
/* Enable I2C for sensors */ /* Enable I2C for sensors */
LL_I2C_Enable(I2C1); LL_I2C_Enable(I2C1);
/* Read config from EEPROM - if unsuccessful, set the default values*/
int8_t config_read_status = config_read(&sensor_config);
if (config_read_status != CONFIG_OK)
{
sensor_config.modbus_addr = MODBUS_DEFAULT_SLAVE_ADDRESS;
sensor_config.led_co2_alert_limit1 = CONFIG_DEFAULT_LED_ALERT1_LIMIT;
sensor_config.led_co2_alert_limit2 = CONFIG_DEFAULT_LED_ALERT2_LIMIT;
sensor_config.led_on = CONFIG_DEFAULT_LED_ON;
sensor_config.led_brightness = CONFIG_DEFAULT_LED_BRIGHTNESS;
sensor_config.led_smooth = CONFIG_DEFAULT_LED_SMOOTH;
sensor_config.scd4x_t_offset = CONFIG_DEFAULT_SCD4x_T_OFFSET;
}
/* Set the modbus address */ /* Set the modbus address */
modbus_slave_set_address(sensor_config.modbus_addr); modbus_slave_set_address(sensor_config.modbus_addr);
@ -361,6 +259,15 @@ int main(void)
lpuart1_rx_done = 0; lpuart1_rx_done = 0;
} }
if (baudrate_changed == 1)
{
/* TODO: TEST */
LL_LPUART_Disable(LPUART1);
MX_LPUART1_UART_Init();
LL_LPUART_Enable(LPUART1);
baudrate_changed = 0;
}
/* It is time for measurement */ /* It is time for measurement */
if (tim21_elapsed_period == 1) if (tim21_elapsed_period == 1)
{ {
@ -386,7 +293,7 @@ int main(void)
if (CO2 <= sensor_config.led_co2_alert_limit1) if (CO2 <= sensor_config.led_co2_alert_limit1)
{ {
/* CO2 is OK -> BLUE */ /* CO2 is OK -> GREEN */
LL_GPIO_SetOutputPin(LED_R_GPIO_Port, LED_R_Pin); LL_GPIO_SetOutputPin(LED_R_GPIO_Port, LED_R_Pin);
LL_GPIO_ResetOutputPin(LED_G_GPIO_Port, LED_G_Pin); LL_GPIO_ResetOutputPin(LED_G_GPIO_Port, LED_G_Pin);
LL_GPIO_SetOutputPin(LED_B_GPIO_Port, LED_B_Pin); LL_GPIO_SetOutputPin(LED_B_GPIO_Port, LED_B_Pin);
@ -410,31 +317,6 @@ int main(void)
/* Reset the TIM21 Elapsed Period Flag */ /* Reset the TIM21 Elapsed Period Flag */
tim21_elapsed_period = 0; tim21_elapsed_period = 0;
} }
/* TEST START */
//LL_LPUART_TransmitData9(LPUART1, 0x69);
//LL_mDelay(250);
/* TODO: DELETE TEST */
/* RS485 test */
/*LL_LPUART_SetDESignalPolarity(LPUART1, 1);
LL_LPUART_TransmitData8(LPUART1, uart_data_dummy);
uart_data_dummy++;*/
/* SHT41 measurement */
/*sht4x_measure(&T_SHT4x, &RH_SHT4x);
LL_mDelay(10);*/
/* SCD4x measurement */
/*scd4x_read_measurement(&CO2, &T_SCD4x, &RH_SCD4x);
LL_mDelay(10);*/
/* SPS30 measurement*/
/*sps30_read_measured_values(sps30_measured_data, 10);*/
/* SLEEP */
/*LL_mDelay(1000);*/
/* TEST END */ /* TEST END */
/* USER CODE END WHILE */ /* USER CODE END WHILE */
@ -608,7 +490,7 @@ static void MX_LPUART1_UART_Init(void)
/* USER CODE BEGIN LPUART1_Init 1 */ /* USER CODE BEGIN LPUART1_Init 1 */
/* USER CODE END LPUART1_Init 1 */ /* USER CODE END LPUART1_Init 1 */
LPUART_InitStruct.BaudRate = 19200; LPUART_InitStruct.BaudRate = baudrates[sensor_config.baudrate_index];
LPUART_InitStruct.DataWidth = LL_LPUART_DATAWIDTH_9B; LPUART_InitStruct.DataWidth = LL_LPUART_DATAWIDTH_9B;
LPUART_InitStruct.StopBits = LL_LPUART_STOPBITS_1; LPUART_InitStruct.StopBits = LL_LPUART_STOPBITS_1;
LPUART_InitStruct.Parity = LL_LPUART_PARITY_EVEN; LPUART_InitStruct.Parity = LL_LPUART_PARITY_EVEN;
@ -732,6 +614,168 @@ void LPUART1_TX_Buffer(uint8_t* buffer_tx, uint8_t buffer_tx_len)
__enable_irq(); __enable_irq();
} }
int8_t modbus_slave_callback(modbus_transaction_t *transaction)
{
uint16_t register_number = transaction->register_number;
switch (transaction->function_code)
{
case MODBUS_READ_INPUT_REGISTERS:
for (int i = 0; i < transaction->register_count; i++, register_number++)
{
switch (register_number)
{
case REGISTER_NUM_CO2:
transaction->input_registers[i] = (uint16_t)CO2;
break;
case REGISTER_NUM_T_SHT4x:
transaction->input_registers[i] = (uint16_t)T_SHT4x;
break;
case REGISTER_NUM_RH_SHT4x:
transaction->input_registers[i] = (uint16_t)RH_SHT4x;
break;
case REGISTER_NUM_T_SCD4x:
transaction->input_registers[i] = (uint16_t)T_SCD4x;
break;
case REGISTER_NUM_RH_SCD4x:
transaction->input_registers[i] = (uint16_t)RH_SCD4x;
break;
case REGISTER_NUM_T_SHT4x_SIGNED:
transaction->input_registers_signed[i] = (int16_t)T_SHT4x;
break;
case REGISTER_NUM_T_SCD4x_SIGNED:
transaction->input_registers_signed[i] = (int16_t)T_SCD4x;
break;
default:
return MODBUS_ERROR_FUNCTION_NOT_IMPLEMENTED;
}
}
return MODBUS_OK;
case MODBUS_READ_HOLDING_REGISTERS:
for (int i = 0; i < transaction->register_count; i++, register_number++)
{
switch (register_number)
{
case REGISTER_NUM_LED_ON:
transaction->holding_registers[i] = (uint16_t)(sensor_config.led_on);
break;
case REGISTER_NUM_LED_BRIGHTNESS:
transaction->holding_registers[i] = (uint16_t)(sensor_config.led_brightness);
break;
case REGISTER_NUM_LED_SMOOTH:
transaction->holding_registers[i] = (uint16_t)(sensor_config.led_smooth);
break;
case REGISTER_NUM_CO2_ALERT_LIMIT1:
transaction->holding_registers[i] = (uint16_t)(sensor_config.led_co2_alert_limit1);
break;
case REGISTER_NUM_CO2_ALERT_LIMIT2:
transaction->holding_registers[i] = (uint16_t)(sensor_config.led_co2_alert_limit2);
break;
case REGISTER_NUM_SCD4x_T_OFFSET:
transaction->holding_registers[i] = (uint16_t)(sensor_config.scd4x_t_offset);
break;
case REGISTER_NUM_MODBUS_ADDR:
transaction->holding_registers[i] = (uint16_t)(sensor_config.modbus_addr);
break;
case REGISTER_NUM_BAUDRATE:
transaction->holding_registers[i] = (uint16_t)(sensor_config.baudrate_index);
break;
default:
return MODBUS_ERROR_FUNCTION_NOT_IMPLEMENTED;
}
}
return MODBUS_OK;
case MODBUS_WRITE_SINGLE_REGISTER:
switch (register_number)
{
case REGISTER_NUM_LED_ON:
sensor_config.led_on = (uint8_t) transaction->holding_registers[0];
break;
case REGISTER_NUM_LED_BRIGHTNESS:
sensor_config.led_brightness = (uint16_t) transaction->holding_registers[0];
break;
case REGISTER_NUM_LED_SMOOTH:
sensor_config.led_smooth = (uint16_t) transaction->holding_registers[0];
break;
case REGISTER_NUM_CO2_ALERT_LIMIT1:
sensor_config.led_co2_alert_limit1 = (uint16_t) transaction->holding_registers[0];
break;
case REGISTER_NUM_CO2_ALERT_LIMIT2:
sensor_config.led_co2_alert_limit2 = (uint16_t) transaction->holding_registers[0];
break;
case REGISTER_NUM_SCD4x_T_OFFSET:
sensor_config.scd4x_t_offset = (int16_t) transaction->holding_registers[0];
break;
case REGISTER_NUM_MODBUS_ADDR:
sensor_config.modbus_addr = (uint16_t) transaction->holding_registers[0];
break;
case REGISTER_NUM_BAUDRATE:
if (transaction->holding_registers[0] < baudrates_length)
{
sensor_config.baudrate_index = (uint16_t) (transaction->holding_registers[0]);
baudrate_changed = 1;
}
break;
default:
return MODBUS_ERROR_FUNCTION_NOT_IMPLEMENTED;
}
/* TODO: Set modbus address on change */
/* TODO: Set UART baudrate on change */
config_write(&sensor_config);
return MODBUS_OK;
case MODBUS_WRITE_MULTIPLE_REGISTERS:
for (int i = 0; i < transaction->register_count; i++, register_number++)
{
switch (register_number)
{
case REGISTER_NUM_LED_ON:
sensor_config.led_on = (uint8_t) transaction->holding_registers[i];
break;
case REGISTER_NUM_LED_BRIGHTNESS:
sensor_config.led_brightness = (uint16_t) transaction->holding_registers[i];
break;
case REGISTER_NUM_LED_SMOOTH:
sensor_config.led_smooth = (uint16_t) transaction->holding_registers[i];
break;
case REGISTER_NUM_CO2_ALERT_LIMIT1:
sensor_config.led_co2_alert_limit1 = (uint16_t) transaction->holding_registers[i];
break;
case REGISTER_NUM_CO2_ALERT_LIMIT2:
sensor_config.led_co2_alert_limit2 = (uint16_t) transaction->holding_registers[i];
break;
case REGISTER_NUM_SCD4x_T_OFFSET:
sensor_config.scd4x_t_offset = (int16_t) transaction->holding_registers[i];
break;
case REGISTER_NUM_MODBUS_ADDR:
sensor_config.modbus_addr = (uint16_t) transaction->holding_registers[i];
break;
case REGISTER_NUM_BAUDRATE:
if (transaction->holding_registers[0] < baudrates_length)
{
sensor_config.baudrate_index = (uint16_t) (transaction->holding_registers[i]);
baudrate_changed = 1;
}
break;
default:
return MODBUS_ERROR_FUNCTION_NOT_IMPLEMENTED;
}
}
/* TODO: Set modbus address on change */
/* TODO: Set UART baudrate on change */
config_write(&sensor_config);
return MODBUS_OK;
default:
return MODBUS_ERROR_FUNCTION_NOT_IMPLEMENTED;
}
/* Catch-all error */
return MODBUS_ERROR_FUNCTION_NOT_IMPLEMENTED; /* nothing implemented yet! TODO */
}
int8_t modbus_transmit_function(uint8_t *buffer, int data_len)
{
/* TODO */
LPUART1_TX_Buffer(buffer, data_len);
return MODBUS_OK;
}
/* USER CODE END 4 */ /* USER CODE END 4 */
/** /**