登录 / 注册

嵌入式(共37篇)

找到 37 篇与嵌入式相关的结果

麒麟9050发布对电子专业影响以及逻辑折叠FPGA或MCU的嵌入式领域普及性摘要麒麟9050采用逻辑折叠技术显著降低芯片功耗，推动高端芯片能效提升。逻辑折叠技术未来将逐步向高端FPGA和高端异构MCU渗透，为电子行业带来更多新岗位。关键词：麒麟9050, 逻辑折叠, FPGA, MCU, 嵌入式领域目录一、逻辑折叠为什么能降低芯片功耗？二、韬定律（Tau 缩放定律）三、逻辑折叠会不会出现在 FPGA？预判四、逻辑折叠会不会来到 MCU（类似 STM32）？五、逻辑折叠落地：芯片设计中有多少是国产自主化了六、立体空间下的时序约束与布局布线：电子专业新方向，行业人才缺口巨大七、逻辑折叠技术普及成必然，但落地节奏循序渐进八、交流环节一、逻辑折叠为什么能降低芯片功耗？ pasted_1789460174481_6bjp5d.png图片先回忆数字芯片动态功耗经典公式： $$P_{dyn}=\alpha C V^2 f$$ C：互连寄生电容（现代芯片里，金属走线电容占大头，远大于晶体管本身电容） V：工作电压，功耗和电压呈平方关系，是功耗最敏感的因子 (P_{dyn})：动态功耗 (\alpha)：翻转因子 f：工作频率传统 ASIC 芯片是单层硅平面布局，同一个功能模块里所有标准单元平铺在同一层晶圆上。信号需要在平面上横向长距离走线，走线越长，寄生电容越大，RC 延迟越高。逻辑折叠（LogicFolding），不是简单的芯粒堆叠、2.5D 封装。它是把同一个功能模块内部的标准单元打散，分到两层有源硅层，依靠高密度晶圆对晶圆（W2W）混合键合做垂直互联。相当于把平面电路折成两层楼房，信号走垂直短互联，不用横穿整个芯片平面。带来三大功耗收益：走线长度大幅缩短 → 寄生电容 C 下降关键路径走线最高可缩短约 70%，时钟网络变短，时钟缓冲器数量显著减少，而时钟树本身就是芯片功耗消耗大户。 RC 延迟变小，时序裕量变好 → 可以降低工作电压 V 电压降低带来平方级的功耗削减，这是能效提升最核心的来源。同等时序约束下，不需要强行拉高频率 f，或者保持频率不变，换取更低功耗。工程实测参考：同等性能下，CPU 性能核功耗下降 41%，GPU 下降 58%，NPU 下降 66%。注意：逻辑折叠不是天然低功耗。设计上可以二选一：要么降电压省电，要么维持电压拉高频率换性能。区分概念：传统 Chiplet / 2.5D 封装：粗粒度模块拆分，CPU、GPU 各自独立裸片，靠中介层互联；逻辑折叠：标准单元级细粒度跨层划分，同一个 ALU、寄存器组都可以拆分到两层，需要三维协同 EDA 做布局布线，实现难度高得多。二、韬定律（Tau 缩放定律）很多人看到逻辑折叠，都会关联到韬定律（τ 缩放定律），这是支撑逻辑折叠架构的核心理论。 pasted_1789460275131_1nvff4.png图片韬定律（τ 缩放定律）：芯片性能与功耗的瓶颈，正在从晶体管本身，转移到片内互连（走线）。当工艺不断缩小，晶体管尺寸越来越小，但金属互连线带来的 RC 延迟、电容功耗下降的速度跟不上晶体管缩放收益。平面工艺走到后段，晶体管已经足够快，但线的延迟和功耗拖后腿，单纯继续缩小晶体管带来的收益越来越弱。逻辑折叠就是韬定律下的工程解法：不单纯靠缩小晶体管，而是通过三维折叠缩短互连长度，绕开平面互连瓶颈，重新拿回能效收益。简单一句话总结韬定律：先进工艺下，限制芯片能效的不再是管子，而是连线。三、逻辑折叠会不会出现在 FPGA？ pasted_1789460360862_7kye54.png图片长期来看，高端超大 FPGA 会出现基于 3D 折叠思想的产品，逻辑折叠向高端 FPGA 渗透是必然趋势，但很难复刻麒麟 9050 的巨大功耗降幅，中低端 FPGA 短期不会普及。 FPGA 和 SoC（麒麟这类芯片）本质差异巨大： FPGA 的核心是大量 LUT、FF 和可编程互连矩阵，功耗很大一部分消耗在可编程布线网络的多路选择器、开关盒。逻辑折叠最大红利来自固定电路的关键路径优化；FPGA 的连线是用户编译之后动态决定的，没法预先固定路径，很难最大化缩短走线。想要逻辑折叠 FPGA，垂直互联也必须做成可配置开关。三维可编程互连的硬件开销巨大，会吃掉大部分功耗收益。 EDA 工具层面，现有 FPGA 布局布线都是 2D 平面引擎。三维 FPGA 布局布线算法需要大规模重构，开发周期和成本极高。预判高端：航天、数据中心超大容量 FPGA，未来几年会出现 3D 堆叠 + 逻辑折叠思路的产品（不是完全相同的华为 LogicFolding，但思想同源：可编程资源分到多层，垂直互联缩短布线）。Intel、AMD（原 Xilinx）已经在研究 3D FPGA。中低端（Artix、Kintex 这类工业 / 消费级 FPGA）：短期不会上逻辑折叠，成本是硬约束，混合键合、双层有源硅成本太高。四、逻辑折叠会不会来到 MCU（类似 STM32）？常规低成本 STM32 产品线不会采用，但未来高端算力 MCU 引入 3D 集成思路是必然方向（粗粒度芯粒堆叠，不一定是标准单元级逻辑折叠）。传统 MCU（STM32 主流系列）定位是大批量、低成本、高稳定性：普通 MCU 的 CPU、外设、存储器规模不大，芯片本身面积小，平面走线并不长。如果上标准单元级逻辑折叠，功耗收益很小，但制造成本会暴涨，违背 MCU 的成本优先定位。双层有源硅 + W2W 混合键合工艺良率控制难度远高于普通平面晶圆，单片成本会大幅抬升。但随着边缘 AI 需求爆发，高端异构 MCU（内置大算力 NPU、高速接口的超大算力 MCU），未来必然会采用芯粒堆叠方案：MCU 核、存储、AI 加速器拆成不同裸片做 3D 集成。 ⚠️ 注意：这种属于粗粒度芯粒堆叠，不是麒麟 9050 这种细粒度标准单元跨层逻辑折叠。普通 STM32 依然会继续走传统平面工艺，依靠低功耗库、电源域门控、时钟门控来优化功耗。五、逻辑折叠落地：芯片设计中有多少是国产自主化了逻辑折叠最大的亮点，是国内团队完整攻克了这套三维芯片全流程工程难题，从理论架构、三维 EDA 工具，到跨层时序约束、W2W 混合键合生产，实现了项目完整自主闭环，克服了大量前所未有的技术难关。架构与前端设计：完全自主自研海思自主提出逻辑折叠架构，构建韬（τ）缩放理论，原创细粒度跨层逻辑拆分策略。工程上采用选择性折叠方案，只针对 CPU/GPU/NPU 这类关键时序模块做标准单元跨层拆分，其余模块保留平面 2D 设计，在保证性能的前提下控制整体工程复杂度，整套架构思路属于原生自主创新。三维 EDA、布局布线、时钟约束、跨层时序签核：国产工具完成完整项目交付三维逻辑折叠最大难点就是两层晶圆之间的耦合时序问题，传统 2D EDA 完全无法处理跨层 RC、层间串扰、热耦合带来的时序偏差。项目采用国产三维 EDA 工具，完成三维协同布局布线、跨层 RC 寄生参数提取、三维时钟树综合、跨层时钟约束，以及多层耦合仿真与时序签核。这是国内首次用国产 EDA 工具完成细粒度逻辑折叠芯片的后端物理设计与时序收敛，攻克了三维芯片最核心的时序收敛难题。晶圆制造与 W2W 混合键合工艺：国内产线自主完成开发与量产两层有源逻辑晶圆在国内 DUV 产线完成制造；W2W 晶圆对晶圆混合键合这项逻辑折叠赖以实现的核心工艺，由国内团队自主完成工艺研发、良率调试，实现规模化量产。要实现两层硅晶圆上数以亿计的垂直微互连精准对位，同时控制层间应力、热均匀性、良率，需要攻克大量工艺、材料、封测工程难题，整套工艺链路已经打通落地。一句话总结：针对麒麟 9050 逻辑折叠这个项目，三维架构理论、三维后端 EDA 工具、跨层时序约束、W2W 混合键合制造，全部实现自主可控，大量原创工程难题被逐一突破。六、立体空间下的时序约束与布局布线：电子专业新方向，行业人才缺口巨大 pasted_1789460412097_keeal8.png图片传统芯片设计，所有单元都平铺在二维平面，我们学习的 STA 静态时序分析、布局布线、时钟树综合，全部建立在二维版图之上。而逻辑折叠把芯片变成三维立体空间，标准单元分布在上下两层硅片，信号不仅在单层横向跑动，还会通过垂直微互联在两层之间穿梭。此时的布局布线不再是平面规划，而是立体空间内的单元分配、跨层走线规划；时序约束也不再只考虑单层内的路径延迟，必须同时计算跨层 RC、层间热耦合带来的时序漂移、上下两层之间的串扰，做全局三维时序收敛。这就带来一个很现实的变化：未来电子信息、集成电路专业的课程体系，一定会新增三维布局布线、空间时序约束、多层耦合仿真相关教学内容。随着逻辑折叠技术逐步普及，能做三维空间时序约束、立体布局布线的工程师会非常紧缺，会诞生大量全新岗位。现在行业里绝大多数后端工程师只熟悉传统 2D 平面芯片设计，三维逻辑折叠的项目经验属于稀缺能力。对于电子专业学生来说，提前学习三维集成、3DIC 时序分析相关知识，就是抓住下一代芯片技术的风口。七、逻辑折叠技术普及成必然，但落地节奏循序渐进结论：从技术价值与产业发展趋势看，逻辑折叠的普及是必然，只是不会一步到位。逻辑折叠是高性能、高成本的先进 3DIC 方案，不是可以替代所有芯片的通用技术。适合场景：旗舰 SoC、超大算力 AI 芯片、高端航天芯片；追求极致能效，能够承担高昂流片、EDA、制造成本。不适合场景：低成本 MCU、中小规模 FPGA、普通消费控制芯片。短期来看，逻辑折叠只会出现在少数高端旗舰芯片；中长期，3D 堆叠思路会逐步下沉到高端 FPGA、高端异构 MCU。细粒度标准单元级逻辑折叠，会持续向高端算力芯片渗透，普及是大势所趋。同时伴随技术推广，三维时序、立体布局布线的人才需求持续上涨，为电子行业带来更多新岗位。八、交流环节欢迎各位电子信息领域业内人士留言评论，或者关于FPGA、嵌入式开发有什么疑问可以评论区交流。关于博主：刘航宇，FPGA工程师，西北大学电子系硕士主页简介：https://www.ee.ac.cn/ 欢迎评论区留言咨询博主

嵌入式＆系统 FPGA&ASIC # ASIC/FPGA # 嵌入式

刘航宇 4天前
0 41 1
基于51/52单片机电容、电感、电阻参数测量系统设计与Proteus仿真摘要本文介绍了基于51/52单片机的电容、电感、电阻参数测量系统的设计与Proteus仿真。系统采用频率转换法，通过单片机读取频率并计算得到参数值，具有高精度和便于数字化显示的特点。文章详细阐述了系统设计、单元电路设计、程序设计以及仿真调试过程。关键词：51单片机, 电容测量, 电感测量, 电阻测量, Proteus仿真目录一、设计任务和要求二、方案设计与论证2.1 系统总设计框图 2.2 方案一：电桥平衡原理① 电阻的测量：直流电桥平衡原理 ② 电容的测量：交流电桥平衡原理 ③ 电感的测量：交流电桥平衡原理 2.3 方案二：频率转换法（本设计采用）① 电阻的测量：555 构成单稳态 ② 电容的测量：555 构成单稳态 ③ 电感的测量：电容三点式正弦波振荡 2.4 方案对比与选择三、单元电路设计和参数计算3.1 电阻的检测单元电路设计 3.2 电容的检测单元电路设计 3.3 电感的检测单元电路设计四、总原理图及元器件清单4.1 总原理图 4.2 元器件清单五、程序设计5.1 程序流程图 5.2 核心代码中断函数（频率测量）主函数显示函数键盘检测函数 5.3 完整程序清单及protues仿真文件（附录）六、安装与调试6.1 仿真调试（1）电阻测量电路仿真（2）电容测量电路仿真（3）电感测量电路仿真调试要点液晶显示电路调试仿真整体显示 6.2 实物调试电阻检测电容检测电感检测八、参考文献九、附录-完整软件程序与protues仿真文件完整程序与仿真文件见文章末尾一、设计任务和要求设计并制作一个元器件参数测量仪电阻阻值测量，范围：100Ω ~ 1MΩ 电容容值测量，范围：100pF ~ 10000pF 测量精度：±5% 电感参数的测量扩大量程提高测量精度二、方案设计与论证 2.1 系统总设计框图 pasted_1784990858481_sxzptf.png图片图1 系统总设计框图在测量各元件参数时，采用首先把电感、电容、电阻的参数转化为频率[1]，再送至单片机检测，检测结束后，送至 LCD1602 进行显示。 2.2 方案一：电桥平衡原理 ① 电阻的测量：直流电桥平衡原理 pasted_1784990980814_5yavx3.png图片图2 直流电桥平衡电路图根据电路平衡原理，不断调节电位器 R3，使得电表指针指向正中间，再测量电位器电阻值。 ② 电容的测量：交流电桥平衡原理 pasted_1784991076614_jito75.png图片图3 交流电桥平衡电路图通过调节 Z1、Z2 使电桥平衡。这时电表的读数为零。通过读取 Z1、Z2、Zn 的值，即可得到被测电容的值。 ③ 电感的测量：交流电桥平衡原理 pasted_1784991402619_84r7tl.png图片图4 交流电桥平衡电路图2.3 方案二：频率转换法（本设计采用） ① 电阻的测量：555 构成单稳态 pasted_1784991953296_lg44ir.png图片图5 555 定时器构成单稳态电路图根据 555 定时器构成单稳态，产生脉冲波形，通过单片机读取高低电平得出频率，通过公式换算得到电阻阻值。 ② 电容的测量：555 构成单稳态 pasted_1785027612555_za97df.png图片图6 555 定时器构成单稳态电路图** 根据 555 定时器构成单稳态，产生脉冲波形，通过单片机读取高低电平得出频率，通过公式换算得到电容值。 ③ 电感的测量：电容三点式正弦波振荡 pasted_1785027682239_4u3sw9.png图片图7 电容三点式正弦波振荡电路图由电容三点式正弦波振荡电路得出频率，通过单片机读取高低电平得出频率，通过公式换算得到电感值。 2.4 方案对比与选择对比项方案一（电桥法）方案二（频率法）测量精度受人为调节影响大单片机数字化，精度高操作难度调节麻烦，不易操作自动测量，一键显示电感测量不易测得准确值振荡电路，相对稳定数字化不易数字化便于单片机处理结论：方案二通过单片机读取转化，精确度会明显提高，且便于数字化显示。故本设计选择方案二。三、单元电路设计和参数计算 3.1 电阻的检测单元电路设计 pasted_1785027698225_mjicut.png图片图8 555 定时器构成单稳态电路图由 555 单稳态触发公式： $$f=\frac{1}{\ln2(R_{1}+2R_x)C}$$ 得： $$R_x=\frac{1}{2}(\frac{1}{\ln2fC}-R_{1})$$ 从而，可以计算得出电阻值的大小。 3.2 电容的检测单元电路设计 pasted_1785028035648_x380cp.png图片图9 555 定时器构成单稳态电路图根据 555 定时器构成单稳态，产生脉冲波形，通过单片机读取高低电平得出频率，通过公式换算得到电容值[2]。由： $$f=\frac{1}{\ln2^*(R_1+2R_2)^*C_x}$$ 若 R1 = R2，得： $$C_x=\frac{1}{3\ln2^*f^*R_1}$$ 从而，可以计算得出电容值的大小。 3.3 电感的检测单元电路设计 pasted_1785028091408_lymeeb.png图片图10 电容三点式正弦波振荡电路图由 LC 振荡频率公式： $$f=\frac{1}{2\pi\sqrt{\frac{C_1*C_2}{C_1+C_2}*L_x}}$$ 得： $$L_x=\frac{1}{\left(2\pi f\right)^2\frac{C_1*C_2}{C_1+C_2}}$$ 从而，可以计算得出电感值的大小。四、总原理图及元器件清单 4.1 总原理图 pasted_1785028273962_o8rzuv.png图片图11 电阻、电容、电感参数测试总原理图 pasted_1785028294514_u0wku4.png图片图12 测量电阻、电容部分的原理图 pasted_1785028310991_mmmde2.png图片图13 测量电感以及 ±5V 发生原理图4.2 元器件清单元件序号型号数量备注U1STC89C52RC1单片机R3A103J1排阻R2, R3, R17, R1810KΩ4电位器X111.0592M1晶振C325V, 10uF1电解电容C1, C2, C11103 (0.01uF)3瓷片电容R1, R13, R1810KΩ3电阻J1, J2, J3, J4—4按键U216021液晶A1, A2NE5552555 定时器R4300Ω1电阻R5, R6510KΩ2电阻C4~C9104 (0.1uF)6瓷片电容R7, R9100KΩ2电阻C1050V, 22uF1电解电容Q1~Q3S9108 (NPN)3三极管R102KΩ1电阻R8, R11, R141KΩ3电阻C12, C1350V, 47uF2电解电容R12, R1939KΩ2电阻R15, R1651Ω2电阻C1425V, 470uF1电解电容U3NE555321运放五、程序设计 5.1 程序流程图图14 中断程序流程图 pasted_1785028347463_kh1ui9.png图片图15 主程序流程图 pasted_1785028417008_m02be6.png图片初始化 (led_init, t_init, keyscan) ↓ 清屏 ↓ 循环: ├── 显示频率 display_f(f) └── 根据 a 值分支: ├── case 1: 计算电阻 R，显示 display_R(R) ├── case 2: 计算电容 C，显示 display_C(C) └── case 3: 计算电感 L，显示 display_L(L)5.2 核心代码中断函数（频率测量） void T0_count() interrupt 1 { switch(a) { case 1: // 电阻测量 while(R_out); while(!R_out); TH0 = 0; TL0 = 0; while(R_out); while(!R_out); th0 = TH0; tl0 = TL0; TR0 = 0; break; case 2: // 电容测量 while(C_out); while(!C_out); TH0 = 0; TL0 = 0; while(C_out); while(!C_out); th0 = TH0; tl0 = TL0; TR0 = 0; break; case 3: // 电感测量 while(L_out); while(!L_out); TH0 = 0; TL0 = 0; while(L_out); while(!L_out); th0 = TH0; tl0 = TL0; TR0 = 0; break; } f = 1000000.0 / 1.085069 / (th0 * 256 + tl0) + 0.5; }主函数 void main() { led_init(); // 液晶初始化 t_init(); // 定时器初始化 keyscan(); // 按键检测 write_com(0x01); // 清屏 while(1) { display_f(f); switch(a) { case 1: // 电阻: R = (T/0.693 - 150) 换算 R = (ulong)(5000000.0 / 0.6931472 / f - 150 + 0.5); display_R(R); break; case 2: // 电容: C = 换算公式 C = (int)(100000000.0 / 153 / 0.6931472 / f + 0.5); display_C(C); break; case 3: // 电感: L = 1/(4π²f²C) 换算 L = (int)(1000000000000.0 / 0.1 / PI / PI / f / f + 0.5); display_L(L); break; } } }显示函数 // 频率显示 void display_f(ulong f) { uchar count = 0; ulong f0 = f; while(f) { f = f / 10; count++; } for(num = 5 + count; num > 5; num--) { table2[num] = f0 % 10 + 48; f0 = f0 / 10; } write_com(0x80); for(num = 0; num < 6 + count; num++) { write_data(table2[num]); delayms(5); } } // 电阻显示 void display_R(ulong R) { uchar count = 0; ulong R0 = R; while(R) { R = R / 10; count++; } for(num = 6 + count; num > 6; num--) { table3[num] = R0 % 10 + 48; R0 = R0 / 10; } write_com(0x80 + 0x40); for(num = 0; num < 7 + count; num++) { write_data(table3[num]); delayms(5); } } // 电容显示 void display_C(uint C) { uchar count = 0; uint C0 = C; while(C) { C = C / 10; count++; } for(num = 5 + count; num > 5; num--) { table4[num] = C0 % 10 + 48; C0 = C0 / 10; } write_com(0x80 + 0x40); for(num = 0; num < 6 + count; num++) { write_data(table4[num]); delayms(5); } } // 电感显示 void display_L(uint L) { uchar count = 0; uint L0 = L; while(L) { L = L / 10; count++; } for(num = 5 + count; num > 5; num--) { table5[num] = L0 % 10 + 48; L0 = L0 / 10; } write_com(0x80 + 0x40); for(num = 0; num < 6 + count; num++) { write_data(table5[num]); delayms(5); } }键盘检测函数 void keyscan() { if(key_R == 0) // 检测电阻按键 { delayms(10); // 消抖 if(key_R == 0) a = 1; } else if(key_C == 0) // 检测电容按键 { delayms(10); if(key_C == 0) a = 2; } else if(key_L == 0) // 检测电感按键 { delayms(10); if(key_L == 0) a = 3; } else while(key_R && key_C && key_L); // 等待按键按下 }5.3 完整程序清单及protues仿真文件（附录）见文末附录部分。六、安装与调试 6.1 仿真调试（1）电阻测量电路仿真图16 电阻测量的仿真电路图 pasted_1785028525830_e8xagf.png图片图17 电阻测量的仿真输出波形 pasted_1785028553380_77yjdf.png图片（2）电容测量电路仿真图18 电容测量的仿真电路图 pasted_1785028566386_213kgj.png图片图19 电容测量的仿真输出波形 pasted_1785028577785_fn2fqc.png图片（3）电感测量电路仿真图20 电感测量的仿真电路图 pasted_1785028588732_9bvoyx.png图片图21 电感测量的仿真输出波形 pasted_1785028599631_39ilf2.png图片调试要点接通电源，用示波器观察输出波形，若为方波，则电路焊接无误，否则检查电路[3] 在调试过程中发现，若改变电源电压，输出方波的频率会发生变化，计算出的数值存在一定误差当 VCC 为 3.25V 左右时误差较小液晶显示电路调试将测量电路的输出分别与单片机的 P1^5、P1^6、P1^7 相接，观察液晶是否显示测量结果在调试过程中发现，电阻、电容的测量误差较小由于电容三点式震荡电路的频率不稳定，电感测量的误差较大仿真整体显示图22 电阻测量显示 pasted_1785028620741_10mwwy.png图片图23 电容测量显示 pasted_1785028631102_motyub.png图片图24 电感测量显示 pasted_1785028644198_twwyn4.png图片图25 电源生成模块显示 pm2vEdK.png图片6.2 实物调试实物按照仿真电路搭建，通电显示 "Welcome! RCL detector"。图26 实物开机界面 pm2vmJe.png图片电阻检测插入 2.7KΩ 电阻若显示不准确，调节仿真中 R2 对应的电位器即可改变输出频率，使得检测精准检测显示 2735Ω，可见调试准确图27 电阻检测显示 pm2vnRH.png图片电容检测插入 0.1uF 电容若显示不准确，调节仿真中 R3 对应的电位器即可改变输出频率，使得检测精准检测显示 101pF，可见调试准确[4] 图28 电容检测显示 pm2vuzd.png图片电感检测插入 65mH 电感若显示不准确，调节程序计算公式5，即可改显示结果，使得检测精准检测显示 65535uH，可见调试准确图29 电感检测显示 pm2vMQA.png图片八、参考文献 [1]杨沁佳.浅谈电感传感器微位移检测仪的原理与设计[J].数字通信世界,2019(09):143+159. [2]张璐雅,阮景.一种基于555时基电路的振荡器设计[J].集成电路应用,2019,36(12):12-13. [3]谢琪林.浅谈STC89S51单片机时序[J].电子测试,2020(24):139-140. [4]黄江.基于STM32的高精度电容测量仪设计[J].信息技术与信息化,2020(11):140-141. [5]王晓辉,王智永,韩智伟,胡帅可,谢印庆.基于三极管放大原理的电容三点式LC振荡器的设计[J].电子世界,2020(03):206. [6] E. L. Pankratov. An approach to model manufacturing of an enhanced swing differential Colpitts oscillator based on heterostructures to increase density of their elements with account mismatch-induced stress: on optimization of annealing. 2020, :1-19. 九、附录-完整软件程序与protues仿真文件 // ============================================ // RCL 测量仪程序 // 基于 STC89C52RC + NE555 + LCD1602 // ============================================ #include <reg52.h> #define uint unsigned int #define uchar unsigned char #define ulong unsigned long #define PI 3.1415926 // ========== 字符串常量 ========== uchar code table1[8] = "Welcome! RCL detector"; uchar table2[16] = "f(Hz)="; uchar table3[16] = "R(Ohm)="; uchar table4[16] = "C(pF)="; uchar table5[16] = "L(uH)=";

嵌入式＆系统通信&信息处理软硬件算法 # 嵌入式 # 信号处理 # 软件算法 # 物联网

刘航宇 7月26日
0 91 5
EBI开发手册|FPGA与STM32 EBI高速并行通信技术详解摘要本文详细介绍了FPGA与STM32 EBI高速并行通信技术，包括EBI的优势、系统框图、读写时序、硬件连接、信号定义、FPGA端Verilog接口设计、STM32端HAL配置与驱动等，适用于复杂电子系统和高可靠FPGA-MCU协同设计。关键词：FPGA, STM32, EBI, 高速并行通信, 内存映射目录 1. 为什么选EBI而非SPI？ 2. EBI系统框图 3. EBI开发手册下载 4. EBI读写时序EBI读时序 EBI写时序 5. EBI硬件连接与信号定义5.1 信号连接表 5.2 硬件设计注意事项 6. FPGA端Verilog接口设计6.1 模块接口定义 6.2 核心设计要点6.2.1 信号直通与数据三态控制 3.2.2 写信号同步 6.2.3 读信号同步 7. 内部模块连接示例 8. STM32端HAL配置与驱动8.1 GPIO初始化 8.2 FMC异步SRAM模式初始化 8.3 读写驱动函数 9. 读写时序分析9.1 读时序 (FPGA → STM32) 9.2 写时序 (STM32 → FPGA) 10. 关键设计决策说明10.1 为什么写信号只用1级同步，读信号用3级？ 10.2 三态门控制逻辑 10.3 地址直通 vs 同步 EBI开发手册下载适用场景：复杂电子系统 / 高可靠FPGA-MCU协同设计关键词：FPGA · STM32 · EBI · LocalBus · 异步SRAM · EE学术1. 为什么选EBI而非SPI？在高可靠嵌入式系统中，STM32与FPGA通信的常见方式有SPI、I2C、UART等串行接口，以及EBI（External Bus Interface）等并行总线。虽然SPI实现简单，但在需要高带宽、低延迟、内存映射访问的场景下，EBI并行总线具有显著优势：对比维度SPIEBI数据宽度1~4 bit (QSPI)8/16 bit理论带宽~50 MB/s (QSPI)~100+ MB/s访问方式寄存器操作内存映射 (直接读写)DMA支持有限原生支持适用场景控制命令、低速数据图像缓冲、FFT数据流、航电总线对于需要FPGA处理高速数据流（如传感器采集、信号处理）并将结果回传MCU的场景，EBI允许STM32像访问内部SRAM一样直接读写FPGA内部寄存器或FIFO，无需复杂的协议栈开销。这种"内存映射"方式使得CPU可以通过简单的指针操作完成数据交换，几乎零额外软件开销。 2. EBI系统框图 pasted_1784792114679_uqlyxj.png图片 pasted_1784792133238_8k92xm.png图片 3. EBI开发手册下载见文章末尾 4. EBI读写时序 EBI读时序 pasted_1784792256693_rqlsy7.png图片 EBI写时序 pasted_1784792336779_i0i8ah.png图片 5. EBI硬件连接与信号定义以STM32F407 + FPGA（Xilinx/Altera）为例，采用16位数据宽度、非复用地址模式，典型连接如下： 5.1 信号连接表 STM32 引脚FPGA 引脚信号说明PD14~PD15, PE7~PE15IO_EBI_data[15:0]EBI数据总线 (16位双向)PF0~PF5, PG0~PG13I_EBI_addr[23:0]EBI地址总线 (24位，可寻址16MB)PG9I_EBI_CS_nEBI片选 (低有效)PD4I_EBI_OE_nEBI读使能 (低有效)PD5I_EBI_WE_nEBI写使能 (低有效)—I_sys_clkFPGA系统时钟 (≥100MHz)—I_rst_n系统复位 (低有效)地址映射：Bank1_NE2 → 0x6400_0000 ~ 0x64FF_FFFF (16MB空间) 5.2 硬件设计注意事项 ⚠️ 关键提示 FPGA的IO电平必须与STM32匹配（通常 3.3V LVTTL/LVCMOS33）数据线建议串联 22~47Ω 电阻抑制信号反射，尤其是高速运行时地址线若不需要全部使用，可接地或接固定电平，减少FPGA引脚占用若使用等待信号（NWAIT），需在EBI配置中使能，并在FPGA中正确驱动航空电子场景需特别关注 EMC/EMI 设计，建议增加滤波和屏蔽 6. FPGA端Verilog接口设计 FPGA侧的核心任务是模拟一个"SRAM设备"，响应STM32的读写时序。以下是基于异步SRAM模式的完整Verilog接口模块，直接对应你的实际工程代码： 6.1 模块接口定义 module EBI_LOCALBUS ( /* --------------------- Input Signals --------------------- */ input I_sys_clk, // 系统时钟 input I_rst_n, // 系统复位 input I_EBI_CS_n, // EBI片选 input I_EBI_WE_n, // EBI写信号 input I_EBI_OE_n, // EBI读信号 input [23 : 00] I_EBI_addr, // EBI地址 (24位) inout [15 : 00] IO_EBI_data, // EBI数据总线 (16位双向) input [15 : 00] I_EBI_RD_data, // CPU读数据 (来自内部模块) /* --------------------- Output Signals -------------------- */ output [15 : 00] O_EBI_WR_data, // CPU写数据 (输出到内部模块) output O_EBI_CS_n, // 片选转接 output reg O_EBI_WE_n, // 写信号同步输出 output O_EBI_RD_n, // 读信号同步输出 output [23 : 00] O_EBI_addr // 地址转接 );6.2 核心设计要点 6.2.1 信号直通与数据三态控制 // EBI片选直通 assign O_EBI_CS_n = I_EBI_CS_n; // EBI地址直通 assign O_EBI_addr = I_EBI_addr; // 写数据：EBI总线 → FPGA内部 (写操作时数据由STM32驱动) assign O_EBI_WR_data = IO_EBI_data; // 读数据：FPGA内部 → EBI总线 (仅在片选有效且读使能有效时驱动) assign IO_EBI_data = ( (I_EBI_CS_n == 1'b0) && (S_EBI_RD_N_d2 == 1'b0) ) ? I_EBI_RD_data : 16'bz;关键设计： O_EBI_CS_n 和 O_EBI_addr 为直通信号，不做时钟域转换，确保地址和片选的最小延迟 IO_EBI_data 采用三态控制：仅在 CS_n == 0 且 RD_N_d2 == 0 时驱动读数据，否则置高阻态，避免总线冲突 O_EBI_WR_data 直接采样 IO_EBI_data，因为写操作时数据总线由STM32驱动，无需三态判断 3.2.2 写信号同步 // EBI写信号打拍同步 always @(posedge I_sys_clk or negedge I_rst_n) begin if (I_rst_n == 1'b0) begin O_EBI_WE_n <= 1'b1; // 复位后写无效 end else begin O_EBI_WE_n <= I_EBI_WE_n; end end设计意图：写信号经过1级同步，从异步EBI域转入FPGA系统时钟域同步后的 O_EBI_WE_n 可直接用于内部模块的写使能，配合 O_EBI_addr 和 O_EBI_WR_data 完成一次完整的写操作 6.2.3 读信号同步 reg S_EBI_RD_N_d0; reg S_EBI_RD_N_d1; reg S_EBI_RD_N_d2; // EBI读信号三级打拍 always @(posedge I_sys_clk or negedge I_rst_n) begin if (I_rst_n == 1'b0) begin S_EBI_RD_N_d0 <= 1'b1; S_EBI_RD_N_d1 <= 1'b1; S_EBI_RD_N_d2 <= 1'b1; end else begin S_EBI_RD_N_d0 <= I_EBI_OE_n; S_EBI_RD_N_d1 <= S_EBI_RD_N_d0; S_EBI_RD_N_d2 <= S_EBI_RD_N_d1; end end assign O_EBI_RD_n = S_EBI_RD_N_d2;为什么读信号需要3级同步？读信号采用三级延迟（而非写信号的1级），原因如下：同步级数作用S_EBI_RD_N_d0第一级同步，消除亚稳态S_EBI_RD_N_d1第二级同步，稳定信号S_EBI_RD_N_d2第三级延迟，为FPGA内部模块预留数据准备时间读操作需要FPGA内部模块在检测到读使能后，将数据放到 I_EBI_RD_data 上，再通过三态门驱动到 IO_EBI_data。三级延迟确保了：内部模块有足够的时间响应读请求数据在 S_EBI_RD_N_d2 == 0 时已经稳定满足STM32 EBI的数据建立时间要求 7. 内部模块连接示例 EBI_LOCALBUS 模块本身是一个总线桥接器，需要配合内部功能模块使用。以下是一个典型的寄存器文件连接示例： module internal_regfile ( input I_sys_clk, input I_rst_n, input I_cs_n, // 来自 EBI_TO_LOCALBUS.O_EBI_CS_n input I_we_n, // 来自 EBI_TO_LOCALBUS.O_EBI_WE_n input I_rd_n, // 来自 EBI_TO_LOCALBUS.O_EBI_RD_n input [23:0] I_addr, // 来自 EBI_TO_LOCALBUS.O_EBI_addr input [15:0] I_wr_data, // 来自 EBI_TO_LOCALBUS.O_EBI_WR_data output reg [15:0] O_rd_data // 送到 EBI_TO_LOCALBUS.I_EBI_RD_data ); reg [15:0] reg_file [0:255]; // 256个16位寄存器 integer i; initial begin for (i = 0; i < 256; i = i + 1) reg_file[i] = 16'd0; end // 写操作：WE_n下降沿 (同步后的信号) always @(posedge I_sys_clk or negedge I_rst_n) begin if (!I_rst_n) begin // 复位逻辑 end else if (!I_cs_n && !I_we_n) begin reg_file[I_addr[7:0]] <= I_wr_data; end end // 读操作：组合逻辑输出 (确保在RD_n有效时数据已稳定) always @(*) begin if (!I_cs_n && !I_rd_n) O_rd_data = reg_file[I_addr[7:0]]; else O_rd_data = 16'h0000; end endmodule顶层连接： module top_fpga_stm32 ( input sys_clk, input sys_rst_n, // EBI物理接口 inout [15:0] fmc_data, input [23:0] fmc_addr, input fmc_cs_n, input fmc_oe_n, input fmc_we_n ); wire [15:0] ebi_rd_data; wire [15:0] ebi_wr_data; wire ebi_cs_n; wire ebi_we_n; wire ebi_rd_n; wire [23:0] ebi_addr; EBI_LOCALBUS u_ebi_bridge ( .I_sys_clk (sys_clk), .I_rst_n (sys_rst_n), .I_EBI_CS_n (fmc_cs_n), .I_EBI_WE_n (fmc_we_n), .I_EBI_OE_n (fmc_oe_n), .I_EBI_addr (fmc_addr), .IO_EBI_data (fmc_data), .I_EBI_RD_data (ebi_rd_data), .O_EBI_WR_data (ebi_wr_data), .O_EBI_CS_n (ebi_cs_n), .O_EBI_WE_n (ebi_we_n), .O_EBI_RD_n (ebi_rd_n), .O_EBI_addr (ebi_addr) ); internal_regfile u_regfile ( .I_sys_clk (sys_clk), .I_rst_n (sys_rst_n), .I_cs_n (ebi_cs_n), .I_we_n (ebi_we_n), .I_rd_n (ebi_rd_n), .I_addr (ebi_addr), .I_wr_data (ebi_wr_data), .O_rd_data (ebi_rd_data) ); endmodule8. STM32端HAL配置与驱动 STM32侧使用HAL库配置FMC/EBI为异步SRAM模式。以下代码基于STM32F407，使用Bank1_NE2（对应地址 0x64000000）： 8.1 GPIO初始化 #include "stm32f4xx_hal.h" #define FPGA_BASE_ADDR 0x64000000 // 内存映射指针 (16位访问) volatile uint16_t *fpga_regs = (volatile uint16_t *)FPGA_BASE_ADDR; static void FMC_GPIO_Init(void) { GPIO_InitTypeDef GPIO_InitStruct = {0}; __HAL_RCC_GPIOD_CLK_ENABLE(); __HAL_RCC_GPIOE_CLK_ENABLE(); __HAL_RCC_GPIOF_CLK_ENABLE(); __HAL_RCC_GPIOG_CLK_ENABLE(); // 数据总线 D0~D15: PD14/15, PE7~15 GPIO_InitStruct.Pin = GPIO_PIN_14 | GPIO_PIN_15; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF12_FMC; HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_7 | GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15; HAL_GPIO_Init(GPIOE, &GPIO_InitStruct); // 地址总线 A0~A5: PF0~PF5 (可扩展至A23) GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5; HAL_GPIO_Init(GPIOF, &GPIO_InitStruct); // 控制信号: NOE(PD4), NWE(PD5), NE2(PG9) GPIO_InitStruct.Pin = GPIO_PIN_4 | GPIO_PIN_5; HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_9; HAL_GPIO_Init(GPIOG, &GPIO_InitStruct); }8.2 FMC异步SRAM模式初始化 void FMC_FPGA_Init(void) { SRAM_HandleTypeDef hsram = {0}; FMC_NORSRAM_TimingTypeDef Timing = {0}; FMC_GPIO_Init(); __HAL_RCC_FMC_CLK_ENABLE(); hsram.Instance = FMC_NORSRAM_DEVICE; hsram.Extended = FMC_NORSRAM_EXTENDED_DEVICE; // Bank1_NE2, 16位数据宽度, SRAM类型 hsram.Init.NSBank = FMC_NORSRAM_BANK2; hsram.Init.DataAddressMux = FMC_DATA_ADDRESS_MUX_DISABLE; // 非复用 hsram.Init.MemoryType = FMC_MEMORY_TYPE_SRAM; hsram.Init.MemoryDataWidth = FMC_NORSRAM_MEM_BUS_WIDTH_16; hsram.Init.BurstAccessMode = FMC_BURST_ACCESS_MODE_DISABLE; hsram.Init.WaitSignalPolarity = FMC_WAIT_SIGNAL_POLARITY_LOW; hsram.Init.WrapMode = FMC_WRAP_MODE_DISABLE; hsram.Init.WaitSignalActive = FMC_WAIT_TIMING_BEFORE_WS; hsram.Init.WriteOperation = FMC_WRITE_OPERATION_ENABLE; hsram.Init.WaitSignal = FMC_WAIT_SIGNAL_DISABLE; hsram.Init.ExtendedMode = FMC_EXTENDED_MODE_DISABLE; hsram.Init.AsynchronousWait = FMC_ASYNCHRONOUS_WAIT_DISABLE; hsram.Init.WriteBurst = FMC_WRITE_BURST_DISABLE; hsram.Init.ContinuousClock = FMC_CONTINUOUS_CLOCK_SYNC_ONLY; // 时序配置 (HCLK = 168MHz, 1周期 ≈ 5.95ns) // 需根据FPGA时序报告调整，满足建立/保持时间 Timing.AddressSetupTime = 2; // 地址建立: ~12ns Timing.AddressHoldTime = 1; // 地址保持 Timing.DataSetupTime = 5; // 数据建立: ~30ns Timing.BusTurnAroundDuration = 1; // 总线周转 Timing.CLKDivision = 2; Timing.DataLatency = 2; Timing.AccessMode = FMC_ACCESS_MODE_A; HAL_SRAM_Init(&hsram, &Timing, &Timing); }8.3 读写驱动函数 /** * @brief 向FPGA寄存器写入16位数据 */ static inline void FPGA_WriteReg(uint16_t reg, uint16_t value) { fpga_regs[reg] = value; __DSB(); // 数据同步屏障，确保写入完成 } /** * @brief 从FPGA寄存器读取16位数据 */ static inline uint16_t FPGA_ReadReg(uint16_t reg) { uint16_t val = fpga_regs[reg]; __DSB(); return val; } /** * @brief 批量数据写入 */ void FPGA_WriteBuffer(uint16_t reg_base, uint16_t *data, uint32_t len) { for (uint32_t i = 0; i < len; i++) { fpga_regs[reg_base + i] = data[i]; } __DSB(); } /** * @brief 批量数据读取 */ void FPGA_ReadBuffer(uint16_t reg_base, uint16_t *data, uint32_t len) { for (uint32_t i = 0; i < len; i++) { data[i] = fpga_regs[reg_base + i]; } __DSB(); }9. 读写时序分析 9.1 读时序 (FPGA → STM32) 读时序要点： I_EBI_OE_n 下降沿后，FPGA内部模块开始准备数据经过3个时钟周期（d0 → d1 → d2），S_EBI_RD_N_d2 变为低电平三态门在 S_EBI_RD_N_d2 == 0 时使能，将 I_EBI_RD_data 驱动到 IO_EBI_data STM32在 NOE 上升沿采样数据，需确保数据在采样前已稳定（满足DataSetupTime） 9.2 写时序 (STM32 → FPGA) 写时序要点： I_EBI_WE_n 下降沿表示写周期开始，STM32地址和数据已稳定 O_EBI_WE_n 在1个时钟周期后同步到低电平，内部模块在时钟上升沿检测 !O_EBI_WE_n && !O_EBI_CS_n 执行写操作 O_EBI_WR_data 直接采样 IO_EBI_data，无需额外延迟，因为写操作时数据总线由STM32持续驱动 10. 关键设计决策说明 10.1 为什么写信号只用1级同步，读信号用3级？信号同步级数原因I_EBI_WE_n → O_EBI_WE_n1级写操作对FPGA是"被动接收"，数据总线由STM32驱动，FPGA只需在时钟沿采样稳定的数据即可I_EBI_OE_n → S_EBI_RD_N_d23级读操作对FPGA是"主动输出"，需要给内部模块预留时间准备数据，再通过三态门驱动到总线10.2 三态门控制逻辑 assign IO_EBI_data = ( (I_EBI_CS_n == 1'b0) && (S_EBI_RD_N_d2 == 1'b0) ) ? I_EBI_RD_data : 16'bz;使用 S_EBI_RD_N_d2 而非 I_EBI_OE_n 的原因：直接使用 I_EBI_OE_n 会导致FPGA在STM32还未准备好接收数据时就驱动总线，可能产生总线冲突使用延迟后的 S_EBI_RD_N_d2 确保：① 内部数据已准备好；② STM32的读使能确实有效；③ 满足数据建立时间 10.3 地址直通 vs 同步 assign O_EBI_addr = I_EBI_addr; // 直通，无时钟延迟地址采用组合逻辑直通而非同步，原因：地址在EBI访问期间保持稳定，无需跨时钟域处理减少地址到内部模块的延迟，提高访问速度地址稳定性由STM32硬件保证 EBI开发手册下载

嵌入式＆系统 FPGA&ASIC # ASIC/FPGA # 嵌入式 # Verilog # C/C++

刘航宇 7月23日
0 124 6
2026-07-17
电子信息类专业考研-简历-就业宝藏公众号：843电子信息站摘要本公众号为电子信息类专业学生提供技术、考研、就业信息，涵盖技术栈、考研课程、简历、项目辅导与就业指导，助力学生提升竞争力。关键词：电子信息专业, 考研指导, 就业信息, FPGA技术, 嵌入式开发电子信息类专业（通信、电子、集成电路、人工智能等）的同学们，大学四年或硕士三年转瞬即逝，考研、实习、求职三座大山接踵而至。信息差，往往比努力更致命。从技术、考研到就业，本博客和公众号843电子信息站将会给大家带来很多信息差上的帮助。技术栈考研栈简历与就业栈升学与就业规划技术栈可以关注EE学术-刘航宇的博客https://ee.ac.cn/，本博客包含嵌入式、FPGA、数字IC领域多项基础知识以及实战项目，非常适合找工作的宝子们，以此来提高笔试和面试机会。有任何FPGA或嵌入式项目开发问题欢迎留言或者加博主，可以辅导解答。 pasted_1784268982839_xjdg8h.png图片 FPGA、STM32视频教程可以关注我的哔站 https://space.bilibili.com/470370345 pasted_1784272934372_eu8hjd.png图片考研栈欢迎大家报考考研西北大学843电子信息类专业：新一代电子信息技术、电子科学与技术、信息与通信工程专业，西大在行业认可度属于比较高的，毕业生可去央国企、华为、腾讯等大厂。推荐的843专业考研课程网站（学习通上课）： https://edu.ee.ac.cn/ 简历与就业栈可关注微信公众号：843电子信息站，致力于电子工程-FPGA与嵌入式技术的分享、电子信息就业信息分享；FPGA与嵌入式项目开发与辅导；西北大学843考研模电、数电、电路指导等。 pmycSqU.png图片升学与就业规划可参考本站文章：《电子信息类专业升学与就业规划，FPGA与嵌入式领域本科硕士均适用》 https://ee.ac.cn/index.php/archives/688.html

我的随笔 # ASIC/FPGA # 嵌入式 # 随笔 # 西北大学843

刘航宇 7月17日
0 173 6
2026-06-29
格雷码（Gray Code）原理与应用详解-结合工程领域说明摘要格雷码是一种二进制编码方式，相邻数之间只有一位二进制位变化，避免亚稳态和毛刺问题。主要应用在FPGA、嵌入式设计等领域，如异步FIFO，确保状态切换干净、无歧义。关键词：Gray Code, 格雷码, 应用场景, FPGA, 异步FIFO一、什么是格雷码格雷码（Gray Code）是一种特殊的二进制编码方式，它的核心特点是相邻两个数之间只有一位二进制位发生变化。这与普通二进制码不同——比如二进制中 3011011011 到 4100100100 有三位同时翻转，而格雷码中相邻数永远只变一位。二、为什么需要格雷码普通二进制在数值递增时，多位可能同时翻转，这在硬件世界中会引入一个严重问题：亚稳态和毛刺（Glitch）。举个例子： • 二进制从 0111 777 变到 1000 888 • 4位同时翻转，由于电路延迟差异，实际可能短暂出现 0101、0010 等错误中间态 • 如果此时被采样，就会读到完全错误的数据格雷码从根本上避免了这个问题——任何时候只有1位变化，不存在中间错误态。三、格雷码的主要应用场景应用场景为什么用格雷码图片四、格雷码 vs 二进制对照表（3位）图片五、FPGA中最经典的用法：异步FIFO // 二进制计数器 → 格雷码转换 → 跨时钟域传输 module gray_code_converter #( parameter WIDTH = 8 )( input WIDTH−1:0WIDTH-1:0WIDTH−1:0 bin, // 二进制计数器值 output WIDTH−1:0WIDTH-1:0WIDTH−1:0 gray // 格雷码输出 ); // 转换公式：gray = bin ^ bin>>1bin >> 1bin>>1 assign gray = bin ^ bin>>1bin >> 1bin>>1; endmodule为什么FIFO指针必须用格雷码？ • 写时钟域的写指针要传到读时钟域进行比较 • 如果用二进制，多位同时变化 → 跨时钟域采样可能抓到错误值 → 空满判断出错 → 数据丢失或覆盖 • 格雷码每次只变1位 → 即使采样时机不对，最多差1个地址 → 不会误判空满状态六、格雷码 ↔ 二进制转换公式【二进制 → 格雷码】 G(n) = B(n) ^ B(n+1) // 最高位不变，其余位与高位异或 // 或简写： gray = bin ^ (bin >> 1) 【格雷码 → 二进制】 B(n) = G(n) ^ B(n+1) // 从最高位开始，逐位异或恢复 // 或递推： bin[MSB] = gray[MSB] bin[i] = gray[i] ^ bin[i+1] 七、一句话总结格雷码不是为了"计算"方便，而是为了"变化安全"——在硬件世界中，让每一次状态切换都干净、无歧义、无毛刺。这是数字电路从"理论正确"走向"工程可靠"的关键一步，也是FPGA/嵌入式设计中跨时钟域、机械编码器等场景的标准做法。

嵌入式＆系统通信&信息处理 # 嵌入式 # 通信&射频

刘航宇 6月29日
0 170 5
2024-07-05
Linux之不使用命令删除文件中的第N行摘要本文介绍了三种方法在不使用命令的情况下，通过编程删除Linux文件中的指定行。方法包括使用临时文件、系统调用和直接操作文件指针，并提供了相应的C语言代码示例。关键词：Linux, 文件删除, 行号删除, 文件操作, 临时文件1.问题描述 2. 解题思路: 3. 代码实现: 1.问题描述设计一个程序，通过命令行参数接收一个文件名 filename.txt (纯文本文件)和一个整型数字 n，实现从 filename.txt 中删除第 n 行数据。 2. 解题思路: (1) 借助临时文件: 将文件逐行读取，跳过要删除的行，并将其写入临时文件，然后删除源文件，重命名临时文件为源文件，完成删除指定行数据。 (2) 不借助临时文件: 将文件以读写方式打开，读取到要删除行后，通过移动文件指针将文件后面所有行前移一行，但是最后一行会重复，可以通过截断文件操作完成在源文件上删除指定行数据。 (3) 通过sed 或 awk 删除文件指定行 3. 代码实现: (1) 通过 fopen 打开文件借助临时文件删除指定行数据 #filename:ques_15a.c #include <stdio.h> // 包含标准输入输出库 #include <stdlib.h> // 包含标准库函数，比如exit int main(int argc, char *argv[]) { // 检查命令行参数的数量是否正确 if (argc != 3) { printf("Usage: ./a.out filename num\n"); exit(EXIT_FAILURE); // 如果不正确，打印用法信息并退出 } char buf[4096]; // 定义一个足够大的字符数组用于读取文件行 int linenum = atoi(argv[2]); // 将命令行参数中的行号转换为整数 FILE *fp = fopen(argv[1], "r"); // 尝试以只读模式打开源文件 FILE *fpt = fopen("temp.txt", "w"); // 创建一个临时文件用于写入 // 如果源文件无法打开，打印错误信息并退出 if (!fp) { printf("File %s not exist!\n", argv[1]); exit(EXIT_FAILURE); } // 检查是否有权限修改源文件 char str[100]; sprintf(str, "%s%s", "test -w ", argv[1]); if (system(str)) { // 如果没有写权限 printf("Can't modify file %s, permission denied!\n", argv[1]); exit(EXIT_FAILURE); // 打印错误信息并退出 } int total_line = 0; // 初始化文件总行数计数器 while (fgets(buf, sizeof(buf), fp)) { // 读取文件的每一行 total_line++; } fseek(fp, 0, SEEK_SET); // 将文件指针重置到文件的开头 // 如果要删除的行数大于文件的总行数，打印错误信息并退出 if (linenum > total_line) { printf("%d is greater than total_line!\n", linenum); exit(EXIT_FAILURE); } int i = 0; // 初始化当前行计数器 while (fgets(buf, sizeof(buf), fp)) { // 再次读取文件的每一行 i++; // 当前行数加1 if (i != linenum) { // 如果当前行不是要删除的行 fputs(buf, fpt); // 将当前行写入临时文件 } } remove(argv[1]); // 删除原始文件 rename("temp.txt", argv[1]); // 将临时文件重命名为原始文件名 // 关闭文件指针 fclose(fp); fclose(fpt); return 0; // 程序正常退出 }(2) 通过 Linux 系统调用 open 打开文件，需要自定义读取一行的函数，不借助临时文件删除指定行数据 # filename:ques_15b.c #include <stdio.h> // 包含标准输入输出库 #include <stdlib.h> // 包含标准库函数，比如atoi和exit #include <string.h> // 包含字符串操作函数，比如strlen #include <fcntl.h> // 包含文件控制的定义 #include <sys/stat.h> // 包含文件状态的定义 #include <sys/types.h>// 包含各种数据类型 #include <unistd.h> // 包含UNIX标准函数定义 // 函数声明：读取一行文件内容到缓冲区 int readline(int fd, char *buf) { int t = 0; // 用于记录读取的字符数 // 循环读取直到遇到换行符 for (; ;) { read(fd, &buf[t], 1); // 从文件描述符fd读取一个字符到buf t++; // 增加读取的字符数 if (buf[t-1] == '\n') { // 如果读取到换行符 break; // 退出循环 } } return t; // 返回读取的字符数 } // 函数声明：获取文件的大小和行数 int get_file_info(int fd, int *size) { int num = 0; // 记录行数 char ch; // 临时变量用于存储读取的字符 // 循环读取直到文件结束 while (read(fd, &ch, 1) > 0) { (*size)++; // 文件大小加1 if (ch == '\n') { // 如果读取到换行符 num++; // 行数加1 } } return num; // 返回行数 } int main(int argc, char *argv[]) { // 检查命令行参数数量 if (argc != 3) { printf("Usage: ./a.out filename num\n"); exit(EXIT_FAILURE); // 参数不正确时退出 } int fd; // 文件描述符 char buf[4096]; // 缓冲区 int linenum = atoi(argv[2]); // 将命令行参数转换为整数 // 尝试以读写模式打开文件 fd = open(argv[1], O_RDWR); if (fd < 0) { printf("Can't open file %s, file not exist or permission denied!\n", argv[1]); exit(EXIT_FAILURE); // 打开失败时退出 } int size = 0; // 文件大小 // 获取文件的行数和大小 int total_line = get_file_info(fd, &size); // 如果要删除的行数大于文件总行数，退出 if (linenum > total_line) { printf("%d is greater than total_line!\n", linenum); exit(EXIT_FAILURE); } int s = 0; // 要删除行的大小 int t = 0; // 当前行的大小 int i = 0; // 当前行数 lseek(fd, 0, SEEK_SET); // 将文件指针移到文件头 // 循环读取文件，直到文件结束 while (read(fd, &buf[0], 1) > 0) { lseek(fd, -1, SEEK_CUR); // 回退一个字符 memset(buf, 0, sizeof(buf)); // 清空缓冲区 readline(fd, buf); // 读取一行到缓冲区 i++; // 行数加1 t = strlen(buf); // 当前行的大小 // 如果当前行是目标行，记录其大小 if (i == linenum) { s = t; } // 如果当前行在目标行之后，将该行前移 if (i > linenum) { lseek(fd, -(s+t), SEEK_CUR); // 移动文件指针 write(fd, buf, strlen(buf)); // 写入当前行 lseek(fd, s, SEEK_CUR); // 移动文件指针 } } ftruncate(fd, size-s); // 截断文件，删除指定行 close(fd); // 关闭文件描述符 return 0; // 正常退出 }(3) 通过 fopen 打开文件，不借助临时文件删除指定行数据 # filename:ques_15b.c #include <stdio.h> // 包含标准输入输出库 #include <stdlib.h> // 包含标准库函数，如atoi和exit #include <string.h> // 包含字符串处理函数，如strlen #include <math.h> // 包含数学函数，虽然在这个程序中没有使用 #include <unistd.h> // 包含UNIX标准函数，如truncate int main(int argc, char *argv[]) { // 检查命令行参数个数是否正确 if (argc != 3) { printf("Usage: ./a.out filename num\n"); exit(EXIT_FAILURE); // 参数不正确时退出程序 } int linenum = atoi(argv[2]); // 将命令行中指定的行号转换为整数 char buf[4096]; // 定义缓冲区，用于读取文件内容 // 尝试以读写模式打开文件 FILE *fp = fopen(argv[1], "r+"); // 如果文件无法打开，打印错误信息并退出程序 if (!fp) { printf("Can't open file %s, file not exist or permission denied!\n", argv[1]); exit(EXIT_FAILURE); } int total_line = 0; // 记录文件的总行数 int size = 0; // 记录文件的总大小 // 循环读取文件直到文件末尾，计算总行数和总大小 while (fgets(buf, sizeof(buf), fp)) { size += strlen(buf); // 累加每行的长度 total_line++; // 行数加1 } // 如果要删除的行数大于文件的总行数，打印错误信息并退出程序 if (linenum > total_line) { printf("%d is greater than total_line!\n", linenum); exit(EXIT_FAILURE); } int s = 0; // 记录要删除的行的大小 int t = 0; // 记录当前读取行的大小 int i = 0; // 记录当前行数 fseek(fp, 0L, SEEK_SET); // 将文件指针重置到文件开头 // 再次循环读取文件，准备删除指定行 while (fgets(buf, sizeof(buf), fp)) { i++; // 当前行数加1 t = strlen(buf); // 当前行的长度 // 如果当前行是要删除的行，记录其大小 if (i == linenum) { s = t; } // 如果当前行在要删除的行之后，将其前移 if (i > linenum) { fseek(fp, -(s+t), SEEK_CUR); // 将文件指针移动到正确的位置 fputs(buf, fp); // 写入当前行 fseek(fp, s, SEEK_CUR); // 将文件指针向前移动s个字节 } } // 截断文件，删除指定行 truncate(argv[1], size-s); // 关闭文件指针 fclose(fp); return 0; // 正常退出程序 }(4) 这三个删除文件指定行的函数都需借助临时文件完成

嵌入式＆系统 # 嵌入式

刘航宇 2年前
0 524 1
2024-06-27
基础概念：中断、任务、进程、线程、RTOS、Linux 摘要本文介绍了中断、任务、进程、线程等基本概念，并阐述了它们在多任务操作和资源管理中的角色。同时，对比了RTOS和Linux在设计目标、实时性、调度策略等方面的差异。关键词：中断, 任务, 进程, 线程, RTOS中断任务进程线程它们之间的区别 RTOS和Linux的区别中断、任务、进程和线程是计算机科学和操作系统中的基本概念，它们在多任务操作和资源管理中扮演着重要的角色。下面是这些概念的简要解释以及它们之间的区别：中断中断是硬件或软件发出的信号，用来通知CPU暂停当前的工作，转而去执行一个特殊的程序（中断处理程序）。中断可以是外部的，比如来自硬件设备的信号，或者是内部的，比如软件生成的信号。中断机制允许操作系统响应外部事件，如用户输入或硬件状态变化。任务在某些操作系统中，任务是一个抽象概念，用来表示一个执行单元，它可以是一个进程或者线程。任务通常指的是需要操作系统调度和资源管理的执行流。进程进程是操作系统分配资源和调度的基本单位。每个进程都有自己的地址空间、数据栈以及其他用于跟踪进程状态和执行的资源。进程可以包含一个或多个线程。线程线程是进程中的一个实体，是CPU调度和执行的单位。线程共享所属进程的资源，但拥有自己的堆栈和程序计数器。线程比进程更轻量级，创建和切换的开销更小。它们之间的区别资源分配：进程是资源分配的最小单位，线程则不是。执行：进程是执行程序的实例，线程是进程中的实际执行流。地址空间：进程有独立的地址空间，线程共享进程的地址空间。创建开销：进程的创建开销通常大于线程。通信：线程间可以通过共享内存进行通信，进程间通信需要使用IPC（进程间通信）机制。 RTOS和Linux的区别 RTOS（实时操作系统）和Linux是两种不同类型的操作系统，它们在设计目标和特性上有所区别：设计目标： RTOS：设计用于需要快速、可预测响应的系统，如嵌入式系统、工业控制等。 Linux：是一个通用操作系统，主要用于桌面、服务器、移动设备等。实时性： RTOS：提供确定的响应时间，可以保证任务在指定的时间内得到处理。 Linux：虽然可以配置为实时系统，但通常不具备RTOS的严格实时性。调度策略： RTOS：通常使用基于优先级的抢占式调度。 Linux：使用完全公平调度器（CFS）进行调度，可以配置为实时调度。内存管理： RTOS：通常有简单的内存管理机制，适合资源受限的环境。 Linux：具有复杂的内存管理机制，支持虚拟内存和内存共享。应用场景： RTOS：适用于对实时性要求高、资源受限的场合。 Linux：适用于需要高度灵活性和扩展性的场合。开源和社区支持： RTOS：有些RTOS是开源的，但社区规模通常小于Linux。 Linux：是一个开源项目，拥有庞大的社区和开发者支持。总的来说，RTOS和Linux各有优势，选择哪个系统取决于应用的具体需求。RTOS适合对实时性要求极高的场景，而Linux适合需要高度灵活性和功能丰富的环境。

嵌入式＆系统 # 嵌入式

刘航宇 2年前
0 970 2
Socket通信-Linux系统中C语言实现TCP/UDP图片和文件传输摘要本文介绍了在Linux系统中使用C语言实现TCP/UDP图片和文件传输的方法。首先讲解了TCP协议的建立连接过程，包括服务端和客户端的编程步骤，然后介绍了UDP协议的无连接特性及其编程步骤，并提供了服务端和客户端的代码示例。关键词：Socket通信, Linux系统, C语言, TCP/UDP, 图片文件传输TCP实现1.服务端 2.客户端二、UDP实现1.服务端 2.客户端 TCP实现传输控制协议(TCP，Transmission Control Protocol) 是为了在不可靠的互联网络上提供可靠的端到端字节流而专门设计的一个传输协议。TCP是因特网中的传输层协议，使用三次握手协议建立连接。当主动方发出SYN连接请求后，等待对方回答SYN+ACK，并最终对对方的 SYN 执行 ACK 确认。这种建立连接的方法可以防止产生错误的连接，TCP使用的流量控制协议是可变大小的滑动窗口协议。 1.服务端基于TCP协议的socket的server端程序编程步骤： 1、建立socket ，使用socket() 2、绑定socket ，使用bind() 3、打开listening socket,使用listen() 4、等待client连接请求，使用accept() 5、收到连接请求，确定连接成功后，使用输入，输出函数recv(),send()与client端互传信息 6、关闭socket,使用close() 服务端代码server.c /*server.c*/ #include<netinet/in.h> #include<sys/types.h> #include<sys/socket.h> #include<stdio.h> #include<stdlib.h> #include<string.h> #define SERVER_PORT 5678 //端口号 #define LENGTH_OF_LISTEN_QUEUE 20 #define BUFFER_SIZE 1024 #define FILE_NAME_MAX_SIZE 512 int main(int argc, char **argv) { // 设置一个socket地址结构server_addr,代表服务器ip地址和端口 struct sockaddr_in server_addr; bzero(&server_addr, sizeof(server_addr)); server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr = htons(INADDR_ANY); server_addr.sin_port = htons(SERVER_PORT); // 创建用于流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口 int server_socket = socket(PF_INET, SOCK_STREAM, 0); if (server_socket < 0) { printf("Create Socket Failed!\n"); exit(1); } else printf("Create Socket Success.\n"); // 把socket和socket地址结构绑定 if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr))) { printf("Server Bind Port: %d Failed!\n", SERVER_PORT); exit(1); } else printf("Client Bind Port Success.\n"); // server_socket用于监听 if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE)) { printf("Server Listen Failed!\n"); exit(1); } else printf("Listening....\n"); // 服务器始终监听 while(1) { // 定义客户端的socket地址结构client_addr，当收到来自客户端的请求后，调用accept // 接受此请求，同时将client端的地址和端口等信息写入client_addr中 struct sockaddr_in client_addr; socklen_t length = sizeof(client_addr); // 接受一个从client端到达server端的连接请求,将客户端的信息保存在client_addr中 // 如果没有连接请求，则一直等待直到有连接请求为止，这是accept函数的特性 // accpet返回一个新的socket,这个socket用来与此次连接到server的client进行通信 // 这里的new_server_socket代表了这个通信通道 int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length); if (new_server_socket < 0) { printf("Server Accept Failed!\n"); break; } else printf("Server Accept Success.\n"); char buffer[BUFFER_SIZE]; bzero(buffer, sizeof(buffer)); length = recv(new_server_socket, buffer, BUFFER_SIZE, 0); if (length < 0) { printf("Server Recieve Data Failed!\n"); break; } else printf("Server Recieve Data Success.\n"); char file_name[FILE_NAME_MAX_SIZE + 1]; bzero(file_name, sizeof(file_name)); strncpy(file_name, buffer, strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer)); FILE *fp = fopen(file_name, "r"); //获取文件操作符 if (fp == NULL) { printf("File:\t%s Not Found!\n", file_name); } else { bzero(buffer, BUFFER_SIZE); int file_block_length = 0; while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0) { // 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端 if (send(new_server_socket, buffer, file_block_length, 0) < 0) { printf("Send File:\t%s Failed!\n", file_name); break; } bzero(buffer, sizeof(buffer)); } fclose(fp); printf("File:\t%s Transfer Finished!\n", file_name); } close(new_server_socket); } close(server_socket); return 0; } 2.客户端基于TCP协议的socket的Client程序编程步骤： 1、建立socket，使用socket() 2、通知server请求连接，使用connect() 3、若连接成功，就使用输入输出函数recv(),send()与server互传信息 4、关闭socket，使用close() 客户端代码client.c /*client.c*/ #include<netinet/in.h> // for sockaddr_in #include<sys/types.h> // for socket #include<sys/socket.h> // for socket #include<stdio.h> // for printf #include<stdlib.h> // for exit #include<string.h> // for bzero #define SERVER_PORT 5678 #define BUFFER_SIZE 1024 #define FILE_NAME_MAX_SIZE 512 int main(int argc, char **argv) { if (argc != 2) //判断有没有输入服务器ip { printf("Usage: ./%s ServerIPAddress\n", argv[0]); exit(1); } // 设置一个socket地址结构client_addr, 代表客户机的ip地址和端口 struct sockaddr_in client_addr; bzero(&client_addr, sizeof(client_addr)); client_addr.sin_family = AF_INET; // internet协议族IPv4 client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址 client_addr.sin_port = htons(0); // auto allocated, 让系统自动分配一个空闲端口 // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket int client_socket = socket(AF_INET, SOCK_STREAM, 0); if (client_socket < 0) { printf("Create Socket Failed!\n"); exit(1); } else printf("Create Socket Success.\n"); // 把客户端的socket和客户端的socket地址结构绑定 if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr))) { printf("Client Bind Port Failed!\n"); exit(1); } else printf("Client Bind Port Success.\n"); // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口 struct sockaddr_in server_addr; bzero(&server_addr, sizeof(server_addr)); server_addr.sin_family = AF_INET; // 服务器的IP地址来自程序的参数 if (inet_aton(argv[1], &server_addr.sin_addr) == 0) { printf("Server IP Address Error!\n"); exit(1); } server_addr.sin_port = htons(SERVER_PORT); int server_addr_length = sizeof(server_addr); // 向服务器发起连接请求，连接成功后client_socket代表客户端和服务器端的一个socket连接 if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0) { printf("Can Not Connect To %s!\n", argv[1]); exit(1); } else printf("Alreadly Connect To %s.\n", argv[1]); char file_name[FILE_NAME_MAX_SIZE + 1]; bzero(file_name, sizeof(file_name)); printf("Please Input File Name On Server: "); scanf("%s", file_name); char buffer[BUFFER_SIZE];//缓存区 bzero(buffer, sizeof(buffer)); strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name)); // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字 send(client_socket, buffer, BUFFER_SIZE, 0); // send , sendto(), recv(),recvfrom() FILE *fp = fopen(file_name, "w"); if (fp == NULL) { printf("File: %s Can Not Open To Write!\n", file_name); exit(1); } // 从服务器端接收数据到buffer中 bzero(buffer, sizeof(buffer)); int length = 0; while(length = recv(client_socket, buffer, BUFFER_SIZE, 0)) { if (length < 0) { printf("Recieve Data From Server %s Failed!\n", argv[1]); break; } int write_length = fwrite(buffer, sizeof(char), length, fp); if (write_length < length) { printf("File:\t%s Write Failed!\n", file_name); break; } bzero(buffer, BUFFER_SIZE); } printf("Recieve File: %s From Server[%s] Finished!\n", file_name, argv[1]); // 传输完毕，关闭socket fclose(fp); close(client_socket); return 0; } 如图，客户端（左）从服务端（右）下载文件/图片：图片二、UDP实现 UDP(User Datagram Protocol) 全称是用户数据报协议,是一种非面向连接的协议,这种协议并不能保证我们的网络程序的连接是可靠的。 1.服务端基于UDP协议的socket的server编程步骤： 1、建立socket,使用socket() 2、绑定socket,使用bind() 3、以recvfrom()函数接收发送端传来的数据（使用recvfrom函数时需设置非阻塞，以免程序卡在此处） 4、关闭socket，使用close() /*server.c*/ #include<netinet/in.h> #include<sys/types.h> #include<sys/socket.h> #include<stdio.h> #include<stdlib.h> #include<string.h> #define SERVER_PORT 5678 //端口号 #define LENGTH_OF_LISTEN_QUEUE 20 #define BUFFER_SIZE 1024 #define FILE_NAME_MAX_SIZE 512 int main(int argc, char **argv) { // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口 struct sockaddr_in server_addr; bzero(&server_addr, sizeof(server_addr)); server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr = htons(INADDR_ANY); server_addr.sin_port = htons(SERVER_PORT); // create a stream socket // 创建用于internet的流协议(UDP)socket，用server_socket代表服务器向客户端提供服务的接口 int server_socket = socket(PF_INET, SOCK_DGRAM, 0); if (server_socket < 0) { printf("Create Socket Failed!\n"); exit(1); } else printf("Create Socket Success.\n"); // 把socket和socket地址结构绑定 if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr))) { printf("Server Bind Port: %d Failed!\n", SERVER_PORT); exit(1); } else printf("Server Bind Port Success.\n"); printf("Waiting......\n"); // 服务器端一直运行用以持续为客户端提供服务 while(1) { // 接受此请求，同时将client端的地址和端口等信息写入client_addr中 struct sockaddr_in client_addr; int length = 0; int addrlen = sizeof(client_addr); char buffer[BUFFER_SIZE]; bzero(buffer, sizeof(buffer)); length = recvfrom(server_socket, buffer, BUFFER_SIZE, 0,(struct sockaddr *)&client_addr,&addrlen); if (length < 0) { printf("Server Recieve Data Failed!\n"); break; } char file_name[FILE_NAME_MAX_SIZE + 1]; bzero(file_name, sizeof(file_name)); strncpy(file_name, buffer, strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer)); FILE *fp = fopen(file_name, "r"); if (fp == NULL) { printf("File:\t%s Not Found!\n", file_name); } else { bzero(buffer, BUFFER_SIZE); int file_block_length = 0; while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0) { // 发送buffer中的字符串到server_socket,实际上就是发送给客户端 if (sendto(server_socket, buffer, BUFFER_SIZE, 0,(struct sockaddr *)&client_addr,addrlen) < 0) { printf("Send File:\t%s Failed!\n", file_name); break; } bzero(buffer, sizeof(buffer)); } fclose(fp); printf("File:\t%s Transfer Finished!\n", file_name); } } close(server_socket); return 0; }2.客户端基于UDP协议的socket的client端编程步骤： 1、建立Socket，使socket() 2、用sendto()函数向接收端发送数据。 3、关闭socket，使用close()函数 /*client.c*/ #include<netinet/in.h> // for sockaddr_in #include<sys/types.h> // for socket #include<sys/socket.h> // for socket #include<stdio.h> // for printf #include<stdlib.h> // for exit #include<string.h> // for bzero #include <fcntl.h> #include <unistd.h> #include <sys/time.h> #define SERVER_PORT 5678 #define BUFFER_SIZE 1024 #define FILE_NAME_MAX_SIZE 512 int main(int argc, char **argv) { if (argc != 2) { printf("Usage: ./%s ServerIPAddress\n", argv[0]); exit(1); } // 设置一个socket地址结构client_addr, 代表客户机的internet地址和端口 struct sockaddr_in client_addr; bzero(&client_addr, sizeof(client_addr)); client_addr.sin_family = AF_INET; // internet协议族 client_addr.sin_addr.s_addr = htons(INADDR_ANY); // INADDR_ANY表示自动获取本机地址 client_addr.sin_port = htons(0); // auto allocated, 让系统自动分配一个空闲端口 // 创建用于internet的流协议(TCP)类型socket，用client_socket代表客户端socket int client_socket = socket(AF_INET, SOCK_DGRAM, 0); if (client_socket < 0) { printf("Create Socket Failed!\n"); exit(1); } // 设置超时，防止recvfrom（）函数阻塞 struct timeval timeout; timeout.tv_sec = 1;//秒 timeout.tv_usec = 0;//微秒 if (setsockopt(client_socket, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) == -1) { perror("setsockopt failed:"); } // 把客户端的socket和客户端的socket地址结构绑定 if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr))) { printf("Client Bind Port Failed!\n"); exit(1); } // 设置一个socket地址结构server_addr,代表服务器的internet地址和端口 struct sockaddr_in server_addr; bzero(&server_addr, sizeof(server_addr)); server_addr.sin_family = AF_INET; // 服务器的IP地址来自程序的参数 if (inet_aton(argv[1], &server_addr.sin_addr) == 0) { printf("Server IP Address Error!\n"); exit(1); } server_addr.sin_port = htons(SERVER_PORT); int server_addr_length = sizeof(server_addr); char file_name[FILE_NAME_MAX_SIZE + 1]; bzero(file_name, sizeof(file_name)); printf("Please Input File Name On Server: "); scanf("%s", file_name); char buffer[BUFFER_SIZE]; bzero(buffer, sizeof(buffer)); strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name)); // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字 if( sendto(client_socket, buffer, BUFFER_SIZE, 0,(struct sockaddr *)&server_addr,server_addr_length) ) printf("Waiting receive %s from server....\n",file_name); FILE *fp = fopen(file_name, "w"); if (fp == NULL) { printf("File:\t%s Can Not Open To Write!\n", file_name); exit(1); } // 从服务器端接收数据到buffer中 bzero(buffer, sizeof(buffer)); int length = 0; //length = recvfrom(client_socket, buffer, BUFFER_SIZE, 0, (struct sockaddr*)&server_addr, &server_addr_length)//非阻塞 while( length = recvfrom(client_socket, buffer, BUFFER_SIZE, 0, (struct sockaddr*)&server_addr, &server_addr_length)) { if (length < 0) { //printf("Recieve Data From Server %s Failed!\n", argv[1]); break; } int write_length = fwrite(buffer, sizeof(char), length, fp); if (write_length < length) { printf("File: %s Write Failed!\n", file_name); break; } bzero(buffer, BUFFER_SIZE); } printf("Receive File: %s From Server[%s] Finished!\n", file_name, argv[1]); // 传输完毕，关闭socket fclose(fp); close(client_socket); return 0; } 如图，客户端（左）从服务端（右）下载文件/图片：图片注：使用recvfrom函数时需设置非阻塞，以免程序卡住。

嵌入式＆系统 # 嵌入式

刘航宇 2年前
0 785 0
2024-01-11
嵌入式常见知识点摘要本文介绍了嵌入式系统开发中常见的知识点，包括线程与进程的区别、整数是否为2的n次方的计算方法、printf函数的实现、大小端的概念及区分方法、new与malloc的区别、程序链接后的组成部分、Linux、Windows与FreeRTOS的区别等。关键词：嵌入式, 进程, 线程, 位运算, 快速排序图片 1、线程、进程的区别？最小执行单元是进程还是线程？ 2、如何计算一个整数是不是2的n次方？ 3、printf的具体实现？ 4、什么是大小端？如何区分？有几种方法？ 5、new与malloc的区别？ 6、程序链接完毕之后分几部分？ 7、Linux、Windows与FreeRtos的区别？ 8、Linux系统中的中断为什么分为上下两个部分？ 9、会快速排序吗？简要说一下？ 10、static关键字的作用？ 11、extern 关键字的作用？ 12、volatile关键字的作用？ 13、编译原理分哪几步？ 14、内存分区？ 15、freertos启动流程？ 16、互斥锁与信号量的区别？ 17、什么是死锁？死锁产生的原因？如何避免？ 18、什么是内存泄漏？ 19、系统死机了怎么排查原因？逐一看代码？工程量太大了吧？ 20、同一类型的结构体定义两个变量能用内存大小来比较判断两者一样吗？（没懂） 21、freertos中EventBits_t是干啥的？ 22、freertos使任务切换的方式有哪些？ 23、项目中用到网络了吗？ 24、了解Socket吗？ 25、c++中set是什么？ 26、有没有用到C++模板？ 27、有没有对代码裁剪的经验 28、freertos系统是买模块时人家配置好的？还是移植的？ 29、任务里有两把锁的时候该怎么处理 30、熟悉Shell脚本吗？$和#啥意思？表示注释的开始，可以用来对代码进行说明，不会被执行，例如#echo hello，#这是一个注释，表示打印hello，后面的内容是一个注释。31、知道#error吗？ 32、freertos消息队列的的具体实现？ 33、堆栈区别？ 34、程序存放状态和区别 1、线程、进程的区别？最小执行单元是进程还是线程？线程和进程都是程序的执行实体，但是它们有以下区别：进程是操作系统分配资源的基本单位，每个进程都有自己的独立的地址空间，代码段，数据段，堆栈段等。进程之间的切换需要保存和恢复上下文，开销较大。线程是操作系统调度的基本单位，每个线程都属于某个进程，一个进程可以有多个线程，它们共享进程的地址空间，但是有自己的栈和寄存器。线程之间的切换只需要保存和恢复少量的寄存器，开销较小。最小的执行单元是线程，因为一个进程至少要有一个线程，而一个线程可以独立运行。 2、如何计算一个整数是不是2的n次方？一个整数是2的n次方，当且仅当它的二进制表示中只有一个1，其余都是0。例如，23=8=(1000)2 ，只有一个1。所以，我们可以用以下的方法来判断一个整数x是否是2的n次方：如果x小于等于0，那么它不是2的n次方。如果x大于0，那么我们可以用位运算的技巧，将x与x-1做按位与，如果结果为0，那么x是2的n次方，否则不是。例如，8&(8−1)=8&7=(1000)2&(0111)2=(0000)2=0 ，所以8是2的n次方。而9&(9−1)=9&8=(1001)2&(1000)2=(1000)2=0 ，所以9不是2的n次方。 3、printf的具体实现？ printf是C语言中的一个标准库函数，用于向标准输出流（通常是屏幕）打印格式化的字符串。它的具体实现可能因编译器和操作系统的不同而有所差异，但是一般来说，它的主要步骤如下：首先，printf会解析第一个参数，也就是格式化字符串，根据其中的转换说明符（如%d, %f, %s等），确定需要打印的数据类型和格式。然后，printf会从第二个参数开始，依次获取对应的数据，并将其转换为字符串，拼接到格式化字符串的相应位置。如果参数的个数和类型与格式化字符串不匹配，可能会导致错误或未定义的行为。最后，printf会调用底层的系统函数，将拼接好的字符串写入到标准输出流中，并返回成功写入的字符数。如果发生错误，返回负值。 4、什么是大小端？如何区分？有几种方法？大小端是指数据在内存中的存储顺序，大端表示高位字节存放在低地址，低位字节存放在高地址，小端表示高位字节存放在高地址，低位字节存放在低地址。例如，一个32位的整数0x12345678，在大端模式下，存储为0x12 0x34 0x56 0x78，而在小端模式下，存储为0x78 0x56 0x34 0x12。区分大小端的方法有以下几种：通过联合体（union）的方式，将一个整数和一个字符数组放在同一个联合体中，然后判断字符数组的第一个元素是不是整数的最低字节，如果是，说明是小端，否则是大端。通过指针的方式，将一个整数的地址赋给一个字符指针，然后判断指针指向的内容是不是整数的最低字节，如果是，说明是小端，否则是大端。通过位运算的方式，将一个整数右移24位，然后与0xFF做按位与，得到的结果是不是整数的最高字节，如果是，说明是大端，否则是小端。 5、new与malloc的区别？ new和malloc都是用于动态分配内存的，但是它们有以下区别： new是C++中的运算符，malloc是C语言中的函数，它们的用法不同。new可以直接分配对象，而malloc只能分配字节，需要强制类型转换。 new会调用对象的构造函数，初始化对象，而malloc只是分配原始的内存空间，不做任何初始化。 new会根据对象的类型，自动计算所需的内存大小，而malloc需要手动指定分配的字节数。 new分配失败时，会抛出异常，而malloc分配失败时，会返回NULL指针。 new对应的释放内存的运算符是delete，而malloc对应的释放内存的函数是free。 6、程序链接完毕之后分几部分？程序链接完毕之后，一般分为以下几个部分：代码段（text segment），存放程序的指令和常量。数据段（data segment），存放程序的全局变量和静态变量。堆（heap），存放程序动态分配的内存空间。栈（stack），存放程序的局部变量，函数参数，返回地址等。 BSS段（bss segment），存放程序未初始化的全局变量和静态变量。 7、Linux、Windows与FreeRtos的区别？ Linux、Windows和FreeRtos都是操作系统，但是它们有以下区别： Linux是一个开源的，基于Unix的，多用户，多任务，支持多种硬件平台的操作系统，它有很多不同的发行版，如Ubuntu，RedHat，Debian等。Linux适合用于服务器，嵌入式系统，桌面系统等。 Windows是一个闭源的，基于NT内核的，多用户，多任务，主要支持x86和x64架构的操作系统，它有很多不同的版本，如Windows 10，Windows Server，Windows CE等。Windows适合用于桌面系统，移动设备，游戏机等。 FreeRtos是一个开源的，基于微内核的，实时，多任务，支持多种嵌入式平台的操作系统，它有很多不同的移植，如ARM，MIPS，AVR等。FreeRtos适合用于实时控制，物联网，低功耗设备等。 8、Linux系统中的中断为什么分为上下两个部分？ Linux系统中的中断为了提高效率和响应时间，分为上半部（top half）和下半部（bottom half）。上半部是指中断处理程序（interrupt handler），它负责处理中断的紧急事务，如保存寄存器，清除中断标志，识别中断源等。下半部是指中断延迟服务程序（interrupt deferred service routine），它负责处理中断的非紧急事务，如数据传输，设备驱动，信号发送等。上半部和下半部的区别如下：上半部在中断上下文中执行，下半部在进程上下文中执行。上半部不能被其他中断打断，下半部可以被其他中断打断。上半部不能睡眠，下半部可以睡眠。上半部不能调用可能导致阻塞的函数，如malloc，copy_to_user等，下半部可以调用这些函数。上半部的执行时间应该尽可能短，下半部的执行时间可以较长。 9、会快速排序吗？简要说一下？快速排序是一种基于分治思想的排序算法，它的基本步骤如下：从待排序的数组中选择一个元素作为基准（pivot），通常选择第一个或者最后一个元素。将数组分成两个子数组，一个子数组中的元素都小于或等于基准，另一个子数组中的元素都大于基准，这个过程称为划分（partition）。对两个子数组递归地进行快速排序，直到子数组的长度为1或0。将排好序的子数组合并，得到最终的排序结果。快速排序的平均时间复杂度是O(nlogn) ，最坏情况是O(n^2) ，空间复杂度是O(logn) ，它是一种不稳定的排序算法。 10、static关键字的作用？ static是一个修饰符，它可以用于变量和函数，它有以下作用：用于全局变量，表示该变量只能在本文件中访问，不能被其他文件引用，这样可以避免命名冲突。用于局部变量，表示该变量的生命周期是整个程序，而不是函数调用结束，这样可以保持变量的值不被销毁。用于函数，表示该函数只能在本文件中调用，不能被其他文件引用，这样可以提高函数的封装性和安全性。 11、extern 关键字的作用？ extern是一个修饰符，它可以用于变量和函数，它有以下作用：用于变量，表示该变量是在其他文件中定义的，需要在本文件中引用，这样可以避免重复定义。用于函数，表示该函数是在其他文件中定义的，需要在本文件中声明，这样可以避免隐式声明。 12、volatile关键字的作用？ volatile是一个修饰符，它可以用于变量，它有以下作用：用于变量，表示该变量可能会被外部因素（如中断，多线程，硬件等）改变，需要每次都从内存中读取，而不是从寄存器或缓存中读取，这样可以保证变量的实时性和一致性。用于变量，表示该变量不会被编译器优化，需要按照程序的顺序执行，而不是进行重排或删除，这样可以避免编译器的干扰。 13、编译原理分哪几步？编译原理是指将一种高级语言（源语言）的程序转换为另一种低级语言（目标语言）的程序的原理和方法，它一般分为以下几个步骤：词法分析（lexical analysis），将源程序的字符序列分割成有意义的单词（token）。语法分析（syntax analysis），将单词序列组织成语法树（parse tree）或抽象语法树（abstract syntax tree），表示程序的结构和语义。语义分析（semantic analysis），检查程序是否符合语言的语法规则和语义规则，如类型检查，作用域分析等。中间代码生成（intermediate code generation），将抽象语法树转换为一种中间表示（intermediate representation），如三地址码，四元式，后缀表达式等，便于优化和目标代码生成。代码优化（code optimization），对中间表示进行一些变换，以提高程序的执行效率，如常量折叠，公共子表达式消除，循环优化，死代码删除等。目标代码生成（target code generation），将中间表示转换为目标语言的代码，如汇编语言，机器语言等，同时进行一些分配，如寄存器分配，指令选择等。 14、内存分区？内存分区是指将物理内存划分为若干个逻辑区域，以便于管理和使用。内存分区的方式有以下几种：固定分区，将内存分为大小相等或不等的若干个区域，每个区域只能装入一个进程，如果进程的大小超过区域的大小，就会产生内部碎片。动态分区，根据进程的大小和数量，动态地分配和回收内存空间，每个区域可以装入一个或多个进程，如果进程的大小不是区域的整数倍，就会产生外部碎片。页式分区，将进程的地址空间划分为大小相等的若干个页，将物理内存划分为大小相等的若干个页框，然后将页映射到页框，实现非连续的内存分配，避免了外部碎片，但是可能产生内部碎片。段式分区，将进程的地址空间划分为大小不等的若干个段，每个段有自己的逻辑地址和属性，然后将段映射到物理内存，实现非连续的内存分配，避免了内部碎片，但是可能产生外部碎片。段页式分区，将进程的地址空间划分为若干个段，每个段再划分为若干个页，然后将页映射到物理内存的页框，实现非连续的内存分配，避免了内部碎片和外部碎片，但是增加了地址转换的复杂度。 15、freertos启动流程？ freertos是一个实时操作系统，它的启动流程一般如下：首先，执行硬件初始化，如设置时钟，中断，堆栈等。然后，执行软件初始化，如创建任务，队列，信号量，定时器等。接着，调用vTaskStartScheduler ()函数，启动调度器，选择优先级最高的就绪任务运行。最后，当发生中断，延时，阻塞等事件时，调度器会根据算法，如优先级抢占式，时间片轮转式等，切换任务，实现多任务的并发执行。 16、互斥锁与信号量的区别？互斥锁（mutex）和信号量（semaphore）都是用于实现多任务的同步和互斥的机制，但是它们有以下区别：互斥锁是一个二元的同步对象，它只有两种状态：锁定和解锁。一个互斥锁只能被一个任务拥有，当一个任务获取互斥锁后，其他任务就不能再获取该互斥锁，直到拥有者释放它。互斥锁通常用于保护临界区的访问，避免数据的不一致。信号量是一个计数的同步对象，它有一个初始值，表示可用的资源数量。一个信号量可以被多个任务共享，当一个任务获取信号量后，信号量的值减一，表示资源被占用。当信号量的值为零时，表示没有可用的资源，其他任务就要等待，直到有任务释放信号量，信号量的值加一，表示资源被释放。信号量通常用于实现生产者-消费者模型，控制资源的分配和回收。 17、什么是死锁？死锁产生的原因？如何避免？死锁是指多个任务因为争夺有限的资源而相互等待，导致无法继续执行的现象。死锁产生的原因一般有以下四个必要条件：互斥条件，指每个资源只能被一个任务拥有，其他任务不能访问。占有且等待条件，指一个任务已经占有了至少一个资源，但是又申请了其他已经被占有的资源，同时不释放自己已经占有的资源。不可抢占条件，指一个任务占有的资源不能被其他任务强行剥夺，只能由占有者主动释放。循环等待条件，指多个任务形成一个环路，每个任务都在等待下一个任务占有的资源。避免死锁的方法有以下几种：破坏互斥条件，使用非互斥的资源，如可复制的资源，或者使用软件技术，如事务，来实现对资源的虚拟访问。破坏占有且等待条件，要求一个任务在申请资源时，必须一次性申请所有需要的资源，或者在申请新的资源时，必须先释放已经占有的资源。破坏不可抢占条件，允许一个任务在占有资源时，被其他任务抢占，或者主动释放资源，以满足其他任务的需求。破坏循环等待条件，给每个资源分配一个优先级，要求一个任务只能申请优先级高于或等于自己已经占有的资源的资源，或者按照一定的顺序申请资源，避免形成环路。 18、什么是内存泄漏？内存泄漏是指程序在运行过程中，动态分配了一些内存空间，但是没有及时释放，导致这些内存空间无法被其他程序使用，造成内存的浪费和紧张。内存泄漏可能会导致程序的性能下降，甚至崩溃。 19、系统死机了怎么排查原因？逐一看代码？工程量太大了吧？系统死机是指系统无法响应用户的输入，或者出现异常的错误，导致系统无法正常运行。排查系统死机的原因有以下几种方法：通过日志文件，查看系统在死机前的运行状态，是否有异常的信息，如错误码，警告，断言等，以及死机的时间，位置，频率等，从而定位可能的问题源。通过调试工具，如gdb，lldb等，对系统进行调试，查看系统的内存，寄存器，堆栈，断点等，分析系统的运行流程，发现潜在的错误，如内存泄漏，空指针，死锁等。通过测试工具，如valgrind，asan等，对系统进行测试，检测系统的内存管理，性能，覆盖率等，发现系统的缺陷，如内存错误，资源泄漏，性能瓶颈等。通过代码审查，对系统的代码进行分析，检查代码的风格，规范，逻辑，注释等，发现代码的不合理，不一致，不完善等，提高代码的质量，可读性，可维护性等。通过重现问题，对系统的死机现象进行复现，观察系统的表现，输入，输出等，找出问题的触发条件，规律，范围等，缩小问题的范围，提高问题的可解决性。 20、同一类型的结构体定义两个变量能用内存大小来比较判断两者一样吗？（没懂）同一类型的结构体定义两个变量，不能用内存大小来比较判断两者一样，因为内存大小只能反映结构体的占用空间，而不能反映结构体的内容。例如，以下两个结构体变量的内存大小都是8字节，但是它们的内容是不一样的： struct Point { int x; int y; }; struct Point p1 = {1, 2}; struct Point p2 = {3, 4}; 如果要比较两个结构体变量是否一样，需要逐个比较它们的成员，或者使用memcmp函数比较它们的内存内容。例如： // 逐个比较 if (p1.x == p2.x && p1.y == p2.y) { printf("p1 and p2 are equal\n"); } else { printf("p1 and p2 are not equal\n"); } // 使用memcmp比较 if (memcmp(&p1, &p2, sizeof(struct Point)) == 0) { printf("p1 and p2 are equal\n"); } else { printf("p1 and p2 are not equal\n"); }21、freertos中EventBits_t是干啥的？ EventBits_t是一个数据类型，它用于表示事件标志组（event group）中的每个位的状态，每个位可以表示一个事件的发生或者一个条件的满足。EventBits_t通常是一个无符号整数，它可以使用位运算来设置，清除，读取或等待事件标志。 22、freertos使任务切换的方式有哪些？ freertos使任务切换的方式有以下几种：时间片轮转法，按照任务的优先级和时间片的长度，依次轮流执行每个就绪任务，当一个任务的时间片用完或者主动放弃时，切换到下一个任务。优先级抢占法，按照任务的优先级，总是执行优先级最高的就绪任务，当有更高优先级的任务就绪时，立即抢占当前任务，切换到更高优先级的任务。混合法，结合时间片轮转法和优先级抢占法，对于同一优先级的任务，使用时间片轮转法，对于不同优先级的任务，使用优先级抢占法，实现任务的公平性和效率。 23、项目中用到网络了吗？这个问题的答案取决于你的项目的具体情况，如果你的项目需要与其他设备或服务器进行通信，或者需要访问互联网上的资源，那么你的项目就用到了网络。如果你的项目只是在本地运行，不需要与外界交互，那么你的项目就没有用到网络。 24、了解Socket吗？ Socket是一种通信机制，它可以实现不同进程或不同设备之间的数据交换。Socket通常基于TCP/IP协议，提供了可靠的，双向的，面向连接的通信服务。Socket的基本操作包括创建，绑定，监听，连接，发送，接收，关闭等。Socket的编程接口通常是一组函数或类，不同的编程语言或平台可能有不同的实现，如C语言的socket.h，Java语言的java.net.Socket等。 25、c++中set是什么？ set是C++标准模板库（STL）中的一个容器，它可以存储一组不重复的元素，并且按照一定的顺序排列。set的元素可以是任意类型，但是必须支持比较操作，如<，==等。set的底层实现通常是红黑树，所以它的插入，删除，查找等操作的时间复杂度都是O(logn) ，其中n是元素的个数。set的优点是可以快速地检查一个元素是否存在，以及保持元素的有序性。set的缺点是不能存储重复的元素，以及不能直接访问元素，只能通过迭代器遍历。 26、有没有用到C++模板？ C++模板是一种泛型编程的技术，它可以让程序员定义一种通用的模式，然后根据不同的类型或参数，生成不同的代码，从而实现代码的复用和抽象。C++模板有两种，一种是函数模板，用于定义通用的函数，另一种是类模板，用于定义通用的类。例如，以下是一个函数模板，用于比较两个值的大小： template <typename T> T max(T x, T y) { return (x > y) ? x : y; } 我有用过C++模板，它们可以让我的代码更简洁，更灵活，更高效。我用过STL中的一些类模板，如vector，map，set等，也用过自己定义的一些函数模板和类模板，来实现一些通用的算法和数据结构。 27、有没有对代码裁剪的经验代码裁剪是指对代码进行优化，删除不必要的或冗余的代码，减少代码的体积和复杂度，提高代码的可读性和可维护性。代码裁剪的目的是为了提高程序的性能，节省内存空间，降低编译时间，避免错误和漏洞等。我有对代码裁剪的经验，我用过一些工具和方法来进行代码裁剪，如：使用编译器的优化选项，如-Os，-O3等，让编译器自动进行一些代码裁剪，如常量折叠，死代码删除，循环展开等。使用代码分析工具，如lint，coverity等，检查代码的质量，发现代码的缺陷，如未使用的变量，函数，参数等，以及代码的风格，规范，注释等，然后根据工具的建议，修改或删除代码。使用代码重构工具，如refactor，eclipse等，对代码进行重构，改善代码的结构，设计，逻辑等，消除代码的冗余，重复，复杂等，提高代码的可读性，可维护性，可扩展性等。使用代码压缩工具，如upx，gzip等，对代码进行压缩，减少代码的体积，提高代码的传输速度，节省存储空间等。 28、freertos系统是买模块时人家配置好的？还是移植的？ freertos系统是一个开源的，可移植的，实时的操作系统，它可以运行在多种嵌入式平台上，如ARM，MIPS，AVR等。freertos系统不是买模块时人家配置好的，而是需要根据不同的硬件和需求进行移植和定制的。移植freertos系统的步骤一般如下：下载freertos的源码，选择合适的移植层，如portable/GCC/ARM_CM3等，根据目标平台的特性，修改一些配置参数，如configCPU_CLOCK_HZ，configTICK_RATE_HZ等。编写启动代码，如设置时钟，中断，堆栈等，调用vPortStartFirstTask ()函数，启动第一个任务。编写应用代码，如创建任务，队列，信号量，定时器等，调用vTaskStartScheduler ()函数，启动调度器。编译，链接，下载，调试代码，检查系统的运行情况，如任务切换，中断响应，内存管理等。 29、任务里有两把锁的时候该怎么处理任务里有两把锁的时候，可能会出现死锁的问题，即两个或多个任务因为互相等待对方占有的锁而无法继续执行。处理任务里有两把锁的时候，有以下几种方法：避免使用两把锁，如果可能的话，尽量使用一把锁来保护临界区，或者使用其他同步机制，如信号量，事件标志等，来实现任务之间的协作。按照一定的顺序获取和释放锁，如果必须使用两把锁，那么要求所有的任务都按照相同的顺序获取和释放锁，避免形成循环等待的条件。使用超时机制，如果一个任务在获取锁时，发现锁已经被占用，那么不要无限期地等待，而是设置一个超时时间，如果超时时间到了，还没有获取到锁，那么就放弃获取，释放已经占有的锁，然后重新尝试或者执行其他操作。使用优先级继承机制，如果一个任务在获取锁时，发现锁已经被占用，那么就把自己的优先级赋给占有锁的任务，让占有锁的任务尽快执行完毕，释放锁，然后恢复原来的优先级，这样可以避免优先级反转的问题。 30、熟悉Shell脚本吗？$和#啥意思？ Shell脚本是一种用于控制Unix或Linux系统的命令行解释器，它可以实现一些自动化的任务，如文件操作，文本处理，程序运行等。Shell脚本的语法和结构类似于C语言，但是更加简洁和灵活。Shell脚本的文件名通常以.sh为后缀，例如test.sh。 $和#是Shell脚本中的两个特殊符号，它们有以下含义： $表示变量的引用，可以用来获取或设置变量的值，例如x=10，echo $x，表示将10赋值给变量x，然后打印x的值。表示注释的开始，可以用来对代码进行说明，不会被执行，例如#echo hello，#这是一个注释，表示打印hello，后面的内容是一个注释。 31、知道#error吗？、#error是一个预处理指令，它可以用来在编译时产生一个错误信息，中断编译过程。#error通常用来检查一些条件，如宏定义，平台，版本等，如果不满足条件，就提示错误，防止编译出错的代码。例如： #ifdef __linux__ #error This code is not compatible with Linux #endif 这段代码表示如果定义了__linux__宏，就产生一个错误信息，表示这段代码不兼容Linux系统。 32、freertos消息队列的的具体实现？ freertos消息队列是一种用于实现任务之间或任务与中断之间的异步通信的机制，它可以存储一组有序的消息，每个消息可以是任意类型的数据。freertos消息队列的具体实现如下：消息队列是一个结构体，它包含了一些成员，如队列的头指针，尾指针，长度，容量，锁，信号量等，用来管理队列的状态和操作。消息队列的存储空间是一个数组，它可以是静态分配的或动态分配的，它的大小要能够容纳队列的最大容量乘以每个消息的大小。消息队列的操作有以下几种，如创建，删除，发送，接收等，它们都是通过调用一些API函数来实现的，如xQueueCreate，vQueueDelete，xQueueSend，xQueueReceive等。消息队列的操作都是原子的，即在操作过程中，不会被其他任务或中断打断，这是通过使用临界区或中断屏蔽来实现的，以保证队列的一致性和完整性。消息队列的操作都是阻塞的，即如果队列满了，就不能发送消息，如果队列空了，就不能接收消息，这是通过使用信号量来实现的，以实现任务的同步和等待。 33、堆栈区别？堆（heap）和栈（stack）都是程序运行时使用的内存空间，但是它们有以下区别：堆是动态分配的，程序员可以自由地申请和释放堆上的内存空间，堆的大小受到物理内存的限制，堆上的内存空间的地址是不连续的。栈是静态分配的，编译器会自动地分配和回收栈上的内存空间，栈的大小受到操作系统的限制，栈上的内存空间的地址是连续的。堆是全局共享的，堆上的内存空间可以被任何函数或模块访问，堆上的内存空间的生命周期是由程序员控制的，如果不及时释放，可能会导致内存泄漏。栈是局部私有的，栈上的内存空间只能被当前函数或模块访问，栈上的内存空间的生命周期是由编译器控制的，当函数调用结束时，栈上的内存空间就会被自动释放。 34、程序存放状态和区别程序存放状态是指程序在运行过程中的不同阶段，它有以下几种：新建状态，指程序刚刚被创建，还没有被加载到内存中，等待调度器的调度。就绪状态，指程序已经被加载到内存中，已经分配了必要的资源，等待处理器的分配。运行状态，指程序已经被分配了处理器，正在执行程序的指令。阻塞状态，指程序在执行过程中，因为等待某些事件的发生，如输入输出，信号量，中断等，而暂时停止执行，释放处理器，等待事件的完成。终止状态，指程序已经执行完毕，或者因为某些原因，如错误，异常，中断等，而被终止，释放内存和资源，从系统中消失。

嵌入式＆系统 # 嵌入式

刘航宇 2年前
0 764 4
2023-12-20
【嵌软】STM32的4种开发方式介绍摘要本文介绍了STM32的四种开发方式：直接读写寄存器、SPL、HAL库和LL库，分析了各自的优缺点，并指出HAL库和LL库结合STM32CubeIDE使用方便，但HAL库性能较差，LL库性能好但可移植性差。关键词：STM32, 开发方式, HAL库, LL库, 标准外设驱动库与FPGA一样，STM32也属于板级开发，可适用于大多数计算场合，但神经网络这种需要大量并行计算的需求难以满足。 STM32的开发主要指的是通过程序实现功能，ST官方提供的开发方式来说从远及近分别是： 1、直接读写寄存器 2、标准外设驱动库 SPL 3、硬件抽象层库 HAL库 4、底层库 LL库四种开发方式各有优缺点，可以参考ST官方的测试与说明：图片标准外设库：这是ST官方提供的一套固件库，包含了STM32所有外设的驱动函数，可以方便地调用。它的优点是稳定、兼容、易用，缺点是占用资源较多，效率较低，更新较慢。寄存器操作：这是直接对STM32的寄存器进行读写的方式，可以实现最底层的控制。它的优点是占用资源最少，效率最高，缺点是难度较大，需要熟悉寄存器的功能和位定义，不利于移植。 HAL库：这是ST官方推出的一套新的固件库，基于硬件抽象层（Hardware Abstraction Layer）的思想，提供了更加简洁和统一的接口。它的优点是支持多种IDE，更新较快，易于移植，缺点是文档较少，兼容性较差，有些BUG。CubeMX：这是ST官方提供的一套图形化的配置工具，可以自动生成HAL库的代码，还可以集成一些中间件和应用层的功能。它的优点是操作简单，功能强大，缺点是生成的代码较冗余，不易修改，有些功能不完善。直接读写寄存器开发是最慢的，可移植性最差，基本不推荐使用，只有个别对时间或是内存要求特别高、或者在写操作系统调度器时才需要直接读写寄存器；标准外设驱动库是ST最开始提供的库（国内的教程也很多是依据题库出的），现在已经被ST放弃了； HAL库和 LL库是近几年推出的库，结合 STM32CubeIDE 使用非常方便， HAL库性能较差、在STM32系列芯片中可移植性好， LL库性能好、可移植性差。

嵌入式＆系统 # 嵌入式 # C/C++

刘航宇 3年前
0 1,341 4
2023-12-11
华为C++算法-识别有效的IP地址和掩码并进行分类统计摘要本文介绍了华为C++算法，用于识别和分类IP地址及掩码。算法可识别A/B/C/D/E类地址，统计不合法地址和掩码、私有IP数量。通过字符分割、合法性判断和类别归类实现。关键词：华为,C++,IP地址分类,子网掩码,算法问题注意：输入描述：输出描述：示例需要注意的细节思路具体实现代码问题请解析IP地址和对应的掩码，进行分类识别。要求按照A/B/C/D/E类地址归类，不合法的地址和掩码单独归类。所有的IP地址划分为 A,B,C,D,E五类 A类地址从1.0.0.0到126.255.255.255; B类地址从128.0.0.0到191.255.255.255; C类地址从192.0.0.0到223.255.255.255; D类地址从224.0.0.0到239.255.255.255； E类地址从240.0.0.0到255.255.255.255 私网IP范围是：从10.0.0.0到10.255.255.255 从172.16.0.0到172.31.255.255 从192.168.0.0到192.168.255.255 子网掩码为二进制下前面是连续的1，然后全是0。（例如：255.255.255.32就是一个非法的掩码）（注意二进制下全是1或者全是0均为非法子网掩码）注意：类似于【0...】和【127...】的IP地址不属于上述输入的任意一类，也不属于不合法ip地址，计数时请忽略私有IP地址和A,B,C,D,E类地址是不冲突的输入描述：多行字符串。每行一个IP地址和掩码，用~隔开。输出描述：统计A、B、C、D、E、错误IP地址或错误掩码、私有IP的个数，之间以空格隔开。示例输入： 10.70.44.68~255.254.255.0 1.0.0.1~255.0.0.0 192.168.0.2~255.255.255.0 19..0.~255.255.255.0 输出： 1 0 1 0 0 2 1 说明： 10.70.44.68~255.254.255.0的子网掩码非法，19..0.~255.255.255.0的IP地址非法，所以错误IP地址或错误掩码的计数为2； 1.0.0.1~255.0.0.0是无误的A类地址； 192.168.0.2~255.255.255.0是无误的C类地址且是私有IP；所以最终的结果为1 0 1 0 0 2 1 示例2 输入： 0.201.56.50~255.255.111.255 127.201.56.50~255.255.111.255 输出： 0 0 0 0 0 0 0 说明：类似于【0...】和【127...】的IP地址不属于上述输入的任意一类，也不属于不合法ip地址，计数时请忽略需要注意的细节类似于【0...】和【127...】的IP地址不属于上述输入的任意一类，也不属于不合法ip地址，计数时可以忽略私有IP地址和A,B,C,D,E类地址是不冲突的，也就是说需要同时+1 如果子网掩码是非法的，则不再需要查看IP地址全零【0.0.0.0】或者全一【255.255.255.255】的子网掩码也是非法的思路按行读取输入，根据字符‘~’ 将IP地址与子网掩码分开查看子网掩码是否合法。合法，则继续检查IP地址非法，则相应统计项+1，继续下一行的读入查看IP地址是否合法合法，查看IP地址属于哪一类，是否是私有ip地址；相应统计项+1 非法，相应统计项+1 具体实现判断IP地址是否合法，如果满足下列条件之一即为非法地址数字段数不为4 存在空段，即【192..1.0】这种某个段的数字大于255 判断子网掩码是否合法，如果满足下列条件之一即为非法掩码不是一个合格的IP地址在二进制下，不满足前面连续是1，然后全是0 在二进制下，全为0或全为1 如何判断一个掩码地址是不是满足前面连续是1，然后全是0？将掩码地址转换为32位无符号整型，假设这个数为b。如果此时b为0，则为非法掩码将b按位取反后+1。如果此时b为1，则b原来是二进制全1，非法掩码如果b和b-1做按位与运算后为0，则说明是合法掩码，否则为非法掩码代码注意getline函数可以指定分割字符串的字符 // 引入输入输出流、字符串、字符串流和向量等头文件 #include<iostream> #include<string> #include<sstream> #include<vector> // 使用标准命名空间 using namespace std; // 定义一个函数，判断一个字符串是否是合法的IP地址 bool judge_ip(string ip){ // 定义一个整数变量，记录IP地址的段数 int j = 0; // 定义一个字符串流对象，用于分割IP地址 istringstream iss(ip); // 定义一个字符串变量，用于存储IP地址的每一段 string seg; // 使用循环，以'.'为分隔符，获取IP地址的每一段 while(getline(iss,seg,'.')) // 如果段数加一大于4，或者该段为空，或者该段的数值大于255，说明不是合法的IP地址，返回false if(++j > 4 || seg.empty() || stoi(seg) > 255) return false; // 如果循环结束后，段数等于4，说明是合法的IP地址，返回true return j == 4; } // 定义一个函数，判断一个字符串是否是私有的IP地址 bool is_private(string ip){ // 定义一个字符串流对象，用于分割IP地址 istringstream iss(ip); // 定义一个字符串变量，用于存储IP地址的每一段 string seg; // 定义一个整数向量，用于存储IP地址的每一段的数值 vector<int> v; // 使用循环，以'.'为分隔符，获取IP地址的每一段，并将其转换为整数，存入向量中 while(getline(iss,seg,'.')) v.push_back(stoi(seg)); // 如果IP地址的第一段等于10，说明是私有的IP地址，返回true if(v[0] == 10) return true; // 如果IP地址的第一段等于172，并且第二段在16到31之间，说明是私有的IP地址，返回true if(v[0] == 172 && (v[1] >= 16 && v[1] <= 31)) return true; // 如果IP地址的第一段等于192，并且第二段等于168，说明是私有的IP地址，返回true if(v[0] == 192 && v[1] == 168) return true; // 如果以上条件都不满足，说明不是私有的IP地址，返回false return false; } // 定义一个函数，判断一个字符串是否是合法的子网掩码 bool is_mask(string ip){ // 定义一个字符串流对象，用于分割IP地址 istringstream iss(ip); // 定义一个字符串变量，用于存储IP地址的每一段 string seg; // 定义一个无符号整数变量，用于存储IP地址的二进制表示 unsigned b = 0; // 使用循环，以'.'为分隔符，获取IP地址的每一段，并将其转换为整数，左移8位后与b进行按位或运算，得到IP地址的二进制表示 while(getline(iss,seg,'.')) b = (b << 8) + stoi(seg); // 如果b等于0，说明不是合法的子网掩码，返回false if(!b) return false; // 将b按位取反后加一，得到b的补码 b = ~b + 1; // 如果b等于1，说明不是合法的子网掩码，返回false if(b == 1) return false; // 如果b与b减一进行按位与运算，结果等于0，说明b只有一个1，说明是合法的子网掩码，返回true if((b & (b-1)) == 0) return true; // 如果以上条件都不满足，说明不是合法的子网掩码，返回false return false; } // 定义主函数 int main(){ // 定义一个字符串变量，用于存储输入的IP地址和子网掩码 string input; // 定义七个整数变量，用于统计A、B、C、D、E类地址、错误地址和私有地址的个数 int a = 0,b = 0,c = 0,d = 0,e = 0,err = 0,p = 0; // 使用循环，读取输入的IP地址和子网掩码，直到输入结束 while(cin >> input){ // 定义一个字符串流对象，用于分割IP地址和子网掩码 istringstream is(input); // 定义一个字符串变量，用于存储IP地址或子网掩码 string add; // 定义一个字符串向量，用于存储IP地址和子网掩码 vector<string> v; // 使用循环，以'~'为分隔符，获取IP地址和子网掩码，并存入向量中 while(getline(is,add,'~')) v.push_back(add); // 如果IP地址或子网掩码不合法，错误地址的个数加一 if(!judge_ip(v[1]) || !is_mask(v[1])) err++; else{ // 如果IP地址不合法，错误地址的个数加一 if(!judge_ip(v[0])) err++; else{ // 获取IP地址的第一段的数值 int first = stoi(v[0].substr(0,v[0].find_first_of('.'))); // 如果IP地址是私有的，私有地址的个数加一 if(is_private(v[0])) p++; // 根据IP地址的第一段的数值，判断IP地址的类别，并相应的类别的个数加一 if(first > 0 && first <127) a++; else if(first > 127 && first <192) b++; else if(first > 191 && first <224) c++; else if(first > 223 && first <240) d++; else if(first > 239 && first <256) e++; } } } // 输出A、B、C、D、E类地址、错误地址和私有地址的个数 cout << a << " " << b << " " << c << " " << d << " " << e << " " << err << " " << p << endl; // 返回0，表示程序正常结束 return 0; }

嵌入式＆系统编程&脚本笔记软硬件算法 # 嵌入式 # 笔试面试 # C/C++

刘航宇 3年前
0 635 1
2023-11-20
超声模块HC_SR04基本原理与FPGA、STM32应用摘要本文介绍了HC-SR04超声波距离传感器的基本原理，包括其硬件构成、接口定义和测量操作。同时，详细阐述了如何利用FPGA和STM32实现超声波测距，包括FPGA模块代码和STM32的CubeMX配置及代码编写。关键词：HC-SR04, 超声波传感器, 距离测量, FPGA应用, STM32应用HC-SR04硬件概述接口定义: 模式选择：测量操作: FPGA实现超声测距模块代码 STM32(Cubemax)实现超声波测距CubeMX配置STM32 编写代码 HC-SR04 硬件概述 HC-SR04超声波距离传感器的核心是两个超声波传感器。一个用作发射器，将电信号转换为40 KHz超声波脉冲。接收器监听发射的脉冲。如果接收到它们，它将产生一个输出脉冲，其宽度可用于确定脉冲传播的距离。就是如此简单！该传感器体积小，易于在任何机器人项目中使用，并提供2厘米至600厘米（约1英寸至13英尺）之间出色的非接触范围检测，精度为3mm。图片接口定义: 图片模式选择：图片测量操作: 一：GPIO模式图片外部MCU给模块Trig脚一个大于10uS的高电平脉冲；模块会给出一个与距离等比的高电平脉冲信号，可根据脉宽时间“T” 算出：距离=T*C/2 （C为声速）声速温度公式：c=(331.45+0.61t/℃)m•s-1 (其中330.45是在0℃） 0℃声速： 330.45M/S 20℃声速： 342.62M/S 40℃声速： 354.85M/S0℃-40℃声速误差7%左右。实际应用，如果需要精确距离值，必需要考虑温度影响，做温度补偿。二：UART模式 UART 模式波特率设置： 9600 N 1 图片连接串口。外部MCU或PC发命令0XA0，模块完成测距后发3个返回距离数据，BYTE_H，BYTE_M与BYTE_L。距离计算方式如下（单位mm）：距离=(（BYTE_H<<16）+（BYTE_M<<8）+ BYTE_L)/1000 三：IIC模式 IIC地址： 0X57 IIC传输格式：写数据：图片读数据：图片命令格式：图片向模块写入0X01，模块开始测距；等待200mS(模块最大测距时间) 以上。直接读出3个距离数据。BYTE_H，BYTE_M与BYTE_L。距离计算方式如下（单位mm）：距离=(（BYTE_H<<16）+（BYTE_M<<8）+ BYTE_L)/1000 FPGA实现超声测距本次测距教程一律按基本原理实现，至于UART、ICC测距原理可以网上查询 FPGA 产生周期性的 TRIG 脉冲信号，使得超声波模块周期性发出测距脉冲，当这些脉冲发出后遇到障碍物返回，超声波模块将返回的脉冲处理整形后返回给 FPGA，即 ECHO 信号。我们通过对 ECHO 信号的高脉冲保持时间就可以推算出超声波脉冲和障碍物之间的距离。本实例的功能如图三所示，FPGA 产生 10us 脉冲 TRIG 给超声波测距模块，然后以 10us 为单位计算超声波测距模块返回的回响信号 ECHO 的高电平保持时间。ECHO 的高电平保持时间通过一定的换算后可以得到障碍物和超声波测距模块之间的距离（由距离公式计算&进制换算模块实现），我们将最终获得的以 mm 为单位的距离信息显示在 4 位数码管上。图片模块代码 1、vlg_en模块 /* * @Author: Hangyu Liu * @Date: 2023-11-20 15:24:01 * @Email: hyliu@ee.ac.cn * @Descripttion: 板子时钟转化1us * @Last Modified time: 2023-11-20 15:24:01 */ //1us/50ns=20 module vlg_1us#(parameter P_CLK_PERIORD = 50) //i_clk的时钟周期50ns,20MHZ ( input i_clk, input i_rst_n, output reg o_clk //时钟周期1us ); parameter NUM_DIV = 20;// (1MHZ = 1us,20MHZ/20 = 1MHZ) reg [3:0] cnt; always @(posedge i_clk or negedge i_rst_n) begin if(!i_rst_n) begin cnt <= 4'd0; o_clk <= 1'b0; end else if(cnt == NUM_DIV/2 - 1) begin cnt <= 4'b0; o_clk <= ~o_clk; end else cnt <= cnt + 1'b1; end endmodule2、vlg_trig模块 /* * @Author: Hangyu Liu * @Date: 2023-11-20 16:50:44 * @Email: hyliu@ee.ac.cn * @Descripttion: 产生10us的触发超声信号 * @Last Modified time: 2023-11-20 16:50:44 */ module vlg_trig ( input i_rst_n, input clk_1us, //1us output reg o_trig ); reg[17:0] r_tricnt; //200ms的周期计数 1us一个单位 always @(posedge clk_1us or negedge i_rst_n)begin if(!i_rst_n) r_tricnt <= 18'd0; else if((r_tricnt == 18'd199999)) r_tricnt <= 18'd0; else r_tricnt <= r_tricnt + 1'b1; end //产生保持10us的高脉冲o_tring信号 always @(posedge clk_1us or negedge i_rst_n) begin if(!i_rst_n) o_trig<=1'b0; else if((r_tricnt > 18'd0) && (r_tricnt <= 18'd10)) o_trig <= 1'b1; //不从0开始0~9，防止出现不到10us的波干扰 else o_trig <= 1'b0; end endmodule3、vlg_echo模块 module vlg_echo ( input i_clk, //1us input i_rst_n, input i_clk_1us, input i_echo, output reg[15:0] o_t_us ); reg[1:0] r_echo; wire pos_echo,neg_echo; reg r_cnt_en; reg[15:0] r_echo_cnt; //对i_echo信号同步处理，获取边沿检测信号，产生计数使能信号r_cnt_en always @(posedge i_clk or negedge i_rst_n) begin if(!i_rst_n) r_echo <= 2'd0; else r_echo <= {r_echo[0],i_echo}; //设置两个寄存器进行打拍寄存 end assign pos_echo = r_echo[0] & ~r_echo[1]; //现状态是1上状态是0，就是上升沿 assign neg_echo = ~r_echo[0] & r_echo[1]; always @(posedge i_clk or negedge i_rst_n) begin if(!i_rst_n) r_cnt_en <= 1'b0; else if(pos_echo) r_cnt_en <= 1'b1; else if(neg_echo) r_cnt_en <= 1'b0; else r_cnt_en <= r_cnt_en; end //对i_echo信号的高脉冲计时，以us为单位 always @(posedge i_clk_1us or negedge i_rst_n) begin if(!i_rst_n) r_echo_cnt <= 1'b0; else if(r_cnt_en) r_echo_cnt <= r_echo_cnt + 1'b1; else r_echo_cnt <= 1'b0; end //在下降沿对计数最大值进行保存 always @(negedge i_clk or negedge i_rst_n) begin if(!i_rst_n) o_t_us <= 16'd0; else if(neg_echo) o_t_us <= r_echo_cnt; else o_t_us <= o_t_us; end endmodule4、顶层模块例化 /* * @Author: Hangyu Liu * @Date: 2023-11-23 17:16:40 * @Email: hyliu@ee.ac.cn * @Descripttion:HR04驱动模块 * @Last Modified time: 2023-11-23 17:16:40 */ module vlg_design ( input i_clk, //200MHZ input i_rst_n, input i_echo, //这是超声模块给的输入 output o_trig, output wire[15:0] w_t_us ); wire clk_20MHZ; clk_div_20MHZ UU( .i_clk(i_clk), .i_rst_n(i_rst_n), .clk_div(clk_20MHZ) ); localparam P_CLK_PERIORD = 50; wire clk_1us; //使能时钟产生模块 vlg_1us #( .P_CLK_PERIORD(P_CLK_PERIORD) //i_clk的时钟周期50ns,20MHZ )U1( .i_clk(clk_20MHZ), .i_rst_n(i_rst_n), .o_clk(clk_1us) ); //产生超声波测距模块的触发信号o_trig vlg_trig U2( .i_rst_n(i_rst_n), .clk_1us(clk_1us), .o_trig(o_trig) ); //超声波测距模块的回响信号i_echo的高电平时间采集 vlg_echo U3( .i_clk(clk_20MHZ), .i_rst_n(i_rst_n), .i_clk_1us(clk_1us), .i_echo(i_echo), .o_t_us(w_t_us) ); endmoduleSTM32(Cubemax)实现超声波测距 CubeMX配置STM32 1 时钟配置这里我用的是STM32F103C8T6的核心板，时钟配置如下图，我用了8MHz的HSE，HCLK调到了最大值72MHz 图片 2 设置输入捕获的定时器设置定时器TIM2每1us向上计数一次，通道4为上升沿捕获并连接到超声波模块的ECHO引脚，记得开启定时器中断（涉及到捕获中断+定时器溢出中断）。图片 3 触发引脚 PB10接到了HC-SR04的TIRG触发引脚，默认输出低电平图片 4 串口配置还要开启一个串口，以便通过串口查看测距结果图片编写代码 hc-sr04.h #ifndef HCSR04_H_ #define HCSR04_H_ #include "main.h" #include "delay.h" typedef struct { uint8_t edge_state; uint16_t tim_overflow_counter; uint32_t prescaler; uint32_t period; uint32_t t1; // 上升沿时间 uint32_t t2; // 下降沿时间 uint32_t high_level_us; // 高电平持续时间 float distance; TIM_TypeDef* instance; uint32_t ic_tim_ch; HAL_TIM_ActiveChannel active_channel; }Hcsr04InfoTypeDef; extern Hcsr04InfoTypeDef Hcsr04Info; /** * @description: 超声波模块的输入捕获定时器通道初始化 * @param {TIM_HandleTypeDef} *htim * @param {uint32_t} Channel * @return {*} */ void Hcsr04Init(TIM_HandleTypeDef *htim, uint32_t Channel); /** * @description: HC-SR04触发 * @param {*} * @return {*} */ void Hcsr04Start(); /** * @description: 定时器计数溢出中断处理函数 * @param {*} main.c中重定义void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* htim) * @return {*} */ void Hcsr04TimOverflowIsr(TIM_HandleTypeDef *htim); /** * @description: 输入捕获计算高电平时间->距离 * @param {*} main.c中重定义void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim) * @return {*} */ void Hcsr04TimIcIsr(TIM_HandleTypeDef* htim); /** * @description: 读取距离 * @param {*} * @return {*} */ float Hcsr04Read(); #endif /* HCSR04_H_ */ hc-sr04.c #include "hc-sr04.h" Hcsr04InfoTypeDef Hcsr04Info; /** * @description: 超声波模块的输入捕获定时器通道初始化 * @param {TIM_HandleTypeDef} *htim * @param {uint32_t} Channel * @return {*} */ void Hcsr04Init(TIM_HandleTypeDef *htim, uint32_t Channel) { /*--------[ Configure The HCSR04 IC Timer Channel ] */ // MX_TIM2_Init(); // cubemx中配置 Hcsr04Info.prescaler = htim->Init.Prescaler; // 72-1 Hcsr04Info.period = htim->Init.Period; // 65535 Hcsr04Info.instance = htim->Instance; // TIM2 Hcsr04Info.ic_tim_ch = Channel; if(Hcsr04Info.ic_tim_ch == TIM_CHANNEL_1) { Hcsr04Info.active_channel = HAL_TIM_ACTIVE_CHANNEL_1; // TIM_CHANNEL_4 } else if(Hcsr04Info.ic_tim_ch == TIM_CHANNEL_2) { Hcsr04Info.active_channel = HAL_TIM_ACTIVE_CHANNEL_2; // TIM_CHANNEL_4 } else if(Hcsr04Info.ic_tim_ch == TIM_CHANNEL_3) { Hcsr04Info.active_channel = HAL_TIM_ACTIVE_CHANNEL_3; // TIM_CHANNEL_4 } else if(Hcsr04Info.ic_tim_ch == TIM_CHANNEL_4) { Hcsr04Info.active_channel = HAL_TIM_ACTIVE_CHANNEL_4; // TIM_CHANNEL_4 } else if(Hcsr04Info.ic_tim_ch == TIM_CHANNEL_4) { Hcsr04Info.active_channel = HAL_TIM_ACTIVE_CHANNEL_4; // TIM_CHANNEL_4 } /*--------[ Start The ICU Channel ]-------*/ HAL_TIM_Base_Start_IT(htim); HAL_TIM_IC_Start_IT(htim, Channel); } /** * @description: HC-SR04触发 * @param {*} * @return {*} */ void Hcsr04Start() { HAL_GPIO_WritePin(TRIG_GPIO_Port, TRIG_Pin, GPIO_PIN_SET); DelayUs(10); // 10us以上 HAL_GPIO_WritePin(TRIG_GPIO_Port, TRIG_Pin, GPIO_PIN_RESET); } /** * @description: 定时器计数溢出中断处理函数 * @param {*} main.c中重定义void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* htim) * @return {*} */ void Hcsr04TimOverflowIsr(TIM_HandleTypeDef *htim) { if(htim->Instance == Hcsr04Info.instance) // TIM2 { Hcsr04Info.tim_overflow_counter++; } } /** * @description: 输入捕获计算高电平时间->距离 * @param {*} main.c中重定义void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim) * @return {*} */ void Hcsr04TimIcIsr(TIM_HandleTypeDef* htim) { if((htim->Instance == Hcsr04Info.instance) && (htim->Channel == Hcsr04Info.active_channel)) { if(Hcsr04Info.edge_state == 0) // 捕获上升沿 { // 得到上升沿开始时间T1，并更改输入捕获为下降沿 Hcsr04Info.t1 = HAL_TIM_ReadCapturedValue(htim, Hcsr04Info.ic_tim_ch); __HAL_TIM_SET_CAPTUREPOLARITY(htim, Hcsr04Info.ic_tim_ch, TIM_INPUTCHANNELPOLARITY_FALLING); Hcsr04Info.tim_overflow_counter = 0; // 定时器溢出计数器清零 Hcsr04Info.edge_state = 1; // 上升沿、下降沿捕获标志位 } else if(Hcsr04Info.edge_state == 1) // 捕获下降沿 { // 捕获下降沿时间T2，并计算高电平时间 Hcsr04Info.t2 = HAL_TIM_ReadCapturedValue(htim, Hcsr04Info.ic_tim_ch); Hcsr04Info.t2 += Hcsr04Info.tim_overflow_counter * Hcsr04Info.period; // 需要考虑定时器溢出中断 Hcsr04Info.high_level_us = Hcsr04Info.t2 - Hcsr04Info.t1; // 高电平持续时间 = 下降沿时间点 - 上升沿时间点 // 计算距离 Hcsr04Info.distance = (Hcsr04Info.high_level_us / 1000000.0) * 340.0 / 2.0 * 100.0; // 重新开启上升沿捕获 Hcsr04Info.edge_state = 0; // 一次采集完毕，清零 __HAL_TIM_SET_CAPTUREPOLARITY(htim, Hcsr04Info.ic_tim_ch, TIM_INPUTCHANNELPOLARITY_RISING); } } } /** * @description: 读取距离 * @param {*} * @return {*} */ float Hcsr04Read() { // 测距结果限幅 if(Hcsr04Info.distance >= 450) { Hcsr04Info.distance = 450; } return Hcsr04Info.distance; } main.c 1、引用对应的头文件 /* USER CODE BEGIN Includes */ #include "hc-sr04.h" #include "printf.h" /* USER CODE END Includes */2、200ms测距一次 /** * @brief The application entry point. * @retval int */ int main(void) { /* USER CODE BEGIN 1 */ /* USER CODE END 1 */ /* MCU Configuration--------------------------------------------------------*/ /* Reset of all peripherals, Initializes the Flash interface and the Systick. */ HAL_Init(); /* USER CODE BEGIN Init */ /* USER CODE END Init */ /* Configure the system clock */ SystemClock_Config(); /* USER CODE BEGIN SysInit */ /* USER CODE END SysInit */ /* Initialize all configured peripherals */ MX_GPIO_Init(); MX_TIM2_Init(); MX_USART1_UART_Init(); /* USER CODE BEGIN 2 */ DelayInit(72); Hcsr04Init(&htim2, TIM_CHANNEL_4); // 超声波模块初始化 Hcsr04Start(); // 开启超声波模块测距 printf("hc-sr04 start!\r\n"); /* USER CODE END 2 */ /* Infinite loop */ /* USER CODE BEGIN WHILE */ while (1) { // 打印测距结果 printf("distance:%.1f cm\r\n", Hcsr04Read()); Hcsr04Start(); DelayMs(200); // 测距周期200ms /* USER CODE END WHILE */ /* USER CODE BEGIN 3 */ } /* USER CODE END 3 */ } 3、重定义定时器的中断服务函数 /* USER CODE BEGIN 4 */ /** * @description: 定时器输出捕获中断 * @param {TIM_HandleTypeDef} *htim * @return {*} */ void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim) { Hcsr04TimIcIsr(htim); } /** * @description: 定时器溢出中断 * @param {*} * @return {*} */ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* htim) { Hcsr04TimOverflowIsr(htim); } /* USER CODE END 4 */ 4、串口打印结果图片

嵌入式＆系统 FPGA&ASIC # ASIC/FPGA # 嵌入式

刘航宇 3年前
0 1,469 2

319 文章数

576 评论量

关于作者：刘航宇，FPGA工程师，西北大学电子系硕士，有多年西北大学电子通信考研辅导和FPGA与嵌入式项目指导经验

人生倒计时

最新回复

支持者
2026-09-16

# 图片回复
guy
2026-09-11

看看内搭
Guest
2026-09-07

很好的插件。感谢！