JiXieShi
/
HW_Lib
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

UP Task,Argpase

main
JiXieShi 2024-05-10 13:47:39 +08:00
parent 84bc401ba4
commit be1d31e732
18 changed files with 591 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
CMakeLists.txt
View File

@ -5,13 +5,16 @@ set(CMAKE_C_STANDARD 23)
include_directories( include_directories(
lib/inc lib/inc
lib/inc/log
lib/inc/spi
lib/inc/iic
demo/spi
demo/iic
) )
file(GLOB LIB_SUBDIRS "lib/inc/*")
foreach (LIB_SUBDIR ${LIB_SUBDIRS})
include_directories(${LIB_SUBDIR})
endforeach ()
file(GLOB DEMO_SUBDIRS "demo/*")
foreach (DEMO_SUBDIR ${DEMO_SUBDIRS})
include_directories(${DEMO_SUBDIR})
endforeach ()
file(GLOB_RECURSE SOURCES file(GLOB_RECURSE SOURCES
"lib/src/*.*" "lib/src/*.*"
"demo/*/*.*") "demo/*/*.*")

10
demo/arg/t_arg.h Normal file
View File

@ -0,0 +1,10 @@
//
// Created by lydxh on 2024/5/10.
//
#ifndef HW_LIB_T_ARG_H
#define HW_LIB_T_ARG_H
void Test_argpase();
#endif //HW_LIB_T_ARG_H

49
demo/arg/test.c Normal file
View File

@ -0,0 +1,49 @@
#include "stdio.h"
#include "argpase.h"
enum Opt {
T0 = 0, T1, T2, T3, T4, T5
};
Option Opts[6] = {{"T0", T0},
{"T1", T1},
{"T2", T2},
{"T3", T3},
{"T4", T4},
{"T5", T5}};
void Test_argpase() {
OptList *Head = Options_Creat("Head", -1);
OptList *t;
int i;
for (i = 0; i < 6; i++) {
t = Options_CreatOpt(&Opts[i]);
Options_Add(Head, t);
}
Options_Print(Head);
char *s = "T1 52 T2 64 T5 72";//模拟串口参数传入
char *argv[20];
size_t argc;
argc = Str_To_Args(s, argv);
printf("\nargs\n");
for (i = 0; i < argc; ++i) {
printf("arg[%d]:%s\n", i, argv[i]);//打印参数拆分情况
}
OptId optid;
while ((optid = Options_Load(Head, argv, argc)) != -1) {//开始匹配 Optarg为匹配的参数(字符类型可atoi等转换)
switch (optid) {
case T0:
case T1:
case T2:
case T3:
case T4:
case T5:
printf("Opt_%s[%d]:%s\n", Optstr, optid, Optarg);
break;
default:
break;
}
}
}

10
demo/iic/test.c
View File

@ -29,7 +29,7 @@ uint8_t SDA_Read() {
} }
void Test_iic() { void Test_iic() {
HW_Dev_IIC dev = { SW_Dev_IIC dev = {
.CLK_SET = CLK_Pin, .CLK_SET = CLK_Pin,
.SDA_SET = SDA_Set, .SDA_SET = SDA_Set,
.SDA = SDA_Read, .SDA = SDA_Read,
@ -38,14 +38,14 @@ void Test_iic() {
}; };
uint8_t internalAddress = 0x56; uint8_t internalAddress = 0x56;
uint32_t len = 10; uint32_t len = 64;
uint8_t writeData[len]; uint8_t writeData[len];
uint8_t readData[len]; uint8_t readData[len];
for (int i = 0; i < len; ++i) { for (int i = 0; i < len; ++i) {
writeData[i] = rand() % 10; writeData[i] = rand() % 200;
} }
HW_IIC_WL(dev, internalAddress, writeData, len); SW_IIC_WL(dev, internalAddress, writeData, len);
BufPrint("<IIC> TX", writeData, 8, len, 16); BufPrint("<IIC> TX", writeData, 8, len, 16);
HW_IIC_RL(dev, internalAddress, readData, len, 1); SW_IIC_RL(dev, internalAddress, readData, len, 1);
BufPrint("<IIC> RX", readData, 8, len, 16); BufPrint("<IIC> RX", readData, 8, len, 16);
} }

8
demo/spi/test.c
View File

@ -33,7 +33,7 @@ uint8_t Miso_Pin() {
} }
void Test_spi() { void Test_spi() {
HW_Dev_Spi ltl = { SW_Dev_Spi ltl = {
.MOSI_SET=Mosi_Pin, .MOSI_SET=Mosi_Pin,
.SCK_SET=Sck_Pin, .SCK_SET=Sck_Pin,
.MISO=Miso_Pin, .MISO=Miso_Pin,
@ -43,20 +43,20 @@ void Test_spi() {
.ENDIAN=LTL, .ENDIAN=LTL,
}; };
uint8_t r, t = rand() % 10; uint8_t r, t = rand() % 10;
r = HW_SPI_RW(ltl, t); r = SW_SPI_RW(ltl, t);
LOGI("<SPI> Tx:%d,Rx:%d", t, r); LOGI("<SPI> Tx:%d,Rx:%d", t, r);
uint8_t rbuf[64], tbuf[64]; uint8_t rbuf[64], tbuf[64];
for (int i = 0; i < 64; ++i) { for (int i = 0; i < 64; ++i) {
tbuf[i] = rand() % 10; tbuf[i] = rand() % 10;
} }
HW_SPI_RWL(ltl, rbuf, tbuf, 64); SW_SPI_RWL(ltl, rbuf, tbuf, 64);
BufPrint("<SPI> TX", tbuf, 8, 64, 8); BufPrint("<SPI> TX", tbuf, 8, 64, 8);
BufPrint("<SPI> RX", rbuf, 8, 64, 8); BufPrint("<SPI> RX", rbuf, 8, 64, 8);
uint16_t rbuf16[64], tbuf16[64]; uint16_t rbuf16[64], tbuf16[64];
for (int i = 0; i < 64; ++i) { for (int i = 0; i < 64; ++i) {
tbuf16[i] = rand() % 1000; tbuf16[i] = rand() % 1000;
} }
HW_SPI_RWL16(ltl, rbuf16, tbuf16, 64); SW_SPI_RWL16(ltl, rbuf16, tbuf16, 64);
BufPrint("<SPI> TX[16]", tbuf16, 16, 64, 16); BufPrint("<SPI> TX[16]", tbuf16, 16, 64, 16);
BufPrint("<SPI> RX[16]", rbuf16, 16, 64, 16); BufPrint("<SPI> RX[16]", rbuf16, 16, 64, 16);
} }

10
demo/task/t_task.h Normal file
View File

@ -0,0 +1,10 @@
//
// Created by lydxh on 2024/5/10.
//
#ifndef HW_LIB_T_TASK_H
#define HW_LIB_T_TASK_H
void Test_task();
#endif //HW_LIB_T_TASK_H

56
demo/task/test.c Normal file
View File

@ -0,0 +1,56 @@
#include <sysinfoapi.h>
#include "stdio.h"
#include "task.h"
Task_t *task1;
Task_t *task2;
Task_t *task3;
Task_t *task4;
uint64_t GetTick() {
return (uint64_t) GetTickCount64();
}
void exampleTimer1Callback(Task_t *task, void *userData) {
printf("[%012ld] Task:%p callback-> %s.\r\n", GetTick(), task, (char *) userData);
TaskDel(task);
}
void exampleTimer2Callback(Task_t *task, void *userData) {
printf("[%012ld] Task:%p callback-> %s.\r\n", GetTick(), task, (char *) userData);
}
void exampleTimer3Callback(Task_t *task, void *userData) {
printf("[%012ld] Task:%p callback-> %s.\r\n", GetTick(), task, (char *) userData);
TaskSetTime(task, 4567);
TaskStart(task);
}
typedef struct CustomUserData {
int count;
char *str;
} CustomUserData;
void exampleTimer4Callback(Task_t *task, void *userData) {
CustomUserData *customUserData = (CustomUserData *) userData;
customUserData->count--;
printf("[%012ld] Task:%p callback-> %s.\r\n", GetTick(), task, customUserData->str);
if (customUserData->count > 0) {
TaskStart(task);
}
}
void Test_task() {
TaskInit(GetTick);
TaskCreat(task1, 1000, -1, exampleTimer1Callback, "1000ms CYCLE task");
TaskCreat(task2, 5000, -1, exampleTimer2Callback, "5000ms ONCE task");
TaskCreat(task3, 3456, 2, exampleTimer3Callback, "3456ms delay start, 4567ms CYCLE task");
CustomUserData customUserData = {
.count = 3,
.str = "2000ms 3 task"
};
TaskCreat(task4, 2000, 1, exampleTimer4Callback, &customUserData);
while (1) {
TaskRun();
}
}

41
lib/inc/arg/argpase.h Normal file
View File

@ -0,0 +1,41 @@
#ifndef ARGPASE_H
#define ARGPASE_H
typedef char OptId;
typedef struct Option {
char *name;
OptId id;
} Option;
typedef struct OptList {
struct OptList *next;
Option *Option;
} OptList;
extern char *Optarg, *Optstr;
//索引指示，可手动重载为0
extern int Optindex;
//选项链表创建
OptList *Options_Creat(char *opt, OptId index);
//使用选项结构体创建
OptList *Options_CreatOpt(Option *opt);
//添加
void Options_Add(OptList *opts, OptList *opt);
//删除
bool Options_Del(OptList *opts, char *opt);
//打印选项和id
void Options_Print(OptList *opts);
//开始匹配参数
OptId Options_Load(OptList *opts, char *argv[], size_t argc);
//字符串转参数数组
size_t Str_To_Args(char *str, char *argv[]);
#endif //ARGPASE_H

16
lib/inc/iic/iic.h
View File

@ -1,9 +1,5 @@
// #ifndef SW_LIB_IIC_H
// Created by lydxh on 2024/5/9. #define SW_LIB_IIC_H
//
#ifndef HW_LIB_IIC_H
#define HW_LIB_IIC_H
#include <stdint.h> #include <stdint.h>
@ -23,7 +19,7 @@ typedef struct {
uint8_t (*SDA)(); // 读取数据引脚状态的函数指针 uint8_t (*SDA)(); // 读取数据引脚状态的函数指针
uint8_t (*SDA_MODE)(uint8_t); // 设置数据引脚模式的函数指针 uint8_t (*SDA_MODE)(uint8_t); // 设置数据引脚模式的函数指针
uint8_t ADD; // IIC设备地址 uint8_t ADD; // IIC设备地址
} HW_Dev_IIC; } SW_Dev_IIC;
/** /**
* @brief 向 IIC 设备写入数据流 * @brief 向 IIC 设备写入数据流
@ -33,7 +29,7 @@ typedef struct {
* @param Len: [输入] 数据流长度 * @param Len: [输入] 数据流长度
* @return void * @return void
**/ **/
void HW_IIC_WL(HW_Dev_IIC Dev, uint8_t InternalAddress, uint8_t *Write_Data, uint32_t Len); void SW_IIC_WL(SW_Dev_IIC Dev, uint8_t InternalAddress, uint8_t *Write_Data, uint32_t Len);
/** /**
* @brief 从 IIC 设备读取数据流 * @brief 从 IIC 设备读取数据流
@ -44,6 +40,6 @@ void HW_IIC_WL(HW_Dev_IIC Dev, uint8_t InternalAddress, uint8_t *Write_Data, uin
* @param Ack: [输入] 确认应答位 * @param Ack: [输入] 确认应答位
* @return void * @return void
**/ **/
void HW_IIC_RL(HW_Dev_IIC Dev, uint8_t InternalAddress, uint8_t *Read_Data, uint32_t Len, uint8_t Ack); void SW_IIC_RL(SW_Dev_IIC Dev, uint8_t InternalAddress, uint8_t *Read_Data, uint32_t Len, uint8_t Ack);
#endif //HW_LIB_IIC_H #endif //SW_LIB_IIC_H

30
lib/inc/spi/spi.h
View File

@ -1,15 +1,11 @@
// #ifndef SW_LIB_SPI_H
// Created by lydxh on 2024/4/8. #define SW_LIB_SPI_H
//
#ifndef HW_LIB_SPI_H
#define HW_LIB_SPI_H
#include <stdint.h> #include <stdint.h>
#define HIGH 1 #define HIGH 1
#define LOW 0 #define LOW 0
#define NOP() ; #define NOP() 0
#define DELAY1US() NOP() #define DELAY1US() NOP()
/** /**
@ -42,7 +38,7 @@ typedef struct {
mode MODE; // SPI模式 mode MODE; // SPI模式
uint8_t CS; // CS引脚编号 uint8_t CS; // CS引脚编号
endian ENDIAN; // 数据端序 endian ENDIAN; // 数据端序
} HW_Dev_Spi; } SW_Dev_Spi;
/** /**
* @brief 向 SPI 设备写入一个字节并读取返回的数据 * @brief 向 SPI 设备写入一个字节并读取返回的数据
@ -50,7 +46,7 @@ typedef struct {
* @param Write_Date: [输入]要写入的数据 * @param Write_Date: [输入]要写入的数据
* @return 读取到的数据 * @return 读取到的数据
**/ **/
uint8_t HW_SPI_RW(HW_Dev_Spi Dev, uint8_t Write_Date); uint8_t SW_SPI_RW(SW_Dev_Spi Dev, uint8_t Write_Date);
/** /**
* @brief 向 SPI 设备写入数据流 * @brief 向 SPI 设备写入数据流
@ -59,7 +55,7 @@ uint8_t HW_SPI_RW(HW_Dev_Spi Dev, uint8_t Write_Date);
* @param Len: [输入] 数据流长度 * @param Len: [输入] 数据流长度
* @return void * @return void
**/ **/
void HW_SPI_WL(HW_Dev_Spi Dev, uint8_t *Write_Date, uint32_t Len); void SW_SPI_WL(SW_Dev_Spi Dev, uint8_t *Write_Date, uint32_t Len);
/** /**
* @brief 从 SPI 设备读取数据流 * @brief 从 SPI 设备读取数据流
@ -68,7 +64,7 @@ void HW_SPI_WL(HW_Dev_Spi Dev, uint8_t *Write_Date, uint32_t Len);
* @param Len: [输入] 读取数据流长度 * @param Len: [输入] 读取数据流长度
* @return void * @return void
**/ **/
void HW_SPI_RL(HW_Dev_Spi Dev, uint8_t *Read_Date, uint32_t Len); void SW_SPI_RL(SW_Dev_Spi Dev, uint8_t *Read_Date, uint32_t Len);
/** /**
* @brief 向 SPI 设备写入数据并读取返回数据流 * @brief 向 SPI 设备写入数据并读取返回数据流
@ -78,7 +74,7 @@ void HW_SPI_RL(HW_Dev_Spi Dev, uint8_t *Read_Date, uint32_t Len);
* @param Len: [输入] 数据流长度 * @param Len: [输入] 数据流长度
* @return void * @return void
**/ **/
void HW_SPI_RWL(HW_Dev_Spi Dev, uint8_t *Read_Date, uint8_t *Write_Date, uint32_t Len); void SW_SPI_RWL(SW_Dev_Spi Dev, uint8_t *Read_Date, uint8_t *Write_Date, uint32_t Len);
/** /**
* @brief 向 SPI 设备写入一个字（16位）并读取返回的数据 * @brief 向 SPI 设备写入一个字（16位）并读取返回的数据
@ -86,7 +82,7 @@ void HW_SPI_RWL(HW_Dev_Spi Dev, uint8_t *Read_Date, uint8_t *Write_Date, uint32_
* @param Write_Date: [输入]要写入的数据 * @param Write_Date: [输入]要写入的数据
* @return 读取到的数据 * @return 读取到的数据
**/ **/
uint16_t HW_SPI_RW16(HW_Dev_Spi Dev, uint16_t Write_Date); uint16_t SW_SPI_RW16(SW_Dev_Spi Dev, uint16_t Write_Date);
/** /**
* @brief 从 SPI 设备读取数据流（16位） * @brief 从 SPI 设备读取数据流（16位）
@ -95,7 +91,7 @@ uint16_t HW_SPI_RW16(HW_Dev_Spi Dev, uint16_t Write_Date);
* @param Len: [输入] 读取数据流长度 * @param Len: [输入] 读取数据流长度
* @return void * @return void
**/ **/
void HW_SPI_RL16(HW_Dev_Spi Dev, uint16_t *Read_Date, uint32_t Len); void SW_SPI_RL16(SW_Dev_Spi Dev, uint16_t *Read_Date, uint32_t Len);
/** /**
* @brief 向 SPI 设备写入数据流（16位） * @brief 向 SPI 设备写入数据流（16位）
@ -104,7 +100,7 @@ void HW_SPI_RL16(HW_Dev_Spi Dev, uint16_t *Read_Date, uint32_t Len);
* @param Len: [输入] 数据流长度 * @param Len: [输入] 数据流长度
* @return void * @return void
**/ **/
void HW_SPI_WL16(HW_Dev_Spi Dev, uint16_t *Write_Date, uint32_t Len); void SW_SPI_WL16(SW_Dev_Spi Dev, uint16_t *Write_Date, uint32_t Len);
/** /**
* @brief 向 SPI 设备写入数据并读取返回数据流（16位） * @brief 向 SPI 设备写入数据并读取返回数据流（16位）
@ -114,6 +110,6 @@ void HW_SPI_WL16(HW_Dev_Spi Dev, uint16_t *Write_Date, uint32_t Len);
* @param Len: [输入] 数据流长度 * @param Len: [输入] 数据流长度
* @return void * @return void
**/ **/
void HW_SPI_RWL16(HW_Dev_Spi Dev, uint16_t *Read_Date, uint16_t *Write_Date, uint32_t Len); void SW_SPI_RWL16(SW_Dev_Spi Dev, uint16_t *Read_Date, uint16_t *Write_Date, uint32_t Len);
#endif //HW_LIB_SPI_H #endif //SW_LIB_SPI_H

13
lib/inc/target.h Normal file
View File

@ -0,0 +1,13 @@
#ifndef RETARGET_H
#define RETARGET_H
#include <sys/stat.h>
#include <stdio.h>
void RetargetInit(UART_HandleTypeDef *huart);
int _write(int fd, char *ptr, int len);
int _read(int fd, char *ptr, int len);
#endif //#ifndef RETARGET_H

60
lib/inc/task/task.h Normal file
View File

@ -0,0 +1,60 @@
#ifndef TASK_H
#define TASK_H
#include "stdint.h"
#define true 0
#define false (-1)
//平台切换相关类型重定义
typedef int64_t TaskStatus_t;
typedef uint64_t TaskTime_t;
typedef int64_t TaskCnt_t;
typedef struct TaskList Task_t;
typedef uint64_t (*PlatformTicksFunc_t)(void);
typedef void (*Task_Callback_t)(Task_t *task, void *userdata);
struct TaskList {
Task_t *next;
uint8_t enable;
TaskCnt_t runcnt;
TaskTime_t lasttime;
TaskTime_t intervaltime;
Task_Callback_t callback;
void *userdata;
};
//时间基准注册，建议1-10ms的基准
TaskStatus_t TaskInit(PlatformTicksFunc_t TicksFunc);
//创建任务
// time:间隔时间
// runcnt:执行次数 为-1无限制执行 为0只创建不运行
// callback:回调函数
// userdata:用户数据传参
TaskStatus_t TaskCreat(Task_t *task, TaskTime_t time, TaskCnt_t runcnt, Task_Callback_t callback, void *userdata);
//添加任务
TaskStatus_t TaskAdd(Task_t *task);
//删除任务
TaskStatus_t TaskDel(Task_t *task);
//重新开始以停止的任务
TaskStatus_t TaskStart(Task_t *task);
//暂停任务执行
TaskStatus_t TaskStop(Task_t *task);
//重设任务执行次数
TaskStatus_t TaskSetCnt(Task_t *task, TaskCnt_t runcnt);
//重设任务间隔时间
TaskStatus_t TaskSetTime(Task_t *task, TaskTime_t time);
//任务调度
TaskStatus_t TaskRun(void);
#endif //TASK_H

106
lib/src/arg/argpase.c Normal file
View File

@ -0,0 +1,106 @@
#include <malloc.h>
#include <stdio.h>
#include <string.h>
#include "argpase.h"
char *Optarg, *Optstr;
int Optindex = 0;
OptList *Options_Creat(char *name, OptId index) {
OptList *p;
p = (OptList *) malloc(sizeof(OptList));
memset(p, 0, sizeof(OptList));
Option *opt = (Option *) malloc(sizeof(Option));
memset(opt, 0, sizeof(Option));
opt->name = name;
opt->id = index;
p->Option = opt;
p->next = NULL;
return p;
}
OptList *Options_CreatOpt(Option *opt) {
OptList *p;
p = (OptList *) malloc(sizeof(OptList));
memset(p, 0, sizeof(OptList));
p->Option = opt;
p->next = NULL;
return p;
}
void Options_Add(OptList *opts, OptList *opt) {
OptList *p = opts;
while (NULL != p->next) {
p = p->next;
}
p->next = opt;
}
bool Options_Del(OptList *opts, char *opt) {
//获取当前头节点的位置
OptList *p = opts;
OptList *prev = NULL;
while (NULL != p->next) {
//保存当前节点的前一个节点的指针
prev = p;
//然后让当前的指针继续往后移动
p = p->next;
//判断，找到了要删除的数据
if (0 == strcmp(p->Option->name, opt)) {
//两种情况，一种是普通节点，还有一种是尾节点
if (p->next != NULL) //普通节点的情况
{
prev->next = p->next;
free(p);
} else //尾节点的情况
{
prev->next = NULL; //将这个尾节点的上一个节点的指针域指向空
free(p);
}
return true;
}
}
return false;
}
void Options_Print(OptList *opts) {
OptList *p = opts;
while (NULL != p) {
printf("Option[%d]:%s\n", p->Option->id, p->Option->name);
p = p->next;
}
}
OptId Options_Load(OptList *opts, char *argv[], size_t argc) {
OptList *p = opts;
OptId id = -2;
while (NULL != p) {
if (0 == strcmp(p->Option->name, argv[Optindex])) {
Optarg = argv[Optindex + 1];
Optstr = p->Option->name;
id = p->Option->id;
}
p = p->next;
}
Optindex++;
if (Optindex >= argc) {
return -1;
}
return id;
}
size_t Str_To_Args(char *str, char *argv[]) {
char *p;
size_t argc = 0;
size_t l = strlen(str);
char *buf = (char *) malloc(sizeof(char) * l + 1);
strcpy(buf, str);
p = strtok(buf, " ");
while (p) {
argv[argc] = p;
argc++;
p = strtok(NULL, " ");
}
return argc;
}

18
lib/src/iic/iic.c
View File

@ -1,6 +1,6 @@
#include "iic.h" #include "iic.h"
static inline void iic_Start(HW_Dev_IIC dev) { static inline void iic_Start(SW_Dev_IIC dev) {
dev.SDA_MODE(OUT); dev.SDA_MODE(OUT);
dev.SDA_SET(HIGH); dev.SDA_SET(HIGH);
dev.CLK_SET(HIGH);DELAY1US(); dev.CLK_SET(HIGH);DELAY1US();
@ -9,7 +9,7 @@ static inline void iic_Start(HW_Dev_IIC dev) {
} }
//结束信号 //结束信号
static inline void iic_Stop(HW_Dev_IIC dev) { static inline void iic_Stop(SW_Dev_IIC dev) {
dev.SDA_MODE(OUT); dev.SDA_MODE(OUT);
dev.CLK_SET(LOW); dev.CLK_SET(LOW);
dev.SDA_SET(LOW);DELAY1US(); dev.SDA_SET(LOW);DELAY1US();
@ -18,7 +18,7 @@ static inline void iic_Stop(HW_Dev_IIC dev) {
} }
//等待信号响应 //等待信号响应
static inline uint8_t iic_WaitAck(HW_Dev_IIC dev, uint16_t timeout) { static inline uint8_t iic_WaitAck(SW_Dev_IIC dev, uint16_t timeout) {
uint16_t time = 0; uint16_t time = 0;
dev.SDA_MODE(IN); dev.SDA_MODE(IN);
dev.SDA_SET(HIGH);DELAY1US(); dev.SDA_SET(HIGH);DELAY1US();
@ -34,7 +34,7 @@ static inline uint8_t iic_WaitAck(HW_Dev_IIC dev, uint16_t timeout) {
return 0; return 0;
} }
static inline void iic_Ack(HW_Dev_IIC dev) { static inline void iic_Ack(SW_Dev_IIC dev) {
dev.CLK_SET(LOW); dev.CLK_SET(LOW);
dev.SDA_MODE(OUT); dev.SDA_MODE(OUT);
dev.SDA_SET(LOW);DELAY1US();DELAY1US(); dev.SDA_SET(LOW);DELAY1US();DELAY1US();
@ -42,7 +42,7 @@ static inline void iic_Ack(HW_Dev_IIC dev) {
dev.CLK_SET(LOW); dev.CLK_SET(LOW);
} }
static inline void iic_NAck(HW_Dev_IIC dev) { static inline void iic_NAck(SW_Dev_IIC dev) {
dev.CLK_SET(LOW); dev.CLK_SET(LOW);
dev.SDA_MODE(OUT); dev.SDA_MODE(OUT);
dev.SDA_SET(HIGH);DELAY1US();DELAY1US(); dev.SDA_SET(HIGH);DELAY1US();DELAY1US();
@ -51,7 +51,7 @@ static inline void iic_NAck(HW_Dev_IIC dev) {
} }
//写入一个字节 //写入一个字节
static inline void iic_W(HW_Dev_IIC dev, uint8_t date) { static inline void iic_W(SW_Dev_IIC dev, uint8_t date) {
dev.SDA_MODE(OUT); dev.SDA_MODE(OUT);
uint8_t i; uint8_t i;
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
@ -67,7 +67,7 @@ static inline void iic_W(HW_Dev_IIC dev, uint8_t date) {
} }
} }
static inline uint8_t iic_R(HW_Dev_IIC dev, uint8_t ack) { static inline uint8_t iic_R(SW_Dev_IIC dev, uint8_t ack) {
unsigned char i, read = 0; unsigned char i, read = 0;
dev.SDA_MODE(IN); dev.SDA_MODE(IN);
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
@ -83,7 +83,7 @@ static inline uint8_t iic_R(HW_Dev_IIC dev, uint8_t ack) {
return read; return read;
} }
void HW_IIC_WL(HW_Dev_IIC Dev, uint8_t InternalAddress, uint8_t *Write_Data, uint32_t Len) { void SW_IIC_WL(SW_Dev_IIC Dev, uint8_t InternalAddress, uint8_t *Write_Data, uint32_t Len) {
iic_Start(Dev); iic_Start(Dev);
iic_W(Dev, Dev.ADD); iic_W(Dev, Dev.ADD);
iic_WaitAck(Dev, 200); iic_WaitAck(Dev, 200);
@ -96,7 +96,7 @@ void HW_IIC_WL(HW_Dev_IIC Dev, uint8_t InternalAddress, uint8_t *Write_Data, uin
iic_Stop(Dev); iic_Stop(Dev);
} }
void HW_IIC_RL(HW_Dev_IIC Dev, uint8_t InternalAddress, uint8_t *Read_Data, uint32_t Len, uint8_t Ack) { void SW_IIC_RL(SW_Dev_IIC Dev, uint8_t InternalAddress, uint8_t *Read_Data, uint32_t Len, uint8_t Ack) {
iic_Start(Dev); iic_Start(Dev);
iic_W(Dev, Dev.ADD); iic_W(Dev, Dev.ADD);
iic_WaitAck(Dev, 200); iic_WaitAck(Dev, 200);

18
lib/src/spi/spi.c
View File

@ -4,7 +4,7 @@
#define CS_ENABLE() Dev.CS ? Dev.CS_SET(HIGH) : Dev.CS_SET(LOW) #define CS_ENABLE() Dev.CS ? Dev.CS_SET(HIGH) : Dev.CS_SET(LOW)
#define CS_DISABLE() Dev.CS ? Dev.CS_SET(LOW) : Dev.CS_SET(HIGH) #define CS_DISABLE() Dev.CS ? Dev.CS_SET(LOW) : Dev.CS_SET(HIGH)
static inline uint8_t spi_RW(HW_Dev_Spi Dev, uint8_t Write_Date) { static inline uint8_t spi_RW(SW_Dev_Spi Dev, uint8_t Write_Date) {
uint8_t i, read_date = 0; uint8_t i, read_date = 0;
switch (Dev.MODE) { switch (Dev.MODE) {
case Mode0: case Mode0:
@ -67,7 +67,7 @@ static inline uint8_t spi_RW(HW_Dev_Spi Dev, uint8_t Write_Date) {
return read_date; return read_date;
} }
uint8_t HW_SPI_RW(HW_Dev_Spi Dev, uint8_t Write_Date) { uint8_t SW_SPI_RW(SW_Dev_Spi Dev, uint8_t Write_Date) {
uint8_t read_date; uint8_t read_date;
CS_ENABLE(); CS_ENABLE();
read_date = spi_RW(Dev, Write_Date); read_date = spi_RW(Dev, Write_Date);
@ -75,28 +75,28 @@ uint8_t HW_SPI_RW(HW_Dev_Spi Dev, uint8_t Write_Date) {
return read_date; return read_date;
} }
void HW_SPI_WL(HW_Dev_Spi Dev, uint8_t *Write_Date, uint32_t Len) { void SW_SPI_WL(SW_Dev_Spi Dev, uint8_t *Write_Date, uint32_t Len) {
CS_ENABLE(); CS_ENABLE();
for (uint32_t i = 0; i < Len; i++) for (uint32_t i = 0; i < Len; i++)
spi_RW(Dev, Write_Date[i]); spi_RW(Dev, Write_Date[i]);
CS_DISABLE(); CS_DISABLE();
} }
void HW_SPI_RL(HW_Dev_Spi Dev, uint8_t *Read_Date, uint32_t Len) { void SW_SPI_RL(SW_Dev_Spi Dev, uint8_t *Read_Date, uint32_t Len) {
CS_ENABLE(); CS_ENABLE();
for (uint32_t i = 0; i < Len; i++) for (uint32_t i = 0; i < Len; i++)
Read_Date[i] = spi_RW(Dev, 0xFF); Read_Date[i] = spi_RW(Dev, 0xFF);
CS_DISABLE(); CS_DISABLE();
} }
void HW_SPI_RWL(HW_Dev_Spi Dev, uint8_t *Read_Date, uint8_t *Write_Date, uint32_t Len) { void SW_SPI_RWL(SW_Dev_Spi Dev, uint8_t *Read_Date, uint8_t *Write_Date, uint32_t Len) {
CS_ENABLE(); CS_ENABLE();
for (uint32_t i = 0; i < Len; i++) for (uint32_t i = 0; i < Len; i++)
Read_Date[i] = spi_RW(Dev, Write_Date[i]); Read_Date[i] = spi_RW(Dev, Write_Date[i]);
CS_DISABLE(); CS_DISABLE();
} }
uint16_t HW_SPI_RW16(HW_Dev_Spi Dev, uint16_t Write_Date) { uint16_t SW_SPI_RW16(SW_Dev_Spi Dev, uint16_t Write_Date) {
Data16 wdate16, rdate16; Data16 wdate16, rdate16;
wdate16.u16 = Write_Date; wdate16.u16 = Write_Date;
CS_ENABLE(); CS_ENABLE();
@ -111,7 +111,7 @@ uint16_t HW_SPI_RW16(HW_Dev_Spi Dev, uint16_t Write_Date) {
return rdate16.u16; return rdate16.u16;
} }
void HW_SPI_RL16(HW_Dev_Spi Dev, uint16_t *Read_Date, uint32_t Len) { void SW_SPI_RL16(SW_Dev_Spi Dev, uint16_t *Read_Date, uint32_t Len) {
Data16 rdate16; Data16 rdate16;
CS_ENABLE(); CS_ENABLE();
switch (Dev.ENDIAN) { switch (Dev.ENDIAN) {
@ -147,7 +147,7 @@ void HW_SPI_RL16(HW_Dev_Spi Dev, uint16_t *Read_Date, uint32_t Len) {
CS_DISABLE(); CS_DISABLE();
} }
void HW_SPI_WL16(HW_Dev_Spi Dev, uint16_t *Write_Date, uint32_t Len) { void SW_SPI_WL16(SW_Dev_Spi Dev, uint16_t *Write_Date, uint32_t Len) {
Data16 wdate16; Data16 wdate16;
CS_ENABLE(); CS_ENABLE();
switch (Dev.ENDIAN) { switch (Dev.ENDIAN) {
@ -183,7 +183,7 @@ void HW_SPI_WL16(HW_Dev_Spi Dev, uint16_t *Write_Date, uint32_t Len) {
CS_DISABLE(); CS_DISABLE();
} }
void HW_SPI_RWL16(HW_Dev_Spi Dev, uint16_t *Read_Date, uint16_t *Write_Date, uint32_t Len) { void SW_SPI_RWL16(SW_Dev_Spi Dev, uint16_t *Read_Date, uint16_t *Write_Date, uint32_t Len) {
Data16 wdate16, rdate16; Data16 wdate16, rdate16;
CS_ENABLE(); CS_ENABLE();
switch (Dev.ENDIAN) { switch (Dev.ENDIAN) {

49
lib/src/target.c Normal file
View File

@ -0,0 +1,49 @@
#include <errno.h>
#include <sys/time.h>
#include <target.h>
#include <stdint.h>
#if !defined(OS_USE_SEMIHOSTING)
#define STDIN_FILENO 0
#define STDOUT_FILENO 1
#define STDERR_FILENO 2
UART_HandleTypeDef *gHuart;
void RetargetInit(UART_HandleTypeDef *huart) {
gHuart = huart;
/* Disable I/O buffering for STDOUT stream, so that
* chars are sent out as soon as they are printed. */
setvbuf(stdout, NULL, _IONBF, 0);
}
__attribute__((unused)) int _write(int fd, char *ptr, int len) {
HAL_StatusTypeDef hstatus;
if (fd == STDOUT_FILENO || fd == STDERR_FILENO) {
hstatus = HAL_UART_Transmit(gHuart, (uint8_t *) ptr, len, HAL_MAX_DELAY);
if (hstatus == HAL_OK)
return len;
else
return EIO;
}
errno = EBADF;
return -1;
}
int _read(int fd, char *ptr, int len) {
HAL_StatusTypeDef hstatus;
if (fd == STDIN_FILENO) {
hstatus = HAL_UART_Receive(gHuart, (uint8_t *) ptr, 1, HAL_MAX_DELAY);
if (hstatus == HAL_OK)
return 1;
else
return EIO;
}
errno = EBADF;
return -1;
}
#endif //#if !defined(OS_USE_SEMIHOSTING)

131
lib/src/task/task.c Normal file
View File

@ -0,0 +1,131 @@
#include "task.h"
#include <malloc.h>
#include <string.h>
static Task_t *TaskHead = NULL;
static PlatformTicksFunc_t platformTicksFunc = NULL;
TaskStatus_t TaskInit(PlatformTicksFunc_t ticksFunc) {
platformTicksFunc = ticksFunc;
TaskHead = (Task_t *) malloc(sizeof(Task_t));
memset(TaskHead, 0, sizeof(Task_t));
TaskHead->enable = false;
return true;
}
TaskStatus_t TaskCreat(Task_t *task, TaskTime_t time, TaskCnt_t runcnt, Task_Callback_t callback, void *userdata) {
if (!callback) {
return false;
}
if (task) {
TaskDel(task);
}
task = (Task_t *) malloc(sizeof(Task_t));
memset(task, 0, sizeof(Task_t));
task->intervaltime = time;
task->lasttime = platformTicksFunc() + task->intervaltime;
task->runcnt = runcnt;
task->enable = true;
task->callback = callback;
task->userdata = userdata;
task->next = NULL;
return TaskAdd(task);;
}
TaskStatus_t TaskAdd(Task_t *task) {
if (task == NULL) {
return false;
}
Task_t *p = TaskHead;
while (p->next != NULL) {
p = p->next;
}
p->next = task;
return true;
}
TaskStatus_t TaskDel(Task_t *task) {
if (task == NULL) {
return false;
}
Task_t *p = TaskHead;
Task_t *prev = NULL;
while (p->next != NULL) {
//保存当前节点的前一个节点的指针
prev = p;
//然后让当前的指针继续往后移动
p = p->next;
//判断，找到了要删除的数据
if (p == task) {
//两种情况，一种是普通节点，还有一种是尾节点
if (p->next != NULL) //普通节点的情况
{
prev->next = p->next;
free(p);
p = NULL;
} else //尾节点的情况
{
prev->next = NULL; //将这个尾节点的上一个节点的指针域指向空
free(p);
p = NULL;
}
return true;
}
}
return false;
}
TaskStatus_t TaskStart(Task_t *task) {
if (task == NULL) {
return false;
}
if (task->runcnt == 0) { task->runcnt = 1; }
task->enable = true;
task->lasttime = platformTicksFunc() + task->intervaltime;
return true;
}
TaskStatus_t TaskStop(Task_t *task) {
if (task == NULL) {
return false;
}
task->enable = false;
return true;
}
TaskStatus_t TaskSetCnt(Task_t *task, TaskCnt_t runcnt) {
if (task == NULL) {
return false;
}
task->runcnt = runcnt;
if (!task->enable && runcnt != 0) task->enable = true;
return true;
}
TaskStatus_t TaskSetTime(Task_t *task, TaskTime_t time) {
if (task == NULL) {
return false;
}
task->intervaltime = time;
return true;
}
TaskStatus_t TaskRun(void) {
Task_t *p = TaskHead;
while (p != NULL) {
if (p->enable == true && platformTicksFunc() >= p->lasttime) {
if (p->runcnt == 0) {
p->enable = false;
p->lasttime = 0;
} else if (p->runcnt > 0) {
p->runcnt--;
}
if (p->callback) {
p->callback(p, p->userdata);
p->lasttime = platformTicksFunc() + p->intervaltime;
}
}
p = p->next;
}
return true;
}

16
main.c
View File

@ -3,12 +3,20 @@
#include <time.h> #include <time.h>
#include "t_spi.h" #include "t_spi.h"
#include "t_iic.h" #include "t_iic.h"
#include "t_task.h"
#include "t_arg.h"
void Test(char *name, void (*pFunction)()) {
printf("\n------< %s TEST >------\n", name);
pFunction();
printf("\n------< %s END >------\n", name);
}
int main() { int main() {
srand((unsigned)time(NULL)); srand((unsigned)time(NULL));
printf("\nSPI TEST\n"); Test("SPI", Test_spi);
Test_spi(); Test("IIC", Test_iic);
printf("\nIIC TEST\n"); Test("ArgPase", Test_argpase);
Test_iic(); Test("Task", Test_task);
return 0; return 0;
} }