File content as of revision 1:8a60d7a33fa5:

#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 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 0
#endif

 
#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()
{
#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();
        
    }
}