一、C语言中的关键字
C语言中的关键字按照功能分为:
- 数据类型(常用char, short, int, long, unsigned, float, double)
- 运算和表达式( =, +, -, *, while, do-while, if, goto, switch-case)
- 数据存储(auto, static, extern,const, register,volatile,restricted),
- 结构(struct, enum, union,typedef),
- 位操作和逻辑运算(<<, >>, &, |, ~,^, &&),
- 预处理(#define, #include, #error,#if...#elif...#else...#endif等),
- 平台扩展关键字(__asm, __inline,__syscall)
这些关键字共同构成了嵌入式平台的C语言语法。嵌入式的应用从逻辑上可以抽象为三个部分:
- 数据的输入,如传感器,信号,接口输入
- 数据的处理,如协议的解码和封包,AD采样值的转换等
- 数据的输出,如GUI的显示,输出的引脚状态,DA的输出控制电压,PWM波的占空比等
对于数据的管理就贯穿着整个嵌入式应用的开发,它包含数据类型,存储空间管理,位和逻辑操作,以及数据结构,C语言从语法上支撑上述功能的实现,并提供相应的优化机制,以应对嵌入式下更受限的资源环境。
数据类型
C语言支持常用的字符型,整型,浮点型变量,有些编译器如keil还扩展支持bit(位)和sfr(寄存器)等数据类型来满足特殊的地址操作。C语言只规定了每种基本数据类型的最小取值范围,因此在不同芯片平台上相同类型可能占用不同长度的存储空间,这就需要在代码实现时考虑后续移植的兼容性,而C语言提供的typedef就是用于处理这种情况的关键字,在大部分支持跨平台的软件项目中被采用,典型的如下:
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
......
typedef signed int int32_t;
既然不同平台的基本数据宽度不同,那么如何确定当前平台的基础数据类型如int的宽度,这就需要C语言提供的接口sizeof,实现如下。
printf("int size:%d, short size:%d, char size:%d\n", sizeof(int), sizeof(char), sizeof(short));
这里还有重要的知识点,就是指针的宽度,如:
char *p;
printf("point p size:%d\n", sizeof(p));
其实这就和芯片的可寻址宽度有关,如32位MCU的宽度就是4,64位MCU的宽度就是8,在有些时候这也是查看MCU位宽比较简单的方式。
内存管理和存储架构
C语言允许程序变量在定义时就确定内存地址,通过作用域,以及关键字extern,static,实现了精细的处理机制,按照在硬件的区域不同,内存分配有三种方式(节选自C++高质量编程):
- 从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。例如全局变量,static 变量。
- 在栈上创建。在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中 ,效率很高,但是分配的内存容量有限。
- 从堆上分配,亦称动态内存分配。程序在运行的时候用 malloc 或 new 申请任意多少的内存,程序员自己负责在何时用 free 或 delete 释放内存。动态内存的生存期由程序员决定,使用非常灵活,但同时遇到问题也最多。
这里先看个简单的C语言实例。
//main.c#include <stdio.h>#include <stdlib.h>
static int st_val; //静态全局变量 -- 静态存储区
int ex_val; //全局变量 -- 静态存储区int main(void)
{
int a = 0; //局部变量 -- 栈上申请
int *ptr = NULL; //指针变量
static int local_st_val = 0; //静态变量
local_st_val += 1;
a = local_st_val;
ptr = (int *)malloc(sizeof(int)); //从堆上申请空间
if(ptr != NULL)
{
printf("*p value:%d", *ptr);
free(ptr);
ptr = NULL;
//free后需要将ptr置空,否则会导致后续ptr的校验失效,出现野指针
}
}
C语言的作用域不仅描述了标识符的可访问的区域,其实也规定了变量的存储区域,在文件作用域的变量st_val和ex_val被分配到静态存储区,其中static关键字主要限定变量能否被其它文件访问,而代码块作用域中的变量a, ptr和local_st_val则要根据类型的不同,分配到不同的区域,其中a是局部变量,被分配到栈中,ptr作为指针,由malloc分配空间,因此定义在堆中,而local_st_val则被关键字限定,表示分配到静态存储区,这里就涉及到重要知识点,static在文件作用域和代码块作用域的意义是不同的:在文件作用域用于限定函数和变量的外部链接性(能否被其它文件访问), 在代码块作用域则用于将变量分配到静态存储区。
对于C语言,如果理解上述知识对于内存管理基本就足够,但对于嵌入式C来说,定义一个变量,它不一定在内存(SRAM)中,也有可能在FLASH空间,或直接由寄存器存储(register定义变量或者高优化等级下的部分局部变量),如定义为const的全局变量定义在FLASH中,定义为register的局部变量会被优化到直接放在通用寄存器中,在优化运行速度,或者存储受限时,理解这部分知识对于代码的维护就很有意义。此外,嵌入式C语言的编译器中会扩展内存管理机制,如支持分散加载机制和__attribute__((section("用户定义区域"))),允许指定变量存储在特殊的区域如(SDRAM, SQI FLASH), 这强化了对内存的管理,以适应复杂的应用环境场景和需求。
LD_ROM 0x00800000 0x10000 { ;load region size_region
EX_ROM 0x00800000 0x10000 { ;load address = execution address
*.o (RESET, +First)
*(InRoot$$Sections)
.ANY (+RO)
}
EX_RAM 0x20000000 0xC000 { ;rw Data
.ANY (+RW +ZI)
}
EX_RAM1 0x2000C000 0x2000 {
.ANY(MySection)
}
EX_RAM2 0x40000000 0x20000{
.ANY(Sdram)
}
}
int a[10] __attribute__((section("Mysection")));
int b[100] __attribute__((section("Sdram")));
采用这种方式,我们就可以将变量指定到需要的区域,这在某些情况下是必须的,如做GUI或者网页时因为要存储大量图片和文档,内部FLASH空间可能不足,这时就可以将变量声明到外部区域,另外内存中某些部分的数据比较重要,为了避免被其它内容覆盖,可能需要单独划分SRAM区域,避免被误修改导致致命性的错误,这些经验在实际的产品开发中是常用且重要,不过因为篇幅原因,这里只简略的提供例子,如果工作中遇到这种需求,建议详细去了解下。
至于堆的使用,对于嵌入式Linux来说,使用起来和标准C语言一致,注意malloc后的检查,释放后记得置空,避免"野指针“,不过对于资源受限的单片机来说,使用malloc的场景一般较少,如果需要频繁申请内存块的场景,都会构建基于静态存储区和内存块分割的一套内存管理机制,一方面效率会更高(用固定大小的块提前分割,在使用时直接查找编号处理),另一方面对于内存块的使用可控,可以有效避免内存碎片的问题,常见的如RTOS和网络LWIP都是采用这种机制,我个人习惯也采用这种方式,所以关于堆的细节不在描述,如果希望了解,可以参考<C Primer Plus>中关于存储相关的说明。
指针和数组
数组和指针往往是引起程序bug的主要原因,如数组越界,指针越界,非法地址访问,非对齐访问,这些问题背后往往都有指针和数组的影子,因此理解和掌握指针和数组,是成为合格C语言开发者的必经之路!
数组是由相同类型元素构成,当它被声明时,编译器就根据内部元素的特性在内存中分配一段空间,另外C语言也提供多维数组,以应对特殊场景的需求,而指针则是提供使用地址的符号方法,只有指向具体的地址才有意义,C语言的指针具有最大的灵活性,在被访问前,可以指向任何地址,这大大方便了对硬件的操作,但同时也对开发者有了更高的要求。参考如下代码。
int main(void)
{
char cval[] = "hello";
int i;
int ival[] = {1, 2, 3, 4};
int arr_val[][2] = {{1, 2}, {3, 4}};
const char *pconst = "hello";
char *p;
int *pi;
int *pa;
int **par;
p = cval;
p++; //addr增加1
pi = ival;
pi+=1; //addr增加4
pa = arr_val[0];
pa+=1; //addr增加4
par = arr_val;
par++; //addr增加8
for(i=0; i<sizeof(cval); i++)
{
printf("%d ", cval[i]);
}
printf("\n");
printf("pconst:%s\n", pconst);
printf("addr:%d, %d\n", cval, p);
printf("addr:%d, %d\n", icval, pi);
printf("addr:%d, %d\n", arr_val, pa);
printf("addr:%d, %d\n", arr_val, par);
}
/* PC端64位系统下运行结果
0x68 0x65 0x6c 0x6c 0x6f 0x0
pconst:hello
addr:6421994, 6421995
addr:6421968, 6421972
addr:6421936, 6421940
addr:6421936, 6421944 */
对于数组来说,一般从0开始获取值,以length-1作为结束,通过[0, length)半开半闭区间访问,这一般不会出问题,但是某些时候,我们需要倒着读取数组时,有可能错误的将length作为起始点,从而导致访问越界,另外在操作数组时,有时为了节省空间,将访问的下标变量i定义为unsigned char类型,而C语言中unsigned char类型的范围是0~255,如果数组较大,会导致数组超过时无法截止,从而陷入死循环,这种在最初代码构建时很容易避免,但后期如果更改需求,在加大数组后,在使用数组的其它地方都会有隐患,需要特别注意。
由于,指针占有的空间与芯片的寻址宽度有关,32位平台为4字节,64位为8字节,而指针的加减运算中的长度又与它的类型相关,如char类型为1,int类型为4,如果你仔细观察上面的代码就会发现par的值增加了8,这是因为指向指针的指针,对应的变量是指针,也就是长度就是指针类型的长度,在64位平台下为8,如果在32位平台则为4,这些知识理解起来并不困难,但是这些特性在工程运用中稍有不慎,就会埋下不易察觉的问题。另外指针还支持强制转换,这在某些情况下相当有用,参考如下代码:
#include <stdio.h>
typedef struct
{
int b;
int a;
}STRUCT_VAL;
static __align(4) char arr[8] = {0x12, 0x23, 0x34, 0x45, 0x56, 0x12, 0x24, 0x53};
int main(void)
{
STRUCT_VAL *pval;
int *ptr;
pval = (STRUCT_VAL *)arr;
ptr = (int *)&arr[4];
printf("val:%d, %d", pval->a, pval->b);
printf("val:%d,", *ptr);
}
//0x45342312 0x53241256
//0x53241256
基于指针的强制转换,在协议解析,数据存储管理中高效快捷的解决了数据解析的问题,但是在处理过程中涉及的数据对齐,大小端,是常见且十分易错的问题,如上面arr字符数组,通过__align(4)强制定义为4字节对齐是必要的,这里可以保证后续转换成int指针访问时,不会触发非对齐访问异常,如果没有强制定义,char默认是1字节对齐的,当然这并不就是一定触发异常(由整个内存的布局决定arr的地址,也与实际使用的空间是否支持非对齐访问有关,如部分SDRAM使用非对齐访问时,会触发异常), 这就导致可能增减其它变量,就可能触发这种异常,而出异常的地方往往和添加的变量毫无关系,而且代码在某些平台运行正常,切换平台后触发异常,这种隐蔽的现象是嵌入式中很难查找解决的问题。另外,C语言指针还有特殊的用法就是通过强制转换给特定的物理地址访问,通过函数指针实现回调,如下:
#include <stdio.h>
typedef int (*pfunc)(int, int);
int func_add(int a, int b){
return a+b;
}
int main(void)
{
pfunc *func_ptr;
*(volatile uint32_t *)0x20001000 = 0x01a23131;
func_ptr = func_add;
printf("%d\n", func_ptr(1, 2));
}
这里说明下,volatile易变的,可变的,一般用于以下几种状况:
- 并行设备的硬件寄存器,如:状态寄存器)
- 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
- 多线程应用中被几个任务共享的变量
volatile可以解决用户模式和异常中断访问同一个变量时,出现的不同步问题,另外在访问硬件地址时,volatile也阻止对地址访问的优化,从而确保访问的实际的地址,精通volatile的运用,在嵌入式底层中十分重要,也是嵌入式C从业者的基本要求之一。函数指针在一般嵌入式软件的开发中并不常见,但对许多重要的实现如异步回调,驱动模块,使用函数指针就可以利用简单的方式实现很多应用,当然我这里只能说是抛砖引玉,许多细节知识是值得详细去了解掌握的。
结构类型和对齐
C语言提供自定义数据类型来描述一类具有相同特征点的事务,主要支持的有结构体,枚举和联合体。其中枚举通过别名限制数据的访问,可以让数据更直观,易读,实现如下:
typedef enum {spring=1, summer, autumn, winter }season;
season s1 = summer;
联合体的是能在同一个存储空间里存储不同类型数据的数据类型,对于联合体的占用空间,则是以其中占用空间最大的变量为准,如下:
typedef union{
char c;
short s;
int i;
}UNION_VAL;
UNION_VAL val;
int main(void)
{
printf("addr:0x%x, 0x%x, 0x%x\n",
(int)(&(val.c)), (int)(&(val.s)), (int)(&(val.i)));
val.i = 0x12345678;
if(val.s == 0x5678)
printf("小端模式\n");
else
printf("大端模式\n");
}
/*
addr:0x407970, 0x407970, 0x407970
小端模式
*/
联合体的用途主要通过共享内存地址的方式,实现对数据内部段的访问,这在解析某些变量时,提供了更为简便的方式,此外测试芯片的大小端模式也是联合体的常见应用,当然利用指针强制转换,也能实现该目的,实现如下:
int data = 0x12345678;
short *pdata = (short *)&data;
if(*pdata = 0x5678)
printf("%s\n", "小端模式");
else
printf("%s\n", "大端模式");
可以看出使用联合体在某些情况下可以避免对指针的滥用。结构体则是将具有共通特征的变量组成的集合,比起C++的类来说,它没有安全访问的限制,不支持直接内部带函数,但通过自定义数据类型,函数指针,仍然能够实现很多类似于类的操作,对于大部分嵌入式项目来说,结构化处理数据对于优化整体架构以及后期维护大有便利。
C语言的结构体支持指针和变量的方式访问,通过转换可以解析任意内存的数据,如我们之前提到的通过指针强制转换解析协议。另外通过将数据和函数指针打包,在通过指针传递,是实现驱动层实接口切换的重要基础,有着重要的实践意义,另外基于位域,联合体,结构体,可以实现另一种位操作,这对于封装底层硬件寄存器具有重要意义。通过联合体和位域操作,可以实现对数据内bit的访问,这在寄存器以及内存受限的平台,提供了简便且直观的处理方式,另外对于结构体的另一个重要知识点就是对齐了,通过对齐访问,可以大幅度提高运行效率,但是因为对齐引入的存储长度问题,也是容易出错的问题,对于对齐的理解,可以分类为如下说明。
- 基础数据类型:以默认的的长度对齐,如char以1字节对齐,short以2字节对齐等
- 数组 :按照基本数据类型对齐,第一个对齐了后面的自然也就对齐了。
- 联合体 :按其包含的长度最大的数据类型对齐。
- 结构体:结构体中每个数据类型都要对齐,结构体本身以内部最大数据类型长度对齐
其中union联合体的大小与内部最大的变量int一致,为4字节,根据读取的值,就知道实际内存布局和填充的位置是一致,事实上学会通过填充来理解C语言的对齐机制,是有效且快捷的方式。
预处理机制
C语言提供了丰富的预处理机制,方便了跨平台的代码的实现,此外C语言通过宏机制实现的数据和代码块替换,字符串格式化,代码段切换,对于工程应用具有重要意义,下面按照功能需求,描述在C语言运用中的常用预处理机制。
#include 包含文件命令,在C语言中,它执行的效果是将包含文件中的所有内容插入到当前位置,这不只包含头文件,一些参数文件,配置文件,也可以使用该文件插入到当前代码的指定位置。其中<>和""分别表示从标准库路径还是用户自定义路径开始检索。
#define宏定义,常见的用法包含定义常量或者代码段别名,当然某些情况下配合##格式化字符串,可以实现接口的统一化处理,实例如下:
#define MAX_SIZE 10
#define MODULE_ON 1
#define ERROR_LOOP() do{\
printf("error loop\n");\
}while(0);
#define global(val) g_##val
int global(v) = 10;
int global(add)(int a, int b)
{
return a+b;
}
#if..#elif...#else...#endif, #ifdef..#endif, #ifndef...#endif条件选择判断,条件选择主要用于切换代码块,这种综合性项目和跨平台项目中为了满足多种情况下的需求往往会被使用。
#undef 取消定义的参数,避免重定义问题。
#error,#warning用于用户自定义的告警信息,配合#if,#ifdef使用,可以限制错误的预定义配置。
#pragma 带参数的预定义处理,常见的#pragma pack(1), 不过使用后会导致后续的整个文件都以设置的字节对齐,配合push和pop可以解决这种问题,代码如下:
#pragma pack(push)
#pragma pack(1)
struct TestA
{
char i;
int b;
}A;
#pragma pack(pop); //注意要调用pop,否则会导致后续文件都以pack定义值对齐,执行不符合预期
//等同于
struct _TestB{
char i;
int b;
}__attribute__((packed))A;
二、
1 十六进制字符转整型数字
功能:
将16进制的字符串转换为10进制的数字。我是没有找到相应的库函数,所以参考网上的代码自己手动写了个函数来实现。
常用的函数有atoi,atol,他们都是将10进制的数字字符串转换为int或是long类型,所以在有些情况下不适用。
/*=============================================================================
# FileName: hex2dec.cpp
# Desc: Convert a hex string to a int number
# Author: Caibiao Lee
# Version:
# LastChange: 2018-11-26
# History:
=============================================================================*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
int c2i(char ch)
{
// 如果是数字,则用数字的ASCII码减去48, 如果ch = '2' ,则 '2' - 48 = 2
if(isdigit(ch))
return ch - 48;
// 如果是字母,但不是A~F,a~f则返回
if( ch < 'A' || (ch > 'F' && ch < 'a') || ch > 'z' )
return -1;
// 如果是大写字母,则用数字的ASCII码减去55, 如果ch = 'A' ,则 'A' - 55 = 10
// 如果是小写字母,则用数字的ASCII码减去87, 如果ch = 'a' ,则 'a' - 87 = 10
if(isalpha(ch))
return isupper(ch) ? ch - 55 : ch - 87;
return -1;
}
int hex2dec(char *hex)
{
int len;
int num = 0;
int temp;
int bits;
int i;
char str[64] = {0};
if(NULL==hex)
{
printf("input para error \n");
return 0;
}
if(('0'==hex[0])&&(('X'==hex[1])||('x'==hex[1])))
{
strcpy(str,&hex[2]);
}else
{
strcpy(str,hex);
}
printf("input num = %s \n",str);
// 此例中 str = "1de" 长度为3, hex是main函数传递的
len = strlen(str);
for (i=0, temp=0; i<len; i++, temp=0)
{
// 第一次:i=0, *(str + i) = *(str + 0) = '1', 即temp = 1
// 第二次:i=1, *(str + i) = *(str + 1) = 'd', 即temp = 13
// 第三次:i=2, *(str + i) = *(str + 2) = 'd', 即temp = 14
temp = c2i( *(str + i) );
// 总共3位,一个16进制位用 4 bit保存
// 第一次:'1'为最高位,所以temp左移 (len - i -1) * 4 = 2 * 4 = 8 位
// 第二次:'d'为次高位,所以temp左移 (len - i -1) * 4 = 1 * 4 = 4 位
// 第三次:'e'为最低位,所以temp左移 (len - i -1) * 4 = 0 * 4 = 0 位
bits = (len - i - 1) * 4;
temp = temp << bits;
// 此处也可以用 num += temp;进行累加
num = num | temp;
}
// 返回结果
return num;
}
int main(int argc, char **argv)
{
int l_s32Ret = 0;
if(2!=argc)
{
printf("=====ERROR!======\n");
printf("usage: %s Num \n", argv[0]);
printf("eg 1: %s 0x400\n", argv[0]);
return 0;
}
l_s32Ret = hex2dec(argv[1]);
printf("value hex = 0x%x \n",l_s32Ret);
printf("value dec = %d \n",l_s32Ret);
return 0;
}
运行结果:
biao@ubuntu:~/test/flash$ ./a.out 0x400
input num = 400
value hex = 0x400
value dec = 1024
biao@ubuntu:~/test/flash$
2 字符串转整型
功能:
将正常输入的16进制或是10进制的字符串转换为int数据类型。
/*=============================================================================
# FileName: hex2dec.cpp
# Desc: Convert a hex/dec string to a int number
# Author:
# Version:
# LastChange:
# History:
=============================================================================*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
int String2int(char *strChar)
{
int len=0;
const char *pstrCmp1="0123456789ABCDEF";
const char *pstrCmp2="0123456789abcdef";
char *pstr=NULL;
int uiValue=0;
int j=0;
unsigned int t=0;
int i=0;
if(NULL==strChar)
return -1;
if(0>=(len=strlen((const char *)strChar)))
return -1;
if(NULL!=(pstr=strstr(strChar,"0x"))||NULL!=(pstr=strstr(strChar,"0X")))
{
pstr=(char *)strChar+2;
if(0>=(len=strlen((const char *)pstr)))
return -1;
for(i=(len-1);i>=0;i--)
{
if(pstr[i]>'F')
{
for(t=0;t<strlen((const char *)pstrCmp2);t++)
{
if(pstrCmp2[t]==pstr[i])
uiValue|=(t<<(j++*4));
}
}
else
{
for(t=0;t<strlen((const char *)pstrCmp1);t++)
{
if(pstrCmp1[t]==pstr[i])
uiValue|=(t<<(j++*4));
}
}
}
}
else
{
uiValue=atoi((const char*)strChar);
}
return uiValue;
}
int main(int argc, char **argv)
{
int l_s32Ret = 0;
if(2!=argc)
{
printf("=====ERROR!======\n");
printf("usage: %s Num \n", argv[0]);
printf("eg 1: %s 0x400\n", argv[0]);
return 0;
}
l_s32Ret = String2int(argv[1]);
printf("value hex = 0x%x \n",l_s32Ret);
printf("value dec = %d \n",l_s32Ret);
return 0;
}
3 创建文件并填充固定数据
功能:
创建固定大小的一个文件,并且把这个文件填充为固定的数据。
/*=============================================================================
# FileName: CreateFile.cpp
# Desc: 创建固定大小的文件,然后填充固定的数据
# Author:
# Version:
# LastChange:
# History:
=============================================================================*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
//#define FILL_DATA_VALUE 0xff
#define FILL_DATA_VALUE 0x30 //char 0
int c2i(char ch)
{
if(isdigit(ch))
return ch - 48;
if( ch < 'A' || (ch > 'F' && ch < 'a') || ch > 'z' )
return -1;
if(isalpha(ch))
return isupper(ch) ? ch - 55 : ch - 87;
return -1;
}
int hex2dec(char *hex)
{
int len;
int num = 0;
int temp;
int bits;
int i;
char str[64] = {0};
if(NULL==hex)
{
printf("input para error \n");
return 0;
}
if(('0'==hex[0])&&(('X'==hex[1])||('x'==hex[1])))
{
strcpy(str,&hex[2]);
}else
{
strcpy(str,hex);
}
printf("input num = %s \n",str);
len = strlen(str);
for (i=0, temp=0; i<len; i++, temp=0)
{
temp = c2i( *(str + i) );
bits = (len - i - 1) * 4;
temp = temp << bits;
num = num | temp;
}
return num;
}
int main(int argc, char **argv)
{
FILE *l_pFile = NULL;
int l_s32Rest = 0;
unsigned int l_WriteLen = 0;
unsigned int l_FileLen = 0;
unsigned char TempData[1024] = {FILL_DATA_VALUE};
if(3!=argc)
{
printf("usage: %s FileName FileLen \n ", argv[0]);
printf("eg: %s ./Outfile.bin 0x400 \n ", argv[0]);
return 0;
};
const char *l_pFileName = argv[1];
if(NULL==l_pFileName)
{
printf("input file name is NULL \n");
return -1;
}
if(('0'==argv[2][0])&&(('X'==argv[2][1])||('x'==argv[2][1])))
{
l_FileLen = hex2dec(argv[2]);
}else
{
l_FileLen = atoi(argv[2]);
}
printf("Need To Write Data Len %d \n",l_FileLen);
printf("Fill Data Vale = 0x%x \n",FILL_DATA_VALUE);
for(int i=0;i<1024;i++)
{
TempData[i] = FILL_DATA_VALUE;
}
l_pFile = fopen(l_pFileName,"w+");
if(l_pFile==NULL)
{
printf("open file %s error \n",l_pFileName);
return -1;
}
while(l_WriteLen<l_FileLen)
{
if(l_FileLen<1024)
{
l_s32Rest = fwrite(TempData,1,l_FileLen,l_pFile);
}
else
{
l_s32Rest = fwrite(TempData,1,1024,l_pFile);
}
if(l_s32Rest <= 0)
{
break;
};
l_WriteLen +=l_s32Rest;
}
if(NULL!=l_pFile)
{
fclose(l_pFile);
l_pFile = NULL;
}
return 0;
}
运行结果:
biao@ubuntu:~/test/flash$ gcc CreateFile.cpp
biao@ubuntu:~/test/flash$ ls
a.out CreateFile.cpp hex2dec.cpp main.cpp out.bin
biao@ubuntu:~/test/flash$ ./a.out ./out.bin 0x10
input num = 10
Need To Write Data Len 16
Fill Data Vale = 0x30
biao@ubuntu:~/test/flash$ ls
a.out CreateFile.cpp hex2dec.cpp main.cpp out.bin
biao@ubuntu:~/test/flash$ vim out.bin
1 0000000000000000
4 批量处理图片
功能:
批处理将图片前面固定的字节数删除。
/*=============================================================================
# FileName: CutFile.cpp
# Desc: 批量处理,将图片的前面固定字节删除
# Author:
# Version:
# LastChange:
# History:
=============================================================================*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#define START_READ_POSITION 128
#define PHOTO_START_TIME 83641
//l_s32PhotoTime = 92809;
int Cut_file(char * InputFile)
{
FILE *l_pFileInput = NULL;
FILE *l_pFileOutput = NULL;
char l_ars8OutputName[128] = {0};
unsigned char l_arru8TempData[1024] = {0};
int l_s32Ret = 0;
static unsigned int ls_u32Num = 0;
if(NULL== InputFile)
{
goto ERROR;
}
//sprintf(l_ars8OutputName,"./outfile/_%s",&InputFile[8]);
sprintf(l_ars8OutputName,"./outfile/00%d.jpg",ls_u32Num++);
//printf("out file name %s \n",l_ars8OutputName);
l_pFileInput = fopen(InputFile,"rb+");
if(NULL==l_pFileInput)
{
printf("input file open error\n");
goto ERROR;
}
l_pFileOutput = fopen(l_ars8OutputName,"w+");
if(NULL==l_pFileOutput)
{
printf("out file open error\n");
goto ERROR;
}
fseek(l_pFileInput,START_READ_POSITION,SEEK_SET);
while(!feof(l_pFileInput))
{
l_s32Ret = fread(l_arru8TempData,1,1024,l_pFileInput);
if(l_s32Ret<0)
{
break;
}
l_s32Ret = fwrite(l_arru8TempData,1,l_s32Ret,l_pFileOutput);
if(l_s32Ret<0)
{
break;
}
}
ERROR:
if(NULL!=l_pFileOutput)
{
fclose(l_pFileOutput);
l_pFileOutput =NULL;
};
if(NULL !=l_pFileInput);
{
fclose(l_pFileInput);
l_pFileInput =NULL;
}
}
int main(void)
{
char l_arrs8InputName[128] = {0};
char l_s8PhotoChannel = 0;
int l_s32PhotoTime = 0;
l_s8PhotoChannel = 3;
l_s32PhotoTime = PHOTO_START_TIME;
/**从第一通道开始**/
for(int j=1;j<l_s8PhotoChannel;j++)
{
for(int i=l_s32PhotoTime;i<235959;i++)
{
memset(l_arrs8InputName,0,sizeof(l_arrs8InputName));
sprintf(l_arrs8InputName,"./image/%dY%06d.jpg",j,i);
if(0==access(l_arrs8InputName,F_OK))
{
printf("%s\n",l_arrs8InputName);
Cut_file(l_arrs8InputName);
}
}
}
}
运行结果:
biao@ubuntu:~/test/photo$ gcc CutFile.cpp
biao@ubuntu:~/test/photo$ ls
a.out CutFile.cpp image outfile
biao@ubuntu:~/test/photo$ ./a.out
./image/1Y083642.jpg
./image/1Y083714.jpg
./image/1Y083747.jpg
./image/1Y083820.jpg
./image/1Y083853.jpg
./image/1Y083925.jpg
./image/1Y084157.jpg
./image/1Y084228.jpg
./image/1Y084301.jpg
./image/1Y084334.jpg
./image/1Y084406.jpg
./image/1Y084439.jpg
./image/1Y084711.jpg
./image/1Y084742.jpg
./image/1Y173524.jpg
./image/1Y173556.jpg
./image/1Y173629.jpg
./image/1Y173702.jpg
./image/1Y173933.jpg
./image/1Y174004.jpg
./image/1Y174244.jpg
./image/1Y174315.jpg
./image/1Y174348.jpg
./image/1Y174420.jpg
./image/1Y174454.jpg
./image/1Y174733.jpg
biao@ubuntu:~/test/photo$ tree
.
├── a.out
├── CutFile.cpp
├── image
│ ├── 1Y083642.jpg
│ ├── 1Y083714.jpg
│ ├── 1Y083747.jpg
│ ├── 1Y083820.jpg
│ ├── 1Y083853.jpg
│ ├── 1Y083925.jpg
│ ├── 1Y084157.jpg
│ ├── 1Y084228.jpg
│ ├── 1Y084301.jpg
│ ├── 1Y084334.jpg
│ ├── 1Y084406.jpg
│ ├── 1Y084439.jpg
│ ├── 1Y084711.jpg
│ ├── 1Y084742.jpg
│ ├── 1Y173524.jpg
│ ├── 1Y173556.jpg
│ ├── 1Y173629.jpg
│ ├── 1Y173702.jpg
│ ├── 1Y173933.jpg
│ ├── 1Y174004.jpg
│ ├── 1Y174244.jpg
│ ├── 1Y174315.jpg
│ ├── 1Y174348.jpg
│ ├── 1Y174420.jpg
│ ├── 1Y174454.jpg
│ └── 1Y174733.jpg
└── outfile
├── 000.jpg
├── 0010.jpg
├── 0011.jpg
├── 0012.jpg
├── 0013.jpg
├── 0014.jpg
├── 0015.jpg
├── 0016.jpg
├── 0017.jpg
├── 0018.jpg
├── 0019.jpg
├── 001.jpg
├── 0020.jpg
├── 0021.jpg
├── 0022.jpg
├── 0023.jpg
├── 0024.jpg
├── 0025.jpg
├── 002.jpg
├── 003.jpg
├── 004.jpg
├── 005.jpg
├── 006.jpg
├── 007.jpg
├── 008.jpg
└── 009.jpg
2 directories, 54 files
biao@ubuntu:~/test/photo$
运行前需要创建两个目录,image用来存放需要处理的图片,outfile用来存放处理过后的文件。这种处理文件批处理方式很暴力,偶尔用用还是可以的。
5 IO控制小程序
嵌入式设备系统一般为了节省空间,一般都会对系统进行裁剪,所以很多有用的命令都会被删除。在嵌入式设备中要调试代码也是比较麻烦的,一般只能看串口打印。现在写了个小程序,专门用来查看和控制海思Hi3520DV300芯片的IO电平状态。
/*=============================================================================
# FileName: Hi3520_IO_CTRL.cpp
# Desc: Hi3520DV300 IO Write and Read
# Author:
# Version:
# LastChange:
# History:
=============================================================================*/
#include <stdio.h>
#include <stdlib.h>
#include "hstGpioAL.h"
int PrintfInputTips(char *ps8Name)
{
printf("=========== error!!! ========\n\n");
printf("usage Write: %s GPIO bit value \n", ps8Name);
printf("usage Read : %s GPIO bit \n", ps8Name);
printf("eg Write 1 to GPIO1_bit02 : %s 1 2 1\n", ps8Name);
printf("eg Read GPIO1_bit02 Value : %s 1 2 \n\n", ps8Name);
printf("=============BT20==================\n")
printf("USB HUB GPIO_0_2 1_UP; 0_Down \n");
printf("RESET_HD GPIO_13_0 0_EN; 1_disEN\n");
printf("Power_HD GPIO_13_3 1_UP; 0_Down \n");
return 0;
}
int main(int argc, char **argv)
{
if((3!=argc)&&(4!=argc))
{
PrintfInputTips(argv[0]);
return -1;
}
unsigned char l_u8GPIONum = 0;
unsigned char l_u8GPIOBit = 0;
unsigned char l_u8SetValue = 0;
GPIO_GROUP_E l_eGpioGroup;
GPIO_BIT_E l_eBit;
GPIO_DATA_E l_eData;
l_u8GPIONum = atoi(argv[1]);
l_u8GPIOBit = atoi(argv[2]);
if(l_u8GPIONum<14)
{
l_eGpioGroup = (GPIO_GROUP_E)l_u8GPIONum;
}else
{
printf("l_u8GPIONum error l_u8GPIONum = %d\n",l_u8GPIONum);
return -1;
};
if(l_u8GPIOBit<8)
{
l_eBit = (GPIO_BIT_E)l_u8GPIOBit;
}else
{
printf("l_u8GPIOBit error l_u8GPIOBit = %d\n",l_u8GPIOBit);
return -1;
}
if(NULL!=argv[3])
{
l_u8SetValue = atoi(argv[3]);
if(0==l_u8SetValue)
{
l_eData = (GPIO_DATA_E)l_u8SetValue;
}else if(1==l_u8SetValue)
{
l_eData = (GPIO_DATA_E)l_u8SetValue;
}else
{
printf("l_u8SetValue error l_u8SetValue = %d\n",l_u8SetValue);
}
}
if(3==argc)
{/**read**/
printf("read GPIO%d Bit%d \n",l_u8GPIONum,l_u8GPIOBit);
/**set input**/
HstGpio_Set_Direction(l_eGpioGroup, l_eBit, GPIO_INPUT);
/**read **/
char l_s8bit_val = 0;
HstGpio_Get_Value(l_eGpioGroup, l_eBit, &l_s8bit_val);
printf("read Data = %d \n",l_s8bit_val);
}else if(4==argc)
{/**write**/
printf("Write GPIO %d; Bit %d; Value %d\n",l_u8GPIONum,l_u8GPIOBit,l_u8SetValue);
/***set IO output*/
HstGpio_Set_Direction(l_eGpioGroup, l_eBit, GPIO_OUPUT);
/**Write To IO**/
HstGpio_Set_Value(l_eGpioGroup,l_eBit,l_eData);
}else
{
}
return 0;
}
6 文件固定位置插入数据
在文件的固定位置插入固定的数据。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define BASIC_FILE_NAME "./nandflash.bin"
#define UBOOT_FILE_NAME "./u-boot.bin"
#define KERNEL_FILE_NAME "./kernel.bin"
#define ROOTFS_FILE_NAME "./rootfs.bin"
#define APP_FILE_NAME "./app.bin"
#define UBOOT_POSITION 0x00
#define KERNEL_POSITION 0x100000
#define ROOTFS_POSITION 0x500000
#define APP_POSITION 0x2700000
int InsertData(FILE *pfBasic,FILE *psInsert,int s32Position)
{
int l_S32Ret = 0;
unsigned char l_arru8Temp[1024] = {0xff};
fseek(pfBasic,s32Position,SEEK_SET);
fseek(psInsert,0,SEEK_SET);
while(1)
{
l_S32Ret = fread(l_arru8Temp,1,1024,psInsert);
if(l_S32Ret > 0)
{
l_S32Ret = fwrite(l_arru8Temp,1,l_S32Ret,pfBasic);
if(l_S32Ret<=0)
{
printf("line %d error l_S32Ret = %d \n",__LINE__,l_S32Ret);
return -1;
}
}else
{
break;
}
}
return 0;
}
int main(void)
{
int l_s32Ret = 0;
FILE *l_pfBasec = NULL;
FILE *l_pfUboot = NULL;
FILE *l_pfKernel = NULL;
FILE *l_pfRootfs = NULL;
FILE *l_pfApp = NULL;
l_pfBasec = fopen(BASIC_FILE_NAME,"r+");
if(NULL==l_pfBasec)
{
printf("line %d error \n",__LINE__);
goto ERROR;
}
l_pfUboot = fopen(UBOOT_FILE_NAME,"r");
if(NULL==l_pfUboot)
{
printf("line %d error \n",__LINE__);
goto ERROR;
}
l_pfKernel = fopen(KERNEL_FILE_NAME,"r");
if(NULL==l_pfKernel)
{
printf("line %d error \n",__LINE__);
goto ERROR;
}
l_pfRootfs = fopen(ROOTFS_FILE_NAME,"r");
if(NULL==l_pfRootfs)
{
printf("line %d error \n",__LINE__);
goto ERROR;
}
l_pfApp = fopen(APP_FILE_NAME,"r");
if(NULL==l_pfApp)
{
printf("line %d error \n",__LINE__);
goto ERROR;
}
if(0> InsertData(l_pfBasec,l_pfUboot,UBOOT_POSITION))
{
printf("line %d error \n",__LINE__);
goto ERROR;
}
if(0> InsertData(l_pfBasec,l_pfKernel,KERNEL_POSITION))
{
printf("line %d error \n",__LINE__);
goto ERROR;
}
if(0> InsertData(l_pfBasec,l_pfRootfs,ROOTFS_POSITION))
{
printf("line %d error \n",__LINE__);
goto ERROR;
}
if(0> InsertData(l_pfBasec,l_pfApp,APP_POSITION))
{
printf("line %d error \n",__LINE__);
goto ERROR;
}
ERROR:
if(NULL!=l_pfBasec)
{
fclose(l_pfBasec);
l_pfBasec = NULL;
}
if(NULL!=l_pfUboot)
{
fclose(l_pfUboot);
l_pfUboot = NULL;
}
if(NULL!=l_pfKernel)
{
fclose(l_pfKernel);
l_pfKernel = NULL;
}
if(NULL!=l_pfRootfs)
{
fclose(l_pfRootfs);
l_pfRootfs = NULL;
}
if(NULL!=l_pfApp)
{
fclose(l_pfApp);
l_pfApp = NULL;
}
return 0;
}
7 获取本地IP地址
在linux设备中获取本地IP地址可以使用下面的程序,支持最大主机有三个网口的设备,当然这个网卡数可以修改。
#include <stdio.h>
#include <ifaddrs.h>
#include <netinet/in.h>
#include <string.h>
#include <arpa/inet.h>
int get_local_ip(char *ps8IpList)
{
struct ifaddrs *ifAddrStruct;
char l_s8IpAddr[INET_ADDRSTRLEN];
void *tmpAddrPtr;
int l_s32IPCount = 0;
getifaddrs(&ifAddrStruct);
while (ifAddrStruct != NULL)
{
if (ifAddrStruct->ifa_addr->sa_family==AF_INET)
{
tmpAddrPtr=&((struct sockaddr_in *)ifAddrStruct->ifa_addr)->sin_addr;
inet_ntop(AF_INET, tmpAddrPtr, l_s8IpAddr, INET_ADDRSTRLEN);
if (strcmp(l_s8IpAddr, "127.0.0.1") != 0)
{
if(l_s32IPCount == 0)
{
memcpy(ps8IpList, l_s8IpAddr, INET_ADDRSTRLEN);
} else
{
memcpy(ps8IpList+INET_ADDRSTRLEN, l_s8IpAddr, INET_ADDRSTRLEN);
}
l_s32IPCount++;
}
}
ifAddrStruct=ifAddrStruct->ifa_next;
}
freeifaddrs(ifAddrStruct);
return l_s32IPCount;
}
int main()
{
char l_arrs8IpAddrList[3][INET_ADDRSTRLEN];
int l_s32AddrCount;
memset(l_arrs8IpAddrList, 0, sizeof(l_arrs8IpAddrList));
l_s32AddrCount = get_local_ip(*l_arrs8IpAddrList);
for(l_s32AddrCount;l_s32AddrCount>0;l_s32AddrCount--)
{
printf("Server Local IP%d: %s\n",l_s32AddrCount,l_arrs8IpAddrList[l_s32AddrCount-1]);
}
return 0;
}