module_universal_io/fw/modules/log/log.c

#include "log.h"
#include "rtc.h"
#include "ringfs.h"
#include "spi_flash.h"
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
#include "event_groups.h"
#include "rtc.h"
#include "settings_api.h"
#include "digital_input.h"
#include "log_ai.h"
#include "log_dio.h"
#include "ringfs_api.h"
#include <string.h>
#include <stdio.h>
#include <inttypes.h>

#undef DBG
#define DBG if(0)

static bool archive_state = true;
static bool log_state = true;

static bool log_init_f = false;
static bool archive_init_f = false;

struct ringfs fs_log;

SemaphoreHandle_t log_mutex;
xQueueHandle log_queue;
//EventGroupHandle_t archive_event;

uint16_t log_entries_capacity;
uint16_t archive_entries_capacity;

void archive_task(void *params);
void log_task(void *params);



//
static struct ringfs_flash_partition ringfs_flash_log = 
{
	.sector_offset = LOG_FLASH_SECTOR_OFFSET,
	.sector_erase = op_sector_erase,
	.program = op_program,
	.read = op_read,
};


//
void log_init(bool format) 
{
	DBG printf("[LOG] Init...\r\n");
    
    // ---------------------------------------------------------------------- //
    // Журнал
        
	ringfs_flash_log.sector_size = spi_flash_desc.sector_size;
	ringfs_flash_log.sector_count = LOG_FLASH_SECTOR_COUNT;

	ringfs_init(&fs_log, &ringfs_flash_log, LOG_ENTRY_VERSION, sizeof(log_entry_t));
    
	if (format || ringfs_scan(&fs_log) != 0) {
		DBG printf("FAT1 false\r\n");
		ringfs_format(&fs_log);
	}
	DBG printf("FAT1 true\r\n");
    
    
#if defined (MDIO_88)    
    log_dio_archive_init();
#endif
    
#if defined (MAI_12)
    log_ai_archive_init();
#endif
    
    // ---------------------------------------------------------------------- //
	log_mutex = xSemaphoreCreateMutex();

    log_entries_capacity = ringfs_capacity(&fs_log);
    
#if defined (MDIO_88) || (MAI_12)     
    archive_entries_capacity = ringfs_capacity(&fs_ch_arch[0]);
    
    // Event
    archive_event = xEventGroupCreate();

	xTaskCreate(archive_task, "archive_task", 2*configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL);
#endif
    
    log_queue = xQueueCreate(10, sizeof(log_entry_t));

    xTaskCreate(log_task, "log_task", 2*configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL);
    
    log_init_f = true;
    
    archive_init_f = true;

    // Таймер для ведения архива с разным периодом по разным каналам
    log_init_archive_tim();  
}

// Настройка таймера на частоту 10 Гц
void log_init_archive_tim(void)
{
    printf("Init log timer...\r\n");
    
    crm_clocks_freq_type crm_clocks_freq_struct = {0};
    
    crm_periph_clock_enable(CRM_TMR14_PERIPH_CLOCK, TRUE);

    crm_clocks_freq_get(&crm_clocks_freq_struct);
    tmr_base_init(TMR14, 999, (crm_clocks_freq_struct.ahb_freq / 10000) - 1);
    tmr_cnt_dir_set(TMR14, TMR_COUNT_UP);
        
    tmr_flag_clear(TMR14, TMR_OVF_FLAG);

    nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
    nvic_irq_enable(TMR8_TRG_HALL_TMR14_IRQn, 5, 0);
       
    tmr_counter_enable(TMR14, TRUE);
    
    tmr_interrupt_enable(TMR14, TMR_OVF_INT, TRUE);
}

//
void TMR8_TRG_HALL_TMR14_IRQHandler(void)
{
    if (tmr_flag_get(TMR14, TMR_OVF_FLAG) != RESET)
    {
        tmr_flag_clear(TMR14, TMR_OVF_FLAG);
        
        if (archive_state) 
        {
            log_check_archive_cnt();
            //printf("TMR_14 irq\r\n");
        }
    }
}

//
int log_fetch(void *entry, entry_type_t entry_type, uint8_t ch, uint32_t timeout) 
{
    int ret;
    
    ret = xSemaphoreTake(log_mutex, (TickType_t)timeout);
    
    if (ret == pdFALSE)
        return ret;
    if (entry_type == LOG_ENTRY)
        ret = ringfs_fetch(&fs_log, entry);
#if defined (MDIO_88) || (MAI_12)     
    else if (entry_type == ARCHIVE_ENTRY)
        ret = ringfs_fetch(&fs_ch_arch[ch], entry);
#endif    
    else ret = -1;

    xSemaphoreGive(log_mutex);
    return ret;   
}

//
int log_discard(void *entry, entry_type_t entry_type, uint8_t ch, uint32_t timeout)
{
    int ret;
      
    ret = xSemaphoreTake(log_mutex, (TickType_t)timeout);
    
    if (ret == pdFALSE)
        return ret;
    if (entry_type == LOG_ENTRY)
        ret = ringfs_discard(&fs_log);
#if defined (MDIO_88) || (MAI_12)     
    else if (entry_type == ARCHIVE_ENTRY)
        ret = ringfs_discard(&fs_ch_arch[ch]);
#endif    
    else ret = -1;
    
    xSemaphoreGive(log_mutex);
    return ret; 
}

//
int log_append(void *entry, entry_type_t entry_type, uint8_t ch)
{
    int ret;
    TM_RTC_t time;
    common_entry_t *entry_ptr = entry;
    log_entry_t *log_etnry_ptr;
    archive_entry_t *archive_etnry_ptr;
    
    ret = xSemaphoreTake(log_mutex, portMAX_DELAY);
    
    if (ret == pdFALSE)
        return ret;
  
    if (entry_ptr->timestamp == 0)
        entry_ptr->timestamp = rtc_get_ms();
    
    if (entry_type == LOG_ENTRY) 
    {
        log_etnry_ptr = (log_entry_t*)entry;
        log_etnry_ptr->crc = crc_8(entry, sizeof(log_entry_t) - 1);
        ret = ringfs_append(&fs_log, entry);
    }
#if defined (MDIO_88) || (MAI_12)     
    else if (entry_type == ARCHIVE_ENTRY) 
    {
        archive_etnry_ptr = (archive_entry_t*)entry;
        archive_etnry_ptr->crc = crc_8(entry, sizeof(archive_entry_t) - 1);
        ret = ringfs_append(&fs_ch_arch[ch], entry);
    }
#endif    
    else ret = -1;
    
    xSemaphoreGive(log_mutex);
    return ret;
    
}

//
uint16_t log_capacity(void)
{
    return ringfs_count_exact(&fs_log);
}

//
uint16_t log_arch_capacity(uint8_t ch)
{
#if defined (MDIO_88) || (MAI_12)   
    return ringfs_count_exact(&fs_ch_arch[ch]);
#endif    
}

// -------------------------------------------------------------------------- //
// misc

uint8_t crc_8(uint8_t *data, int length)
{
    uint8_t crc = 0x00;
    uint8_t extract;
    uint8_t sum;
    
    for (int i = 0; i < length; i++) {
        extract = *data;
        for (uint8_t tmp = 8; tmp; tmp--) {
            sum = (crc ^ extract) & 0x01;
            crc >>= 1;
            if (sum)
                crc ^= 0x8C;
            extract >>= 1;
        }
        data++;
    }
    return crc;
}

// -------------------------------------------------------------------------- //
// Tests

// val - 0 - журнал
// val - 1 - архив
// ch - номер канала архива
void log_info(uint8_t val, uint8_t ch)
{
    if (val > 1)
        return;
#if defined (MDIO_88) || (MAI_12)   
    struct ringfs *fs = val == 0 ? &fs_log : &fs_ch_arch[ch];
#else
    struct ringfs *fs = &fs_log;
#endif    
    
    int capacity_flash = 0;
    int count_flash = 0;
    int count_estimate = 0;
    
    capacity_flash = ringfs_capacity(fs);
    count_flash = ringfs_count_exact(fs);
    count_estimate = ringfs_count_estimate(fs);
    
    if (val == 0)
    {
        DBG printf("Log partition capacity: %u\r\n", capacity_flash);
        DBG printf("Count log entry: %u\r\n", count_flash);
        DBG printf("Estimate count: %u\r\n", count_estimate);
    }
    else 
    {
        DBG printf("Archive partition capacity: %u\r\n", capacity_flash);
        DBG printf("Count archive entry: %u\r\n", count_flash);
        DBG printf("Estimate count: %u\r\n", count_estimate);
    }
}

// val - 0 - журнал
// val - 1 - архив
// ch - номер канала архива
void log_format(uint8_t val, uint8_t ch)
{
    if (val == 0) {
        DBG printf("Formating log partition...\r\n");
        ringfs_format(&fs_log);
    } 
#if defined (MDIO_88) || (MAI_12)       
    else if (val == 1) {
        DBG printf("Formating archive partition...\r\n");
        ringfs_format(&fs_ch_arch[ch]);
    }
#endif    
}

// Добавить n записей журнала
int log_add_random_entry(uint8_t val, uint32_t cnt_entry, uint8_t ch)
{
    int ret;
    log_entry_t log_entry = {0};
    archive_entry_t archive_entry = {0};
    
    static uint8_t log_index = 0;
    static uint32_t archive_index = 0;
    
    if (val == 0)
    {
        DBG printf("Appending %u archive entries\r\n", cnt_entry);
        
        for (uint32_t i = 0; i < cnt_entry; i++)
        {
            log_entry.code_type = log_index;
            log_entry.code_state = log_index;
            log_entry.channel_number = log_index;
            log_entry.value = (float)log_index++;
            
            ret = log_append((void*)&log_entry, LOG_ENTRY, 0);
        }
        DBG printf("Result: %u\r\n", ret);
    }
      
    if (val == 1)
    {
        DBG printf("Appending %u archive entries\r\n", cnt_entry);

        for (uint32_t i = 0; i < cnt_entry; i++)
        {
            archive_entry.input_value = archive_index++;

            ret = log_append((void*)&archive_entry, ARCHIVE_ENTRY, ch);
        }
        DBG printf("Result: %u\r\n", ret);
    }
    return ret;
}

//
int log_add_entry(log_event_type_t type, log_event_state_t state, 
                  uint8_t channel_number, float value)
{
    log_entry_t entry;
    
    if (!log_init_f)
        return -1;
    
    entry.timestamp = rtc_get_ms();
    entry.code_type = (uint8_t)type;
    entry.code_state = (uint8_t)state;
    entry.channel_number = channel_number;
    entry.value = value;
    
    xQueueSend(log_queue, &entry, 0);
    
    return 0;
}


//
void test_fetch(void)
{
    archive_entry_t entry = {0};
    log_fetch(&entry, ARCHIVE_ENTRY, 0, portMAX_DELAY);
    //printf("\r\n%" PRId64 " [ms]\r\n", rtc_get_ms());
    printf("[entry] timestamp = % " PRId64 ", value = %u, crc = %u\r\n", entry.timestamp, entry.input_value, entry.crc);
}

//
void log_archive_state(bool state)
{
    archive_state = state;
}

//
void log_log_state(bool state)
{
    log_state = state;
}


void archive_task(void *params)
{
    int ret = 0;
    uint32_t event = 0;
    archive_entry_t entry = {0};
    EventBits_t bits;
    uint8_t channel_number = log_get_arch_channel_number();
        
    for (;;)
    {
        log_archive_task_device();
    }
}

//
void log_task(void *params)
{
    int ret;
    log_entry_t entry;
      
    for (;;)
    {
        if (xQueueReceive(log_queue, &entry, portMAX_DELAY) == pdTRUE)
        {
            DBG printf("Try append LOG entry... ");
            ret = log_append((void*)&entry, LOG_ENTRY, 0);
            DBG printf("Result: %i\r\n", ret);
        }
    }
}

// Вызывается в прерывании таймера с частотой 10 Гц 
// TODO
void log_check_archive_cnt(void)
{
#if defined (MDIO_88) || (MAI_12)   
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    uint8_t channel_number = log_get_arch_channel_number();

    for (uint8_t i = 0; i < channel_number; i++)
    {
        if (archive_cnt[i]++ >= 10*settings.period_archive[i])
        {
            archive_cnt[i] = 0;

            if (log_is_channel_on(i)) 
            {
                DBG printf("Send event: %u\r\n", 1 << i);
                xEventGroupSetBitsFromISR(archive_event, 1 << i, &xHigherPriorityTaskWoken);
            }
        }
    }
#endif    
}