返回发烧友论坛
发 帖  

[文章]【HarmonyOS HiSpark Wi-Fi IoT 套件试用连载】八：天气显示

李元江
2021-01-05 23:15:18
阅读量0
鸿蒙系统HarmonyOSHiSpark
1
3
上一次帖子，已经通过网络获取天气数据，但是还没显示到显示屏上。今天的帖子我写的是关于如何取模天气图片，并显示天气图标和天气数据。
一、SSD1306显存填充
显示板使用的OLED驱动芯片为SSD1306，我们来看看这款芯片的显存和该显存填充方式。下面是从SSD1303芯片手册上的截图，可以看得出它的显存是大小为128*64bit的RAM，并且分成为8页，PAGE0-PAGE7。显示板像素点大小为128*64,所以一个像素点对应RAM中的1bit。

GDDRAM.JPG
往RAM的某一位写入1或者0,该位对应的像素点就显示亮点或者不显示。但是它是按照什么顺序写入数据的。下面也是从芯片手册上的截图。
填充.JPG
可以看得出RAM填充顺序了 ,写入一个字节数据时，最低位数据写入一页中最上面那行，最高位写入一页中最下面那行。这样，使用取模软件取模图片或者字符时，我们才能知道按照什么顺序取模。之后再写相应代码，按照顺序把取模数据写入RAM中。

二、天气图标取模
首先当然是先在网络下载我们需要的天气图标，大小看你像显示多大区域的图标，我的是48*48大小图标，在OLED上显示大小也是48*48。
天气图标.JPG

我使用的是下面这款取模软件，我觉得图标取模不太好，不知道大家有没有推荐的。需要根据SSD1306进行取模软件的设置。比较重要的是取模方式的选择，这是跟SSD1306显示填充顺序对应的，我们需要选择列行式。其他数据点阵选择48，自定义格式选择C51。
设置.JPG

选择晴图标，生成如下数组。

取模.JPG
上面的小花就是太阳图标，是有点丑，先凑合用吧。

二、软件设计
1、显示天气图标
我们已经按照SSD1306显存填充顺序，取模好图片数据，接下来按照顺序把数据写入RAM就行了，代码如下。
  1. typedef enum
  2. {
  3.     QINGLOGO =0,
  4.     YINGLOGO,
  5.     DUOYULOGO,
  6.     YULOGO,
  7.     LEIYULOGO,
  8.     XUELOGO,
  9. }WEATHER_TYPE;
  10. void OLED_ShowWeather(uint8_t x,uint8_t y,WEATHER_TYPE type)
  11. {
  12.     unsigned char (*temp)[48];
  13.     //if(type ==qinglogo )
  14.         //temp=Qing48;
  15.     switch(type)
  16.         {
  17.             case    QINGLOGO:   temp=Qing48;break;
  18.             case    YINGLOGO:   temp=Yin48;break;
  19.             case    YULOGO:     temp=Yu48;break;
  20.             case    LEIYULOGO:  temp=LeiYu48;break;
  21.             case    DUOYULOGO:  temp=DuoYun48;break;
  22.             case    XUELOGO:    temp=Xue48;break;
  23.             default :
  24.              temp=Qing48;
  25.             break;
  26.     }
  27.     //OledSetPosition(x,y);
  28.     for(uint8_t i=0;i<6;i++){
  29.         OledSetPosition(x,y+i);
  30.         for(uint8_t j = 0;j<48;j++){
  31.             WriteData(temp[i][j]);
  32.         }
  33.     }
  34. }
复制代码
2、按键任务
OLED显示板上的两个按键，主要用于界面切换、获取实时时间、天气数据。增加了按键任务，主要进行这两个按键的处理。右边按键，按下后可以切换界面，现在设置有四个界面。在时间显示界面按下左键，会获取实时时间。在天气显示界面，按下左键会获取实时天气。
  1. #include <stdio.h>
  2. #include <unistd.h>
  3. #include <stdbool.h>
  4. #include "ohos_init.h"
  5. #include "cmsis_os2.h"
  6. #include "wifiiot_gpio.h"
  7. #include "wifiiot_gpio_ex.h"
  8. #include "wifiiot_pwm.h"
  9. #include "wifiiot_adc.h"
  10. ​
  11. #include "oled_ssd1306.h"
  12. ​
  13. #define ANALOG_KEY_CHAN_NAME WIFI_IOT_ADC_CHANNEL_2
  14. ​
  15. typedef enum{
  16.     TIMESCREEN=0,
  17.     NOWSCREEN,
  18.     TOSCREEN,
  19.     ATOSCREEN,
  20. } SCREEN_STATUS;
  21. extern SCREEN_STATUS Now_Screen ;
  22. extern SCREEN_STATUS Last_Screen ;
  23. ​
  24. typedef enum{
  25.     GET_NORMAL =0 ,
  26.     GET_PROPRESS,
  27.     GET_SUC,
  28.     GET_FAIL,
  29. }GET_STATUS;
  30. ​
  31. GET_STATUS Get_Status = GET_NORMAL;
  32. GET_STATUS Last_Get_Status = GET_NORMAL;
  33. ​
  34. extern void getNtpTime(void);
  35. extern bool getWeather(void);
  36. ​
  37. static float ConvertToVoltage(unsigned short data)
  38. {
  39.     return (float)data * 1.8 * 4 / 4096; /* adc code equals: voltage/4/1.8*4096  */
  40. }
  41. ​
  42. static void KeyTask(void *arg)
  43. {
  44.     (void)arg;
  45.     unsigned short data = 0;
  46. ​
  47.     GpioInit();
  48.     static bool keyflag = false;
  49.     while(1)
  50.     {
  51.         AdcRead(ANALOG_KEY_CHAN_NAME, &data, WIFI_IOT_ADC_EQU_MODEL_4, WIFI_IOT_ADC_CUR_BAIS_DEFAULT, 0);
  52.         float voltage = ConvertToVoltage(data);
  53. ​
  54.         if((voltage>0.45 && voltage<0.65)&&(!keyflag))
  55.         {
  56.             keyflag = true;
  57.             //OledShowString(16,7,"Sync time...",1);
  58.             //getNtpTime();
  59.             //OledFillScreen(0);
  60.             switch (Now_Screen){
  61.                 case TIMESCREEN:
  62.                 //OledShowString(16,7,"Sync time...",1);
  63.                 Get_Status = GET_PROPRESS;
  64.                 getNtpTime();
  65.                 //OledFillScreen(0);
  66.                 Get_Status = GET_SUC;
  67.                 break;
  68.                 case NOWSCREEN:
  69.                     //OledShowString(0,7,"Get Weather...",1);
  70.                     Get_Status = GET_PROPRESS;
  71.                     if(getWeather())
  72.                     //OledFillScreen(0);
  73.                     Get_Status = GET_SUC;
  74.                     else
  75.                     {
  76.                     //OledShowString(0,7,"Get fail...",1);
  77.                     Get_Status = GET_FAIL;
  78.                     }
  79.                 break;
  80.                 case TOSCREEN:
  81.                     Get_Status = GET_PROPRESS;
  82.                     if(getWeather())
  83.                      Get_Status = GET_SUC;
  84.                     else
  85.                     {
  86.                     Get_Status = GET_FAIL;
  87.                     }
  88.                 break;
  89.                 case ATOSCREEN:
  90.                     Get_Status = GET_PROPRESS;
  91.                     if(getWeather())
  92.                     Get_Status = GET_SUC;
  93.                     else
  94.                     {
  95.                     Get_Status = GET_FAIL;
  96.                     }
  97.                 break;
  98. ​
  99.                 default:
  100.                 break;
  101.             }
  102.         }
  103.         else if((voltage>0.9 && voltage<1)&&(!keyflag))
  104.         {
  105.             keyflag = true;
  106.             Now_Screen ++;
  107.             if(Now_Screen > ATOSCREEN)
  108.             {
  109.                 Now_Screen = TIMESCREEN;
  110.             }
  111.         }
  112. ​
  113.         if((!(voltage>0.45 && voltage<0.65)) && (!(voltage>0.9 && voltage<1))) {
  114.              keyflag = false;
  115.         }
  116. ​
  117.         usleep(300000);
  118.     }
  119. }
  120. ​
  121. static void KeyTaskHandle(void)
  122. {
  123.     osThreadAttr_t attr;
  124.     attr.name = "KeyTask";
  125.     attr.attr_bits = 0U;
  126.     attr.cb_mem = NULL;
  127.     attr.cb_size = 0U;
  128.     attr.stack_mem = NULL;
  129.     attr.stack_size = 4096;
  130.     attr.priority = osPriorityNormal+2;
  131. ​
  132.     if (osThreadNew(KeyTask, NULL, &attr) == NULL) {
  133.         printf("[KeyTaskHandle] Falied to create KeyTask!n");
  134.     }
  135. }
  136. APP_FEATURE_INIT(KeyTaskHandle);
复制代码
3、 OLED任务修改
修改oled_demo.c内容。增加页面切换，获取时间、天气数据情况提示，显示天气数据和天气图标。

  1. typedef enum{
  2.     TIMESCREEN=0,
  3.     NOWSCREEN,
  4.     TOSCREEN,
  5.     ATOSCREEN,
  6. } SCREEN_STATUS;
  7. SCREEN_STATUS Now_Screen = TIMESCREEN;
  8. SCREEN_STATUS Last_Screen = TIMESCREEN;
  9. ​
  10. typedef enum{
  11.     GET_NORMAL =0 ,
  12.     GET_PROPRESS,
  13.     GET_SUC,
  14.     GET_FAIL,
  15. }GET_STATUS;
  16. extern GET_STATUS Get_Status ;
  17. extern GET_STATUS Last_Get_Status ;
  18. ​
  19. static uint8_t i=0;   
  20. ​
  21. static void TimeScreenDisp(void)
  22. {
  23. //OledShow
  24.         rtc_time_t mData;
  25.         OLED_ShowCHinese(0,3,0);//温
  26.         OLED_ShowCHinese(16,3,2);//度
  27.         OledShowChar(32,3,':',2);
  28.         sprintf((char *)TimeStr,"%02d",
  29.         (uint32_t)temperature);
  30.         OledShowString(40,3,(char *)TimeStr,2);
  31.         OLED_ShowCHinese(64,3,1);//湿
  32.         OLED_ShowCHinese(80,3,2);//度
  33.         OledShowChar(96,3,':',2);
  34.         sprintf((char *)TimeStr,"%02d",
  35.         (uint32_t)humidity);
  36.         OledShowString(104,3,(char *)TimeStr,2);
  37.         covUnixTimeStp2Beijing(timedata, &mData);
  38.         sprintf((char *)TimeStr,"%04d-%02d-%02d",
  39.         mData.ui8Year, mData.ui8Month, mData.ui8DayOfMonth);
  40.         OledShowString(24,0,(char *)TimeStr,1);
  41.         sprintf((char *)TimeStr,"%02d:%02d:%02d",
  42.         mData.ui8Hour,mData.ui8Minute,mData.ui8Second);
  43.         OledShowString(32,1,(char *)TimeStr,1);
  44. ​
  45.         if(Get_Status != Last_Get_Status)
  46.         {
  47.             Last_Get_Status = Get_Status;
  48.             switch ( Get_Status)
  49.             {
  50.             case GET_NORMAL:
  51.                 break;
  52.             case GET_PROPRESS:
  53.                 OledShowString(16,7,"Sync time...",1);
  54.                 break;
  55.             case GET_SUC:
  56.                 OledClearString(16,7,"Sync time...",1);
  57.                 OledShowString(16,7,"Sync Suc...",1);
  58.                 break;
  59.             case GET_FAIL:
  60.                 OledClearString(16,7,"Sync time...",1);
  61.                 OledShowString(16,7,"Sync fail...",1);
  62.                 break;
  63.             default:
  64.                 break;
  65.             }
  66.         }
  67. }
  68. ​
  69. static void DispWeather(uint8_t x, uint8_t y ,uint8_t code){
  70.         switch(code)
  71.         {
  72.             case 0:
  73.             case 1:
  74.             case 2:
  75.             case 3:
  76.                     OLED_ShowWeather(x,y,QINGLOGO);
  77.                     break;
  78.             case 4:
  79.             case 5:
  80.             case 6:
  81.             case 7:
  82.             case 8:
  83.                 OLED_ShowWeather(x,y,DUOYULOGO);
  84.                 break;
  85.             case 9:
  86.                
  87.             case 10:
  88.                 OLED_ShowWeather(x,y,YINGLOGO);
  89.                 break;
  90.             case 11:
  91.             case 12:
  92. ​
  93.                 OLED_ShowWeather(x,y,LEIYULOGO);
  94.                 break;
  95.             case 13:
  96.             case 14:
  97.             case 15:
  98.             case 16:
  99.             case 17:
  100.             case 18:
  101.             case 19:
  102.                 OLED_ShowWeather(x,y,YULOGO);
  103.                 break;
  104.             case 20:
  105.             case 21:
  106.             case 22:
  107.             case 23:
  108.             case 24:
  109.             case 25:
  110.                 OLED_ShowWeather(x,y,XUELOGO);
  111.                 break;
  112.             case 30:
  113.                 //OLED_ShowWeather(x,y,YULOGO);
  114.                 //break;
  115.             default:
  116.                 OLED_ShowWeather(x,y,QINGLOGO);
  117.             break;
  118.         }
  119. ​
  120. }
  121. ​
  122. extern weather weatherValue;
  123. static void  WeatherDisp(SCREEN_STATUS Screen){
  124.     switch (Screen)
  125.     {
  126.         case NOWSCREEN:
  127.             DispWeather(5, 1 ,weatherValue.nowcode);
  128.             OLED_ShowCHinese(56,0,9);//今
  129.             OLED_ShowCHinese(72,0,12);//天
  130.             sprintf((char *)DispStr,"%02d",
  131.             (uint32_t)weatherValue.nowtemp);
  132.             OledShowString(60,5,(char *)DispStr,2);
  133.             OLED_ShowCHinese(76,5,13);//天
  134.             sprintf((char *)DispStr,"%02d/%02d",
  135.             (uint32_t)weatherValue.low[Screen-1],(uint32_t)weatherValue.high[Screen-1]);
  136.             OledShowString(60,3,(char *)DispStr,2);
  137.             sprintf((char *)DispStr,"%d%%",
  138.             (uint32_t)weatherValue.humi[Screen-1]);
  139.             OledShowString(100,5,(char *)DispStr,2);
  140.             break;
  141.         case TOSCREEN:
  142.             DispWeather(5, 1 ,weatherValue.code[Screen-1]);
  143.             OLED_ShowCHinese(56,0,10);//明
  144.             OLED_ShowCHinese(72,0,12);//天
  145.             sprintf((char *)DispStr,"%02d/%02d",
  146.             (uint32_t)weatherValue.low[Screen-1],(uint32_t)weatherValue.high[Screen-1]);
  147.             OledShowString(60,3,(char *)DispStr,2);
  148.             sprintf((char *)DispStr,"%d%%",
  149.             (uint32_t)weatherValue.humi[Screen-1]);
  150.             OledShowString(70,5,(char *)DispStr,2);
  151.             break;
  152.         case ATOSCREEN:
  153.             DispWeather(5, 1 ,weatherValue.code[Screen-1]);
  154.             OLED_ShowCHinese(56,0,11);//后
  155.             OLED_ShowCHinese(72,0,12);//天
  156.             sprintf((char *)DispStr,"%02d/%02d",
  157.             (uint32_t)weatherValue.low[Screen-1],(uint32_t)weatherValue.high[Screen-1]);
  158.             OledShowString(60,3,(char *)DispStr,2);
  159.             sprintf((char *)DispStr,"%d%%",
  160.             (uint32_t)weatherValue.humi[Screen-1]);
  161.             OledShowString(70,5,(char *)DispStr,2);
  162.             break;
  163.         default:
  164.         break;   
  165.     }
  166.     if(Get_Status != Last_Get_Status)
  167.         {
  168.             Last_Get_Status = Get_Status;
  169.             switch ( Get_Status)
  170.             {
  171.             case GET_NORMAL:
  172.                 break;
  173.             case GET_PROPRESS:
  174.                 OledShowString(0,7,"Get Weather...",1);
  175.                 break;
  176.             case GET_SUC:
  177.                 OledClearString(0,7,"Get Weather...",1);
  178.                 OledShowString(0,7,"Get Suc...",1);
  179.                 i=0;
  180.                 break;
  181.             case GET_FAIL:
  182.                 OledClearString(0,7,"Get Weather...",1);
  183.                 OledShowString(0,7,"Get fail...",1);
  184.                 i=0;
  185.                 break;
  186.             default:
  187.                 break;
  188.             }
  189.         }
  190. }
  191. static void OledTask(void *arg)
  192. {
  193.     (void)arg;
  194.     GpioInit();
  195.     OledInit();
  196.     OledFillScreen(0x00);

  198.     while (1) {
  199.         if(Now_Screen != Last_Screen)
  200.         {
  201.             Last_Screen = Now_Screen;
  202.             OledFillScreen(0);
  203.             Get_Status = GET_NORMAL;
  204.             Last_Get_Status = GET_NORMAL;
  205.             i=0;
  206.         }
  207. ​
  208.         if((Get_Status == GET_FAIL) ||(Get_Status == GET_SUC))
  209.         {
  210.             i++;
  211.             if(i > 20)
  212.             {
  213.                 Get_Status = GET_NORMAL;
  214.                 i=0;
  215. ​
  216.                 switch(Now_Screen){
  217.                     case TIMESCREEN:
  218.                         OledClearString(16,7,"Sync time...",1);
  219.                         break;
  220.                     case NOWSCREEN:
  221.                         
  222.                     case TOSCREEN:
  223. ​
  224.                     case ATOSCREEN:
  225.                         printf("clear oled i = %dn",i);
  226.                         OledClearString(0,7,"Get Weather...",1);
  227.                         break;
  228.                     default :
  229.                     break;
  230. ​
  231.                 }        
  232.             }
  233.         }
  234. ​
  235.         switch (Now_Screen){
  236. ​
  237.             case TIMESCREEN:
  238.             TimeScreenDisp();
  239.             break;
  240. ​
  241.             case NOWSCREEN:
  242.             WeatherDisp(NOWSCREEN);
  243.             break;
  244. ​
  245.             case TOSCREEN:
  246.             WeatherDisp(TOSCREEN);
  247.             break;
  248. ​
  249.             case ATOSCREEN:
  250.             WeatherDisp(ATOSCREEN);
  251.             break;
  252. ​
  253.             default:
  254.             break;   
  255.         }      
  256.          usleep(100000);
  257.     }
  258. }


复制代码
4、加入rtc.c
现在时间调整是通过每一秒时间戳加1，再把时间戳转化为北京时间，到达时间的更新。为了减少任务中因为其他函数存在，增加时间误差，所以单独创建一个任务来进行时间戳的调整。
  1. #include <stdio.h>
  2. #include <unistd.h>
  3. #include <stdbool.h>
  4. ​
  5. #include "ohos_init.h"
  6. #include "cmsis_os2.h"
  7. uint32_t timedata=1608362368;
  8. ​
  9. static void RtcTask(void *arg)
  10. {
  11.     (void)arg;
  12.     while(1)
  13.     {
  14.         timedata++;
  15.         sleep(1);
  16.     }
  17. }
  18. ​
  19. static void RtcTaskHandle(void)
  20. {
  21.     osThreadAttr_t attr;
  22.     attr.name = "RtcTask";
  23.     attr.attr_bits = 0U;
  24.     attr.cb_mem = NULL;
  25.     attr.cb_size = 0U;
  26.     attr.stack_mem = NULL;
  27.     attr.stack_size = 512;
  28.     attr.priority = osPriorityNormal;
  29. ​
  30.     if (osThreadNew(RtcTask, NULL, &attr) == NULL) {
  31.         printf("[RtcTaskHandle] Falied to create KeyTask!n");
  32.     }
  33. }
  34. APP_FEATURE_INIT(RtcTaskHandle);
复制代码


5、修改BUILD.gn
修改OLED文件夹下的BUILD.gn文件，sources中加入keytask.c
  1.     sources = [
  2.         "oled_demo.c",
  3.         "oled_ssd1306.c",
  4.         "timeconv.c",
  5.         "envrionment_demo.c",
  6.         "aht20.c",
  7.         "wifi_connecter.c",
  8.         "getNTP.c",
  9.         "getweather.c",
  10.         "cjsonparse.c",
  11.         "keytask.c",
  12.         "rtc.c"
  13.     ]
复制代码
三、结果演示
按下右边按键，可以切换界面，有四个界面，分别为时间显示界面，今天、明天、后天天气显示界面。在时间显示界面按下左键，会获取实时时间，在天气显示界面，按下左键会获取实时天气，并且显示天气获取情况提示。
微信图片_20210105231135.jpg
微信图片_202101052311351.jpg
微信图片_202101052311352.jpg
微信图片_202101052311353.jpg
微信图片_202101052311354.jpg

四、总结
这一篇先写到这里，下一篇是关于通过一个公网的中转服务器，进行wifiiot和手机之间的远程数据传输。

举报

回帖

声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容图片侵权或者其他问题，请联系本站作侵删。 侵权投诉
链接复制成功，分享给好友