嵌入式C语言

已于 2023-11-11 09:40:54 修改
阅读量398 收藏 5
点赞数 1
分类专栏： 嵌入式 文章标签： c语言 嵌入式硬件 单片机
于 2023-03-30 11:46:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lshuangye/article/details/129854340
版权

文章目录

一、char/short/int关键字

  1. 不同数据类型存储的长度

    #include <stdio.h>

char a;    //0x00~0xff
short b;   //0x00~0xffff
int c;     //0x00~0xffffffff

void main()
{
  printf("hello world!\n");
  printf("%d %d %d\n", sizeof(a), sizeof(b), sizeof(c));
}

  2. 数据类型的转换

    #include <stdio.h>

unsigned char time_buffer[4] = { 0x5F, 0xCB, 0x0F, 0x4F };
unsigned int time;

//数据转换函数
unsigned int u8tou32B(unsigned char *buffer)
{
	return (((((((unsigned int)buffer[0]) << 8) | buffer[1]) << 8) | buffer[2]) << 8) | buffer[3];
}

void main()
{
  printf("hello world!\n");
  time = u8tou32B(time_buffer);
  printf("time = %ld s\n",time);
}

二、 if & switch语句

条件判断语句if和switch，当判断的类型较少的时候，使用if去判断；当判断的类型较多的时候，使用switch去判断。

#include <stdio.h>


typedef enum{
	NET_INIT = 0,
	NET_CONNECTING,
	NET_CONNECT_SUCCESS,
	NET_CONNECT_FAIL,
	NET_ERROR,
}E_NET_STATUS;


void main()
{
	printf("hello world\n");

	E_NET_STATUS net_status = NET_CONNECTING;

	//1. 第一种方式
	if (net_status == NET_INIT)
	{
	}
	else if (net_status == NET_CONNECTING)
	{
	}
	else if (net_status == NET_CONNECT_SUCCESS)
	{
	}
	else if (net_status == NET_CONNECT_FAIL)
	{
	}
	else if (net_status == NET_ERROR)
	{
	}

	//2. 第二种方式
	switch (net_status)
	{
    case NET_INIT:
      break;
    case NET_CONNECTING:
      break;
    case NET_CONNECT_SUCCESS:
      break;
    case NET_CONNECT_FAIL:
      break;
    case NET_ERROR:
      break;
    default:
      break;
	}
}

三、 for & while 语句

  1. while 的用法

    # include <stdio.h>

void main()
{
	int wifi_array[5] = { 1, 2, 3, 4, 5 };
	int index = 0;

	while (index < sizeof(wifi_array)/sizeof(int)){
		printf("%d \n", wifi_array[index]);
		index++;
	}
}

  2. for 的用法

    # include <stdio.h>

void main()
{
	int wifi_array[5] = { 1, 2, 3, 4, 5 };

	int sum = 0;
	for (int index = 0; index < sizeof(wifi_array) / sizeof(int); index++)
	{
		sum += wifi_array[index];
	}
	printf("%d \n", sum);
}

四、static 关键字

此处我们需要创建两个文件

主函数main.cpp

# include <stdio.h>
//这里使用 "" 符号加载自己创建的头文件
# include "test.h"

void main()
{
	printf("hello world\n");
	test();
	test1();
	test1();
	test1();
}

test.cpp文件

# include <stdio.h>
# include "test.h"


//创建静态函数,表明函数只能在本文件中使用,其他文件若是调用会报错
//若其他文件想要使用,可以创建外部函数,把此函数放到外部函数内部。
static void test_printf()
{
	printf("test_printf\n");
}

void test(void)
{
	test_printf();
}

void test1()
{
  //创建静态变量,编译器只会执行一次这个语句
	static int num = 0;
	num++;
	printf("%d\n", num);
}

test.h文件

//文件多的时候，多个文件调用同一个文件，会出现重复定义的情况
//我们使用 #ifndef---#endif 来确保头文件重复创建

#ifndef _TEST_H_
#define _TEST_H_

void test(void);
//此处使用会报错
static void test_printf(void);
void test1(void);

#endif

运行结果：

hello world
test_printf
1
2
3

五、define 关键字

# include <stdio.h>

//算法运算需要加上括号
# define A (3+1)

//使用define关键字声明一个值,程序中使用 ifdef 来判断,
//可以很方便的应用于程序调试中
//# define VERSION_PRE 0
# define VERSION_GLOD 1

void main()
{
	printf("hello world\n");

	printf("sum = %d \n", 10 * A);

#ifdef VERSION_PRE
	printf("THIS is a Pre version\n");
#elif VERSION_GLOD
	printf("THIS is Gold version\n");
#endif
}

六、typedef 关键字

# include <stdio.h>

//注意typedef和define的区别
typedef char* PCHAR1;
#define PCHAR2 char*

//c1、c2都为char*,typedef为char* 引入了一个新的别名
PCHAR1 c1, c2;
//等价于
char *c1, *c2;

//相当于char* c3,c4; c3是char*,而c4是char
PCHAR2 c3, c4;
//等价于
char* c3;
char c4;

//在单片机开发中,定义变量时使用unsigned char会过于繁琐,通常把unsigned char重定义为uint8
//当程序中需要定义unsigned char时,直接使用uint8即可。
typedef unsigned char  uint8;
typedef unsigned short uint16;
typedef unsigned int   uint32;

七、enum 关键字

# include <stdio.h>


//使用enum定义枚举类型
typedef enum{
	NET_INIT = 1,
	NET_CONNECTING,
	NET_CONNECT_SUCCESS,
	NET_CONNECT_FAIL,
	NET_ERROR,
}E_NET_STATUS;


void main()
{
  //定义枚举类型变量,可以限制数据的范围,方便检查程序
	E_NET_STATUS ble_status = NET_CONNECTING;
	
  //以下判断网络的连接状态
	if (ble_status == NET_INIT)
	{
		printf("Initing\n");
	}
	else if (ble_status == NET_CONNECTING)
	{
		printf("Connecting\n");
	}
	else if (ble_status == NET_CONNECT_SUCCESS)
	{
		printf("Connect success\n");
	}
	else if (ble_status == NET_CONNECT_FAIL)
	{
		printf("Connect fail\n");
	}
	else
	{
		printf("error");
	}
}

八、struct 类型

使用struct把同一事物的所有属性包含在一起，使程序结构整洁，条理清晰。

# include <stdio.h>


typedef enum{
	NET_INIT = 1,
	NET_CONNECTING,
	NET_CONNECT_SUCCESS,
	NET_CONNECT_FAIL,
	NET_ERROR,
}E_NET_STATUS;

typedef struct{
	int num;
}T_Manager;

typedef struct{
	int num;
	int time;
	int money;
}T_Pay;

typedef struct{
	int system_status;
	int net_status;
	int motor_status[4];
	int pay_status;
	T_Pay m_pay;
	T_Manager m_manager;
}T_Device;


//定义两个不同的网卡
T_Device g_Device;
T_Device g_Device1;


void main()
{
	g_Device.net_status = NET_INIT;
	g_Device1.net_status = NET_CONNECTING;
	g_Device.m_pay.num = 1;
	g_Device.m_manager.num = 2;

	printf("Net status = %d\n", g_Device.net_status);
	printf("Net1 status = %d\n", g_Device1.net_status);
	printf("m_pay = %d\n", g_Device.m_pay.num);
	printf("m_Manager = %d\n", g_Device.m_manager.num);
}

执行结果：

Net status = 1
Net1 status = 2
m_pay = 1
m_Manager = 2

九、指针类型

  1. 指针操作的是地址

    # include <stdio.h>

void main()
{
	int val = 10;
	int *p;
	p = &val;

	printf("p = %d *p = %d\n", p,*p);
}

    在这里插入图片描述

执行结果：

p = 2096592 *p = 10

此处p代表变量地址， *p才代表变量里面的数值

  1. 交换a,b

    # include <stdio.h>

//1. 不使用指针类（保存临时变量,交换不成功）
void swap(int data1, int data2)
{
	int temp = data2;
	data2 = data1;
	data1 = temp;
}

void main()
{
	int a = 10, b = 20;
	swap(a, b);

	printf("a = %d, b = %d\n", a, b);
}

//2. 使用指针类型（直接交换变量的地址,交换成功）
void swap(int *data1, int *data2)
{
	int temp = *data2;
	*data2 = *data1;
	*data1 = temp;
}

void main()
{
	int a = 10, b = 20;
	swap(&a, &b);

	printf("a = %d, b = %d\n", a, b);
}

  2. 100个钥匙使用指针操作

    #include <stdio.h>

void open(int *key, int num)
{
	printf("data = %d\n", key[num]);
}

void main()
{
	int key[100] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	open(key, 5);
}

十、回调函数

使用场景：

  1. 送餐机器人：底盘移动到目标位置后，如何通知应用程序？
  2. 智能音箱：网络状态更改后，如何通知应用程序？

传统方式：

  1. 开放变量，让别人直接获取
  2. 通过getStatus()类似的函数定时获取

建议方式：

​ 使用回调函数

具体实现：

# include <stdio.h>

//工具代码
typedef struct{
	int status;
	void(*statusChange)(int status);
}T_Device;

T_Device g_Device;

void addCallbackFunc(void (*pstatusChange)(int status)){
	g_Device.statusChange = pstatusChange;
}

void run(){
	g_Device.status = 10;
	if (g_Device.status == 10){
		if (g_Device.statusChange != NULL){
			g_Device.statusChange(g_Device.status);
		}
	}
}


//用户代码
void callBack(int status){
	printf("status = %d\n", status);
}

void main()
{
	//当自己的状态等于10，并且有回调函数的时候，执行这个回调函数，
	//从而实现自己的状态到了某个值时主动执行回调函数
	addCallbackFunc(callBack);
	run();
}

十一、综合项目

1. 可变参数的实现

可变参数函数：可以在运行时取任意的实参个数并根据实参的个数自动处理不同实参的情形，或者至少可以在运行时指定任意个数的实参个数。

  1. c语言中的printf()函数就是典型的可变参数函数，它除了有一个固定的format参数外，后面的参数都是可变的。

  2. printf()函数通过第一个参数确定形参的个数，通过占位符确定形参类型。

  3. printf()函数源码

    #include <stdarg.h>

int printf(const char *fmt, ...)
{
	char printf_buf[1024];
	va_list args;      		
	                     
	int printed;
	va_start(args, fmt);  	
	
	printed = vsprintf(printf_buf, fmt, args);
	va_end(args);          
	puts(printf_buf);
	return printed;
}

  4. 宏介绍：

    1. va_list：用于定义va_list类型的变量
    2. va_start：用于初始化va_list类型的变量
    3. va_end：关闭变参扩展，进行内存回收
2. Zlog日志框架

  1. 第一种方式：整个c文件

    #include <stdio.h>
//可变参数使用的头文件
#include <stdarg.h>  

//声明是否打开日志输出
#define OPEN_LOG 1          
//声明当前程序的日志等级状态，只输出等级等于或高于该值的内容
#define LOG_LEVEL LOG_DEBUG   

//日志等级，越往下越高
typedef enum{
	LOG_DEBUG = 0,
	LOG_INFO,
	LOG_WARN,
	LOG_ERROR,
}E_LOGLEVEL;

//判断当前输入的日志等级
char *EM_LOGLevelGet(const int level){
	if (level == LOG_DEBUG){
		return "LOG_DEBUG";
	}
	else if (level == LOG_INFO){
		return "LOG_INFO";
	}
	else if (level == LOG_WARN){
		return "LOG_WARN";
	}
	else if (level == LOG_ERROR){
		return "LOG_ERROR";
	}
	return "UNKNOW";
}

//日志输出函数
void EM_LOG(const int level, const char* fun, const int line, char *fmt, ...){
#ifdef OPEN_LOG
	va_list arg;
	va_start(arg, fmt);
	char buf[vsnprintf(NULL, 0, fmt, arg) + 1];
	vsnprintf(buf, sizeof(buf), fmt, arg);
	va_end(arg);
	if (level >= LOG_LEVEL)
		printf("[%s] [%s %d] %s\n",EM_LOGLevelGet(level), fun, line, buf);
	//TODO 存储
#endif
}

//宏定义，隐藏形参，只需要日志等级和可变参数
#define EMlog(level, fmt, ...) EM_LOG(level, __FUNCTION__, __LINE__, fmt, ##__VA_ARGS__)


void main(){
	int a = 10, b = 11;
	EMlog(LOG_DEBUG, "app start");
	EMlog(LOG_INFO, "a = %d, b=%d", a, b);
	EMlog(LOG_WARN, "app LOG_WARN");
	EMlog(LOG_ERROR, "app LOG_ERROR");
}

  2. 独立多文件：main.cpp log.cpp log.h

    main.cpp

    #include <stdio.h>
#include <stdarg.h>
#include "log.h"


void main(){
	int a = 10, b = 11;
	EMlog(LOG_DEBUG, "app start");
	EMlog(LOG_INFO, "A = %d", a);
	EMlog(LOG_WARN, "app LOG_WARN");
	EMlog(LOG_ERROR, "app LOG_ERROR");
}

    log.h

    #ifndef _EM_LOG_H_
#define _EM_LOG_H_

//可变参数使用的头文件
#include <stdarg.h>  

//声明是否打开日志输出
#define OPEN_LOG 1          
//声明当前程序的日志等级状态，只输出等级等于或高于该值的内容
#define LOG_LEVEL LOG_DEBUG   
//是否保存日志文件
#define LOG_SAVE 1

//日志等级，越往下越高
typedef enum{
	LOG_DEBUG = 0,
	LOG_INFO,
	LOG_WARN,
	LOG_ERROR,
}E_LOGLEVEL;

//函数声明
void EM_LOG(const int level, const char* fun, const int line, char *fmt, ...);

//宏定义，隐藏形参，只需要日志等级和可变参数
#define EMlog(level, fmt, ...) EM_LOG(level, __FUNCTION__, __LINE__, fmt, ##__VA_ARGS__)

#endif

    log.cpp

    #include <stdio.h>
#include "log.h"

//判断当前输入的日志等级
char *EM_LOGLevelGet(const int level){
	switch (level){
		case LOG_DEBUG: 
			return "LOG_DEBUG"; break;
		case LOG_INFO: 
			return "LOG_INFO"; break;
		case LOG_WARN: 
			return "LOG_WARN"; break;
		case LOG_ERROR: 
			return "LOG_ERROR"; break;
		default: 
			return "UNKNOW"; break;
	}
}

//日志输出函数
void EM_LOG(const int level, const char* fun, const int line, char *fmt, ...){
#ifdef OPEN_LOG
	va_list arg;
	va_start(arg, fmt);
	char buf[1 + vsnprintf(NULL, 0, fmt, arg)];
	vsnprintf(buf, sizeof(buf), fmt, arg);
	va_end(arg);
	if (level >= LOG_LEVEL)
		printf("[%s] [%s %d] %s\n", EM_LOGLevelGet(level), fun, line, buf);
	//TODO 存储
#endif
}
3. google测试框架
#include <stdio.h>
#include <stdlib.h>

typedef struct
{
	int output;
	int a;
	int b;
	int(*TeseFunc)(int, int);  
	int line;                   
}T_Test;


// 结构体作为函数返回值（新建结构体）
T_Test *addFunc(int(*TeseFunc)(int, int), int a, int b, int output, int line){
	T_Test *m_Test = (T_Test *)malloc(sizeof(T_Test));  
	m_Test->a = a;
	m_Test->b = b;
	m_Test->TeseFunc = TeseFunc;
	m_Test->output = output;
	m_Test->line = line;
	return m_Test;
}

// 宏定义函数，缺省line
#define addFunc(TeseFunc, a, b, output) addFunc(TeseFunc, a, b, output, __LINE__)

//测试函数
void runTest(T_Test *p_Test){
	if (p_Test != NULL){
		int count = p_Test->TeseFunc(p_Test->a, p_Test->b);
		if (count == p_Test->output){
			printf("success \n");
		}
		else{
			printf("[LINE: %d] fail %d != %d\n", p_Test->line, count, p_Test->output);
		}
		free(p_Test);   
	}
}

int add(int a, int b){
	return a + b;
}

int main(){
	printf("Test app start.\n");
	T_Test *m_Test = addFunc(add, 1, 2, 4);
	runTest(m_Test);
	return 0;
}
turbosqi
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
嵌入式C语言精华+.pdf
07-26
宋宝华嵌入式 C/C++语言精华文章集锦 C/C+语言 struct 深层探索 ............................................................................2 C++中 extern "C"含义深层探索.....................................
卜若的代码笔记-js编程技巧-第一章：u8和u32的转换
qq_37080133的博客
04-22 1453
function u8tou32(array) { var l0 = array[3]; var l1 = array[2]<<8; var l2 = array[1]<<16; var l3 = array[0]<<24; retur...
字节序问题 u8u32快速赋值问题 待整理
GKoSon的博客
10-05 2512
#include&lt;stdio.h&gt; #include &lt;string.h&gt; typedef unsigned char uint8_t; typedef unsigned short uint16_t; typedef unsigned int uint32_t; void u8_to_u32(unsigned char* u8,unsigned int *u3...
嵌入式C语言（入门必看）
热门推荐
qq_61672347的博客
09-08 2万+
入门必看，STM32的数据类型、const关键字、static 关键字、volatile关键字、extern关键字、struct结构体、enum、typedef、#define、回调函数、#ifdef 、#ifndef、#else 、#if
标准c语言与嵌入式,嵌入式C语言与C语言的区别
weixin_42310572的博客
05-19 3662
嵌入式C语言与C语言的区别：最常用的系统编程语言是C，它是在汇编语言中使用的一种简单的编程语言，源代码采用自由格式。Embeddedc是c语言用于编写嵌入式软件的扩展，这两者有什么区别？首先是启动过程1.普通C语言程序的起始器。普通的C语言启动程序是在PC上安装windows或linux之类的通用操作系统，编译器自动完成启动程序，微处理器和周边设备在调用main函数之前进行初始化，用户无需自己制作...
嵌入式C语言自我修养分享课件
baidu_41191295的博客
03-22 3417
一.异构计算 1.背景： 随着物联网、大数据、人工智能时代的到来，海量的数据分析和大量复杂的运算对CPU 的算力要求越来越高，CPU 的大部分资源用于缓存和逻辑控制，适合运行各种复杂的串行程序，但是单核或者多核CPU处理性能的提升空间已经达到极限了(也就是说，单靠CPU很难满足现代科技发展的需求)。 2.异构计算简介： 异构计算就是在SoC 芯片内部集成不同架构的Core，比如DSP、GPU、NPU、TPU、BPU等不同架构的处理单元，各个核心协同运算，等于CPU找来了一系列的伙伴来共同协助自己的工作。 C
嵌入式C语言视频教程（148集）百度网盘下载
12-22
嵌入式C语言视频教程（148集）百度网盘下载
嵌入式C语言自我修养：从芯片、编译器到操作系统.docx
09-13
嵌入式C语言自我修养：从芯片、编译器到操作系统.docx
嵌入式C语言面试题汇总
02-26
第一部分：基本概念及其它问答题 第二部分：程序代码评价或者找错 第三部分：编程题
再谈C语言——理解指针（四）
Lucas_Micheal的博客
04-24 1053
assert.h 头⽂件定义了宏 assert() ，⽤于在运⾏时确保程序符合指定条件，如果不符合，就报错终⽌运⾏。这个宏常常被称为“断⾔”。上⾯代码在程序运⾏到这⼀⾏语句时，验证变量 p 是否等于 NULL。如果确实不等于 NULL ，程序 继续运⾏，否则就会终⽌运⾏，并且给出报错信息提⽰。assert() 宏接受⼀个表达式作为参数。如果该表达式为真（返回值⾮零）， assert() 不会产⽣ 任何作⽤，程序继续运⾏。
Atcoder Beginner Contest 350 C - Sort
2301_76723927的博客
04-27 1029
给定一个排列 A=(A1, ..., AN) ，其中包含数字 1 到 N 的一个排列。通过执行 0 到 N-1 次操作，将排列 A 转换为 (1, 2, ..., N)。每次操作如下：选择任意一对整数 (i, j)，其中 1≤i<j≤N，在排列 A 中交换第 i 个位置和第 j 个位置上的元素。在给定的约束条件下，可以证明始终可以将排列 A 转换为 (1, 2, ..., N)。通过从开头迭代元素并将每个元素与正确位置上的元素交换，最多可以通过 (N-1) 次操作实现目标。
【C语言】typedef
qq_45951891的博客
04-25 201
2)在连续定义几个变量的时候，typedef能够保证定义的所有变量的均为同一类型，而#define却无法保证。1)可以使用其他类型说明符对宏类型名进行扩展，但对typedef所定义的类型名却不能这样做。为一个数据类型起一个新的别名。
【经典算法】LeetCode104二叉树的最大深度(Java/C/Python3实现含注释说明,Easy)
2401_84427485的博客
04-25 885
方式优点缺点时间复杂度空间复杂度递归深度优先搜索代码直观，易于理解递归可能导致栈溢出，对于深层树效率较低O(n)O(h)非递归深度优先搜索避免递归栈溢出，适用于深层树需要手动维护栈，代码相对复杂O(n)O(h)广度优先搜索层次遍历，易于实现需要额外的队列空间，空间复杂度较高O(n)O(n)
Linux学习（嵌入式硬件知识）
weixin_47273943的博客
04-19 5125
Linux硬件知识（持续补充...）
FA-128晶振用于医疗设备
2301_80759319的博客
04-25 207
此外爱普生FA-128进口晶振通过外部电路可产生稳定的频率信号,并且输出仅含基频分量,用于RF参考设计时,FA-128晶振的具有以下特点谐波次数,基频,激励功率100μW(RF参考)1200μW(时钟),频率容差+10ppm(RF参考)1+30ppm(时钟)频率老化率±1ppm(RF参考)/±5ppm(时钟)频率温度系数±10ppm(RF参考)1±30ppm(时钟)存储温度-40°℃~+125°℃,工作温度-40℃℃~+85℃℃应用:移动电话,蓝牙无线-局域网ISM 频段电台广播,MPU时钟等。
基于单片机公交语音报站系统设计 含源码,Proteus仿真原理图
最新发布
qq_35654286的博客
04-27 1158
系统的总体设计需要充分运用STC单片机作为主控控制芯片，完成主控控制电路的基本设计，辅助控制电路是语音控制电路、12864显示电路、按键控制电路、GPS电路、LED显示、温度和时钟模块。仿真用串口模拟语音播报，gps没法仿真
socket编程-----常用socket编程函数
ZZZCY2003的博客
04-25 836
操作系统：Linux编程语言：C语言简述：socket编程函数是socket编程中的基础，通过组合使用它们，可以实现各种网络通信功能。socket编程函数较多，在这里只是列出较为常用的socket函数。
STM32与Proteus的串口仿真详细教程与源程序
qq_35654286的博客
04-24 1138
解决了STM32的Proteus串口收发问题。
嵌入式c语言选择题库
08-07
嵌入式C语言选择题库是一种集成的软件工具，用于帮助学习和测试嵌入式C语言知识的工具。它包含了一系列的选择题，涵盖了嵌入式C语言的各个方面，包括语法、数据类型、指针、运算符、条件语句、循环语句、函数等。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值