#include "stm32f4xx.h"
#include "FreeRTOS.h"
#include "task.h"

// Дефиниране на състоянията според IEC 61851-1:2017 с добавено STATE_ERROR
typedef enum {
    STATE_A = 0,     // Не е свързано (+12V)
    STATE_B = 1,     // Свързано, но не зарежда (+9V)
    STATE_C = 2,     // Зареждане (+6V)
    STATE_D = 3,     // Зареждане с вентилация (+3V)
    STATE_E = 4,     // Грешка (0V)
    STATE_F = 5,     // Отрицателно напрежение (-1V до -12V)
    STATE_ERROR = 6  // Всичко извън валидните диапазони (над +12V или под -12V)
} EVSE_State;

// Дефиниране на резисторите за делителя (в омове) и макрос за мащаба
#define RU 10000.0f  // Горно съпротивление (R_U) = 10kΩ
#define RD 2000.0f   // Долно съпротивление (R_D) = 2kΩ
#define SCALER ((RU + RD) / RD)  // Мащаб за резисторния делител

// Глобална променлива за съхранение на ADC резултата
volatile uint16_t adc_value = 0;

....................

// Функция за детекция на PWM нива и състояния
EVSE_State Detect_PWM_Level(void) {
    float voltage = (adc_value * 3.3) / 4095.0; // Преобразуване в напрежение (при 3.3V референтно)
    float scaled_voltage = voltage * SCALER; // Изчисление с макроса SCALER

    // Забележки за диапазоните на напрежение според IEC 61851-1:2017
    if (scaled_voltage > 11.0 && scaled_voltage <= 12.0) {
        // State A: +12V (11V до 12V)
        return STATE_A;
    } else if (scaled_voltage > 8.0 && scaled_voltage <= 11.0) {
        // State B: +9V (8V до 11V)
        return STATE_B;
    } else if (scaled_voltage > 5.0 && scaled_voltage <= 8.0) {
        // State C: +6V (5V до 8V)
        return STATE_C;
    } else if (scaled_voltage > 2.0 && scaled_voltage <= 5.0) {
        // State D: +3V (2V до 5V)
        return STATE_D;
    } else if (scaled_voltage >= -1.0 && scaled_voltage <= 1.0) {
        // State E: 0V (-1V до 1V)
        return STATE_E;
    } else if (scaled_voltage < -1.0 && scaled_voltage >= -12.0) {
        // State F: Отрицателно напрежение (-1V до -12V)
        return STATE_F;
    } else {
        // State ERROR: Всичко извън валидните диапазони (над +12V или под -12V)
        return STATE_ERROR;
    }
}

global.h
c

#ifndef GLOBAL_H
#define GLOBAL_H

#include "stm32f4xx.h"
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"

// Дефиниция на идентификатори за задачите
#define TASK_MAIN_ID    0
#define TASK_UART_ID    1
#define TASK_RGB_ID     2

// Дефиниция на съобщения
#define MSG_TOGGLE_LED  1
#define MSG_SEND_UART   2
#define MSG_ON_LED      3
#define MSG_OFF_LED     4

// Дефиниция на структурата за съобщения
typedef struct {
    uint8_t DST;  // Дестинация (за кой таск е)
    uint8_t SRC;  // Източник (от кой таск идва)
    uint8_t MSG;  // Номер на съобщението
    uint32_t ARG; // Полезни данни (аргумент)
} Message_t;

// Структура за данни на задача
typedef struct {
    TaskFunction_t taskFunction;    // Функцията на задачата
    const char *name;               // Име на задачата
    uint16_t stackSize;             // Размер на стека
    void *parameters;               // Параметри за задачата
    UBaseType_t priority;           // Приоритет
    TaskHandle_t handle;            // Хендъл на задачата (след създаване)
    QueueHandle_t queue;            // Локална опашка за съобщения
    uint16_t queueSize;             // Размер на опашката (брой съобщения)
} TaskDescriptor_t;

// Глобален масив от дескриптори на задачи
extern TaskDescriptor_t tasks[];

// Макрос за изчисляване на броя задачи
#define MAX_TASKS (sizeof(tasks) / sizeof(tasks[0]))

#endif // GLOBAL_H

main.c
c

#include "global.h"
#include "task_main.h"
#include "task_uart.h"
#include "task_rgb.h"
#include "message.h"
#include "system.h"

// Глобален масив от дескриптори на задачи
TaskDescriptor_t tasks[] = {
    [TASK_MAIN_ID] = {
        .taskFunction = TASK_MAIN,
        .name = "TASK_MAIN",
        .stackSize = configMINIMAL_STACK_SIZE * 2,
        .parameters = NULL,
        .priority = 3,
        .handle = NULL,
        .queue = NULL,
        .queueSize = 20
    },
    [TASK_UART_ID] = {
        .taskFunction = TaskUART,
        .name = "TaskUART",
        .stackSize = configMINIMAL_STACK_SIZE,
        .parameters = NULL,
        .priority = 1,
        .handle = NULL,
        .queue = NULL,
        .queueSize = 10
    },
    [TASK_RGB_ID] = {
        .taskFunction = TaskRGB,
        .name = "TaskRGB",
        .stackSize = configMINIMAL_STACK_SIZE,
        .parameters = NULL,
        .priority = 2,
        .handle = NULL,
        .queue = NULL,
        .queueSize = 5
    }
};

// Главна функция
int main(void) {
    // Инициализация на хардуера
    HAL_Init();
    SystemClock_Config();

    // Инициализация на опашките в масива tasks
    for (uint8_t i = 0; i < MAX_TASKS; i++) {
        tasks[i].queue = xQueueCreate(tasks[i].queueSize, sizeof(Message_t));
        if (tasks[i].queue == NULL) {
            while (1); // Грешка при създаване на опашка
        }
    }

    // Създаване на задачите
    for (uint8_t i = 0; i < MAX_TASKS; i++) {
        xTaskCreate(tasks[i].taskFunction, tasks[i].name, tasks[i].stackSize,
                    tasks[i].parameters, tasks[i].priority, &tasks[i].handle);
    }

    // Стартиране на scheduler-а
    vTaskStartScheduler();

    while (1) {
    }
}

task_main.h
c

#ifndef TASK_MAIN_H
#define TASK_MAIN_H

#include "global.h"

// Прототип на TASK_MAIN
void TASK_MAIN(void *pvParameters);

#endif // TASK_MAIN_H

task_main.c
c

#include "task_main.h"
#include "message.h"

void TASK_MAIN(void *pvParameters) {
    Message_t receivedMsg;

    while (1) {
        if (GetMessage(TASK_MAIN_ID, &receivedMsg) == pdPASS) {
            switch (receivedMsg.MSG) {
                case MSG_TOGGLE_LED:
                    SendMessage(TASK_RGB_ID, TASK_MAIN_ID, MSG_TOGGLE_LED, receivedMsg.ARG);
                    break;
                case MSG_ON_LED:
                    SendMessage(TASK_RGB_ID, TASK_MAIN_ID, MSG_ON_LED, receivedMsg.ARG);
                    break;
                case MSG_OFF_LED:
                    SendMessage(TASK_RGB_ID, TASK_MAIN_ID, MSG_OFF_LED, receivedMsg.ARG);
                    break;
                case MSG_SEND_UART:
                    // Пример: изпращане на текст до TaskUART
                    char *text = "Hello from TASK_MAIN\r\n";
                    SendMessage(TASK_UART_ID, TASK_MAIN_ID, MSG_SEND_UART, (uint32_t)text);
                    break;
                default:
                    break;
            }
        }
        vTaskDelay(pdMS_TO_TICKS(10)); // Малко закъснение
    }
}

task_uart.h
c

#ifndef TASK_UART_H
#define TASK_UART_H

#include "global.h"

// Прототип на TaskUART
void TaskUART(void *pvParameters);

#endif // TASK_UART_H

task_uart.c
c

#include "task_uart.h"
#include "message.h"

void TaskUART(void *pvParameters) {
    Message_t receivedMsg;

    while (1) {
        if (GetMessage(TASK_UART_ID, &receivedMsg) == pdPASS) {
            switch (receivedMsg.MSG) {
                case MSG_SEND_UART:
                    // Получава текста от съобщението (ARG е указател към char*)
                    char *textToSend = (char *)receivedMsg.ARG;
                    if (textToSend != NULL) {
                        HAL_UART_Transmit(&huart2, (uint8_t*)textToSend, strlen(textToSend), 100);
                    }
                    break;
                default:
                    break;
            }
        }
        vTaskDelay(pdMS_TO_TICKS(10)); // Малко закъснение
    }
}

task_rgb.h
c

#ifndef TASK_RGB_H
#define TASK_RGB_H

#include "global.h"

// Прототип на TaskRGB
void TaskRGB(void *pvParameters);

#endif // TASK_RGB_H

task_rgb.c
c

#include "task_rgb.h"
#include "message.h"

void TaskRGB(void *pvParameters) {
    Message_t receivedMsg;

    while (1) {
        if (GetMessage(TASK_RGB_ID, &receivedMsg) == pdPASS) {
            switch (receivedMsg.MSG) {
                case MSG_TOGGLE_LED:
                    HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
                    break;
                case MSG_ON_LED:
                    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_SET); // Включва LED
                    break;
                case MSG_OFF_LED:
                    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_RESET); // Изключва LED
                    break;
                default:
                    break;
            }
        }
        // Пример: изпращане на съобщение до TASK_MAIN на всеки 2s
        SendMessage(TASK_MAIN_ID, TASK_RGB_ID, MSG_TOGGLE_LED, 0x5678);
        vTaskDelay(pdMS_TO_TICKS(2000));
    }
}

message.h
c

#ifndef MESSAGE_H
#define MESSAGE_H

#include "global.h"

// Прототипи на функции за съобщения
BaseType_t SendMessage(uint8_t dst, uint8_t src, uint8_t msg, uint32_t arg);
BaseType_t GetMessage(uint8_t taskId, Message_t *msg);

#endif // MESSAGE_H

message.c
c

#include "message.h"

BaseType_t SendMessage(uint8_t dst, uint8_t src, uint8_t msg, uint32_t arg) {
    if (dst >= MAX_TASKS || tasks[dst].queue == NULL) {
        return pdFAIL;
    }

    Message_t message;
    message.DST = dst;
    message.SRC = src;
    message.MSG = msg;
    message.ARG = arg;

    return xQueueSend(tasks[dst].queue, &message, pdMS_TO_TICKS(10));
}

BaseType_t GetMessage(uint8_t taskId, Message_t *msg) {
    if (taskId >= MAX_TASKS || tasks[taskId].queue == NULL) {
        return pdFAIL;
    }

    return xQueueReceive(tasks[taskId].queue, msg, portMAX_DELAY);
}

system.h
c

#ifndef SYSTEM_H
#define SYSTEM_H

#include "global.h"

// Прототип на системна функция
void SystemClock_Config(void);

#endif // SYSTEM_H

system.c
c

#include "system.h"

void SystemClock_Config(void) {
    // Добави своята конфигурация от STM32CubeMX тук
}

.......................