WiFi_433_Transceiver/main/receiver.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_sleep.h"
#include "esp_log.h"
#include "driver/uart.h"
#include "driver/rtc_io.h"
#include "esp_intr_alloc.h"
#include "esp_attr.h"
#include "driver/timer.h"
#include <stddef.h>
#include "esp_intr_alloc.h"

#include "receiver.h"
#include "transceiver.h"
#include "rxTimer.h"
#include "Sensors/ClasOSensor.h"
#include "Sensors/proovesmartSensor.h"
#include "Sensors/nexa.h"
#include "Sensors/oregon.h"
#include "Sensors/esic.h"
#include "led.h"
#include "udp_client.h"
#include "wifi.h"

uint32_t dataArr[1000];
uint32_t dataArrIdx = 0;

static int convertToSignedTemp(unsigned int value)
{

	//int signValue;

	return ( (value >> 11) == 0 )? value : ((-1 ^ 0xFFF) | value);
}

void receiverTask(void *pvParameter)
{
    ESP_LOGI("RX", "Receiver task starting.");
    uint32_t width;

    char dataStr[UDP_QUEUE_OBJ_LENGTH];

    while (1) {

        while( xQueueReceive( rxQueue, &width, portMAX_DELAY ) == pdTRUE ) {

            dataArr[dataArrIdx++] = width;
            if( dataArrIdx == 1000 ) dataArrIdx=0;

            // Receive the Clas Ohlsson Sensors
            int64_t data = nextPulseClasOSensor(width);
            if( data != -1 ) {

                int value      = convertToSignedTemp( data & 0xFFF );
                unsigned char id         = (data>>12) & 0x007;

                ESP_LOGI("RX", "ClasO:  <TR%08llX> %u               %4.1f",data,id, (float)value/10);

                sprintf(dataStr,"<TR%08llX>",data);
#ifdef WIFI_ENABLED
                sendUDPMessage(dataStr, true);
#endif
            }

            // Receive the Telldus / Proovesmart Sensors
            data = nextPulseProovesmartSensor(width);
            if( data != -1 ) {

                const int value = (data & 0x00FFF0000) >> 16;
                const int id = (data & 0xFF0000000) >> 28;

                ESP_LOGI("RX", "Proove: <Tr%016llX> ID:%d  %4.1f",data,id,(float)value/10);

                sprintf(dataStr,"<Tr%016llX>",data);
#ifdef WIFI_ENABLED
                sendUDPMessage(dataStr, true);
#endif
            }

            // Receive the NEXA Sensors
            data = nextPulseNEXA(width);
            if( data != -1 ) {

                ESP_LOGI("RX", "NEXA: <NR%08llX>",data);

                sprintf(dataStr,"<NR%08llX>%u",data,startPulseWidth);

#ifdef WIFI_ENABLED
                sendUDPMessage(dataStr, false);
#endif
            }

            // Receive the Oregon (Rain) Sensor
            char *ch_data_p = nextPulseOregonSensor(width);
            if( ch_data_p != NULL ) {

                // Nibbles 17..12 = Total Rain = LSD is 0.001 inch (0,0254 mm)
                
                //   0 1 2 3  4 5  6 7 8  9                     Rate    Total
                // RR2A1904CE 0000 601600 70 = 001.660          0000    001660
                // RR2A1904CE 2001 702000 60 = 002.070 = 0,41   0120    002070
                // RR2A1904CE 0001 902400 A0 = 002.490 = 0,42           002490
                // RR2A1904CE 0000 906600 F0 = 006.690 = 6.69 = 109,62903 cm2
                // Sequence:       563412  
                // 1 cubic mm of water = 0,001 gram
                // 7 grams of water = 7000 mm2
                // Area of the rain sensor is 7697.69 sq.mm. It flips every ~7grams of water
                // Every flip is therefore 0.90936402542048 mm or rain
                // The value that is reported is in 1/1000 cubic inches of water.
                // Multiply with 16387 / 1000 to get cm2

                double total = 100 * (ch_data_p[4+12]-'0') + 
                                10 * (ch_data_p[5+12]-'0') +
                                     (ch_data_p[2+12]-'0') +
                               0.1 * (ch_data_p[3+12]-'0') +
                              0.01 * (ch_data_p[0+12]-'0') +
                             0.001 * (ch_data_p[1+12]-'0');

                total = (total * 16387) / 1000; // Convert to cubic centimeters

                char ch_data[21];
                strncpy(ch_data,ch_data_p, sizeof(ch_data));
                ESP_LOGI("RX", "OREGON: <RR%s> %6.4f cm2", ch_data, total );

#ifdef WIFI_ENABLED
                sprintf(dataStr,"<RR%s>",ch_data);
                sendUDPMessage(dataStr, true);
#endif

                Oregon_ResetDecoder();
            }

            // ESIC (Fridge / Freezer Sensors)
            data = nextPulseESICSensor(width);
            if( data != -1 ) {

                int32_t value	   = (data & 0xFFFE) >> 1;
		                value	   = (value - 6400) * 10 / 128;

                int32_t id         = (data>>12) & 0x007;

                ESP_LOGI("RX", "ESIC:   <TE%08llX> %u               %4.1f",data,id, (float)value/10);

                sprintf(dataStr,"<TE%08llX>",data);
#ifdef WIFI_ENABLED
                sendUDPMessage(dataStr, true);
#endif
            }
        }
    }
    vTaskDelete(NULL);
}

void initReceiver() {

    Oregon_ResetDecoder();
    ClasO_ResetDecoder();
    ProovesmartSensor_ResetDecoder();
    ESIC_ResetDecoder();
            
    ESP_LOGI("RX", "Receiver has been initialized.");

    xTaskCreatePinnedToCore(&receiverTask, "receiverTask", 8192, NULL, tskIDLE_PRIORITY + 5, NULL, 0);
}