标题: 瑞萨单片机计步器设计 附原理图+PCB源文件+程序代码+BOM清单 [打印本页]

---

作者: liu147    时间: 2019-5-7 19:24
标题: 瑞萨单片机计步器设计 附原理图+PCB源文件+程序代码+BOM清单
分享瑞萨单片机计步器设计，包含程序及原理图


单片机源程序如下:

1. /***********************************************************************************************************************
   
2. * File Name    : r_main.c
   
3. * Version      : V1.00
   
4. * Device(s)    : R7F0C002G2DFB
   
5. * Tool-Chain   : CA78K0R
   
6. * Description  : This file implements main function.
   
7. ***********************************************************************************************************************/
   
8. 
   
9. /***********************************************************************************************************************
   
10. * History : DD.MM.YYYY Version Description
    
11. * : 31.03.2015 1.00 First Release
    
12. ***********************************************************************************************************************/
    
13. 
    
14. /***********************************************************************************************************************
    
15. Includes <System Includes> , <Project Includes>
    
16. ***********************************************************************************************************************/
    
17. #include "r_macrodriver.h"
    
18. #include "r_cgc.h"
    
19. #include "r_port.h"
    
20. #include "string.h"
    
21. #include "r_lcd.h"
    
22. #include "r_rtc.h"
    
23. #include "r_timer.h"
    
24. #include "r_userdefine.h"
    
25. #include "r_Communication.h"
    
26. #include "r_ADXL362.h"
    
27. 
    
28. 
    
29. #include "pfdl.h"
    
30. #include "pfdl_types.h"
    
31. /***********************************************************************************************************************
    
32. Global variables and functions
    
33. ***********************************************************************************************************************/
    
34. static uint16_t g_FontData[LCD_NUM_DATA_FONT_COUNT] = { LCD_DATA_0, LCD_DATA_1, LCD_DATA_2, LCD_DATA_3, LCD_DATA_4,
    
35.                                                         LCD_DATA_5, LCD_DATA_6, LCD_DATA_7, LCD_DATA_8, LCD_DATA_9,
    
36.                                                         LCD_DATA_NONE, LCD_DATA_COLON };
    
37. 
    
38. static uint8_t g_WatchStatus;
    
39. static uint8_t g_WeightStatus;
    
40. static uint8_t g_Hour;
    
41. static uint8_t g_Minute;
    
42. uint8_t g_Weight = 0x40U;
    
43. uint8_t g_Length = 0x70U;
    
44. uint16_t g_Step;
    
45. uint16_t g_Step_last;
    
46. 
    
47. uint8_t Count_flag = 0U;
    
48. 
    
49. uint8_t g_Step_temp1[2] = {0x00,0x00};
    
50. uint8_t g_Step_temp2[2] = {0x00,0x00};
    
51. 
    
52. uint16_t g_Calorie;
    
53. uint8_t set_flag = 0U;
    
54. 
    
55. uint8_t step1_flag = 0U;
    
56. uint8_t step2_flag = 0U;
    
57. 
    
58. uint8_t switch_status      = 0U;
    
59. uint8_t status             = 0U;
    
60. short         xAxis        = 0U;
    
61. short         yAxis        = 0U;
    
62. short         zAxis        = 0U;
    
63. float         temperature  = 0U;
    
64. pfdl_u16 StartAddrIndex    = 0U;
    
65. 
    
66. #define FALSE    0
    
67. #define TRUE     1
    
68. #define BLOCKBYTES 1024
    
69. 
    
70. void R_MAIN_UserInit(void);
    
71. pfdl_u08 Write_DataFlash(void);
    
72. pfdl_u08 Read_DataFlash(void);
    
73. pfdl_u08 Erase_DataFlash(pfdl_u16 block);
    
74. /***********************************************************************************************************************
    
75. * Function Name: main
    
76. * Description  : This function implements main function.
    
77. * Arguments    : None
    
78. * Return Value : None
    
79. ***********************************************************************************************************************/
    
80. void main(void)
    
81. {
    
82.     uint8_t set_count = 0U;
    
83.     uint8_t count = 0U;
    
84.     rtc_counter_value_t time_data;
    
85.     g_Hour = 0x00U;
    
86.     g_Minute = 0x00U;
    
87.    
    
88.     R_MAIN_UserInit();
    
89. 
    
90.     Read_DataFlash();
    
91.     g_Step_last = (((short)g_Step_temp2[1] << 8) + g_Step_temp2[0]);
    
92.     if(0xFFFFU == g_Step_last)
    
93.         g_Step_last = 0U;
    
94. 
    
95.     while(1U)
    
96.     {
    
97.         switch_status = R_MAIN_Get_SwitchStatus();
    
98. 
    
99.         if((0x23U == HOUR) && (0x59U == MIN) && (0x59U == SEC)&& (1U == RIFG))
    
100.         {
     
101.             DI();
     
102.             RIFG = 0U;
     
103.             g_Step_temp1[0] = (uint8_t)(g_Step & 0x00ff);
     
104.             g_Step_temp1[1] = (uint8_t)((g_Step >> 8) & 0x00ff);
     
105. 
     
106.             Write_DataFlash();
     
107.             g_Step = 0U;
     
108.             g_Calorie = 0U;
     
109.             Read_DataFlash();
     
110.             g_Step_last = (((short)g_Step_temp2[1] << 8) + g_Step_temp2[0]);
     
111.             EI();
     
112.         }
     
113. 
     
114.         if(0U == set_flag)
     
115.         {
     
116.             switch(count)
     
117.             {
     
118.                 case 0:
     
119.                 {
     
120.                     R_RTC_Get_CounterValue(&time_data);
     
121.                     g_Hour = time_data.hour;
     
122.                     g_Minute = time_data.min;
     
123.                     /* ---- Time displays on LCD ---- */
     
124.                     R_MAIN_LcdDisplayNormal();
     
125.                 }
     
126.                 break;
     
127.                
     
128.                 case 1:
     
129.                 {
     
130.                     /* ---- Steps displays on LCD ---- */
     
131.                     R_MAIN_LcdStepDisplayNormal();
     
132.                 }
     
133.                 break;
     
134.                     
     
135.                 case 2:
     
136.                 {
     
137.                     
     
138.                     /* ---- Carlorie displays on LCD ---- */
     
139.                     R_MAIN_LcdCalorieDisplayNormal();
     
140.                 }
     
141.                 break;
     
142.                
     
143.                 case 3:
     
144.                 {
     
145.                     /* ---- Last Steps displays on LCD ---- */
     
146.                     R_MAIN_LcdLastStepDisplayNormal();
     
147.                 }
     
148.                 break;
     
149.                 default:
     
150.                 break;
     
151.             }
     
152.             if(switch_status == TRANS_SWITCH_ON)
     
153.             {
     
154.                 count++;
     
155.                 if(4U == count)
     
156.                 count = 0U;
     
157.             }
     
158.         }
     
159. 
     
160.         else if(1U == set_flag)
     
161.         {
     
162.             switch(set_count)
     
163.             {
     
164.                 case 0 :
     
165.                 {
     
166.                     R_MAIN_LcdHourBlink();
     
167.                     if(UP_SWITCH_ON == switch_status)
     
168.                     {
     
169.                         g_Hour = adbcdb(g_Hour, 1U);
     
170.                         /* ---- When hour data is 0x24 ---- */
     
171.                         if (0x24U == g_Hour)
     
172.                         {
     
173.                             g_Hour = 0x00U;
     
174.                         }
     
175.                         time_data.hour = g_Hour;
     
176.                         R_RTC_Set_CounterValue(time_data);
     
177.                     }
     
178.                     else if(DOWN_SWITCH_ON == switch_status)
     
179.                     {
     
180.                         g_Hour = sbbcdb(g_Hour, 1U);
     
181.                         if (0x99U == g_Hour)
     
182.                         {
     
183.                             g_Hour = 0x23U;
     
184.                         }
     
185.                         time_data.hour = g_Hour;
     
186.                         R_RTC_Set_CounterValue(time_data);
     
187.                     }
     
188.                 }
     
189.                 break;
     
190.                
     
191.                 case 1 :
     
192.                 {
     
193.                     R_MAIN_LcdMinuteBlink();
     
194.                     if(UP_SWITCH_ON == switch_status)
     
195.                     {
     
196.                         g_Minute = adbcdb(g_Minute, 1U);
     
197.                         /* ---- When hour data is 0x24 ---- */
     
198.                         if (0x60U == g_Minute)
     
199.                         {
     
200.                             g_Minute = 0x00U;
     
201.                         }
     
202.                         time_data.min = g_Minute;
     
203.                         R_RTC_Set_CounterValue(time_data);
     
204.                     }
     
205.                     else if(DOWN_SWITCH_ON == switch_status)
     
206.                     {
     
207.                         g_Minute = sbbcdb(g_Minute, 1U);
     
208.                         /* ---- When hour data is 0x24 ---- */
     
209.                         if (0x99U == g_Minute)
     
210.                         {
     
211.                             g_Minute = 0x59U;
     
212.                         }
     
213.                         time_data.min = g_Minute;
     
214.                         R_RTC_Set_CounterValue(time_data);
     
215.                     }
     
216.                     
     
217.                 }
     
218.                 break;
     
219.                
     
220.                 case 2 :
     
221.                 {
     
222.                     R_MAIN_LcdWeightBlink();
     
223.                     if(UP_SWITCH_ON == switch_status)
     
224.                     {
     
225.                         g_Weight = adbcdb(g_Weight, 1U);
     
226.                         /* ---- When hour data is 0x24 ---- */
     
227.                         if (0x9AU == g_Weight)
     
228.                         {
     
229.                             g_Weight = 0x00U;
     
230.                         }
     
231.                     }
     
232.                     else if(DOWN_SWITCH_ON == switch_status)
     
233.                     {
     
234.                         /* ---- When hour data is 0x24 ---- */
     
235.                         if (0x00U == g_Weight)
     
236.                         {
     
237.                             g_Weight = 0x9AU;
     
238.                         }
     
239.                         g_Weight = sbbcdb(g_Weight, 1U);
     
240.                     }
     
241.                 }
     
242.                 break;
     
243.                
     
244.                 case 3 :
     
245.                 {
     
246.                     R_MAIN_LcdLengthBlink();
     
247.                     if(UP_SWITCH_ON == switch_status)
     
248.                     {
     
249.                         g_Length = adbcdb(g_Length, 1U);
     
250.                         /* ---- When hour data is 0x24 ---- */
     
251.                         if (0x9AU == g_Length)
     
252.                         {
     
253.                             g_Length = 0x00U;
     
254.                         }
     
255.                     }
     
256.                     else if(DOWN_SWITCH_ON == switch_status)
     
257.                     {
     
258.                         /* ---- When hour data is 0x24 ---- */
     
259.                         if (0x00U == g_Length)
     
260.                         {
     
261.                             g_Length = 0x9AU;
     
262.                         
     
263.                         }
     
264.                         g_Length = sbbcdb(g_Length, 1U);
     
265.                     }
     
266.                 }
     
267.                 break;
     
268.                
     
269.                 default:
     
270.                 break;
     
271.             }
     
272.             if(TRANS_SWITCH_ON == switch_status)
     
273.             {
     
274.                 set_count++;
     
275.                 if(4U == set_count)
     
276.                 {
     
277.                      set_count = 0U;
     
278.                      set_flag = 0U;
     
279.                 }
     
280.             }
     
281.         }
     
282.     }
     
283. }
     
284. /***********************************************************************************************************************
     
285. End of function main
     
286. ***********************************************************************************************************************/
     
287. 
     
288. /***********************************************************************************************************************
     
289. * Function Name: R_MAIN_UserInit
     
290. * Description  : This function adds user code before implementing main function.
     
291. * Arguments    : None
     
292. * Return Value : None
     
293. ***********************************************************************************************************************/
     
294. void R_MAIN_UserInit(void)
     
295. {
     
296.     EI();
     
297.    
     
298.     R_LCD_Start();
     
299.     /* ---- Initialize display ---- */
     
300.     memset(LCD_POSITION_MINUTE_LOW, LCD_DATA_NONE, 9U);
     
301. 
     
302.     g_WatchStatus = WATCH_DISPLAY;
     
303. 
     
304.     R_RTC_Set_ConstPeriodInterruptOn(ONESEC);
     
305.     R_RTC_Start();
     
306.     R_TAU0_Channel0_Start();
     
307.     R_TAU0_Channel1_Start();
     
308. 
     
309.     /* Init device ADXL362. */
     
310.     ADXL362_Init();
     
311.     /* Put the device in standby mode. */
     
312.     ADXL362_SetPowerMode(0U);
     
313.     /* Set accelerometer's output data rate to: 12.5 Hz. */
     
314.     ADXL362_SetOutputRate(ADXL362_ODR_12_5_HZ);
     
315.     /* Setup the activity and inactivity detection. */
     
316.     ADXL362_SetRegisterValue(
     
317.                   ADXL362_ACT_INACT_CTL_LINKLOOP(ADXL362_MODE_LINK),
     
318.                   ADXL362_REG_ACT_INACT_CTL,
     
319.                   1U);
     
320.     ADXL362_SetupActivityDetection(1U, 30U, 1U);
     
321.     ADXL362_SetupInactivityDetection(1U, 700U, 25U);
     
322.     /* Start the measurement process. */
     
323.     ADXL362_SetPowerMode(1U);
     
324.     /* Clear ACT and INACT bits by reading the Status Register. */
     
325.     ADXL362_GetRegisterValue(&status,
     
326.                              ADXL362_REG_STATUS,
     
327.                              1U);
     
328. }
     
329. /***********************************************************************************************************************
     
330. End of function R_MAIN_UserInit
     
331. ***********************************************************************************************************************/
     
332. 
     
333. /***********************************************************************************************************************
     
334. * Function Name: R_MAIN_GetSwitchStatus
     
335. * Description  : This function get switch status.
     
336. * Arguments    : None
     
337. * Return Value : switch_status -The kind of pushed switch
     
338. ***********************************************************************************************************************/
     
339. uint8_t R_MAIN_Get_SwitchStatus(void)
     
340. {
     
341.     uint8_t set_switch;
     
342.     uint8_t up_switch;
     
343.     uint8_t down_switch;
     
344.     uint8_t trans_switch;
     
345. 
     
346.     uint8_t switch_status = SWITCH_ALL_OFF;
     
347. 
     
348.     set_switch = P2.1;
     
349.     up_switch = P2.0;
     
350.     down_switch = P14.4;
     
351.     trans_switch = P14.3;
     
352. 
     
353.     /* ---- Set switch status ---- */
     
354.     if ((0U == set_switch) && (1U == up_switch) && (1U == down_switch) && (1U == trans_switch))
     
355.     {
     
356.         R_MAIN_Delay1ms(10U);
     
357.         set_switch = P2.1;
     
358.         up_switch = P2.0;
     
359.         down_switch = P14.4;
     
360.         trans_switch = P14.3;
     
361.         if((0U == set_switch) && (1U == up_switch) && (1U == down_switch) && (1U == trans_switch))
     
362.         {
     
363.             while(0U == set_switch)
     
364.             {
     
365.                 set_switch = P2.1;
     
366.                 set_flag  = 1U;
     
367.             }
     
368.             switch_status = SET_SWITCH_ON;
     
369.         }
     
370.     }
     
371.     else if ((1U == set_switch) && (0U == up_switch) && (1U == down_switch) && (1U == trans_switch))
     
372.     {
     
373.         R_MAIN_Delay1ms(10U);
     
374.         set_switch = P2.1;
     
375.         up_switch = P2.0;
     
376.         down_switch = P14.4;
     
377.         trans_switch = P14.3;
     
378.         if((1U == set_switch) && (0U == up_switch) && (1U == down_switch) && (1U == trans_switch))
     
379.         {
     
380.             while(0U == up_switch)
     
381.             {
     
382.                 up_switch = P2.0;
     
383.             }
     
384.             switch_status = UP_SWITCH_ON;
     
385.         }
     
386.     }
     
387.     else if ((1U == set_switch) && (1U == up_switch) && (0U == down_switch) && (1U == trans_switch))
     
388.     {
     
389.         R_MAIN_Delay1ms(10U);
     
390.         set_switch = P2.1;
     
391.         up_switch = P2.0;
     
392.         down_switch = P14.4;
     
393.         trans_switch = P14.3;
     
394.         if((1U == set_switch) && (1U == up_switch) && (0U == down_switch) && (1U == trans_switch))
     
395.         {
     
396.             while(0U == down_switch)
     
397.             {
     
398.                 down_switch = P14.4;
     
399.             }
     
400.             switch_status = DOWN_SWITCH_ON;
     
401.         }
     
402.     }
     
403.     else if ((1U == set_switch) && (1U == up_switch) && (1U == down_switch) && (0U == trans_switch))
     
404.     {
     
405.         R_MAIN_Delay1ms(10U);
     
406.         set_switch = P2.1;
     
407.         up_switch = P2.0;
     
408.         down_switch = P14.4;
     
409.         trans_switch = P14.3;
     
410.         if((1U == set_switch) && (1U == up_switch) && (1U == down_switch) && (0U == trans_switch))
     
411.         {
     
412.             while(0U == trans_switch)
     
413.             {
     
414.                 trans_switch = P14.3;
     
415.             }
     
416.             switch_status = TRANS_SWITCH_ON;
     
417.         }
     
418.     }
     
419.     else
     
420.     {
     
421.         /* Do Nothing */
     
422.     }
     
423.     return (switch_status);
     
424. }
     
425. /***********************************************************************************************************************
     
426. End of function R_MAIN_GetSwitchStatus
     
427. ***********************************************************************************************************************/
     
428. 
     
429. /***********************************************************************************************************************
     
430. * Function Name: R_MAIN_LcdHourBlink
     
431. * Description  : This function hour blink data setup.
     
432. * Arguments    : None
     
433. * Return Value : None
     
434. ***********************************************************************************************************************/
     
435. void R_MAIN_LcdHourBlink(void)
     
436. ……………………
     
437. 
     
438. …………限于本文篇幅 余下代码请从51黑下载附件…………
     

复制代码

所有资料51hei提供下载:
电子计步器设计方案，附原理图+PCB源文件+源代码+BOM清单.zip (3.92 MB, 下载次数: 61)

2019-5-7 19:18 上传

点击文件名下载附件
下载积分: 黑币 -5

r7f0c002_pedometer_brochure.pdf (287.65 KB, 下载次数: 27)

2019-5-7 19:19 上传

点击文件名下载附件
下载积分: 黑币 -5

---

作者: gemxie    时间: 2019-5-27 10:41
谢谢楼主分享了，学习学习了

---

作者: leowyou    时间: 2021-7-15 18:10
很不错，值得推荐的资料

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1