firmware/main/main.c

#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <freertos/event_groups.h>
#include <esp_system.h>
#include <esp_timer.h>
#include <esp_log.h>
#include <driver/gpio.h>

#include <lwip/err.h>
#include <lwip/sys.h>
#include <lwip/sockets.h>

#include "wifi.h"

#define HOST_IP_ADDR "10.0.0.1"
#define HOST_UDP_PORT 40586

#define RI_PIN 5
#define RI_LONG_TIME 3000
#define RI_SHORT_TIME 1000

static const char *UDP_TAG = "udp";

static xQueueHandle ri_gpio_evt_queue;
static xQueueHandle ri_message_queue;

static void udp_client_task(void *pvParameters)
{
	char tx_buffer[64];
	char addr_str[128];
	int addr_family;
	int ip_protocol;

	while(true)
	{
		struct sockaddr_in destAddr;
		destAddr.sin_addr.s_addr = inet_addr(HOST_IP_ADDR);
		destAddr.sin_family = AF_INET;
		destAddr.sin_port = htons(HOST_UDP_PORT);
		addr_family = AF_INET;
		ip_protocol = IPPROTO_IP;
		inet_ntoa_r(destAddr.sin_addr, addr_str, sizeof(addr_str) - 1);

		int sock = socket(addr_family, SOCK_DGRAM, ip_protocol);
		if (sock < 0)
		{
			ESP_LOGE(UDP_TAG, "Unable to create socket: errno %d", errno);
			break;
		}
		ESP_LOGI(UDP_TAG, "Socket created");

		while(true)
		{
			uint16_t ri_message;
			if(xQueueReceive(ri_message_queue, &ri_message, portMAX_DELAY))
			{
				snprintf(tx_buffer, sizeof(tx_buffer), "RI_MESSAGE: %u\n", ri_message);
				int err = sendto(sock, tx_buffer, strlen(tx_buffer), 0, (struct sockaddr *)&destAddr, sizeof(destAddr));
				if (err < 0)
				{
					ESP_LOGE(UDP_TAG, "Error occured during sending: errno %d", errno);
					break;
				}
				ESP_LOGI(UDP_TAG, "Message sent");
				gpio_set_level(2, true);
			}
		}

		if(sock != -1)
		{
			ESP_LOGE(UDP_TAG, "Shutting down socket and restarting...");
			shutdown(sock, 0);
			close(sock);
		}
	}
}

struct ri_gpio_event
{
	bool level;
	uint64_t time;
};

void ri_gpio_isr_handler(void* data)
{
	struct ri_gpio_event event;
	event.level = gpio_get_level(RI_PIN);
	event.time = esp_timer_get_time();
	xQueueSendFromISR(ri_gpio_evt_queue, &event, NULL);
}

void ri_reciver_setup(void)
{
	gpio_config_t config;

	config.intr_type = GPIO_INTR_ANYEDGE;
	config.mode = GPIO_MODE_INPUT;
	config.pin_bit_mask = 1 << RI_PIN;
	config.pull_down_en = false;
	config.pull_up_en = false;
	gpio_config(&config);

	ri_gpio_evt_queue = xQueueCreate(10, sizeof(struct ri_gpio_event));
	ri_message_queue = xQueueCreate(10, sizeof(uint16_t));

	gpio_install_isr_service(0);
	gpio_isr_handler_add(RI_PIN, ri_gpio_isr_handler, NULL);
}

typedef enum
{
	RI_STATE_SEARCH,
	RI_STATE_WAIT_SYNC_PULSE,
	RI_STATE_BIT_START_WAIT,
	RI_STATE_BIT_START,
	RI_STATE_BIT_DATA,
} ri_state_t;

bool time_matches(uint64_t time, uint64_t referance, uint32_t tollerance)
{
	return time + tollerance > referance && time - tollerance < referance;
}

void ri_reciver_task(void *pvParameters)
{
	(void)pvParameters;

	ri_state_t state = RI_STATE_SEARCH;
	unsigned int bit = 0;
	uint64_t prev_time = 0;
	uint16_t data;

	while(true)
	{
		struct ri_gpio_event event;
		if(xQueueReceive(ri_gpio_evt_queue, &event, portMAX_DELAY))
		{
			if(state == RI_STATE_SEARCH && event.level)
			{
				state = RI_STATE_WAIT_SYNC_PULSE;
				bit = 0;
				data = 0;
			}
			else if(state == RI_STATE_WAIT_SYNC_PULSE && !event.level)
			{
				uint64_t elapsed = event.time - prev_time;
				if(!time_matches(elapsed, RI_LONG_TIME, 500))
					state = RI_STATE_SEARCH;
				else
					state = RI_STATE_BIT_START_WAIT;
			}
			else if(state == RI_STATE_BIT_START_WAIT && event.level)
			{
				uint64_t elapsed = event.time - prev_time;
				if(!time_matches(elapsed, RI_SHORT_TIME, 150))
					state = RI_STATE_SEARCH;
				else
					state = RI_STATE_BIT_START;
			}
			else if(state == RI_STATE_BIT_START && !event.level)
			{
				uint64_t elapsed = event.time - prev_time;
				if(!time_matches(elapsed, RI_SHORT_TIME, 150))
					state = RI_STATE_SEARCH;
				else
					state = RI_STATE_BIT_DATA;
			}
			else if(state == RI_STATE_BIT_DATA && event.level)
			{
				uint64_t elapsed = event.time - prev_time;
				if(elapsed > RI_SHORT_TIME + 500)
					data |= 1 << bit;
				++bit;
				if(bit >= 12)
				{
					gpio_set_level(2, false);
					xQueueSendToBack(ri_message_queue, &data, portMAX_DELAY);
					state = RI_STATE_SEARCH;
				}
				else
				{
					state = RI_STATE_BIT_START;
				}
			}
			prev_time = event.time;
		}
	}
}

void app_main()
{
	gpio_config_t config = {};
	config.intr_type = GPIO_INTR_DISABLE;
	config.mode = GPIO_MODE_OUTPUT;
	config.pin_bit_mask = 1 << 2;
	gpio_config(&config);
	gpio_set_level(2, false);

	wifi_init_sta();

	ri_reciver_setup();

	xTaskCreate(ri_reciver_task, "ri_reciver_task", 2048, NULL, 10, NULL);

	xTaskCreate(udp_client_task, "udp_client", 4096, NULL, 5, NULL);

	gpio_set_level(2, true);
}