SmartPDCode/pro/ui/led.c

#include "led.h"
#include "timer.h"
#include "gpio.h"
#include "elog.h"
#include "common.h"
#include "paras.h"


#if 1
    #define LOGD  log_d
    #define LOGE  log_e
#else
    #define LOGD  printf
    #define LOGE  printf
#endif

#if (CHIP_TYPE == CHIP_T113s)
    #define LEDR_GPIO  (192 + 9 )     
    #define LEDG_GPIO  (192 + 10  )     
#else
    #define LEDR_GPIO  106      //PD10=96+10
    #define LEDG_GPIO  105      //PD9=96+9

#endif


typedef struct {
    int         gpio;
    int         on_level;
    int         off_level;
}led_info_t;
static led_info_t led_info[LED_ID_MAX]={
    {LEDR_GPIO, 0, 1},
    {LEDG_GPIO, 0, 1},
};
typedef struct {
    int         io;
    led_para_t  para;
    led_info_t  *info;
    uint32_t    cnt;
    int         tmr;
}led_data_t;
typedef struct {
    int         tmr;
    int         mode;
    led_data_t  data[LED_ID_MAX];
}led_handle_t;

static led_para_t led_para[LED_MODE_MAX]={
#if 0
    {LED_ID_GREEN,  1000,0,     -1,   0},     //LED_MODE_NORMAL
    {LED_ID_GREEN,  300, 300,   -1,   0},     //LED_MODE_UPGRADING
    {LED_ID_RED,    1000, 1000,  5,   0},     //LED_MODE_WARN1,
    {LED_ID_RED,    1000, 1000,  10,  0},     //LED_MODE_WARN2,
    {LED_ID_RED,    500, 500,    10,  0},     //LED_MODE_ERROR,
    {LED_ID_RED,    200, 200,    25,  0},     //LED_MODE_FAULT
    {LED_ID_RED,    50,  50,     -1,  0},     //LED_MODE_FATAL
#else
    {LED_ID_RED,   0,   1000, -1, 0},      //LED_MODE_NORMAL
    {LED_ID_RED,   300, 1000,  -1, 0},      //LED_MODE_UPGRADING
    {LED_ID_RED,   500, 500,  300,  0},    //LED_MODE_WARN1,
    {LED_ID_RED,   333, 333,  450,  0},    //LED_MODE_WARN2,
    {LED_ID_RED,   500, 500,  10, 0},      //LED_MODE_ERROR,
    {LED_ID_RED,   200, 200,  25, 0},      //LED_MODE_FAULT
    {LED_ID_RED,   50,  50,   -1, 0},      //LED_MODE_FATAL
#endif
};
static led_handle_t ledHandle={0};


static inline MiscInfo_t* get_misc(void)
{
    return &__globalDeviceManage._globalDevInfo.misc;
}

static void led_handler(void *arg, int last)
{
    int level;
    led_data_t *h=(led_data_t*)arg;
    
    if(h->para.on_ms>0 && h->para.off_ms) {
        h->cnt++;
        if(h->cnt%2) {
            gpio_set(h->io, h->info->off_level);
        }
        else {
            gpio_set(h->io, h->info->on_level);
        }
    }
    
    if(last) {
        timer_stop(h->tmr);
        if(h->para.end_on) {
            gpio_set(h->io, h->info->on_level);
        }
        else {
            gpio_set(h->io, h->info->off_level);
        }

        //led_set(LED_MODE_NORMAL);
    } 
}
//////////////////////////////////////////////////
int led_init(void)
{
    int i;
    led_handle_t *h=&ledHandle;
    MiscInfo_t* misc=get_misc();

    led_para[LED_MODE_WARN1].off_ms =  misc->interval;
    led_para[LED_MODE_WARN1].on_ms =   misc->interval;
    led_para[LED_MODE_WARN1].times = misc->interval > 0 ? (misc->duption * 1000) / (misc->interval * 2) : 0;

    led_para[LED_MODE_WARN2].off_ms =  misc->interval;
    led_para[LED_MODE_WARN2].on_ms =  misc->interval;
    led_para[LED_MODE_WARN2].times = misc->interval > 0 ? (misc->duption * 1000) / (misc->interval * 2) : 0;

    h->tmr = timer_init();
    for(i=0; i<LED_ID_MAX; i++) {
        h->data[i].info = &led_info[i];
        h->data[i].cnt = 0;
        h->data[i].tmr = h->tmr;
        h->data[i].io = gpio_init(led_info[i].gpio, GPIO_OUT);
        gpio_set(h->data[i].io, led_info[i].off_level);
    }
    h->mode = -1;
    
    //led_set(LED_MODE_UPGRADING);
    
    return 0;
}


int led_deinit(void)
{
    int i;
    led_handle_t *h=&ledHandle;
    
    timer_deinit(h->tmr);
    for(i=0; i<LED_ID_MAX; i++) {
        gpio_deinit(h->data[i].io);
        h->data[i].io = -1;
    }
    return 0;
}


int led_set(int mode)
{
    led_handle_t *h=&ledHandle;

    h->mode = mode;
    return led_set_ex(&led_para[h->mode]);
}


int led_set_ex(led_para_t *para)
{
    int r=0;
    led_handle_t *h=&ledHandle;
    MiscInfo_t* misc=get_misc();
    
    if(!misc->led || !para || (para->on_ms<=0 && para->off_ms<=0) || para->times==0) {
        return -1;
    }
    led_data_t *ld=&h->data[para->led_id];
    
    ld->cnt = 0;
    ld->para = *para;
    if(ld->para.on_ms>0) {
        gpio_set(ld->io, ld->info->on_level);
        if(ld->para.off_ms>0) {
            ld->para.times *= 2;
        }
        else {
            ld->para.on_ms *= ld->para.times;
            ld->para.times = 1;
        }
        r = timer_start(h->tmr, ld->para.on_ms, ld->para.times, led_handler, ld);
    }
    else {
        gpio_set(ld->io, ld->info->on_level);
        if(ld->para.off_ms>0) {
            ld->para.off_ms *= ld->para.times;
            ld->para.times = 1;
            r = timer_start(h->tmr, ld->para.off_ms, ld->para.times, led_handler, ld);
        }
    }
    
    return r;
}


int led_reset(void)
{
    led_handle_t *h=&ledHandle;

    if(h->mode==-1) {
        return -1;
    }

    h->mode = -1;
    timer_stop(h->tmr);
    gpio_set(h->data[LED_ID_RED].io, led_info[LED_ID_RED].off_level);
    return 0;
}


int led_set_val(web_led_t *para)
{
    MiscInfo_t* misc=get_misc();
    if(para->enable)
    {
        misc->led = 1;
    }else
    {
        misc->led = 0;
    }
    // misc->led_on = para->on;
    // misc->led_off = para->off;
    // misc->led_count = para->time;
    misc->interval = para->interval;
    misc->duption = para->duption;
    led_para[LED_MODE_WARN1].off_ms = misc->interval;
    led_para[LED_MODE_WARN1].on_ms =  misc->interval;
    led_para[LED_MODE_WARN1].times = misc->interval > 0 ? (misc->duption * 1000) / (misc->interval * 2) : 0;

    led_para[LED_MODE_WARN2].off_ms = misc->interval;
    led_para[LED_MODE_WARN2].on_ms =  misc->interval;
    led_para[LED_MODE_WARN2].times = misc->interval > 0 ? (misc->duption * 1000) / (misc->interval * 2) : 0;
    
    paras_save();
    return 0;
}


// int led_get_val(web_led_t *para)
// {
//     if(!para)
//         return -1;
//     MiscInfo_t* misc=get_misc();
//     para->enable = misc->led;
//     para->on = misc->led_on;
//     para->off =  misc->led_off;
//     para->time = misc->led_count;
//     return 0;
// }