irDA + marvell 收发信号

#include "gconf.h"

#include "peripheral.h"

#include "IrDA.h"



//##############   recv ####################################################

static uint16_t ir_data[512];

static uint16_t oft;



static const char *IrDARecv_thread_name = "IrDARecv_thread";

static os_thread_t IrDARecv_thread;

static os_thread_stack_define(IrDARecv_thread_stack, 1024);





//???????è???í???é.

static int IrDA_RECV_PushBtn_Gpio;

static int IrDA_RECV_LED_Gpio, IrDA_MODE_LED_Gpio;

static volatile bool bInIrDARecvMode = false;



static void IrDARecv_task_exec(os_thread_arg_t arg)

{

    volatile uint8_t curr, lasted;



    bInIrDARecvMode= true;

    led_on(IrDA_RECV_LED_Gpio);

    led_on(IrDA_MODE_LED_Gpio);



    lasted = GPIO_ReadPinLevel(CONFIG_IrDA_RECV);

    while ((curr = GPIO_ReadPinLevel(CONFIG_IrDA_RECV)) == lasted)

    {

    //    nd_delay_ms(1);

        os_thread_relinquish();

    }



    nd_reset_stopwatch();

    lasted = curr;

    oft= 0;

    led_off(IrDA_MODE_LED_Gpio);



    while (1) {

        curr = GPIO_ReadPinLevel(CONFIG_IrDA_RECV);

        if (curr != lasted) {

            ir_data[oft] =     nd_get_stopwatch();

            nd_reset_stopwatch();

            lasted = curr;

            oft++;

        }

        else {

            if (nd_get_stopwatch() > 10000) {

                if (oft > 0) {

                    break;

                }

            }

            os_thread_relinquish();

        }

    }

    nd_close_stopwatch();

    if (oft > 0) {

        dump_data_u16("ir_data",ir_data,oft);

    }



    led_off(IrDA_RECV_LED_Gpio);

    bInIrDARecvMode= false;



    os_thread_self_complete(NULL);

}





static void IrDARecvMode_callback(void)

{

    if (bInIrDARecvMode) return;



    PMU_PowerOnVDDIO(PMU_VDDIO_D0);

    GPIO_PinMuxFun(CONFIG_IrDA_RECV,GPIO9_GPIO9);

    GPIO_SetPinDir(CONFIG_IrDA_RECV,GPIO_INPUT);



    //when uart is OK, then prepare zigbee TASK and queue TASK.

    int ret = os_thread_create(&IrDARecv_thread,

        IrDARecv_thread_name, (void *)IrDARecv_task_exec, 0,

        &IrDARecv_thread_stack, OS_PRIO_1);


    if (ret)
    {
        dbg("Failed to create uart_monitor_thread");
        //appln_critical_error_handler(NULL);

    }

}



void init_IrDA_env(void)

{

    // push_button sw1 to indicate start SIR_RECV mode, and LED_2 for RUNNING

    IrDA_RECV_PushBtn_Gpio = board_button_1();

    IrDA_RECV_LED_Gpio = board_led_1();

    IrDA_MODE_LED_Gpio = board_led_2();

    gpio_drv_set_cb(NULL, IrDA_RECV_PushBtn_Gpio, GPIO_INT_FALLING_EDGE, IrDARecvMode_callback);

    return;

}



void final_IrDA_env(void)

{

    gpio_drv_set_cb(NULL, IrDA_RECV_PushBtn_Gpio, GPIO_INT_FALLING_EDGE, NULL);

    return;

}

//######################### SIR send API ##############################################

static void IrDA_load(void)

{

    int div, ton, toff, period;



    /* Set GPT3 at ~ 32.768KHz */

    PMU_PowerOnVDDIO(PMU_VDDIO_D2);

    GPIO_PinMuxFun(CONFIG_IrDA_PWM, GPIO63_GPT3_CH2);

    GPIO_PinMuxFun(CONFIG_IrDA_DATA,GPIO64_GPIO64);

    GPIO_SetPinDir(CONFIG_IrDA_DATA,GPIO_OUTPUT);



    CLK_GPTInternalClkSrc(CLK_GPT_ID_3, CLK_MAINXTAL); //32MHz. so cycle time is 1000000us/32M = 0.03125 us



    div = 8;

    period = (32000/div)/38; //cycles -- (1000000ns/38KHz) / (1000000/(32MHz/div))

    ton = period / 3;

    toff = period - ton;



    //dbg("pwm div=%d period=%d ton=%d toff=%d", div, period, ton, toff);



    CLK_ModuleClkDivider(CLK_GPT3, div);

    gpt_drv_pwm(g_rt_context.gpt3_dev, GPT_CH_2, ton, toff);



}



static void IrDA_unload(void)

{

    GPIO_PinMuxFun(CONFIG_IrDA_PWM, GPIO63_GPIO63);

    GPIO_SetPinDir(CONFIG_IrDA_DATA,GPIO_INPUT);

    //PMU_PowerOffVDDIO(PMU_VDDIO_D2);

}



#if 0

static inline void IrDA_Level_Change(bool high_level, uint16_t timeout)

{

    if (high_level) {

        GPIO_WritePinOutput(CONFIG_IrDA_DATA, GPIO_IO_LOW);

    }

    else {

        GPIO_WritePinOutput(CONFIG_IrDA_DATA, GPIO_IO_HIGH);

    }

    nd_delay_us(timeout);



}



static void IrDA_Send_Buffer(uint16_t *buf, uint16_t length)

{

    uint16_t idx;

    bool high_level = true;

    gpt_drv_start(g_rt_context.gpt3_dev);



    for (idx=0; idx<length; idx++) {

        IrDA_Level_Change(high_level, buf[idx]);

        high_level = !high_level;

    }



    gpt_drv_stop(g_rt_context.gpt3_dev);

    GPIO_WritePinOutput(CONFIG_IrDA_DATA, GPIO_IO_LOW);

}



#else

#define Ir_int_time       10

uint16_t ir_idx = 0, ir_length=0;

uint16_t *ir_buf, ir_count;

bool high_level = true;



static inline void IrDA_Gptimer_cb(void);



static void IrDA_Level_Change(bool high_level, uint16_t timeout)

{

    if (high_level) {

        GPIO_WritePinOutput(CONFIG_IrDA_DATA, GPIO_IO_LOW);

    }

    else {

        GPIO_WritePinOutput(CONFIG_IrDA_DATA, GPIO_IO_HIGH);

    }

}



static void IrDA_Gptimer_cb(void)

{

    ir_count += Ir_int_time * 10;

    if (ir_buf[ir_idx] <= ir_count) {

        ir_count = 0;

        ir_idx++;

        high_level= !high_level;



        IrDA_Level_Change(high_level, ir_buf[ir_idx]);

        if (ir_idx >= ir_length) {

            gpt_drv_setcb(g_rt_context.gpt3_dev, NULL);

            gpt_drv_stop(g_rt_context.gpt3_dev);

            GPIO_WritePinOutput(CONFIG_IrDA_DATA, GPIO_IO_LOW);

        }

    }

}



static void IrDA_Send_Buffer(uint16_t *buf, uint16_t length)

{

    ir_length = length;

    ir_idx = 0;

    high_level = true;

    ir_buf= buf;

    ir_count=0;



    dbg("IrDA_Send_Buffer...");

    gpt_drv_set(g_rt_context.gpt3_dev, Ir_int_time);

    gpt_drv_setcb(g_rt_context.gpt3_dev, IrDA_Gptimer_cb);



    IrDA_Level_Change(high_level, ir_buf[ir_idx]);

    gpt_drv_start(g_rt_context.gpt3_dev);



    while (ir_idx < ir_length) {

        //os_thread_relinquish();

        os_thread_sleep(os_msec_to_ticks(100));

    }

}



#endif





#ifdef _TEST_CODE_INC_



void test_IrDA_func(void)

{

    //vTaskPrioritySet(NULL, OS_PRIO_0);



    uint16_t  gree_shake_data[] = {

        1310, 386,1256, 436, 410,1280,1306, 388,1258, 434, 412,1278, 406,1286, 462,1230,

         462,1230, 462,1232,1258, 436, 410,8046,1260, 436,1256, 436, 410,1280,1258, 436,

        1256, 436, 410,1280, 412,1280, 460,1232, 462,1230, 460,1232,1306, 388, 410,8048,

        1306, 388,1258, 434, 410,1280,1302, 392,1256, 436, 410,1280, 462,1230, 412,1280,

         458,1236, 456,1234,1304, 390, 412,8046,1260, 434,1258, 436, 410,1278,1304, 392,

        1256, 436, 410,1278, 462,1230, 462,1230, 464,1228, 462,1232,1258, 436, 410,8046,

        1310, 386,1256, 436, 410,1280,1258, 436,1256, 436, 410,1280, 412,1280, 412,1280,

         460,1232, 412,1280,1258, 436, 410,8048,1310, 386,1256, 436, 410,1280,1258, 436,

        1256, 436, 410,1280, 460,1230, 414,1280, 458,1234, 412,1280,1308, 386, 410

    };



    dbg("Enter IrDA test...");

    IrDA_load();

    IrDA_Send_Buffer(gree_shake_data, ARRAYSIZE(gree_shake_data));

    IrDA_unload();

    dbg("Exit IrDA test...");



    //vTaskPrioritySet(NULL, OS_PRIO_3);

}



#endif

#ifndef _PERIPERAL_IrDA_INC_

#define _PERIPERAL_IrDA_INC_





#define CONFIG_IrDA_PWM               GPIO_63        //GPT3 channel 2

#define CONFIG_IrDA_DATA            GPIO_64       //GPT3 channel 3



#define CONFIG_IrDA_RECV            GPIO_9        //?ì???????·



void init_IrDA_env(void);

void final_IrDA_env(void);



#ifdef _TEST_CODE_INC_

void test_IrDA_func(void);

#endif





#endif //_PERIPERAL_IrDA_INC_