Diff: main.cpp

Revision:

0:7f12b35d7969

Child:

1:8a60d7a33fa5

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Sat Mar 28 21:23:50 2020 +0000
@@ -0,0 +1,359 @@
+//#include "stm32f4xx_hal.h"
+//#include "stm32f4xx.h"
+//#include "hal_tick.h"
+#include "mbed.h"
+//#include "stdio.h"
+//#include <sstream>
+//#include <iostream>  
+#include <string> 
+#include "DS18B20.h"
+#include "OneWireDefs.h"
+
+#define DEVICE_LPTICKER 1
+#define MBED_TICKLESS 1
+
+//#define MBED_CONF_TARGET_TICKLESS_FROM_US_TICKER 0
+/* Select the clock sources (other than HSI) to start with (0=OFF, 1=ON) */
+//#define USE_PLL_HSE_EXTC (1) /* Use external clock */
+//#define USE_PLL_HSE_XTAL (1) /* Use external xtal */
+//#define DEBUG_MCO        (0) // Output the MCO1/MCO2 on PA8/PC9 for debugging (0=OFF, 1=ON)
+
+
+#ifndef DEBUG_CONSOLE
+    #define DEBUG_CONSOLE 1
+#endif
+
+#define MBED_CONF_TARGET_TICKLESS_FROM_US_TICKER 0
+ 
+#define V_BATT_REFF 8.20                                                // max napatie baterii
+const double voltage_divider_ref = V_BATT_REFF * (1.00/(1.00+1.60));    // max uroven napatia na delici
+const char *delimiter=":";                                              // delimiter na prijatie spravy
+// #define MEASURE_PERIOD 30.00
+volatile int measurePeriod = 60;                                  // in seconds
+volatile uint32_t timeCounter = 0;
+
+
+#define USB_TX       PA_9
+#define USB_RX       PA_10
+
+#define LORA_TX     PA_11
+#define LORA_RX     PA_12
+
+#define THERM_PIN   PB_8
+#define LED_PIN     PB_0
+
+#define BUF_SIZE    256
+
+#define FOTO_PIN        PA_1
+#define BATTERY_PIN     PA_3
+
+AnalogIn foto(FOTO_PIN);
+AnalogIn battery(BATTERY_PIN);
+DigitalOut led(LED_PIN);
+Ticker measureTicker;
+
+Serial lora(LORA_TX, LORA_RX,115200);
+#if DEBUG_CONSOLE
+    Serial usb(USB_TX, USB_RX,115200);
+#endif
+
+DS18B20 thermometer(true, true, false,THERM_PIN);
+char buffer[64];
+char hexBuffer[128];
+char rxBuffer[BUF_SIZE];
+char rxMessage[BUF_SIZE];
+char message[BUF_SIZE];
+volatile int8_t rxPtr = 0;
+volatile bool measure = true;
+volatile bool rxDone = false;
+
+volatile bool receiveOK=false;
+volatile bool receiveACK=false;
+volatile bool receiveJOIN=false;
+volatile bool receiveERR=false;
+volatile uint8_t numOfERR = 0;
+volatile float batteryValue = 0.00;
+volatile uint16_t fotoValue = 0;
+/*
+int main() {
+
+    while(1) {
+        while(usb.readable()) {
+            lora.putc(usb.getc());
+        }
+        while(lora.readable()) {
+            usb.putc(lora.getc());
+        }
+    }
+}
+*/
+
+void clearRxBuffer()
+{
+    memset(rxBuffer, '\0', sizeof(rxBuffer));
+    rxPtr = 0;
+};
+
+void resetModule()
+{
+    numOfERR = 0;
+    lora.printf("at+set_config=device:sleep:0\r\n");
+    wait(0.2);
+    receiveJOIN = false;
+    lora.printf("at+set_config=device:restart\r\n");
+#if DEBUG_CONSOLE
+    usb.printf("Joining to network... \r\n");
+#endif
+    
+    Timer timer;
+    timer.reset();
+    timer.start();
+    while(1)
+    {       
+        if(receiveJOIN)
+        {
+#if DEBUG_CONSOLE
+            usb.printf("Join OK \r\n");
+#endif
+            timer.stop();
+            receiveJOIN=false;
+            break;
+        }
+        if(timer.read_ms() > 30000)
+        {
+            timer.stop();
+            timer.reset();
+            timer.start();
+            lora.printf("at+join\r\n");
+#if DEBUG_CONSOLE
+            usb.printf("Joining...\r\n");
+#endif  
+        }
+    }
+    timer.stop();
+}
+
+
+void rxLoraInterrupt()
+{
+    while (lora.readable()) 
+    {
+        char c = lora.getc();
+//        usb.putc(c);
+        if(rxPtr >= sizeof(rxBuffer) - 1)
+            clearRxBuffer();
+        rxBuffer[rxPtr++] = c;
+    
+        if(c =='\n') 
+        {
+            rxDone = true;
+         
+            if( strncmp( ( const char* )rxBuffer, "at+recv", 7) == 0)
+            {
+                receiveACK = true;
+                snprintf((char *)rxMessage, BUF_SIZE, "%s", rxBuffer);
+                clearRxBuffer();
+                return;
+            }
+               
+            if(strncmp( ( const char* )rxBuffer, "OK", 2) == 0)
+            {
+                receiveOK = true;
+                clearRxBuffer();
+                return;
+            }
+            
+            if(strncmp( ( const char* )rxBuffer, "ERROR", 5) == 0)
+            {
+                receiveERR = true;
+                numOfERR++;
+                clearRxBuffer();
+                return;
+            }
+
+            if( strncmp( ( const char* )rxBuffer, "[LoRa]:Join Success", 19) == 0)
+            {
+                receiveJOIN = true;
+                clearRxBuffer();
+                return;
+            }
+            
+            clearRxBuffer();
+        }
+    }
+}
+
+void onMeasure()
+{
+    timeCounter++;
+    if(timeCounter >= measurePeriod)
+    {
+        timeCounter = 0;
+        measure = true;
+        return;
+    }
+}
+
+void init()
+{
+    timeCounter = 0;
+    measureTicker.detach();
+    led = 1;
+    clearRxBuffer();
+    lora.attach(&rxLoraInterrupt, Serial::RxIrq);
+    resetModule();
+    thermometer.initialize();
+    thermometer.setResolution(twelveBit);
+    memset(buffer, '\0', sizeof(buffer));
+    memset(hexBuffer, '\0', sizeof(hexBuffer));
+    memset(rxBuffer, '\0', sizeof(rxBuffer));
+    sprintf(hexBuffer,"at+send=lora:11:");
+    measureTicker.attach(&onMeasure, 1.0);
+}
+
+
+
+int main()
+{
+//    SystemInit();
+//    SetSysClock_PLL_HSE(0);
+//    SystemCoreClockUpdate();
+#if DEBUG_CONSOLE
+    usb.printf("\r\n ------------ START APPLICATION ------------ \r\n");
+    usb.printf("HCLK frequency : %d \r\n",HAL_RCC_GetHCLKFreq());
+    usb.printf("System clock : %d \r\n", SystemCoreClock);
+#endif
+    init();
+    float val = 0.0;
+    while(true)
+    {
+        if(measure)
+        {
+            fotoValue = foto.read_u16();
+            batteryValue = (((battery.read_u16()/65535.0)*3.30)/voltage_divider_ref)*V_BATT_REFF;
+            lora.printf("at+set_config=device:sleep:0\r\n");
+            val = thermometer.readTemperature();
+            sprintf(buffer, "%.2f;%.2f;%d", batteryValue, val, fotoValue);
+            for(int i=0; i < sizeof(buffer); i++)
+            {
+                if(buffer[i] == '\0')        
+                    break;
+                sprintf(hexBuffer + strlen(hexBuffer), "%02x",buffer[i]);
+            }
+#if DEBUG_CONSOLE
+            usb.printf("Buffer : %s\r\n", buffer);
+//            usb.printf("HEX Buffer : %s\r\n", hexBuffer);
+#endif
+            lora.printf("%s\r\n", hexBuffer);
+            memset(buffer, '\0', sizeof(buffer));
+            memset(hexBuffer, '\0', sizeof(hexBuffer));
+            sprintf(hexBuffer,"at+send=lora:11:");
+            measure=false;
+        }
+        
+        if(receiveACK)
+        {
+#if DEBUG_CONSOLE
+             usb.printf("%s",rxMessage);
+#endif            
+             if(rxMessage[8] != '0')
+             {             
+                char *e;
+                int idx;
+
+                e = strchr(rxMessage, ':');
+                idx = (int)(e - rxMessage);
+
+                char str[3];
+                str[2]='\0';
+                int8_t j = 0;
+                memset(message, '\0', sizeof(message));
+
+                for(int i=idx+1; i<sizeof(rxMessage); i+=2)
+                {
+                    if((rxMessage[i] == '\r') || (rxMessage[i] == '\n'))
+                        break;
+                    str[0]=rxMessage[i];
+                    str[1]=rxMessage[i+1];
+                    char chr = (char)(int)strtol((const char *)str, NULL, 16);
+
+                    message[j++] = chr;
+                }
+                
+                if(rxMessage[8] == '1')                 // nastavenie intervalu merania v sekundach
+                {
+                    timeCounter = 0;
+                    measurePeriod = atoi((const char*)(message));
+#if DEBUG_CONSOLE
+                    usb.printf("Converted number : %d \r\n", measurePeriod);
+#endif
+//                    measure = true;
+                }
+                else if(rxMessage[8] == '2')
+                {
+                    lora.printf("%s\r\n", message);
+                    wait(0.2);
+                }
+#if DEBUG_CONSOLE
+                usb.printf("Received message : %s \r\n", message);
+#endif
+
+//                if( strncmp( ( const char* )message, "at+set_config=lora:class:", 25) == 0)
+//                    resetModule();
+                
+
+             }
+      
+             memset(rxMessage, '\0', sizeof(rxMessage));
+//             usb.printf("HAL SLEEP \r\n");
+             lora.printf("at+set_config=device:sleep:1\r\n");
+             receiveACK = false;
+ //            hal_sleep();
+        }
+        
+        if(receiveERR)
+        {
+            receiveERR = false;
+//            memset(rxMessage, '\0', sizeof(rxMessage));
+            if(numOfERR > 4)
+            {
+                measureTicker.detach();
+                resetModule();
+                measureTicker.attach(&onMeasure, 1.00);
+            }
+        }
+        
+        if(receiveOK)
+        {
+             receiveOK = false;
+        }
+        
+        hal_sleep();
+//        hal_deepsleep();
+        
+    }
+}
+
+
+/*
+void ticker_irq_handler(void)   
+{
+}
+
+   
+int main()
+{
+    led = 1;
+    LowPowerTicker t;
+    lp_ticker_set_interrupt(1000);
+    lp_ticker_init();
+//    set_lp_ticker_irq_handler(&ticker_irq_handler  ); 
+
+    usb.printf("start application... \r\n");
+    while(1)
+    {
+        usb.printf("Bla bla \r\n");
+        hal_deepsleep();
+    }
+}
+*/
\ No newline at end of file