Skip to content

Giraffe硬件API使用说明 ​

giraffe 硬件相关 API接口 在 grf_hw_i.h 文件中,创建项目后可以从 inc 文件夹 中找到。

本文档主要讲解该文件夹中的相关API的使用方法,不同产品支持的硬件接口不同,详细可以查阅产品规格书。

  • Giraffe现存的硬件函数包括 LCD, Touch, UART, WDT, GPIO, RTC, FLASH, SPI, IIC, PWM
  • 硬件文件均可在工程内直接生成
  • 添加硬件文件后,grf_hw.c 初始化函数里会进行调用:
c
#include "grf_hw.h"

void grf_hw_init(void)
{
	grf_pwm_test();

	grf_iic_test();

	grf_spi_test();

	grf_rtc_test();

	grf_gpio_test();

    grf_uart_init();
  
    grf_wdt_task_create();
}

1. LCD相关函数 ​

1.1设置屏幕亮度 ​

c
s32 grf_disp_set_bright(u8 bright);

bright :屏幕亮度,亮度等级 0-99 ,99 为最亮,0 为最暗

返回值:成功返回 GRF_OK ,失败返回 GRF_FAIL

提示 :
此接口通常配合 slider控件 使用,用于调节屏幕的显示亮度

2. Touch相关函数 ​

c
typedef struct 
{
    grf_touch_state t_state;
    u16 touch_x;
    u16 touch_y;
}grf_touch_t;

触摸结构体,结构体成员包括 触摸点的 (x,y)坐标值 和 触摸状态 ,触摸状态 包含 抬起 和 按下 两种状态,枚举如下:

c
typedef enum
{
    GRF_TOUCH_UP,
    GRF_TOUCH_DOWN
}grf_touch_state;

2.1 获取触摸 ​

c
s32 grf_touch_get(grf_touch_t *_touch_t);

_touch_t :要获取的触摸对象指针

返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL

使用该API需要先创建一个触摸对象,然后才能获取到具体的触摸参数。

2.2 设置输入长按时间 ​

c
s32 grf_touch_set_long_press_time(u32 time);

time :长按时间(ms)

返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL

2.2 设置输入长按重复时间 ​

c
s32 grf_touch_set_long_press_repeat_time(u32 time);

time :长按重复时间(ms)

返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL

例程:

本例程主要演示了如何获取触摸坐标和触摸状态,同时将获取到的触摸坐标和触摸状态在不同的 label 中以文本的方式显示出来,获取到的触摸坐标同时赋给了鼠标图片,让鼠标跟随触摸移动。

具体代码如下,代码中用到了任务系统去实时获取触摸,任务系统的用法在Giraffe API使用说明文档中已有介绍,具体位置在第6章定时任务,此处不再赘述。具体的使用还要用户根据实际情况自行决定。

c
void touch_task(grf_task_t *task_t)
{
	grf_touch_t touch_t = {0};
	grf_touch_get(&touch_t);
	u8 touchbuf[10] = {0};
	sprintf(touchbuf,"(%d,%d)",touch_t.touch_x,touch_t.touch_y);
	grf_ctrl_t* touch_label0 = grf_ctrl_get_form_id(GRF_VIEW1_ID,VIEW1_LABEL0_ID);
	grf_label_set_txt(touch_label0,touchbuf);
	grf_ctrl_t* touch_label3 = grf_ctrl_get_form_id(GRF_VIEW1_ID,VIEW1_LABEL3_ID);
	if(touch_t.t_state == GRF_TOUCH_UP){
		grf_label_set_txt(touch_label3,"up");
	}else{
		grf_label_set_txt(touch_label3,"down");
	}
	grf_ctrl_t* img = grf_ctrl_get_form_id(GRF_VIEW1_ID,VIEW1_IMAGE0_ID);
	grf_ctrl_set_pos(img,touch_t.touch_x,touch_t.touch_y);
}

void view_create_time_task(void)
{
	grf_task_create(touch_task,10,NULL);
}

3. UART相关函数 ​

3.1串口打开 ​

c
grf_drv_t* grf_drv_uart_open(grf_uart_cfg_t cfg_t);

cfg_t :要打开的串口对象

返回值:设备句柄

串口参数结构体如下:

c
typedef struct 
{
    s32 win_port;               //电脑端口号
    s32 port;                   //IC 端口号,-1为默认端口
    grf_uart_speed_e speed_e;   //波特率
    grf_uart_bit_e bit_e;       //数据位
    grf_uart_parity_e parity_e; //奇偶校验位
    grf_uart_stop_e stop_e;     //停止位
}grf_uart_cfg_t;

相关枚举如下:

c
typedef enum{
    UART_SPEED_2400,
    UART_SPEED_4800,
    UART_SPEED_9600,
    UART_SPEED_19200,
    UART_SPEED_38400,
    UART_SPEED_57600,
    UART_SPEED_115200,
    UART_SPEED_230400,
    UART_SPEED_460800,
    UART_SPEED_500000,
    UART_SPEED_576000,
    UART_SPEED_921600
}grf_uart_speed_e;
typedef enum{
    UART_BIT_7,
    UART_BIT_8
}grf_uart_bit_e;
typedef enum{
    UART_PARITY_NONE,
    UART_PARITY_ODD,
    UART_PARITY_EVEN
}grf_uart_parity_e;
typedef enum{
    UART_STOP_1,
    UART_STOP_2
}grf_uart_stop_e;

3.2串口关闭 ​

c
s32 grf_drv_uart_close(grf_drv_t *drv_t);

drv_t : 设备句柄

返回值:成功返回 GRF_OK ,失败返回 GRF_FAIL

3.3串口发送 ​

c
s32 grf_drv_uart_send(grf_drv_t *drv_t,char* databuf, int datalen);

drv_t : 设备句柄

databuf :要发送的数据地址

datalen :要发送的数据长度

返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL

3.4串口接收中断 ​

3.4.1串口接收中断服务函数 ​

c
typedef void (*uart_rev_bfun)(u8* databuf,u32 datalen);

databuf :接收数据的地址

datalen :接收数据的长度

返回值:无

串口接收中断服务函数用于编写串口接收中断的处理逻辑

3.4.2启用串口接收中断服务函数 ​

c
s32 grf_drv_uart_rev_set_bfun(grf_drv_t *drv_t,uart_rev_bfun rev_bfun,u32 max_len);

drv_t : 设备句柄

rev_bfun :串口接收中断服务函数

max_len :一次接收数据的最大值

返回值:成功返回 GRF_OK ,失败返回 GRF_FAIL

在Giraffe IDE软件中,串口相关的函数已经全部写好,用户直接从上位机项目工程处新建giraffe硬件文件即可一键添加,添加后的硬件文件包括串口部分和看门狗部分代码,用户可以直接调用。

添加过后只需在 grf_hw_init() 硬件初始化函数中打开 grf_uart_init() 函数即可,串口相关参数需要在串口初始化函数中设置好,端口号默认为3,串口端口号要与自己所用设备硬件匹配。

串口初始化之后,需要根据自己定义的协议设置对应寄存器的地址、键值等信息,设置好之后在 grf_reg_set_user 函数中编写相关接收逻辑即可。

添加串口相关代码如下:

c
#include "../grf_hw.h"
#if GRF_HW_ENABLE
#include "grf_hw_uart.h"

static grf_drv_t *drv_uart = NULL;


//用户编写串口逻辑函数
//addr:寄存器地址
//data:寄存器数据,数据从首地址依次获取
//datalen:接收数据长度

void grf_reg_set_user(u16 addr,u16* data,u8 datalen)
{
    //user code 
}


#define HEAD_FH 0x5A
#define HEAD_FL 0xA5
#define REG_LEN 0x800 
static u16 ctrlreg[REG_LEN] = {0};

//设置寄存器数据
//addr:要设置的寄存器地址
//data:要设置的数据
s32 grf_reg_set(u16 addr,u16 data)
{
    if(addr>REG_LEN){
        return GRF_FAIL;
    }
    ctrlreg[addr] = data;
    // grf_printf("set reg %04X = %04X\n",addr,data);
    return GRF_OK;
}

//获取寄存器数据
//addr:要获取的寄存器地址
s32 grf_reg_get(u16 addr)
{
    if(addr>REG_LEN){
        return GRF_FAIL;
    }
    // grf_printf("get reg %04X = %04X\n",addr,ctrlreg[addr]);
    return ctrlreg[addr];
}
//*********write reg********** 
//TX - FH FL len cmd addr data0 data1
//     5A A5 07  82  0001 FFFF  FFFF
//RX - 无

//*********read reg********** 
//TX -  FH FL len cmd addr reglen
//      5A A5 04  83  0001  02
//RX -  FH FL len cmd addr reglen data0 data1
//      5A A5 08  83  0001  02    FFFF  FFFF

static s32 grf_reg_s_set(u16 addr,u8* data,u8 len)
{
    if(addr>REG_LEN){
        return GRF_FAIL;
    }
    u8 i=0;
    for(i=0;i<len;i++){
        ctrlreg[addr+i] = (data[i*2]<<8)+data[i*2+1];
        // grf_printf("reg_s_set %04X = %04X\n",addr+i,ctrlreg[addr+i]);
        grf_reg_set_user(addr,ctrlreg+addr+i,1);
    }
    return GRF_OK;
}

//寄存器发送函数
//addr:要发送的寄存器地址
//len:要发送的数据长度
s32 grf_reg_com_send(u16 addr,u16 len)
{
    u8 txdata[257] = {0};
    u32 i=0,j=0;
    txdata[i++] = HEAD_FH;
    txdata[i++] = HEAD_FL;
    txdata[i++] = len*2+4;
    txdata[i++] = 0x83;
    txdata[i++] = addr>>8;
    txdata[i++] = (addr&0x00ff);
    txdata[i++] = len;
    for(j=0;j<len;j++){
        txdata[i++] = (ctrlreg[addr+j]>>8);
        txdata[i++] = (ctrlreg[addr+j]&0x00ff);
    }
    grf_drv_uart_send(drv_uart,txdata,i);
}

//指令解析函数
static s32 grf_comm_handle(u8* data)
{
	u8 cmd = data[3];
	u8 len = data[2];
    u16 addr = (data[4]<<8)+data[5];
    u32 i=0;
    if(addr>REG_LEN){
        return GRF_FAIL;
    }
//    grf_printf("cmd=%x\n",cmd);
    switch (cmd)
    {
        case 0x82: //写寄存器
        {
            u32 regcount = (len-3)>>1;
            grf_reg_s_set(addr,data+6,regcount);
        }
        break;
        case 0x83: //读寄存器
        	grf_reg_com_send(addr,data[6]);
        break;
    }
    return GRF_OK;
}

#define UART_LASTBUFF 1
#if UART_LASTBUFF
#define RX_BUF_LEN   1024
static u8 RX_HAND_BUF[RX_BUF_LEN];
#endif

//串口接收中断服务函数
//databuf:接收的数据
//datalen:接收数据的长度
static void recive_data_handle(u8* databuf,u32 datalen)
{
	u16 i=0;
	static u16 last_data_num=0;
#if UART_LASTBUFF
	if(last_data_num + datalen > RX_BUF_LEN){
		datalen = datalen-last_data_num;
	}
	if(last_data_num){ 
		memcpy(RX_HAND_BUF+last_data_num,databuf,datalen);
		databuf=RX_HAND_BUF;
		datalen+=last_data_num;
		last_data_num = 0;
	}
#endif
#if 1
    grf_printf("uart rx[%d]:",datalen);
	for(i=0;i<datalen;i++){
		grf_printf(" %02X",databuf[i]);
	}
	grf_printf("\n",datalen);
#endif
	if(datalen>=6){//最短的指令为6个
		for(i=0;i<=datalen-6;i++)
        {
			if((databuf[i]==HEAD_FH) && (databuf[i+1]==HEAD_FL))
			{
    			if(databuf[i+2] <= (datalen-i-3)){
                    if(grf_comm_handle(databuf+i)==GRF_OK){
                        i += (databuf[i+2]+3)-1;
                    }
    			}
		        else{
                    last_data_num = datalen-i;
                    break;
		        }
			}
		}
	}
	else{
		last_data_num = datalen;
	}
#if UART_LASTBUFF
	if(last_data_num<=256 && last_data_num!=0)
	{
		u8  last_data_buf[256] = {0};
		memcpy(last_data_buf,databuf+i,last_data_num);
		memcpy(RX_HAND_BUF,last_data_buf,last_data_num);
	}else{
		last_data_num=0;
	}
#else
	last_data_num = 0;
#endif
}

//串口初始化函数
void grf_uart_init(void)
{
    grf_uart_cfg_t cfg_t = {0};
    cfg_t.port = 3;//IC 端口号
    cfg_t.win_port = 2;//电脑端口号
    cfg_t.speed_e = UART_SPEED_115200;
    cfg_t.bit_e = UART_BIT_8;
    cfg_t.parity_e = UART_PARITY_NONE;
    cfg_t.stop_e = UART_STOP_1;
    drv_uart = grf_drv_uart_open(cfg_t);
    if(drv_uart){
        grf_drv_uart_rev_set_bfun(drv_uart,recive_data_handle,1024);
    }
}

4.WDT相关函数 ​

4.1打开看门狗 ​

c
s32 grf_wdt_open(void);

返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL

4.2关闭看门狗 ​

c
s32 grf_wdt_close(void);

返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL

4.3设置看门狗超时时间 ​

c
s32 grf_wdt_set_timeout(u32 time);

time:超时时间,单位秒

返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL

4.4刷新看门狗时间(喂狗) ​

c
s32 grf_wdt_keepalive(void);

返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL

添加看门狗硬件文件代码如下:

c
#include "../grf_hw.h"
#if GRF_HW_ENABLE
#include "grf_hw_wdt.h"

void grf_wdt_task_cb(grf_task_t *task_t)
{
    grf_wdt_keepalive();
}

grf_task_t *wdt_task_t = NULL;
void grf_wdt_task_create(void)
{
    if(wdt_task_t==NULL){
        wdt_task_t = grf_task_create(grf_wdt_task_cb,500,NULL);
        grf_wdt_set_timeout(5);
        grf_wdt_open();
    }
}

#endif

看门狗任务执行周期500ms,即500ms喂一次狗,超时时间5S,异常超过5s系统自动重启。

添加后的代码已经写好,用户直接将 grf_hw.c 初始化函数里面的看门狗任务打开即可使用,具体如下:

c
#include "grf_hw.h"
void grf_hw_init(void)
{
	grf_wdt_task_create();
}

5.GPIO相关函数 ​

5.1GPIO初始化函数 ​

c
s32 grf_gpio_init(grf_gpio_para_t* para_t);

para_t :要初始化的 gpio结构体 变量

返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL

5.2设置GPIO引脚 ​

c
s32 grf_gpio_setPin(u8 gpio_group,u8 gpio_pin,u8 value);

gpio_group :gpio端口

gpio_pin :gpio引脚

value :引脚电平,0:低电平 1:高电平

返回值:成功返回 GRF_OK ,失败返回 GRF_FAIL

5.3获取输入引脚电平 ​

c
s32 grf_gpio_readInputPin(u8 gpio_group,u8 gpio_pin);

gpio_group :gpio端口

gpio_pin :gpio引脚

返回值:成功返回获取 引脚电平 ,失败返回 GRF_FAIL

5.4获取输出引脚电平 ​

c
s32 grf_gpio_readOutputPin(u8 gpio_group,u8 gpio_pin);

gpio_group :gpio端口

gpio_pin :gpio引脚

返回值:成功返回获取引脚电平,失败返回 GRF_FAIL

5.5设置GPIO中断 ​

c
s32 grf_gpio_group_set_irq(grf_gpio_irq_para_t irq_para_t);

irq_para_t :要配置的中断结构体变量

返回值:成功返回 GRF_OK ,失败返回 GRF_FAIL

5.6获取中断引脚 ​

c
s32 grf_gpio_group_get_irq_pin(grf_gpio_irq_t *irq_t);

irq_t :中断结构体变量

返回值:成功返回获取 gpio引脚号 ,失败返回 GRF_FAIL

5.7获取中断模式 ​

c
s32 grf_gpio_group_get_irq_mode(grf_gpio_irq_t *irq_t);

irq_t :中断结构体变量

返回值:成功返回获取的 gpio中断模式 ,失败返回 GRF_FAIL

添加GPIO相关代码如下:

c

#include "../grf_hw.h"
#if GRF_HW_ENABLE
#include "grf_hw_gpio.h"


//配置
void gpio_set_data_test(void)
{
    grf_gpio_para_t gpio_para = {0};
    gpio_para.gpio_group = 4;
    gpio_para.gpio_pin = 18;
    gpio_para.gpio_mode = GRF_GPIO_OUTPUT;
    grf_gpio_init(&gpio_para);

    while (1)
    {
        grf_gpio_setPin(4,18,1);
        grf_printf("set pin 1\n");
        grf_delay(500);

        grf_gpio_setPin(4,18,0);
        grf_printf("set pin 0\n");
        grf_delay(500);
    }
}

//读取
void gpio_get_data_test(void)
{
    grf_gpio_para_t gpio_para = {0};
    gpio_para.gpio_group = 4;
    gpio_para.gpio_pin = 0;
    gpio_para.gpio_mode = GRF_GPIO_INPUT;
    grf_gpio_init(&gpio_para);
    while (1)
    {
        u8 pinvalue=grf_gpio_readInputPin(4,0);
        grf_printf("Get pin value=%d\n",pinvalue);
        grf_delay(100);
    }
}

//按键中断例程
typedef enum {
    KEY_UP,
    KEY_DOWN,

    KEY_DOWN_LONG,
    KEY_NO
}key_state_e;
typedef struct  
{
    key_state_e key_state;
    u32 key_time;
  
    key_state_e last_key_state;
}key_param_t;
key_param_t key_para[2] = {0};
void irq_task_test1(grf_gpio_irq_t *irq_t)
{
    u8 irq_pin = grf_gpio_group_get_irq_pin(irq_t);
    u8 irq_mode = grf_gpio_group_get_irq_mode(irq_t);
    // grf_printf("irq_pin = %d irq_mode=%d \n",irq_pin,irq_mode);
    switch (irq_pin)
    {
        case 0://PE 0 IRQ 中断
            if(irq_mode == GRF_GPIO_IRQ_RISING){
                key_para[0].key_state = KEY_DOWN;
                key_para[0].key_time = grf_sys_time_ms();
            }
            else{
                key_para[0].key_state = KEY_UP;
                key_para[0].key_time = grf_sys_time_ms();
            }
        break;
        case 1://PE 1 IRQ 中断
            if(irq_mode == GRF_GPIO_IRQ_RISING){
                key_para[1].key_state = KEY_DOWN;
                key_para[1].key_time = grf_sys_time_ms();
            }
            else{
                key_para[1].key_state = KEY_UP;
                key_para[1].key_time = grf_sys_time_ms();
            }
        break;
  
    default:
        break;
    }
}
static key_state_e key_get_state(key_param_t *key_para)
{
    key_state_e state_e = KEY_NO;
    if(key_para->key_state == KEY_DOWN){
        u32 cur_time = grf_sys_time_ms();
        u32 key_time = key_para->key_time;
        if(cur_time>key_time && cur_time-key_time>10){ //10ms抖动
            key_para->last_key_state = KEY_DOWN;
            state_e = KEY_DOWN;
            if(cur_time-key_time>2000){//2s长按
                state_e = KEY_DOWN_LONG;
            }
        }
    }
    else{
        if(key_para->key_state == KEY_UP && key_para->last_key_state == KEY_DOWN){
            state_e = KEY_UP;
            key_para->last_key_state = KEY_UP;
        }
    }
    return state_e;
}
static void irq_task_cb_t(grf_task_t *task_t)
{
    key_state_e state_e = key_get_state(&key_para[0]);
    if(state_e!=KEY_NO){
        grf_printf("KEY 0 state_e=%d \n",state_e);
    }
    state_e = key_get_state(&key_para[1]);
    if(state_e!=KEY_NO){
        grf_printf("KEY 1 state_e=%d \n",state_e);
    }
}

void gpio_irq_test(void)
{
    grf_gpio_irq_para_t irq_para_t = {0};
    u8 pins[2] = {0,1};//PE0,PE1
    irq_para_t.irq_group = GRF_GPIO_GROUP_E;
    irq_para_t.irq_pins = pins;
    irq_para_t.gpio_pin_num = 2;
    irq_para_t.mode_e = GRF_GPIO_IRQ_RISING_FALLING;//上升沿中断
    irq_para_t.irq_task = irq_task_test1;
    s32 ret = grf_gpio_group_set_irq(irq_para_t);
    grf_printf("ret=%d\n",ret);

    grf_task_create(irq_task_cb_t, 10,NULL);
}

void grf_gpio_test(u8 cmd)
{
    switch (cmd)
    {
        case SET_GPIO_TEST:
            gpio_set_data_test();
            break;
        case GET_GPIO_TEST:
            gpio_get_data_test();
            break;
        case GPIO_IRQ_TEST:
            gpio_irq_test();
            break;  
        default:
            break;
    }

}

#endif

6.RTC相关函数 ​

6.1设置RTC ​

c
s32 grf_rtc_set_time(grf_rtc_time_t* rtc_t);

rtc_t :RTC结构体变量

返回值:成功返回 GRF_OK,失败返回 GRF_FAIL

6.2获取RTC ​

c
s32 grf_rtc_get_time(grf_rtc_time_t* rtc_t);

rtc_t :RTC结构体变量

返回值:成功返回 GRF_OK ,失败返回 GRF_FAIL

结构体变量如下:

c
typedef  struct 
{
    u16 year;//年,1900-2099
    u8 month;//月,1-12
    u8 day;//日
    u8 hour;//时
    u8 minute;//分
    u8 second;//秒
}grf_rtc_time_t;

添加RTC相关代码如下:

c

#include "../grf_hw.h"
#if GRF_HW_ENABLE
#include "grf_hw_rtc.h"

//获取时间
static void get_rtc_time(void)
{
    grf_rtc_time_t rtc_t = {0};
    grf_rtc_get_time(&rtc_t);
    grf_printf("get y=%d m=%d d=%d h=%d m=%d s=%d \n",rtc_t.year,rtc_t.month,rtc_t.day,rtc_t.hour,rtc_t.minute,rtc_t.second);
}

//设置时间
void set_rtc_time(void) 
{
    grf_rtc_time_t rtc_t = {0};
    rtc_t.year = 2023;//年
    rtc_t.month = 4;        //月
    rtc_t.day = 5;          //日
    rtc_t.hour = 6;         //时
    rtc_t.minute = 7;       //分
    rtc_t.second = 8;       //秒   
    grf_rtc_set_time(&rtc_t);
    grf_printf("set y=%d m=%d d=%d h=%d m=%d s=%d \n",rtc_t.year,rtc_t.month,rtc_t.day,rtc_t.hour,rtc_t.minute,rtc_t.second);	  
}

void grf_rtc_test_task_cb(grf_task_t *task_t)
{
    get_rtc_time();
}

void grf_rtc_test(void)
{
    get_rtc_time();
    grf_delay(500);
    set_rtc_time();
    grf_task_create(grf_rtc_test_task_cb,500,NULL);
}


#endif

7.FLASH相关函数 ​

c
u8 *grf_dir_get_ddisk();

返回值:返回获取到的文件路径

7.2获取TF卡文件路径 ​

c
u8 *grf_dir_get_tfdisk();

返回值:返回获取到的文件路径

7.3获取U盘文件路径 ​

c
u8 *grf_dir_get_udisk();

返回值:返回获取到的文件路径

添加FLASH相关代码如下:

c
#include "../grf_hw.h"
#if GRF_HW_ENABLE
#include "grf_hw_flash.h"

#define BINFILE   "grf_data.bin" 

//字符串拼接
s32 ConnectStr(char * dest,int len, const char * str1, const char * str2) 
{
	if (!dest || len < 1) return GRF_FAIL;
	int pos = 0;
	memset(dest,0,len);
	strcat(dest,str1);
	strcat(dest,str2);
	return GRF_OK;
}

/*
*函 数 名:u32 grf_flash_write_Data(__u8 type,u32 addr,__u8* databuf,u32 len)
*功能说明:向flash(grf_data.bin)中写入数据
*形     参:
	type – 存储设备类型,0:flash 1:TF 卡 2:U 盘
	addr – 写入数据首地址(0-0xFFFFFFFF)
	databuf – 需存储写入的数据缓冲区
	len – 写入数据长度,单位字节
*返 回 值:实际读取的字节数
*/
u32 flash_write_Data(u8 type,u32 addr,u8* databuf,u32 len)
{
    char wfilename[256] = {0};
	u8* pathtype = NULL;
	s8 ret = 0;
	u32 reallen = 0;

	//选择路径
	if(type==1){
        pathtype = grf_dir_get_ddisk();
        ConnectStr(wfilename,256,pathtype,BINFILE);
	}
	else if(type==2){
        pathtype = grf_dir_get_tfdisk();
        ConnectStr(wfilename,256,pathtype,BINFILE); 
	}
	else{
        pathtype = grf_dir_get_udisk();
        ConnectStr(wfilename,256,pathtype,BINFILE);
	}
	// grf_printf("wfilename=%s\n",wfilename);
	if(wfilename[0]!=0)
	{
		FILE*   datafp=NULL;
		datafp = fopen(wfilename,"r+b");
		if(datafp == NULL){
        //首先认为文件没有创建
			datafp = fopen(wfilename,"wb");
		}
		if(datafp==NULL)
		{
			printf("create grf_data.bin fail\n");
	        goto __err;
		}
		ret = fseek(datafp,addr,SEEK_SET);
		//grf_printf("ret=%d\n",ret);
		if(ret!=0){//如果写入的地址超过了文件的总大小,先用0扩大文件,然后再写入数据
			u32 endlen,offset;
			void *data_p;
			fseek(datafp,0,SEEK_END);
			endlen = ftell(datafp);
			offset = addr-endlen;
			data_p = malloc(offset);
			memset(data_p,0, offset);
			fwrite(data_p,1,offset,datafp);
			free(data_p);
			//grf_printf("endlen=%d offset=%d \n",endlen,offset);
		}
		reallen = fwrite(databuf,1,len,datafp);
		fclose(datafp);
	}
__err:
	return reallen;
}

/*
*函 数 名:u32 grf_flash_read_Data(__u8 type,u32 addr,__u8* databuf,u32 len)
*功能说明:向flash(grf_data.bin)中读取数据
*形     参:
	type – 存储设备类型,0:flash 1:TF 卡 2:U 盘
	addr – 读取数据首地址(0-0xFFFFFFFF)
	databuf – 需存储读取的数据缓冲区
	len – 读取数据长度,单位字节
*返 回 值:实际写入的字节数
*/
u32 flash_read_Data(u8 type,u32 addr,u8* databuf,u32 len)
{
    char rfilename[256];
	s8 ret = 0;
	u32 reallen = 0;
    memset(rfilename,0,256);
	//选择路径
	if(type==1){
        u8* pathtype = grf_dir_get_ddisk();
        ConnectStr(rfilename,64,pathtype,BINFILE);
	}
	else if(type==2){
        u8* pathtype = grf_dir_get_tfdisk();
        ConnectStr(rfilename,64,pathtype,BINFILE); 
	}
	else{
        u8* pathtype = grf_dir_get_udisk();
        ConnectStr(rfilename,64,pathtype,BINFILE);
	}
	// grf_printf("rfilename=%s\n",rfilename);
	{
		FILE*   datafp=NULL;
		datafp = fopen(rfilename,"rb");
		if(datafp==NULL)
		{
			grf_printf("open grf_data.bin fail\n");
	        goto __err;
		}
		ret =fseek(datafp,addr,SEEK_SET);
		if(ret==0){//寻址成功
			reallen = fread(databuf,1,len,datafp);
		}
		else{
			grf_printf("The location exceeds the file size,addr=0x%04x\n",addr);
		}
		fclose(datafp);
	}
__err:
	return reallen;
}

#endif

8.SPI相关函数 ​

8.1 SPI打开 ​

c
grf_drv_t* grf_spi_open(grf_spi_para_t *para_t);

para_t :要打开的SPI结构体变量

返回值:设备句柄

SPI结构体如下:

c
typedef struct
{
  u32   port;       //端口号
  u32	work_clk;   //总线速率 单位:HZ
  u32   work_mode;  //SPI工作模式 
  u8	nbits;      //位数
  u16	delay;      //发送时间间隔   
}grf_spi_para_t;
c
work_mode:
#define SPI_WORK_MODE0		(0|0)			    //上升沿采样,下降沿发送
#define SPI_WORK_MODE1		(0|SPI_CPHA)	    //上升沿发送,下降沿采样
#define SPI_WORK_MODE2		(SPI_CPOL|0)	    //上升沿发送,下降沿采样
#define SPI_WORK_MODE3		(SPI_CPOL|SPI_CPHA) //上升沿采样,下降沿发送

8.2 SPI传输接口 ​

c
s32 grf_spi_transfer(grf_drv_t* drv_t,u8 *tx,u32 tx_len,u8 *rx,u32 rx_len);

drv_t : 设备句柄

tx :数据发送缓冲区地址

tx_len : 发送数据长度

rx :数据接收缓冲区地址

len :接收数据长度

返回值:成功返回GRF_OK,失败返回GRF_FAIL

8.3 SPI关闭 ​

c
s32 grf_spi_close(grf_drv_t *drv_t);

drv_t :设备句柄

返回值:成功返回GRF_OK,失败返回GRF_FAIL

添加SPI相关代码如下:

c

#include "../grf_hw.h"
#if GRF_HW_ENABLE
#include "grf_hw_spi.h" 

static grf_drv_t *drv_spi = NULL;

void grf_spi_test(void)
{
    grf_spi_para_t para_t;   
    u8 tx_buf[10] = {0,1,2,3,4,5,6,7,8,9};
    u8 rx_buf[10] ={0}; 
    int i=0;   
    para_t.port = 1;  
    para_t.work_mode = SPI_WORK_MODE3;
    para_t.work_clk = 50*100*100;  
    para_t.nbits = 8;
    para_t.delay = 0;
	drv_spi = grf_spi_open(&para_t);
    grf_spi_transfer(drv_spi,tx_buf,10,rx_buf,10);
    for(i=0;i<sizeof(tx_buf);i++){
        grf_printf("readdata[%d]=%x\n", i,rx_buf[i]);   
    }  
}
   
#endif

9.IIC相关函数 ​

9.1 IIC打开 ​

c
grf_drv_t* grf_iic_open(grf_iic_para_t* para_t);

para_t :要打开的IIC结构体变量

返回值:设备句柄

IIC结构体如下:

c
typedef struct
{
    u32     port;            //端口号
    u8      slave_addr;      //设备地址
    u8      reg_addr;        //寄存器地址
    u8      reg_addr_width;  //寄存器字节个数
}grf_iic_para_t;

9.2 IIC读数据 ​

c
s32 grf_iic_read(grf_drv_t* drv_t,u16 addr,u8 *buff,u16 len);

drv_t : 设备句柄

addr :要读取的设备地址

buff :接收数据缓冲区

len :读取数据长度

返回值:实际读取的字节数

9.3 IIC写数据 ​

c
s32 grf_iic_write(grf_drv_t* drv_t,u16 addr,u8 *buff,u16 len);

drv_t : 设备句柄

addr :要写入的设备地址

buff :发送数据缓冲区

len :发送数据长度

返回值:实际写入的字节数

9.4 IIC关闭 ​

c
s32 grf_iic_close(grf_drv_t *drv_t);

drv_t : 设备句柄

返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL

添加IIC相关代码如下:

c

#include "../grf_hw.h"
#if GRF_HW_ENABLE
#include "grf_hw_iic.h"

static grf_drv_t *drv_iic = NULL;
grf_task_t *iic_rtc_task = NULL;

u8 bcd_to_dec(u8 bcd)
{
    bcd = bcd & 0x7f;
    return ((bcd & 0xF0) >> 4) * 10 + (bcd & 0x0F);
}

u8 dec_to_bcd(u8 dec) {
    return ((dec / 10) << 4) | (dec % 10);
}
 
void iic_rtc_task_cb(grf_task_t *task_t)
{
    u8 rbuff[10]={0};
    grf_iic_read(drv_iic,0x02,rbuff,10);
    u8 second = bcd_to_dec(rbuff[0]);
    u8 minute = bcd_to_dec(rbuff[1]);
    u8 hour = bcd_to_dec(rbuff[2]);
    u8 day = bcd_to_dec(rbuff[3]);
    u8 month = bcd_to_dec(rbuff[5]);
    u8 year = bcd_to_dec(rbuff[6]);

    grf_printf("iic rtc time = %04d/%02d/%02d %02d:%02d:%02d \n",year+2000,month,day,hour,minute,second);
}
static void iic_rtc_set(void)
{
    u8 rbuff[10]={0};
    rbuff[0] = dec_to_bcd(10);            //second
    rbuff[1] = dec_to_bcd(13);            //minute
    rbuff[2] = dec_to_bcd(17);            //hour
    rbuff[3] = dec_to_bcd(30);            //day
    rbuff[5] = dec_to_bcd(5);             //month
    rbuff[6] = dec_to_bcd(2024-2000);     //year
    grf_iic_write(drv_iic,0x02,rbuff,7);
}
void grf_iic_test(void)
{
	if(iic_rtc_task == NULL){
  
        grf_iic_para_t para_t={0};
        para_t.port=0;
        para_t.slave_addr =0x51;
        para_t.reg_addr_width=1;
        drv_iic = grf_iic_open(&para_t);
        iic_rtc_set();
		iic_rtc_task = grf_task_create(iic_rtc_task_cb,500,NULL);
	}
}
#endif

10.PWM相关函数 ​

10.1 PWM打开 ​

c
grf_drv_t* grf_pwm_open(grf_pwm_para_t* para_t);

para_t :要打开的PWM结构体变量

PWM结构体如下:

c
typedef struct
{
    u32     channel;        //pwm通道
    u32     period_time;    //周期 单位:ns
    u32     pulse_time;     //脉冲时间 单位:ns
}grf_pwm_para_t;

10.2 PWM启动 ​

c
s32 grf_pwm_start(grf_drv_t *drv_t);

drv_t : 设备句柄

返回值:成功返回GRF_OK,失败返回GRF_FAIL

10.3 设置PWM ​

c
s32 grf_pwm_set(grf_drv_t *drv_t,u32 period_time,u32 pulse_time);

drv_t : 设备句柄

period_time :周期

pulse_time :脉宽

返回值:成功返回GRF_OK,失败返回GRF_FAIL

10.4 PWM终止 ​

c
s32 grf_pwm_stop(grf_drv_t *drv_t);

drv_t : 设备句柄

返回值:成功返回GRF_OK,失败返回GRF_FAIL

10.5 PWM关闭 ​

c
s32 grf_pwm_close(grf_drv_t *drv_t);

drv_t : 设备句柄

返回值:成功返回 GRF_OK ,失败返回 GRF_FAIL

添加PWM相关代码如下:

c

#include "../grf_hw.h"
#if GRF_HW_ENABLE
#include "grf_hw_pwm.h"
static grf_drv_t* pwm_drv = NULL;
grf_task_t *pwm_task_t = NULL;
void grf_pwm_task_cb(grf_task_t *task_t)
{
    static u8 flag = 0;
    static u8 value = 0;
    if(!flag){
         value+=2;
         if(value >= 100){
            flag = 1;
         }
    }
    else{
        value-=2;
        if(value == 0){
            flag = 0;
        }
    }
    grf_printf("pwm=%d\n",value);
    grf_pwm_set(pwm_drv,1000,10*value);
}


void grf_pwm_test(void)
{
    if(pwm_task_t==NULL){
        grf_pwm_para_t para_t;
        para_t.channel = 1;
        para_t.period_time = 1000;
        para_t.pulse_time = 0;
        pwm_drv = grf_pwm_open(&para_t);
        grf_pwm_start(pwm_drv);

        pwm_task_t = grf_task_create(grf_pwm_task_cb,10,NULL);
    }
}

#endif

11.网络使用说明 ​

目前仅支持TR660 linux 平台

本章节主要讲解在Giraffe中如何适配网络驱动,Giraffe目前在硬件上只适配了以太网和WIFi,应用层协议上只有HTTP 和 MQTT ;其他应用层协议和蓝牙硬件后面会逐步完善。

11.1 测试环境(IDE 1.2.10及以上版本) ​

固件版本:2024年8月后

支持以太网/WIFI的TR660 Linux板子

Giraffe SDK 版本: 1.2.10及以上版本

源码链接: 下载

11.1.1 拷贝动态库驱动 ​

将tr6_libs 文件夹 和 init.d 文件夹 拷贝至 Giraffe 项目的res文件夹下

image

再次将lib文件夹下的文件,拷贝至 Giraffe 安装目录下 ~/platform/tr660/usr/lib/(lib 文件夹在tr6_libs文件夹内)

11.1.2 拷贝硬件参数API函数 ​

11.1.2.1 将net文件夹拷贝至Giraffe 项目的apps/hardware/ 目录下 ​

image

11.1.2.2 修改apps/hardware/grf_hw.h 头文件添加头文件包含 ​

修改后的文件:

c
#ifndef __GRF_HW_H_
#define __GRF_HW_H_



#include "../../inc/grf_apis.h"
#define GRF_HW_ENABLE  1




//以下.h自动添加
#include "../apps.h"
#include "uart/grf_hw_uart.h"
#include "wdt/grf_hw_wdt.h"
#include "net/hw_net.h"




void grf_hw_init(void);

#endif

11.1.3 修改apps/hardware/net/hw_net.h ​

根据编译需要修改包含的头文件 (iperf/curl/matt)

image

至此网络编译环境搭建成功,(Giraffe SDK 版本: 1.2.10及以上版本不需要修改编译选项)

11.2 添加网络库(1.2.10 以下版本) ​

固件版本:2024年8月后

支持以太网/WIFI的TR660 Linux板子

Giraffe IDE 版本: 1.2.10 以下版本

(对于1.2.10及以上版本详见1.2.10及以上版本)

源码链接: http://download.giraffeide.com/net-server/net.zip

11.2.1 拷贝动态库驱动 ​

将lib 文件夹 和 init.d 文件夹 拷贝至 Giraffe 项目的res文件夹下

image

11.2.2 再次将lib文件夹下的文件,拷贝至 Giraffe 安装目录下 ~/platform/tr660/usr/lib/ ​

11.2.3 拷贝硬件参数API函数 ​

11.2.3.1 将net文件夹拷贝至Giraffe 项目的apps/hardware/ 目录下 ​

image

11.2.3.2 修改apps/hardware/grf_hw.h 头文件添加头文件包含 ​

修改后的文件:

c
#ifndef __GRF_HW_H_
#define __GRF_HW_H_



#include "../../inc/grf_apis.h"
#define GRF_HW_ENABLE  1




//以下.h自动添加
#include "../apps.h"
#include "uart/grf_hw_uart.h"
#include "wdt/grf_hw_wdt.h"
#include "net/hw_net.h"




void grf_hw_init(void);

#endif
11.2.3 修改apps/hardware/net/hw_net.h ​

根据编译需要修改包含的头文件 (iperf/curl/matt)

image

11.2.4 修改编译选项 ​

修改Giraffe SDK 安装目录下 ~/platform/tr660/Makefile

makefile
#连接库
#LIBFLAGS = -lgrfui -lmingw32 -lSDL2main -lSDL2 -lfreetype-6
LIBFLAGS = -ltr660grfui -lts -lm -lz -lfaad -lmad -lmpp_base -lmpp_decoder -lmpp_encoder -lmpp_ge -lmpp_ve -lopenmax_base -lopenmax -lmedia_player -lasound -lmpp_audio_decoder -lpthread -lfreetype

添加 -lssl -lmosquitto -lcrypto -lcurl ,修改结果为

makefile
#连接库
#LIBFLAGS = -lgrfui -lmingw32 -lSDL2main -lSDL2 -lfreetype-6
LIBFLAGS = -ltr660grfui -lts -lm -lz -lfaad -lmad -lmpp_base -lmpp_decoder -lmpp_encoder -lmpp_ge -lmpp_ve -lopenmax_base -lopenmax -lmedia_player -lasound -lmpp_audio_decoder -lpthread -lfreetype -lssl -lmosquitto -lcrypto -lcurl

此处修改需要注意,Makefile 修改后,当编译普通TR660工程时(即屏幕硬件不支持网络的TR660工程),此时也会链接网络相关库文件,下载进去后,导致因为缺少库文件无法运行,需要删除添加项:-lssl -lmosquitto -lcrypto -lcurl后才能正常运行。

至此网络编译环境搭建成功,可以正常编译mqtt和http代码

11.3. wifi/以太网参数配置 API 说明 ​

11.3.1 以太网静态IP配置函数 ​

c
void eth_setting_static_ip(char* ipaddr,char* netmask,char* getway,char* dnsserver);

ipaddr : IP地址
netmask :子网掩码
getway :网关地址
dnsserver :DNS服务器地址
返回值 :无

11.3.2 以太网DHCP使能函数 ​

c
void eth_dhcp_enable(void);

返回值 :无

11.3.3 WIFI 账号 密码配置函数 ​

c
void wlan_setting_account(char* ssid,char* passwd);

ssid :无线网账号
passwd :无线网密码
返回值 :无

11.3.4 WIFI_DHCP使能函数 ​

c
void wlan_dhcp_enable(void);

返回值 :无

11.3.5 WIFI_静态IP配置函数 ​

c
void wlan_setting_static_ip(char* ipaddr,char* netmask,char* getway,char* dnsserver);

ipaddr : IP地址
netmask :子网掩码
getway :网关地址
dnsserver :DNS服务器地址
返回值 :无

11.3.6 网络测试demo ​

c
void net_test(void);

USING_WLAN0 宏定义打开时 配置wifi信息 USING_ETH0 宏定义打开时 配置以太网信息

11.3.7 打开网卡 ​

c
int open_netif(const char* netifname);

netifname : 网卡名称

返回值 : 0 操作成功

11.3.8 检测网卡IP地址 ​

c
int check_netif(const char* netifname,char* ipaddr);

netifname : 网卡名称
ipaddr :IP地址字符串

返回值 : 0 操作成功 -1 失败

11.3.9 扫描无线接入点 ​

c
struct grf_aps* scan_wifi(char* netifname);

netifname : 网卡名称

返回值 : AP结构体链表

11.3.10 释放AP结构体链表 ​

c
void grf_aps_release(struct grf_aps* aps);

返回值 : 无

11.4. MQTT/HTTP 使用说明 ​

11.4.1 环境 ​

TR660 Linux 上已经移植CURL库 实现HTTP/TTPS协议 、MOSQUITTO 库来实现MQTT协议,因此Giraffe SDK 上可以正常使用CURL的标准API和MOSQUITTO的标准API

CURL库版本相关信息:image

MOSQUITTO库版本:2.0.18

net/http 实现了 http/https的标准get请求 的demo net/mqtt 实现了 mqtt 初始化 以及消息的相互转发 的demo

更多详细用法可参考 CURL官网文档 和 MOSQUITTO官网文档

12. CAN相关函数 ​

12.1 CAN打开 ​

c
grf_drv_t* grf_can_open(grf_can_cfg_t cfg_t);

cfg_t:要打开的CAN对象 返回值:成功返回GRF_OK,失败返回GRF_FAIL

CAN参数结构体如下:

c
typedef struct
{
    s32 port;                   // IC 端口号,-1为默认端口
    grf_can_speed_e speed_e;    // 波特率
    grf_can_filter *filter;     // 过滤器
}grf_can_cfg_t;

相关枚举如下:

c
typedef enum{
    CAN_SPEED_1M     = 1000UL * 1000,    /* 1 MBit/sec   */
    CAN_SPEED_800K   = 1000UL * 800,     /* 800 kBit/sec */
    CAN_SPEED_500K   = 1000UL * 500,     /* 500 kBit/sec */
    CAN_SPEED_250K   = 1000UL * 250,     /* 250 kBit/sec */
    CAN_SPEED_125K   = 1000UL * 125,     /* 125 kBit/sec */
    CAN_SPEED_100K   = 1000UL * 100,     /* 100 kBit/sec */
    CAN_SPEED_50K    = 1000UL * 50,      /* 50 kBit/sec  */
    CAN_SPEED_20K    = 1000UL * 20,      /* 20 kBit/sec  */
    CAN_SPEED_10K    = 1000UL * 10       /* 10 kBit/sec  */
}grf_can_speed_e;
typedef enum {
    CAN_FRAME_FORMAT_STD = 0,
    CAN_FRAME_FORMAT_EXT = 1,
}grf_can_frame_format_e;
typedef enum {
    CAN_FRAME_TYPE_DATA      = 0,
    CAN_FRAME_TYPE_REMOTE    = 1,
}grf_can_frame_type_e;
typedef struct
{
    u32 id;                           /* 报文 ID */
    u32 idmask;                       /* ID 掩码,0 表示对应的位不关心,1 表示对应的位必须匹配 */
    grf_can_frame_format_e ide;       /* 只接收 标准帧/扩展帧*/
}grf_can_filter;
c
//Only receive standard data frame with ID 0x100~0x1FF
cfg_t.filter->id = 0x100;
cfg_t.filter->ide = CAN_FRAME_FORMAT_STD;
cfg_t.filter->idmask = 0x700;

12.2CAN关闭 ​

c
s32 grf_can_close(grf_drv_t *drv_t);

drv_t: 设备句柄 返回值:成功返回GRF_OK,失败返回GRF_FAIL

12.3CAN发送 ​

c
s32 grf_can_send(grf_drv_t *drv_t,grf_can_msg_t *msg);

drv_t: 设备句柄 msg: 消息对象 返回值:成功返回GRF_OK,失败返回GRF_FAIL

CAN消息结构体如下:

c
typedef struct {
    u32 id;                      // ID号
    grf_can_frame_type_e ide;    // 标准帧 / 扩展帧
    grf_can_frame_format_e rtr;  // 数据帧 / 远程帧
    u8 dlc;                      //数据长度
    u8 data[8];
}grf_can_msg_t;

12.4CAN接收中断 ​

12.4.1CAN接收中断服务函数 ​

c
typedef void (*can_rev_bfun)(grf_can_msg_t* msg_t);

msg_t:消息对象 返回值:无

CAN接收中断服务函数用于编写CAN接收中断的处理逻辑

12.4.2启用CAN接收中断服务函数 ​

c
s32 grf_can_rev_set_bfun(grf_drv_t *drv_t,can_rev_bfun rev_bfun);

drv_t: 设备句柄 rev_bfun:CAN接收中断服务函数 返回值:成功返回GRF_OK,失败返回GRF_FAIL

在Giraffe IDE软件中,CAN相关的函数已经全部写好,用户直接从上位机项目工程处新建giraffe硬件文件即可一键添加,添加后的硬件文件包括串口部分和看门狗部分代码,用户可以直接调用。

添加过后只需在 grf_hw_init() 硬件初始化函数中打开 grf_can_init() 函数即可,CAN相关参数需要在CAN初始化函数中设置好,端口号默认为0,CAN端口号要与自己所用设备硬件匹配。

添加CAN相关代码如下:

c
#include "../grf_hw.h"
#if GRF_HW_ENABLE
#include "grf_hw_can.h"
static grf_drv_t *drv_can = NULL;
#define ide_tostr(x) x == CAN_FRAME_FORMAT_STD?"std":"ext"
#define rtr_tostr(x) x == CAN_FRAME_TYPE_DATA?"data":"remote"
#define CAN_RX_FILTER_ENABLE 1
static void prase_data(grf_can_msg_t *msg_t)
{
	if(msg_t->dlc == 0)
	{
		grf_printf("%s error data must > 0\n",__func__);
		return ;
	}
	grf_printf("frame : id = %X ide = %s rtr = %s len = %d\n",msg_t->id,ide_tostr(msg_t->ide),rtr_tostr(msg_t->rtr),msg_t->dlc);
	for(int i = 0;i < msg_t->dlc;i++)
	{
		grf_printf("%02X ",msg_t->data[i]);
	}
	grf_printf("\n");
}

#define CAN_ID 0x55
static void recive_data_handle(grf_can_msg_t* msg_t)
{
	if(msg_t->id == CAN_ID)
	{
		grf_printf("loop\n");
		return;
	}
	prase_data(msg_t);
	msg_t->id = CAN_ID;
	grf_can_send(drv_can, msg_t);
}

void grf_can_init(void)
{
    grf_can_cfg_t cfg_t = {0};
    cfg_t.port = 0;
    cfg_t.speed_e = CAN_SPEED_1M;
#if CAN_RX_FILTER_ENABLE
    // Only receive standard data frame with ID <CAN_ID>
    if(cfg_t.filter == NULL)cfg_t.filter = (grf_can_filter*)malloc(sizeof(grf_can_filter));
    cfg_t.filter->id = CAN_ID;
    cfg_t.filter->ide = CAN_FRAME_FORMAT_STD;
    cfg_t.filter->idmask = 0x7ff;
#endif
    drv_can = grf_can_open(cfg_t);
    if(drv_can){
        if(grf_can_rev_set_bfun(drv_can,recive_data_handle)==GRF_FAIL)grf_printf("grf can irq fail\n");
    }
}
#endif