基于双核ARM-LPC54114-Lite的真有效值交流电压表

wenyangzeng

一、  项目名称
基于双核ARM-LPC54114-Lite的真有效值交流电压表




二、项目概述

   一般的交流电压测量采用的是分压整流后测量其有效值的方法，由于整流二极管非线性特性，测量并不能得到真实的有效值测量结果，且对于非正弦波的测量，误差更大。基于双核ARM-LPC54114-Lite的真有效值交流电压表测量方法是对一个交流电的周期连续采样，按下式进行计算，得到真实的真有效值电压值。对于非正弦波波形的测量，也能得到正确的测量结果。


      本项目使用LPC54114-Lite开发板的4个ADC通道对三相交流电压进行ADC转换，并按照上式进行数学运算，得出三相交流电压R、S、T的线对线(L-L)、线对零(L-N)共6组的真有效值电压数据，然后在OLED屏上显示。充分利用LPC54114-Lite双核的优势，M4负责数学运算和显示，M0+负责ADC转换和数据传送，轻松实现本项目的功能。本项目具有成本低、测量交流电压真实度高的特点，具有一定的推广使用价值。


三、功能的实现
1、双核任务分配
     如果使用LPC54114-Lite仍按照单核ARM的模式来写代码，就失去了LPC54114双核的优势。本项目利用NXP官方现成的Remote Processor Messaging_Lite库(RPMsg-Lite)工程框架，很方便的实现双核通讯机制来调度M4与M0+对共享RAM的访问权限，很好地解决了双核访问共享RAM的互斥的问题。任务分配：M0+负责4个通道ADC转换和数据传输任务，M4内核负责对数据进行复杂数学运算和显示。双核RPMsg-Lite通讯框图参见图1：


                             图1

2、硬件
   开发板资源：
    需要使用LPC54114-Lite 4个通道ADC,在不改变开发板硬件连接前提下，阅读原理图查阅LPC54114-Lite剩余可利用资源，可知ADC功能可分配GPIO引脚为P1.3、P1.4、P1.8和P1.0（ADC3、6、7、11），驱动OLED显示屏可用的GPIO引脚为P0.11、P0.12、P0.14、P1.10、P1.11。


    外扩资源：
       需要外扩ADC采样前置电路（见图2）：3只1：1电压互感器T1-T3用于初级交流电高压端和次级输入信号低压端的安全隔离，初级串接的高阻值电阻R1-R3保证电压互感器线圈绕组工作在线性区并且不过流。T1-T3次级经过R7-R9、C1-C3的RC滤波后进入LPC54114-Lite的ADC输入端。并联在次级线圈上的电阻R4-R6阻尼了次级绕组的反峰压，保护LPC54114输入端不因脉冲过压损坏。图2中T1-T3次级线圈公共点连接到ADC3，ADC3连接到开发板上的可调电阻调节在1/2VCC。这样的连接把交流电波形的负电压巧妙的“垫高”到GND电平，使得ADC能够完整采样整个交流电波形。


                               图2

3、 软件

开发环境：
    MDK5.23

工程模板：
    直接利用SDK_2.3.0_LPCXproesso5441\boards\lpcxpresso54114\multicore_examples\rpmsg_lite_pingpong这个官方演示包进行修改使用。

双核通讯：
       演示包rpmsg_lite_pingpong这个工程预先为我们建立了一个双核乒乓通讯触发事件机制，稍加修改用来运行本工程非常方便。M4与M0+的通讯调度过程如下：
①         首先在0x20022000建立一个共享内存：二维数组results[40][4]用于双核共享存取ADC数据；
②         修改rpmsg_lite_send（）函数为我所用；
③         在M0+工程添加nxp官方ADC库函数，ADC转换速率设置刚好满足一个交流电周期采样4个通道每通道40次，M0+不停的进行ADC转换；
④         在M4工程添加OLED和真有效值数学计算函数；
⑤         M4发送msg数据请求通知给M0+，M0+将最近转换完成的ADC数据传送到共享内存数组results中；
⑥         M0+发送数据准备好msg给M4;
⑦         M4处理数据、刷新OLED后与M0+进行下一次通讯。

修改后的工程结构见图3



                     图3

双核调试：

      在社区看到帖子介绍双核的调试，有的说要打开2个MDK，有的说要IAR8才能调双核等等。菜鸟初次接触双核LPC，一开始确实有点信心不足。参阅NXP官网资料和NXP社区大侠详细介绍调试经验，经过一段时间动手练习，逐步掌握正确的调试方法。调试过程中发现：LPC54114-Lite开发板附带的CMSIS DAP仿真工具给双核调试带来极大方便。先编译M0+核，生成.BIN文件。(NXP官方已经在rpmsg_lite_pingpong工程里把生成BIN的参数配置都预设好)，然后编译M4核、下载代码，M0+的.BIN也自动下载了。当需要修改M0+时，激活m0+的工程(社区大侠有许多帖子详细介绍，不再贴图了)，修改编译后回到M4工程，重新编译下载后即可运行。

    其实：用MDK调试双核是很简单的。

    下载完成，点击运行，运行结果达到原设计要求，参见附件的图片和视频链接。初次接触LPC54114-Lite，亲身体验到双核ARM相对单核ARM的性能的差异，感受到双核ARM的更强大，对将来产品设计优先选择双核ARM有了深刻的认识。

如果无法播放，请点击此处在新窗口打开

True RMS.part01.rar (9.02 MB, 下载次数: 0)

2018-7-6 11:34 上传

点击文件名下载附件
阅读权限: 200
True RMS.part02.rar (8.17 MB, 下载次数: 0)

2018-7-6 11:34 上传

点击文件名下载附件
阅读权限: 200

图片.rar (1.8 MB, 下载次数: 21)

2018-5-25 10:37 上传

点击文件名下载附件


LPC54114_word.rar (244.6 KB, 下载次数: 120)

2018-5-25 12:34 上传

点击文件名下载附件
部分代码：
main_core0.c

1. int main(void)
   
2. {
   
3.     volatile int has_received;
   
4.     volatile uint16_t RPMsgRemoteReadyEventData = 0;
   
5.     struct rpmsg_lite_ept_static_context my_ept_context;
   
6.     struct rpmsg_lite_endpoint *my_ept;
   
7.     struct rpmsg_lite_instance rpmsg_ctxt;
   
8.     struct rpmsg_lite_instance *my_rpmsg;
   
9. 
   
10.     /* Initialize MCMGR - low level multicore management library.
    
11.        Call this function as close to the reset entry as possible,
    
12.        (into the startup sequence) to allow CoreUp event triggering. */
    
13.     MCMGR_EarlyInit();
    
14.         
    
15.           CLOCK_EnableClock(kCLOCK_InputMux);
    
16.     CLOCK_EnableClock(kCLOCK_Gpio0);
    
17.     CLOCK_EnableClock(kCLOCK_Gpio1);
    
18. 
    
19. 
    
20.     /* Initialize standard SDK demo application pins */
    
21.     /* attach 12 MHz clock to FLEXCOMM0 (debug console) */
    
22.     CLOCK_AttachClk(kFRO12M_to_FLEXCOMM0);
    
23. 
    
24.     BOARD_InitPins_Core0();
    
25.     BOARD_BootClockFROHF48M();
    
26.     BOARD_InitDebugConsole();
    
27.                
    
28.     OLED_Init_Interface();
    
29.     OLED_Init();
    
30.     OLED_Clear()          ;
    
31.                
    
32.     LCD_Print(26, 10,"恩智浦社区",TYPE16X16,TYPE8X16);
    
33.     LCD_Print(54, 36,"NXP",TYPE16X16,TYPE8X16);
    
34.     delay_ms(55000);
    
35.      OLED_Clear()          ;
    
36.      LCD_Print(16, 0, "基于双核ARM",TYPE16X16,TYPE8X16);
    
37.      LCD_Print(16,16, "LPC-54114的",TYPE16X16,TYPE8X16);
    
38.      LCD_Print(26,32, "真有效值",TYPE16X16,TYPE8X16);
    
39.      LCD_Print(16,48, "交流电压表 ",TYPE16X16,TYPE8X16);
    
40.      delay_ms(55000);
    
41.       Main_Screen();
    
42. 
    
43. #ifdef CORE1_IMAGE_COPY_TO_RAM
    
44.     /* Calculate size of the image */
    
45.     uint32_t core1_image_size;
    
46.     core1_image_size = get_core1_image_size();
    
47.     PRINTF("Copy CORE1 image to address: 0x%x, size: %d\r\n", CORE1_BOOT_ADDRESS, core1_image_size);
    
48. 
    
49.     /* Copy application from FLASH to RAM */
    
50.     memcpy(CORE1_BOOT_ADDRESS, (void *)CORE1_IMAGE_START, core1_image_size);
    
51. #endif
    
52. 
    
53.     /* Initialize MCMGR before calling its API */
    
54.     MCMGR_Init();
    
55.    
    
56.     /* Register the application event before starting the secondary core */
    
57.     MCMGR_RegisterEvent(kMCMGR_RemoteApplicationEvent, RPMsgRemoteReadyEventHandler, (void *)&RPMsgRemoteReadyEventData);
    
58. 
    
59.     /* Boot Secondary core application */
    
60.     MCMGR_StartCore(kMCMGR_Core1, CORE1_BOOT_ADDRESS, (uint32_t)rpmsg_lite_base, kMCMGR_Start_Synchronous);
    
61. 
    
62.     /* Print the initial banner */
    
63.     PRINTF("\r\nRPMsg demo starts\r\n");
    
64. 
    
65.     /* Wait until the secondary core application signals the rpmsg remote has been initialized and is ready to communicate. */
    
66.     while(APP_RPMSG_READY_EVENT_DATA != RPMsgRemoteReadyEventData) {};
    
67. 
    
68.     my_rpmsg = rpmsg_lite_master_init(rpmsg_lite_base, SH_MEM_TOTAL_SIZE, RPMSG_LITE_LINK_ID, RL_NO_FLAGS, &rpmsg_ctxt);
    
69. 
    
70.     my_ept = rpmsg_lite_create_ept(my_rpmsg, LOCAL_EPT_ADDR, my_ept_read_cb, (void *)&has_received, &my_ept_context);
    
71. 
    
72.     has_received = 0;
    
73. 
    
74.     /* Wait until the secondary core application signals the rpmsg remote endpoint has been created. */
    
75.     while(APP_RPMSG_EP_READY_EVENT_DATA != RPMsgRemoteReadyEventData) {};
    
76. 
    
77.     /* Send the first message to the remoteproc */
    
78.     msg.DATA = 0;
    
79.     rpmsg_lite_send(my_rpmsg, my_ept, REMOTE_EPT_ADDR, (char *)&msg, sizeof(THE_MESSAGE), RL_DONT_BLOCK);
    
80. 
    
81.     while(1)
    
82.     {
    
83.         if (has_received)
    
84.         {
    
85.            has_received = 0;
    
86.                                          calculate();
    
87.                                         msg.DATA=msg.DATA=results[0][3];        
    
88.             rpmsg_lite_send(my_rpmsg, my_ept, REMOTE_EPT_ADDR, (char *)&msg, sizeof(THE_MESSAGE), RL_DONT_BLOCK);
    
89.                                          
    
90.         }
    
91.     }
    
92. 
    
93. }
    

复制代码

main_core1.c

1. int main(void)
   
2. {   uint8_t i;
   
3.     volatile int has_received = 0;
   
4.     struct rpmsg_lite_ept_static_context my_ept_context;
   
5.     struct rpmsg_lite_endpoint *my_ept;
   
6.     struct rpmsg_lite_instance rpmsg_ctxt;
   
7.     struct rpmsg_lite_instance *my_rpmsg;
   
8.     static  uint16_t ADC_Temp[40][4]={0x00};
   
9.   
   
10. 
    
11.   CLOCK_EnableClock(kCLOCK_Iocon);
    
12.   CLOCK_EnableClock(kCLOCK_Gpio0);
    
13.   CLOCK_EnableClock(kCLOCK_Gpio1);
    
14. 
    
15. 
    
16. #ifdef MCMGR_USED
    
17.     /* Initialize MCMGR - low level multicore management library.
    
18.        Call this function as close to the reset entry as possible,
    
19.        (into the startup sequence) to allow CoreUp event triggering. */
    
20.     MCMGR_EarlyInit();
    
21. #endif /* MCMGR_USED */
    
22. 
    
23.     /* Initialize standard SDK demo application pins */
    
24.     BOARD_InitPins_Core1();
    
25.                
    
26.                
    
27. 
    
28. #ifdef MCMGR_USED
    
29.     uint32_t startupData;
    
30.     mcmgr_status_t status;
    
31. 
    
32.     /* Initialize MCMGR before calling its API */
    
33.     MCMGR_Init();
    
34. 
    
35.     /* Get the startup data */
    
36.     do{
    
37.         status = MCMGR_GetStartupData(&startupData);
    
38.     }while(status != kStatus_MCMGR_Success);
    
39. 
    
40.     my_rpmsg = rpmsg_lite_remote_init((void *)startupData, RPMSG_LITE_LINK_ID, RL_NO_FLAGS, &rpmsg_ctxt);
    
41. 
    
42.     /* Signal the other core we are ready by triggering the event and passing the APP_RPMSG_READY_EVENT_DATA */
    
43.     MCMGR_TriggerEvent(kMCMGR_RemoteApplicationEvent, APP_RPMSG_READY_EVENT_DATA);
    
44. #else
    
45.     my_rpmsg = rpmsg_lite_remote_init((void *)RPMSG_LITE_SHMEM_BASE, RPMSG_LITE_LINK_ID, RL_NO_FLAGS, &rpmsg_ctxt);
    
46. #endif /* MCMGR_USED */
    
47. 
    
48.     while (!rpmsg_lite_is_link_up(my_rpmsg))
    
49.         ;
    
50. 
    
51.     my_ept = rpmsg_lite_create_ept(my_rpmsg, LOCAL_EPT_ADDR, my_ept_read_cb, (void *)&has_received, &my_ept_context);
    
52. 
    
53. #ifdef MCMGR_USED
    
54.     /* Signal the other core the endpoint has been created by triggering the event and passing the APP_RPMSG_READY_EP_EVENT_DATA */
    
55.     MCMGR_TriggerEvent(kMCMGR_RemoteApplicationEvent, APP_RPMSG_EP_READY_EVENT_DATA);
    
56. #endif
    
57. 
    
58. #ifdef RPMSG_LITE_NS_USED
    
59.     rpmsg_ns_announce(my_rpmsg, my_ept, RPMSG_LITE_NS_ANNOUNCE_STRING, RL_NS_CREATE);
    
60. #endif /*RPMSG_LITE_NS_USED*/
    
61.     has_received = 0;
    
62.     led_init();
    
63.    adc_init();
    
64.     while(1)
    
65.     {
    
66.         if (has_received)
    
67.           {
    
68.             has_received = 0;
    
69.                 for(i=0;i<40;i++)
    
70.                     {
    
71.                         results[i][0]=ADC_Temp[i][0];
    
72.                         results[i][1]=ADC_Temp[i][1];
    
73.                         results[i][2]=ADC_Temp[i][2];
    
74.                           results[i][3]=ADC_Temp[i][3];
    
75.                       }
    
76.         msg.DATA=results[0][3];        
    
77.            }
    
78.            else
    
79.            {
    
80.               for(i=0;i<40;i++)
    
81.                   {
    
82.                     ADC_Temp[i][0]=adc_read(6);
    
83.                     ADC_Temp[i][1]=adc_read(7);
    
84.                     ADC_Temp[i][2]=adc_read(11);
    
85.                      ADC_Temp[i][3]=adc_read(3);
    
86.                   }        
    
87.               LED_RED_TOGGLE();
    
88.          rpmsg_lite_send(my_rpmsg, my_ept, remote_addr, (char *)&msg, sizeof(THE_MESSAGE), RL_DONT_BLOCK);
    
89.                                 
    
90.           }
    
91.     }
    
92. }
    

复制代码

app_adc.c

1. #define ADC_GPIO_CFG IOCON_MODE_PULLUP | IOCON_FUNC0 | IOCON_GPIO_MODE | IOCON_DIGITAL_EN | IOCON_INPFILT_OFF
   
2. const uint8_t  ADC_GPIO_PORT[ADC_NUM] = { 1 };
   
3. const uint8_t  ADC_GPIO_PIN [ADC_NUM] = { 0 };
   
4. volatile uint8_t bADCSampleFlag = 0;
   
5. static adc_result_info_t gAdcResultInfoStruct;
   
6. adc_result_info_t *volatile gAdcResultInfoPtr = &gAdcResultInfoStruct;
   
7. uint8_t adc_init(void)
   
8. {        
   
9.         uint8_t ret = 0;
   
10. adc_config_t adcConfigStruct;
    
11.         adc_conv_seq_config_t adcConvSeqConfigStruct;
    
12. POWER_DisablePD(kPDRUNCFG_PD_ADC0);
    
13.   POWER_DisablePD(kPDRUNCFG_PD_VD7_ENA);
    
14.   POWER_DisablePD(kPDRUNCFG_PD_VREFP_SW);
    
15.   POWER_DisablePD(kPDRUNCFG_PD_TEMPS);
    
16. CLOCK_EnableClock(kCLOCK_Adc0);
    
17. IOCON_PinMuxSet(IOCON, 1, 0, IOCON_MODE_INACT | IOCON_FUNC0 | IOCON_ANALOG_EN | IOCON_INPFILT_OFF);
    
18.         IOCON_PinMuxSet(IOCON, 1, 3, IOCON_MODE_INACT | IOCON_FUNC0 | IOCON_ANALOG_EN | IOCON_INPFILT_OFF);
    
19.         IOCON_PinMuxSet(IOCON, 1, 4, IOCON_MODE_INACT | IOCON_FUNC0 | IOCON_ANALOG_EN | IOCON_INPFILT_OFF);
    
20.         IOCON_PinMuxSet(IOCON, 1, 8, IOCON_MODE_INACT | IOCON_FUNC0 | IOCON_ANALOG_EN | IOCON_INPFILT_OFF);
    
21. if (ADC_DoSelfCalibration(ADC0))
    
22.         {
    
23.     ;
    
24.         }
    
25.         else
    
26.         {
    
27.     return 0;
    
28.         }
    
29. adcConfigStruct.clockMode = kADC_ClockSynchronousMode;
    
30.         adcConfigStruct.clockDividerNumber = 0XFF;
    
31.         adcConfigStruct.resolution = kADC_Resolution12bit;
    
32.         adcConfigStruct.enableBypassCalibration = false;
    
33.         adcConfigStruct.sampleTimeNumber = 0X07;
    
34.         ADC_Init(ADC0, &adcConfigStruct);
    
35. ADC_EnableTemperatureSensor(ADC0, true);
    
36. adcConvSeqConfigStruct.channelMask = 0x08C8;
    
37.         adcConvSeqConfigStruct.triggerMask = 0U;
    
38.         adcConvSeqConfigStruct.triggerPolarity = kADC_TriggerPolarityNegativeEdge;
    
39.         adcConvSeqConfigStruct.enableSingleStep = false;
    
40.         adcConvSeqConfigStruct.enableSyncBypass = false;
    
41.         adcConvSeqConfigStruct.interruptMode = kADC_InterruptForEachSequence;
    
42.         ADC_SetConvSeqAConfig(ADC0, &adcConvSeqConfigStruct);
    
43.         ADC_EnableConvSeqA(ADC0, true);
    
44. #if 0               
    
45.   ADC_EnableInterrupts(ADC0, kADC_ConvSeqAInterruptEnable);
    
46.   NVIC_EnableIRQ(ADC0_SEQA_IRQn);
    
47. ADC_EnableConvSeqABurstMode(ADC0, true);
    
48. #endif        
    
49.   bADCSampleFlag = 0;
    
50. ret = 1;
    
51.         return ret;
    
52. }
    
53. uint16_t adc_read(uint16_t num)
    
54. {
    
55. #if 0
    
56.         if(bADCSampleFlag == 0)
    
57.         {
    
58.                 return 0xFFFF;
    
59.         }
    
60.         if(bADCSampleFlag == 1) // set 1 in ADC interrupt
    
61.         {
    
62.                 bADCSampleFlag = 0;
    
63.                 if(gAdcResultInfoStruct.channelNumber == num)
    
64.                 {
    
65.                         return (gAdcResultInfoStruct.result&0x0FFF);
    
66.                 }
    
67. return 0xFFFF;
    
68.         }
    
69. #endif
    
70.         ADC_DoSoftwareTriggerConvSeqA(ADC0);
    
71. while (!ADC_GetChannelConversionResult(ADC0, num, &gAdcResultInfoStruct))
    
72.         {
    
73.         }        
    
74.         return (gAdcResultInfoStruct.result&0x0FFF);
    
75. }

复制代码

oled.c

1. #include "oled.h"
   
2. #include "oledfont.h"
   
3. #include "fonts.h"
   
4. void delay_ms(unsigned int ms)
   
5. {                        
   
6.         unsigned int a;
   
7.         while(ms)
   
8.         {
   
9.                 a=1800;
   
10.                 while(a--);
    
11.                 ms--;
    
12.         }
    
13.         return;
    
14. }
    
15. #if OLED_MODE==1
    
16. 
    
17. void OLED_WR_Byte(u8 dat,u8 cmd)
    
18. {
    
19.         DATAOUT(dat);            
    
20.         if(cmd)
    
21.           OLED_DC_Set();
    
22.         else
    
23.           OLED_DC_Clr();                  
    
24.         OLED_CS_Clr();
    
25.         OLED_WR_Clr();         
    
26.         OLED_WR_Set();
    
27.         OLED_CS_Set();         
    
28.         OLED_DC_Set();         
    
29. }                        
    
30. #else
    
31. 
    
32. void OLED_WR_Byte(u8 dat,u8 cmd)
    
33. {        
    
34.         u8 i;                          
    
35.         if(cmd)
    
36.           OLED_DC_Set();
    
37.         else
    
38.           OLED_DC_Clr();                  
    
39.         OLED_CS_Clr();
    
40.         for(i=0;i<8;i++)
    
41.         {                          
    
42.                 OLED_SCLK_Clr();
    
43.                 if(dat&0x80)
    
44.                         {
    
45.                    OLED_SDIN_Set();
    
46.                         }
    
47. else
    
48.                    OLED_SDIN_Clr();
    
49.                                 OLED_SCLK_Set();
    
50.                 dat<<=1;   
    
51.         }                                                   
    
52.         OLED_CS_Set();
    
53.         OLED_DC_Set();            
    
54. }
    
55. #endif
    
56.         void OLED_Set_Pos(unsigned char x, unsigned char y)
    
57. {
    
58.         OLED_WR_Byte(0xb0+y,OLED_CMD);
    
59.         OLED_WR_Byte(((x&0xf0)>>4)|0x10,OLED_CMD);
    
60.         OLED_WR_Byte((x&0x0f)|0x01,OLED_CMD);
    
61. }            
    
62. 
    
63. void OLED_Display_On(void)
    
64. {
    
65.         OLED_WR_Byte(0X8D,OLED_CMD);
    
66.         OLED_WR_Byte(0X14,OLED_CMD);
    
67.         OLED_WR_Byte(0XAF,OLED_CMD);
    
68. }
    
69.   
    
70. void OLED_Display_Off(void)
    
71. {
    
72.         OLED_WR_Byte(0X8D,OLED_CMD);
    
73.         OLED_WR_Byte(0X10,OLED_CMD);
    
74.         OLED_WR_Byte(0XAE,OLED_CMD);
    
75. }                                            
    
76.   
    
77. void OLED_Clear(void)  
    
78. {  
    
79.         u8 i,n;                    
    
80.         for(i=0;i<8;i++)  
    
81.         {  
    
82.                 OLED_WR_Byte (0xb0+i,OLED_CMD);
    
83.                 OLED_WR_Byte (0x00,OLED_CMD);   
    
84.                 OLED_WR_Byte (0x10,OLED_CMD);  
    
85.                 for(n=0;n<130;n++)OLED_WR_Byte(0,OLED_DATA);
    
86.         }
    
87. }
    
88. 
    
89. 
    
90. void OLED_ShowChar(u8 x,u8 y,u8 chr)
    
91. {              
    
92.         unsigned char c=0,i=0;        
    
93.                 c=chr-' ';
    
94.                 if(x>Max_Column-1){x=0;y=y+2;}
    
95.                 if(SIZE ==16)
    
96.                         {
    
97.                         OLED_Set_Pos(x,y);        
    
98.                         for(i=0;i<8;i++)
    
99.                         OLED_WR_Byte(F8X16[c*16+i],OLED_DATA);
    
100.                         OLED_Set_Pos(x,y+1);
     
101.                         for(i=0;i<8;i++)
     
102.                         OLED_WR_Byte(F8X16[c*16+i+8],OLED_DATA);
     
103.                         }
     
104.                         else {        
     
105.                                 OLED_Set_Pos(x,y+1);
     
106.                                 for(i=0;i<6;i++)
     
107.                                 OLED_WR_Byte(F6x8[c][i],OLED_DATA);
     
108.                                 
     
109.                         }
     
110. }
     
111. 
     
112. u32 oled_pow(u8 m,u8 n)
     
113. {
     
114.         u32 result=1;         
     
115.         while(n--)result*=m;   
     
116.         return result;
     
117. }                                 
     
118.                   
     
119. void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size2)
     
120. {                 
     
121.         u8 t,temp;
     
122.         u8 enshow=0;                                                   
     
123.         for(t=0;t<len;t++)
     
124.         {
     
125.                 temp=(num/oled_pow(10,len-t-1))%10;
     
126.                 if(enshow==0&&t<(len-1))
     
127.                 {
     
128.                         if(temp==0)
     
129.                         {
     
130.                                 OLED_ShowChar(x+(size2/2)*t,y,' ');
     
131.                                 continue;
     
132.                         }else enshow=1;
     
133.                           
     
134.                 }
     
135.                  OLED_ShowChar(x+(size2/2)*t,y,temp+'0');
     
136.         }
     
137. }
     
138. 
     
139. void OLED_ShowString(u8 x,u8 y,u8 *chr)
     
140. {
     
141.         unsigned char j=0;
     
142.         while (chr[j]!='\0')
     
143.         {                OLED_ShowChar(x,y,chr[j]);
     
144.                         x+=8;
     
145.                 if(x>120){x=0;y+=2;}
     
146.                         j++;
     
147.         }
     
148. }
     

复制代码

oled.h

1. #ifndef __OLED_H
   
2. #define __OLED_H
   
3. 
   
4. #include "fsl_gpio.h"
   
5. #define  u8 unsigned char
   
6. #define  u32 unsigned int
   
7. #define OLED_CMD  0        
   
8. #define OLED_DATA 1        
   
9. #define OLED_MODE 0
   
10. #define OLED_RES_GPIO GPIO
    
11. #define OLED_RES_GPIO_PORT 1U
    
12. #define OLED_RES_GPIO_PIN 10U
    
13. #define OLED_DC_GPIO GPIO
    
14. #define OLED_DC_GPIO_PORT 1U
    
15. #define OLED_DC_GPIO_PIN 11U
    
16. #define OLED_CS_GPIO GPIO
    
17. #define OLED_CS_GPIO_PORT 0U
    
18. #define OLED_CS_GPIO_PIN 14U
    
19. #define OLED_SCLK_GPIO GPIO
    
20. #define OLED_SCLK_GPIO_PORT 0U
    
21. #define OLED_SCLK_GPIO_PIN 11U
    
22. #define OLED_SDIN_GPIO GPIO
    
23. #define OLED_SDIN_GPIO_PORT 0U
    
24. #define OLED_SDIN_GPIO_PIN 12U
    
25. #define OLED_CS_Clr()  GPIO_WritePinOutput(GPIO, OLED_CS_GPIO_PORT, OLED_CS_GPIO_PIN, 0)
    
26. #define OLED_CS_Set()  GPIO_WritePinOutput(GPIO, OLED_CS_GPIO_PORT, OLED_CS_GPIO_PIN, 1)
    
27. #define OLED_RST_Clr() GPIO_WritePinOutput(GPIO, OLED_RES_GPIO_PORT, OLED_RES_GPIO_PIN, 0)
    
28. #define OLED_RST_Set() GPIO_WritePinOutput(GPIO, OLED_RES_GPIO_PORT, OLED_RES_GPIO_PIN, 1)
    
29. #define OLED_DC_Clr() GPIO_WritePinOutput(GPIO, OLED_DC_GPIO_PORT, OLED_DC_GPIO_PIN, 0)
    
30. #define OLED_DC_Set() GPIO_WritePinOutput(GPIO, OLED_DC_GPIO_PORT, OLED_DC_GPIO_PIN, 1)
    
31. #define OLED_SCLK_Clr() GPIO_WritePinOutput(GPIO, OLED_SCLK_GPIO_PORT, OLED_SCLK_GPIO_PIN, 0)
    
32. #define OLED_SCLK_Set() GPIO_WritePinOutput(GPIO, OLED_SCLK_GPIO_PORT, OLED_SCLK_GPIO_PIN, 1)
    
33. #define OLED_SDIN_Clr() GPIO_WritePinOutput(GPIO, OLED_SDIN_GPIO_PORT, OLED_SDIN_GPIO_PIN, 0)
    
34. #define OLED_SDIN_Set() GPIO_WritePinOutput(GPIO, OLED_SDIN_GPIO_PORT, OLED_SDIN_GPIO_PIN, 1)
    
35. #define SIZE 24
    
36. #define XLevelL                0x02
    
37. #define XLevelH                0x10
    
38. #define Max_Column        128
    
39. #define Max_Row                64
    
40. #define        Brightness        0xFF
    
41. #define X_WIDTH         128
    
42. #define Y_WIDTH         64                                                              
    
43. 
    
44. void delay_ms(unsigned int ms);
    
45. void OLED_WR_Byte(u8 dat,u8 cmd);            
    
46. void OLED_Display_On(void);
    
47. void OLED_Display_Off(void);                                                                                          
    
48. void OLED_Init(void);
    
49. void OLED_Init_Interface(void);
    
50. void OLED_Clear(void);
    
51. void OLED_DrawPoint(u8 x,u8 y,u8 t);
    
52. void OLED_Fill(u8 x1,u8 y1,u8 x2,u8 y2,u8 dot);
    
53. void OLED_ShowChar(u8 x,u8 y,u8 chr);
    
54. void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size2);
    
55. void OLED_ShowString(u8 x,u8 y, u8 *p);         
    
56. void OLED_Set_Pos(unsigned char x, unsigned char y);
    
57. void OLED_ShowCHinese(u8 x,u8 y,u8 no);
    
58. void OLED_DrawBMP(unsigned char x0, unsigned char y0,unsigned char x1, unsigned char y1,unsigned char BMP[]);
    
59. void LCD_Print(uint8_t x, uint8_t y, uint8_t *ch,uint8_t char_size, uint8_t ascii_size);
    
60. void Main_Screen(void);
    
61. #endif  
    
62.         

复制代码

阅读全文

landeng1986

这个厉害了

wenyangzeng

landeng1986 发表于 2018-5-25 11:52
这个厉害了

谢谢支持！

NXP管管

赞赞！

eric_bestmyself

完成速度很快，支持一下！

wenyangzeng

eric_bestmyself 发表于 2018-5-25 23:58
完成速度很快，支持一下！

谢谢支持

zwei99999999

碎了心

就冲楼主这么认真上传的东西，我就得投一票。

wenyangzeng

碎了心 发表于 2018-6-5 17:50
就冲楼主这么认真上传的东西，我就得投一票。

谢谢楼上的支持。认真做好每一件工作才对得起LPC54114。

碎了心

wenyangzeng 发表于 2018-6-5 18:59
谢谢楼上的支持。认真做好每一件工作才对得起LPC54114。

不用客气，作为小白的我，想问大佬一个问题。就是想用上位机调电机PID。这个好像是被人写的上位机，但我不知道怎么整合到我的程序里，是只要改UART吗，具体应该怎么改？望大佬不吝赐教。

/*
* wave.h
*
*  Created on: Nov 29, 2014
*      Author: ass
*/
#ifndef WAVE_H_
#define WAVE_H_

#include "uart.h"

void Uart1_Send_AF(signed int aa,signed int bb,signed int cc,signed int dd,signed int ee,signed int ff,signed int gg,signed int hh);
unsigned char UART_Putc(unsigned char data);
void send_wave(void);

void printhh(void);
void print5n(unsigned int x);
void print4n(unsigned int x);
void print3n(unsigned int x);
void print2n(unsigned int x);

#endif /* WAVE_H_ */


#include "wave.h"
#include "uart.h"

#define tx_num        32

unsigned char TxBuffer[tx_num];
unsigned char count=0;

#define BYTE0(dwTemp)       (*(char *)(&dwTemp))
#define BYTE1(dwTemp)       (*((char *)(&dwTemp) + 1))
#define BYTE2(dwTemp)       (*((char *)(&dwTemp) + 2))
#define BYTE3(dwTemp)       (*((char *)(&dwTemp) + 3))

/**************************向物理串口发一个字节***************************************
*******************************************************************************/
__inline unsigned char UART_Putc(unsigned char data)                        //
{
        uart_send1(UART_1,data);
        return data;
}

unsigned char Uart1_Put_Char(unsigned char DataToSend)
{
        TxBuffer[count++] = DataToSend;  
        return DataToSend;
}

unsigned char Uart1_Put_Int16(uint16_t DataToSend)
{
        unsigned char sum = 0;
        TxBuffer[count++] = BYTE1(DataToSend);
        TxBuffer[count++] = BYTE0(DataToSend);
        sum += BYTE1(DataToSend);
        sum += BYTE0(DataToSend);
        return sum;
}


void Uart1_Send_AF(signed int aa,signed int bb,signed int cc,signed int dd,signed int ee,signed int ff,signed int gg,signed int hh)
{
        unsigned char sum = 0;
        count=0;
        sum += Uart1_Put_Char(0x88);
        sum += Uart1_Put_Char(0xAF);
        sum += Uart1_Put_Char(0x1C);
        sum += Uart1_Put_Char(BYTE1(aa));//1
        sum += Uart1_Put_Char(BYTE0(aa));
        sum += Uart1_Put_Char(BYTE1(bb));//2
        sum += Uart1_Put_Char(BYTE0(bb));
        sum += Uart1_Put_Char(BYTE1(cc));//3
        sum += Uart1_Put_Char(BYTE0(cc));
        sum += Uart1_Put_Char(BYTE1(dd));//4
        sum += Uart1_Put_Char(BYTE0(dd));
        sum += Uart1_Put_Char(BYTE1(ee));//5
        sum += Uart1_Put_Char(BYTE0(ee));
        sum += Uart1_Put_Char(BYTE1(ff));//6
        sum += Uart1_Put_Char(BYTE0(ff));
        Uart1_Put_Char(0);
        Uart1_Put_Char(0);
        Uart1_Put_Char(0);
        Uart1_Put_Char(0);
        Uart1_Put_Char(0);
        Uart1_Put_Char(0);
        sum += Uart1_Put_Char(BYTE1(gg));//7,4500->45'//这是姿态!!!
        sum += Uart1_Put_Char(BYTE0(gg));
        sum += Uart1_Put_Char(BYTE1(hh));//8
        sum += Uart1_Put_Char(BYTE0(hh));
        Uart1_Put_Char(0);
        Uart1_Put_Char(0);
        Uart1_Put_Char(0);
        Uart1_Put_Char(0);
        Uart1_Put_Char(0);
        Uart1_Put_Char(0);
        Uart1_Put_Char(sum);
}

void send_wave(void)
{
        char count_1=0;
        while(count_1<tx_num)
      UART_Putc(TxBuffer[count_1++]);
}
///////////////////////////////////////////////////////////////////////

void printhh(void)
  {
        UART_Putc(0x0d);                                //output'CR'
        UART_Putc(0x0A);                                //output'CR'
  }

void print5n(unsigned int x)
  {          
           UART_Putc((x/10000)+0x30);           //计算万位数字
           UART_Putc(((x%10000)/1000)+0x30);    //计算千位数字
           UART_Putc(((x%1000)/100)+0x30);      //计算百位数字
           UART_Putc(((x%100)/10)+0x30);        //计算十位数字
           UART_Putc((x%10)+0x30);              //计算个位数字
  }

void print4n(unsigned int x)
  {          
          UART_Putc((x/1000)+0x30);    //计算千位数字
          UART_Putc(((x%1000)/100)+0x30);      //计算百位数字
          UART_Putc(((x%100)/10)+0x30);        //计算十位数字
          UART_Putc((x%10)+0x30);              //计算个位数字
  }
void print3n(unsigned int x)
{
        UART_Putc((x/100)+0x30);      //计算百位数字
        UART_Putc(((x%100)/10)+0x30);        //计算十位数字
        UART_Putc((x%10)+0x30);   
}
void print2n(unsigned int x)
{

        UART_Putc((x/10)+0x30);        //计算十位数字
        UART_Putc((x%10)+0x30);   
}


这个好像是被人写的上位机，但我不知道怎么整合到我的程序里，是只要改UART吗，具体应该怎么改？