BLSJ/bl_zc/appTask.c

#include "r_cg_macrodriver.h"
#include "appTask.h"
#include "event.h"
#include "r_cg_port.h"
#include "r_cg_timer.h"
#include "r_cg_wdt.h"
#include "hwCtrl.h"

static uint8_t autoflag = 0;
static uint8_t updown = 0,stopflag = 0;
static uint8_t shortflag = 0;

#define UPDOWN_DOWN 1
#define UPDOWN_UP   2
#define UPDOWN_NO   0
uint16_t timedelay_cnt;


void HardWare_Init(void)
{
    //time base init
    R_TAU0_Channel0_Start();

    //output init 
    RLY1_Ctrl(OFF);
    RLY2_Ctrl(OFF);
    MOS_Ctrl(OFF);

    //adc init
    R_ADC_Start();
    R_ADC_Set_OperationOn();
    R_TAU0_Channel1_Start();//for adc scan
}

void Variable_Init(void)
{
    autoflag = 0;
    updown = 0;
    shortflag = 0;
}


#define MOS_OPEN_DELAY_TIME 3

#define KEY_DELAY_TIME 6
#define KEY_DELAY_TIME_50ms 10
#define KEY_DELAY_TIME_8000ms 1600
void keyScan(void)//5ms
{
    static uint16_t keydelay[4]={0,0,0,0};
    static uint8_t keyflag[4]={0,0,0,0};
    static uint8_t shoudong = 0;
    if (GetKeyState(KEY_DOWN) == KEY_PRESSED)
    {
        keydelay[KEY_DOWN]++;
        if (keydelay[KEY_DOWN] > KEY_DELAY_TIME)
        {
            keydelay[KEY_DOWN] = KEY_DELAY_TIME;
            updown = UPDOWN_DOWN;
        
            keyflag[KEY_DOWN] = 1;
            if (autoflag == UPDOWN_DOWN)
            {
                shoudong = KEY_DOWN;
            }
            autoflag = UPDOWN_NO;
        }
    }
    else
    {
        
        if (keydelay[KEY_AUTO]>=KEY_DELAY_TIME_50ms &&  keydelay[KEY_AUTO] < KEY_DELAY_TIME_8000ms && keyflag[KEY_DOWN] == 1 && shoudong != KEY_DOWN)
        {
            autoflag = UPDOWN_DOWN;
        }
        
        //updown = UPDOWN_NO;
        keydelay[KEY_DOWN] = 0;
        keyflag[KEY_DOWN] = 0;
        if (shoudong == KEY_DOWN )
        {
            shoudong = 0;
        }
    }

    if (GetKeyState(KEY_UP) == KEY_PRESSED)
    {
        keydelay[KEY_UP]++;
        if (keydelay[KEY_UP] > KEY_DELAY_TIME)
        {
            keydelay[KEY_UP] = KEY_DELAY_TIME;
            updown = UPDOWN_UP;
            keyflag[KEY_UP] = 1;
            if (autoflag == UPDOWN_DOWN)
            {
                shoudong = KEY_UP;
            }
            autoflag = UPDOWN_NO;
        }
    }
    else
    {

        //updown = UPDOWN_NO;
        keydelay[KEY_UP] = 0;
        keyflag[KEY_UP] = 0;
        if (shoudong == KEY_UP )
        {
            shoudong = 0;
        }
    }

    if (shoudong != 0)
    {
        updown = UPDOWN_NO;
    }
    

    if (keyflag[KEY_UP]==0 && keyflag[KEY_DOWN]==0)
    {
        updown = UPDOWN_NO;
        shortflag = 0;
        stopflag = 0;
        shoudong = 0;
    }

    if (GetKeyState(KEY_AUTO) == KEY_PRESSED)
    {
        keydelay[KEY_AUTO]++;
        if (keydelay[KEY_AUTO] >= 2000)
        {
            keydelay[KEY_AUTO] = 2000;
        }
    }
    else
    {
        if (keyflag[KEY_UP]==0 && keyflag[KEY_DOWN]==0)
        {
            keydelay[KEY_AUTO] = 0;
        }
        
    }
}
#define MOTOR_NONE  0
#define MOTOR_UP    1
#define MOTOR_DOWN  2
#define MOTOR_BREAK 3
void Motor_Ctrl(uint8_t state)
{
    static uint8_t now_state=0;
    switch (now_state)
    {
    case 0://init
        if (state == MOTOR_UP)
        {
            timedelay_cnt = MOS_OPEN_DELAY_TIME;
            now_state = 1;
            RLY1_Ctrl(ON);
        }
        else if (state == MOTOR_DOWN)
        {
            timedelay_cnt = MOS_OPEN_DELAY_TIME;
            now_state = 1;
            RLY2_Ctrl(ON);
        }
        else
        {
            RLY1_Ctrl(OFF);
            RLY2_Ctrl(OFF);
            MOS_Ctrl(OFF);
        }
        break;
    case 1://wait
        if (timedelay_cnt == 0)
        {
            MOS_Ctrl(ON);
            now_state = 2;
        }
        break;
    case 2://on
        if (state == MOTOR_NONE)
        {
            timedelay_cnt = MOS_OPEN_DELAY_TIME;
            MOS_Ctrl(OFF);
            now_state = 3;
        }
        
        break;
    case 3://wait
        if (timedelay_cnt == 0)
        {
            RLY1_Ctrl(OFF);
            RLY2_Ctrl(OFF);
            now_state = 0;
        }
        break;
    default:
        break;
    }
    /*
    switch (state)
    {
    case MOTOR_UP:
        RLY1_Ctrl(ON);
        RLY2_Ctrl(OFF);
        MOS_Ctrl(ON);
        break;
    case MOTOR_DOWN:
        RLY1_Ctrl(OFF);
        RLY2_Ctrl(ON);
         MOS_Ctrl(ON);
        break;
    case MOTOR_BREAK:
        RLY1_Ctrl(ON);
        RLY2_Ctrl(ON);
        MOS_Ctrl(ON);
        break;
    default:
        RLY1_Ctrl(OFF);
        RLY2_Ctrl(OFF);
        MOS_Ctrl(OFF);
        break;
    }
    */
}

#define OC_13A      30
#define OC_9A       21//30(13A)->21(9A)
#define OC_6A       12
extern uint16_t g_adcval;
void Output_Ctrl(void)
{
    static uint16_t autotime=0;
    static uint8_t oc_delay = 0;
    
    if (g_adcval > OC_9A)
    {
        oc_delay++;
        if (oc_delay > 20)
        {
            Motor_Ctrl(MOTOR_NONE);
            shortflag = 1;
            autoflag = UPDOWN_NO;
        }
    }
    else
    {
        oc_delay = 0;
    }
    
    
    if (shortflag == 1)
    {
        Motor_Ctrl(MOTOR_NONE);
        return;
    }

    if (stopflag == 1 )
    {
        Motor_Ctrl(MOTOR_NONE);
        return;
    }
    
    
   
    if (updown == UPDOWN_DOWN)
    {
        Motor_Ctrl(MOTOR_UP);
        //autotime = 0;
        autotime++;
        if (autotime > 800)//8s
        {
            Motor_Ctrl(MOTOR_NONE);
            autotime = 0;
            autoflag = 0;
            stopflag = 1;
        }
    }
    else if (updown == UPDOWN_UP)
    {
        Motor_Ctrl(MOTOR_DOWN);
        //autotime = 0;
        autotime++;
        if (autotime > 800)//8s
        {
            Motor_Ctrl(MOTOR_NONE);
            autotime = 0;
            autoflag = 0;
            stopflag = 1;
        }
    }
    else if (updown == UPDOWN_NO)
    {
        if (autoflag == UPDOWN_DOWN)
        {
            Motor_Ctrl(MOTOR_UP);
            autotime++;
            if (autotime > 800)//8s
            {
                Motor_Ctrl(MOTOR_NONE);
                autotime = 0;
                autoflag = 0;
                stopflag = 1;
            }
        }
        else
        {
            Motor_Ctrl(MOTOR_NONE);
            autotime = 0;
        }
    }
    if (autotime > 800)//10ms * 800 = 8000 ms
    {
        autotime = 0;
        autoflag = UPDOWN_NO;
    }
    
}


void AppTask(void)
{
    static uint8_t ledno = 1,last = 0;
    if (TimeBase5msFlag == 1)
    {
        TimeBase5msFlag = 0;
        keyScan();
    }
    

    if (TimeBase10msFlag == 1)
    {
        TimeBase10msFlag = 0;
        Output_Ctrl();
        //Motor_Ctrl(MOTOR_DOWN);
    }
    
    if (TimeBase100msFlag == 1)
    {
        TimeBase100msFlag = 0;
        
        R_WDT_Restart();
    }
    
    if (TimeBase1000msFlag == 1)
    {
        TimeBase1000msFlag = 0;
	/*
        LED_Ctrl1LED(ledno,LED_ON);
        LED_Ctrl1LED(last,LED_OFF);
        last = ledno;
        ledno++;
        if (ledno > 9)
        {
            ledno = 1;
        }
        */
    }
    
}