bool ENV_TMP_read_temp(float* temp){
if(index_data < 8){
return false;
}
int j;
int i;
char temporary[10];
memset(temporary , 0 , 10);
i = index_data -1;
while(buffer[i] != '\r' && i >= 7){
i--;
}
j = i - 1;
while(buffer[j] != '\r' && j > 0){
j--;
}
if(buffer[j] != '\r') {
memset(buffer , 0 , 20);
usart_read_job(&ENV_TMP_uart , &get_char_buffer);
}
strncpy(temporary , buffer + j + 1 , i-j-1);
*temp = atof(temporary);
memset(buffer , 0 , 20);
index_data = 0;
global_temp = *temp;
usart_read_job(&ENV_TMP_uart , &get_char_buffer);
return true;
}
bool COZIR_WV_100_read(float* CO2 , float* temp , float* humi){
if(index_data < 24){
return false;
}
int i = index_data -1;
while(buffer[i] != '\n' && buffer[i-1] != '\r' && i >= 23){
i--;
}
if(buffer[i-24] != 'H' || buffer[i-16] != 'T' || buffer[i-8] != 'Z' || buffer[i-1] != '\r' || buffer[i] != '\n'){
memset(buffer , 0 , 50);
index_data = 0;
usart_read_job(&COZIR_WV_100_uart , &get_char_buffer);
return false;
}
int zero = i -24;
char temporary[5];
strncpy(temporary , buffer + zero + 2 , 5);
*humi = atof(temporary);
*humi /= 10;
strncpy(temporary , buffer + zero + 10 , 5);
*temp = atof(temporary);
*temp -= 1000;
*temp /= 10;
strncpy(temporary , buffer + zero + 18 , 5);
*CO2 = atof(temporary);
memset(buffer , 0 , 50);
index_data = 0;
usart_read_job(&COZIR_WV_100_uart , &get_char_buffer);
return true;
}
bool PHPROBE_read_ph(float* ph){
if(index_data < 8){
return false;
}
float temp = ENV_TEMP_get_temp();
char calib[8];
sprintf( calib , "T,%4.2f\r" , temp);
usart_write_buffer_wait(&PHPROBE_uart , (unsigned char*) calib , 8);
int j;
int i;
char temporary[10];
memset(temporary , 0 , 10);
i = index_data -1;
while(buffer[i] != '\r' && i >= 7){
i--;
}
j = i - 1;
while(buffer[j] != '\r' && j > 0){
j--;
}
if(buffer[j] != '\r') {
memset(buffer , 0 , 20);
usart_read_job(&PHPROBE_uart , &get_char_buffer);
}
strncpy(temporary , buffer + j + 1 , i-j-1);
*ph = atof(temporary);
memset(buffer , 0 , 20);
index_data = 0;
usart_read_job(&PHPROBE_uart , &get_char_buffer);
return true;
}
void COZIR_WV_100_buffer_received(struct usart_module *const module){
buffer[index_data] = (char) get_char_buffer;
if(index_data < 49){
index_data++;
usart_read_job(&COZIR_WV_100_uart , &get_char_buffer);
}
}
/*---------------------------------------------------------------------------*/
static int
open(int32_t baudrate, uart_rx_char_callback char_cb, uart_rx_frame_callback frame_cb)
{
struct usart_config config_usart;
struct port_config pin_conf;
usart_get_config_defaults(&config_usart);
config_usart.baudrate = baudrate;
config_usart.mux_setting = RS485_SERCOM_MUX_SETTING;
config_usart.pinmux_pad0 = RS485_SERCOM_PINMUX_PAD0;
config_usart.pinmux_pad1 = RS485_SERCOM_PINMUX_PAD1;
config_usart.pinmux_pad2 = RS485_SERCOM_PINMUX_PAD2;
config_usart.pinmux_pad3 = RS485_SERCOM_PINMUX_PAD3;
while (usart_init(&usart_instance, RS485_MODULE, &config_usart) != STATUS_OK) {}
usart_enable(&usart_instance);
port_get_config_defaults(&pin_conf);
pin_conf.direction = PORT_PIN_DIR_OUTPUT;
port_pin_set_config(RS485_TXE, &pin_conf);
port_pin_set_output_level(RS485_TXE, false);
char_callback = char_cb;
usart_register_callback(&usart_instance,
usart_read_callback, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_RECEIVED);
usart_read_job(&usart_instance, &rx_char);
return 1;
}
otError otPlatUartEnable(void)
{
struct usart_config configUsart;
usart_get_config_defaults(&configUsart);
configUsart.baudrate = 115200;
configUsart.mux_setting = UART_SERCOM_MUX_SETTING;
configUsart.pinmux_pad0 = UART_SERCOM_PINMUX_PAD0;
configUsart.pinmux_pad1 = UART_SERCOM_PINMUX_PAD1;
configUsart.pinmux_pad2 = UART_SERCOM_PINMUX_PAD2;
configUsart.pinmux_pad3 = UART_SERCOM_PINMUX_PAD3;
while (usart_init(&sUsartInstance, UART_SERCOM_MODULE, &configUsart) != STATUS_OK)
;
usart_enable(&sUsartInstance);
sReceive.mHead = 0;
sReceive.mTail = 0;
usart_register_callback(&sUsartInstance, usartWriteCallback, USART_CALLBACK_BUFFER_TRANSMITTED);
usart_register_callback(&sUsartInstance, usartReadCallback, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&sUsartInstance, USART_CALLBACK_BUFFER_TRANSMITTED);
usart_enable_callback(&sUsartInstance, USART_CALLBACK_BUFFER_RECEIVED);
usart_read_job(&sUsartInstance, (uint16_t *)&sReceive.mBuffer[sReceive.mTail]);
return OT_ERROR_NONE;
}
void ENV_TMP_buffer_received(struct usart_module *const module){
buffer[index_data] = (char) get_char_buffer;
if(index_data < 19){
index_data++;
usart_read_job(&ENV_TMP_uart , &get_char_buffer);
}
}
static void usartReadCallback(struct usart_module *const usartModule)
{
if (sReceive.mHead != (sReceive.mTail + 1) % kReceiveBufferSize)
{
sReceive.mTail = (sReceive.mTail + 1) % kReceiveBufferSize;
}
usart_read_job(&sUsartInstance, (uint16_t *)&sReceive.mBuffer[sReceive.mTail]);
}
static void
usart_read_callback(struct usart_module *const usart_module)
{
ENERGEST_ON(ENERGEST_TYPE_IRQ);
if (char_callback) {
char_callback(rx_char & 0xff);
}
usart_read_job(&usart_instance, &rx_char);
ENERGEST_OFF(ENERGEST_TYPE_IRQ);
}
bool COZIR_WV_100_init(void){
struct usart_config usart_conf;
usart_get_config_defaults(&usart_conf);
usart_conf.mux_setting = USART_RX_3_TX_2_XCK_3;
usart_conf.pinmux_pad0 = PINMUX_UNUSED;
usart_conf.pinmux_pad1 = PINMUX_UNUSED;
usart_conf.pinmux_pad2 = PINMUX_PA18C_SERCOM1_PAD2;
usart_conf.pinmux_pad3 = PINMUX_PA19C_SERCOM1_PAD3;
usart_conf.baudrate = 9600;
while (usart_init(&COZIR_WV_100_uart, SERCOM1, &usart_conf) != STATUS_OK ) {
//add a timeout if blocked here
}
usart_register_callback(&COZIR_WV_100_uart, COZIR_WV_100_buffer_received , USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&COZIR_WV_100_uart, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable(&COZIR_WV_100_uart);
usart_read_job(&COZIR_WV_100_uart , &get_char_buffer);
//usart_write_buffer_wait(&COZIR_WV_100_uart ,"*\r\n" , 3);
return true;
}
bool PHPROBE_init(void){
struct usart_config usart_conf;
usart_get_config_defaults(&usart_conf);
usart_conf.mux_setting = USART_RX_3_TX_2_XCK_3;
usart_conf.pinmux_pad0 = PINMUX_UNUSED;
usart_conf.pinmux_pad1 = PINMUX_UNUSED;
usart_conf.pinmux_pad2 = PINMUX_PA10C_SERCOM0_PAD2;
usart_conf.pinmux_pad3 = PINMUX_PA11C_SERCOM0_PAD3;
usart_conf.baudrate = 9600;
while (usart_init(&PHPROBE_uart, SERCOM0, &usart_conf) != STATUS_OK ) {
//add a timeout if blocked here
}
usart_register_callback(&PHPROBE_uart, PHPROBE_buffer_received , USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&PHPROBE_uart, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable(&PHPROBE_uart);
usart_read_job(&PHPROBE_uart , &get_char_buffer);
return true;
}
uint8_t serial_read_byte(uint16_t* data)
{
return usart_read_job(&usart_instance, data);
}
/**
* \brief Main application function.
*
* Application entry point.
*
* \return program return value.
*/
int main(void)
{
tstrWifiInitParam param;
int8_t ret;
char topic[strlen(MAIN_CHAT_TOPIC) + MAIN_CHAT_USER_NAME_SIZE + 1];
/* Initialize the board. */
system_init();
/* Initialize the UART console. */
configure_console();
/* Output example information */
printf(STRING_HEADER);
/* Initialize the Timer. */
configure_timer();
/* Initialize the MQTT service. */
configure_mqtt();
/* Initialize the BSP. */
nm_bsp_init();
/* Setup user name first */
printf("Enter the user name (Max %d characters)\r\n", MAIN_CHAT_USER_NAME_SIZE);
scanf("%64s", mqtt_user);
printf("User : %s\r\n", mqtt_user);
sprintf(topic, "%s%s", MAIN_CHAT_TOPIC, mqtt_user);
/* Initialize Wi-Fi parameters structure. */
memset((uint8_t *)¶m, 0, sizeof(tstrWifiInitParam));
/* Initialize Wi-Fi driver with data and status callbacks. */
param.pfAppWifiCb = wifi_callback; /* Set Wi-Fi event callback. */
ret = m2m_wifi_init(¶m);
if (M2M_SUCCESS != ret) {
printf("main: m2m_wifi_init call error!(%d)\r\n", ret);
while (1) { /* Loop forever. */
}
}
/* Initialize socket interface. */
socketInit();
registerSocketCallback(socket_event_handler, socket_resolve_handler);
/* Connect to router. */
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID),
MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
while (1) {
/* Handle pending events from network controller. */
m2m_wifi_handle_events(NULL);
/* Try to read user input from USART. */
usart_read_job(&cdc_uart_module, &uart_ch_buffer);
/* Checks the timer timeout. */
sw_timer_task(&swt_module_inst);
/* Checks the USART buffer. */
check_usart_buffer(topic);
}
}
/**
* \brief Main application function.
*
* Application entry point.
* Initialize board and WINC1500 Wi-Fi module.
* Read input data from serial interface and sent it to the remote device.
*
* \return program return value.
*/
int main(void)
{
tstrWifiInitParam param;
int8_t ret;
/* Initialize the board. */
system_init();
/* Initialize the UART console. */
configure_console();
printf(STRING_HEADER);
/* Initialize the BSP. */
nm_bsp_init();
/* Initialize Wi-Fi parameters structure. */
memset((uint8_t *)¶m, 0, sizeof(tstrWifiInitParam));
/* Initialize Wi-Fi driver with data and status callbacks. */
param.pfAppWifiCb = wifi_cb;
ret = m2m_wifi_init(¶m);
if (M2M_SUCCESS != ret) {
printf("main: m2m_wifi_init call error!(%d)\r\n", ret);
while (1) {
}
}
/* Initialize socket interface. */
socketInit();
registerSocketCallback(socket_cb, NULL);
/* Connect to router. */
m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID),
MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL);
while (1) {
if (wifi_connected == M2M_WIFI_CONNECTED && tcp_server_socket < 0) {
struct sockaddr_in addr;
/* Create TCP server socket. */
if ((tcp_server_socket = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("Failed to create TCP server socket!\r\n");
continue;
}
/* Initialize socket address structure and bind service. */
addr.sin_family = AF_INET;
addr.sin_port = _htons(MAIN_WIFI_M2M_SERVER_PORT);
addr.sin_addr.s_addr = 0;
bind(tcp_server_socket, (struct sockaddr *)&addr, sizeof(struct sockaddr_in));
}
/* Handle pending events from network controller. */
m2m_wifi_handle_events(NULL);
/* Try to read user input from EDBG. */
usart_read_job(&cdc_uart_module, &uart_ch_buffer);
/* Handle user message from EDBG. */
handle_input_message();
}
return 0;
}
