Giraffe硬件API使用说明
giraffe 硬件相关 API接口 在 grf_hw_i.h 文件中,创建项目后可以从 inc 文件夹 中找到。
本文档主要讲解该文件夹中的相关API的使用方法,不同产品支持的硬件接口不同,详细可以查阅产品规格书。

- Giraffe现存的硬件函数包括
LCD,Touch,UART,WDT,GPIO,RTC,FLASH,SPI,IIC,PWM - 硬件文件均可在工程内直接生成


- 添加硬件文件后,
grf_hw.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设置屏幕亮度
s32 grf_disp_set_bright(u8 bright);bright :屏幕亮度,亮度等级 0-99 ,99 为最亮,0 为最暗
返回值:成功返回 GRF_OK ,失败返回 GRF_FAIL
提示 :
此接口通常配合slider控件使用,用于调节屏幕的显示亮度
2. Touch相关函数
typedef struct
{
grf_touch_state t_state;
u16 touch_x;
u16 touch_y;
}grf_touch_t;触摸结构体,结构体成员包括 触摸点的 (x,y)坐标值 和 触摸状态 ,触摸状态 包含 抬起 和 按下 两种状态,枚举如下:
typedef enum
{
GRF_TOUCH_UP,
GRF_TOUCH_DOWN
}grf_touch_state;2.1 获取触摸
s32 grf_touch_get(grf_touch_t *_touch_t);_touch_t :要获取的触摸对象指针
返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL
使用该API需要先创建一个触摸对象,然后才能获取到具体的触摸参数。
2.2 设置输入长按时间
s32 grf_touch_set_long_press_time(u32 time);time :长按时间(ms)
返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL
2.2 设置输入长按重复时间
s32 grf_touch_set_long_press_repeat_time(u32 time);time :长按重复时间(ms)
返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL
例程:
本例程主要演示了如何获取触摸坐标和触摸状态,同时将获取到的触摸坐标和触摸状态在不同的 label 中以文本的方式显示出来,获取到的触摸坐标同时赋给了鼠标图片,让鼠标跟随触摸移动。
具体代码如下,代码中用到了任务系统去实时获取触摸,任务系统的用法在Giraffe API使用说明文档中已有介绍,具体位置在第6章定时任务,此处不再赘述。具体的使用还要用户根据实际情况自行决定。
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串口打开
grf_drv_t* grf_drv_uart_open(grf_uart_cfg_t cfg_t);cfg_t :要打开的串口对象
返回值:设备句柄
串口参数结构体如下:
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;相关枚举如下:
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串口关闭
s32 grf_drv_uart_close(grf_drv_t *drv_t);drv_t : 设备句柄
返回值:成功返回 GRF_OK ,失败返回 GRF_FAIL
3.3串口发送
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串口接收中断服务函数
typedef void (*uart_rev_bfun)(u8* databuf,u32 datalen);databuf :接收数据的地址
datalen :接收数据的长度
返回值:无
串口接收中断服务函数用于编写串口接收中断的处理逻辑
3.4.2启用串口接收中断服务函数
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 函数中编写相关接收逻辑即可。
添加串口相关代码如下:
#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打开看门狗
s32 grf_wdt_open(void);返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL
4.2关闭看门狗
s32 grf_wdt_close(void);返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL
4.3设置看门狗超时时间
s32 grf_wdt_set_timeout(u32 time);time:超时时间,单位秒
返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL
4.4刷新看门狗时间(喂狗)
s32 grf_wdt_keepalive(void);返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL
添加看门狗硬件文件代码如下:
#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 初始化函数里面的看门狗任务打开即可使用,具体如下:
#include "grf_hw.h"
void grf_hw_init(void)
{
grf_wdt_task_create();
}5.GPIO相关函数
5.1GPIO初始化函数
s32 grf_gpio_init(grf_gpio_para_t* para_t);para_t :要初始化的 gpio结构体 变量
返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL
5.2设置GPIO引脚
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获取输入引脚电平
s32 grf_gpio_readInputPin(u8 gpio_group,u8 gpio_pin);gpio_group :gpio端口
gpio_pin :gpio引脚
返回值:成功返回获取 引脚电平 ,失败返回 GRF_FAIL
5.4获取输出引脚电平
s32 grf_gpio_readOutputPin(u8 gpio_group,u8 gpio_pin);gpio_group :gpio端口
gpio_pin :gpio引脚
返回值:成功返回获取引脚电平,失败返回 GRF_FAIL
5.5设置GPIO中断
s32 grf_gpio_group_set_irq(grf_gpio_irq_para_t irq_para_t);irq_para_t :要配置的中断结构体变量
返回值:成功返回 GRF_OK ,失败返回 GRF_FAIL
5.6获取中断引脚
s32 grf_gpio_group_get_irq_pin(grf_gpio_irq_t *irq_t);irq_t :中断结构体变量
返回值:成功返回获取 gpio引脚号 ,失败返回 GRF_FAIL
5.7获取中断模式
s32 grf_gpio_group_get_irq_mode(grf_gpio_irq_t *irq_t);irq_t :中断结构体变量
返回值:成功返回获取的 gpio中断模式 ,失败返回 GRF_FAIL
添加GPIO相关代码如下:
#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;
}
}
#endif6.RTC相关函数
6.1设置RTC
s32 grf_rtc_set_time(grf_rtc_time_t* rtc_t);rtc_t :RTC结构体变量
返回值:成功返回 GRF_OK,失败返回 GRF_FAIL
6.2获取RTC
s32 grf_rtc_get_time(grf_rtc_time_t* rtc_t);rtc_t :RTC结构体变量
返回值:成功返回 GRF_OK ,失败返回 GRF_FAIL
结构体变量如下:
typedef struct
{
u16 year;//年,1900-2099
u8 month;//月,1-12
u8 day;//日
u8 hour;//时
u8 minute;//分
u8 second;//秒
}grf_rtc_time_t;添加RTC相关代码如下:
#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);
}
#endif7.FLASH相关函数
u8 *grf_dir_get_ddisk();返回值:返回获取到的文件路径
7.2获取TF卡文件路径
u8 *grf_dir_get_tfdisk();返回值:返回获取到的文件路径
7.3获取U盘文件路径
u8 *grf_dir_get_udisk();返回值:返回获取到的文件路径
添加FLASH相关代码如下:
#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;
}
#endif8.SPI相关函数
8.1 SPI打开
grf_drv_t* grf_spi_open(grf_spi_para_t *para_t);para_t :要打开的SPI结构体变量
返回值:设备句柄
SPI结构体如下:
typedef struct
{
u32 port; //端口号
u32 work_clk; //总线速率 单位:HZ
u32 work_mode; //SPI工作模式
u8 nbits; //位数
u16 delay; //发送时间间隔
}grf_spi_para_t;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传输接口
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关闭
s32 grf_spi_close(grf_drv_t *drv_t);drv_t :设备句柄
返回值:成功返回GRF_OK,失败返回GRF_FAIL
添加SPI相关代码如下:
#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(¶_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]);
}
}
#endif9.IIC相关函数
9.1 IIC打开
grf_drv_t* grf_iic_open(grf_iic_para_t* para_t);para_t :要打开的IIC结构体变量
返回值:设备句柄
IIC结构体如下:
typedef struct
{
u32 port; //端口号
u8 slave_addr; //设备地址
u8 reg_addr; //寄存器地址
u8 reg_addr_width; //寄存器字节个数
}grf_iic_para_t;9.2 IIC读数据
s32 grf_iic_read(grf_drv_t* drv_t,u16 addr,u8 *buff,u16 len);drv_t : 设备句柄
addr :要读取的设备地址
buff :接收数据缓冲区
len :读取数据长度
返回值:实际读取的字节数
9.3 IIC写数据
s32 grf_iic_write(grf_drv_t* drv_t,u16 addr,u8 *buff,u16 len);drv_t : 设备句柄
addr :要写入的设备地址
buff :发送数据缓冲区
len :发送数据长度
返回值:实际写入的字节数
9.4 IIC关闭
s32 grf_iic_close(grf_drv_t *drv_t);drv_t : 设备句柄
返回值:成功返回 GRF_OK , 失败返回 GRF_FAIL
添加IIC相关代码如下:
#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(¶_t);
iic_rtc_set();
iic_rtc_task = grf_task_create(iic_rtc_task_cb,500,NULL);
}
}
#endif10.PWM相关函数
10.1 PWM打开
grf_drv_t* grf_pwm_open(grf_pwm_para_t* para_t);para_t :要打开的PWM结构体变量
PWM结构体如下:
typedef struct
{
u32 channel; //pwm通道
u32 period_time; //周期 单位:ns
u32 pulse_time; //脉冲时间 单位:ns
}grf_pwm_para_t;10.2 PWM启动
s32 grf_pwm_start(grf_drv_t *drv_t);drv_t : 设备句柄
返回值:成功返回GRF_OK,失败返回GRF_FAIL
10.3 设置PWM
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终止
s32 grf_pwm_stop(grf_drv_t *drv_t);drv_t : 设备句柄
返回值:成功返回GRF_OK,失败返回GRF_FAIL
10.5 PWM关闭
s32 grf_pwm_close(grf_drv_t *drv_t);drv_t : 设备句柄
返回值:成功返回 GRF_OK ,失败返回 GRF_FAIL
添加PWM相关代码如下:
#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(¶_t);
grf_pwm_start(pwm_drv);
pwm_task_t = grf_task_create(grf_pwm_task_cb,10,NULL);
}
}
#endif11.网络使用说明
目前仅支持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文件夹下

再次将lib文件夹下的文件,拷贝至 Giraffe 安装目录下 ~/platform/tr660/usr/lib/(lib 文件夹在tr6_libs文件夹内)
11.1.2 拷贝硬件参数API函数
11.1.2.1 将net文件夹拷贝至Giraffe 项目的apps/hardware/ 目录下

11.1.2.2 修改apps/hardware/grf_hw.h 头文件添加头文件包含
修改后的文件:
#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);
#endif11.1.3 修改apps/hardware/net/hw_net.h
根据编译需要修改包含的头文件 (iperf/curl/matt)

至此网络编译环境搭建成功,(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文件夹下

11.2.2 再次将lib文件夹下的文件,拷贝至 Giraffe 安装目录下 ~/platform/tr660/usr/lib/
11.2.3 拷贝硬件参数API函数
11.2.3.1 将net文件夹拷贝至Giraffe 项目的apps/hardware/ 目录下

11.2.3.2 修改apps/hardware/grf_hw.h 头文件添加头文件包含
修改后的文件:
#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);
#endif11.2.3 修改apps/hardware/net/hw_net.h
根据编译需要修改包含的头文件 (iperf/curl/matt)

11.2.4 修改编译选项
修改Giraffe SDK 安装目录下 ~/platform/tr660/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 ,修改结果为
#连接库
#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配置函数
void eth_setting_static_ip(char* ipaddr,char* netmask,char* getway,char* dnsserver);ipaddr : IP地址netmask :子网掩码getway :网关地址dnsserver :DNS服务器地址
返回值 :无
11.3.2 以太网DHCP使能函数
void eth_dhcp_enable(void);返回值 :无
11.3.3 WIFI 账号 密码配置函数
void wlan_setting_account(char* ssid,char* passwd);ssid :无线网账号passwd :无线网密码
返回值 :无
11.3.4 WIFI_DHCP使能函数
void wlan_dhcp_enable(void);返回值 :无
11.3.5 WIFI_静态IP配置函数
void wlan_setting_static_ip(char* ipaddr,char* netmask,char* getway,char* dnsserver);ipaddr : IP地址netmask :子网掩码getway :网关地址dnsserver :DNS服务器地址
返回值 :无
11.3.6 网络测试demo
void net_test(void);USING_WLAN0 宏定义打开时 配置wifi信息 USING_ETH0 宏定义打开时 配置以太网信息
11.3.7 打开网卡
int open_netif(const char* netifname);netifname : 网卡名称
返回值 : 0 操作成功
11.3.8 检测网卡IP地址
int check_netif(const char* netifname,char* ipaddr);netifname : 网卡名称ipaddr :IP地址字符串
返回值 : 0 操作成功 -1 失败
11.3.9 扫描无线接入点
struct grf_aps* scan_wifi(char* netifname);netifname : 网卡名称
返回值 : AP结构体链表
11.3.10 释放AP结构体链表
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库版本相关信息:
MOSQUITTO库版本:2.0.18
net/http 实现了 http/https的标准get请求 的demo net/mqtt 实现了 mqtt 初始化 以及消息的相互转发 的demo
更多详细用法可参考 CURL官网文档 和 MOSQUITTO官网文档
12. CAN相关函数
12.1 CAN打开
grf_drv_t* grf_can_open(grf_can_cfg_t cfg_t);cfg_t:要打开的CAN对象 返回值:成功返回GRF_OK,失败返回GRF_FAIL
CAN参数结构体如下:
typedef struct
{
s32 port; // IC 端口号,-1为默认端口
grf_can_speed_e speed_e; // 波特率
grf_can_filter *filter; // 过滤器
}grf_can_cfg_t;相关枚举如下:
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;//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关闭
s32 grf_can_close(grf_drv_t *drv_t);drv_t: 设备句柄 返回值:成功返回GRF_OK,失败返回GRF_FAIL
12.3CAN发送
s32 grf_can_send(grf_drv_t *drv_t,grf_can_msg_t *msg);drv_t: 设备句柄 msg: 消息对象 返回值:成功返回GRF_OK,失败返回GRF_FAIL
CAN消息结构体如下:
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接收中断服务函数
typedef void (*can_rev_bfun)(grf_can_msg_t* msg_t);msg_t:消息对象 返回值:无
CAN接收中断服务函数用于编写CAN接收中断的处理逻辑
12.4.2启用CAN接收中断服务函数
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相关代码如下:
#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