嵌入式Linux--项目--基于I.MX6ULL的智能家居体系（驱动开发、mqtt、qt、Jso ...

耶耶耶耶耶  论坛元老 | 2025-3-16 05:24:42 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 1639|帖子 1639|积分 4917

一、项目概述

学了俩月嵌入式Linux却感觉什么都不会做，看到韦东山老师的《嵌入式Linux应用开发实行班(快速入门)》课程做一个最简朴的产物：
① 在屏幕上点击图标控制 LED
② 在屏幕上显示温湿度的值
③ 使用OneNet物联网云平台远程控制这个产物
   花了5天做完项目，在此仅是个人学习记载、错误不少，请各位指正
  以这个功能为例，抛弃临时没必要穷究的知识，把产物做出来。然后在它的底子上扩展功能：该补什么知识就去补 ！！！
干中学！！！
干中学！！！
干中学！！！
   韦东山老师课程链接（后续课程收费，但腾讯云平台收费了，后续也没法跟着课程做了，这部分我查阅大佬的教程使用OneNet平台做的）：百问网韦东山嵌入式Linux应用开发入门实行班(快！做生产物！而不是学一堆知识点！！)哔哩哔哩bilibili
  1、硬件框架


2、软件框架


3、开发情况设置

开发情况：ubuntu18.04、Linux4.9.88、Qt5.12.9
使用100ask imx6ULLPro开发板；
使用rfs从ubuntu传输文件到单板；
毗连OneNet平台需要单板毗连到外网，这里使用的WIFI毗连，需要插上天线；
   详细设置流程参考韦东山老师文档《嵌入式Linux应用开发实行班(快速入门)》
  二、使用文件IO操纵

1、操纵LED


在 Linux 体系里，我们可以使用 2 种方法去操纵上面的 LED：
① 使用 GPIO SYSFS 体系：
这需要一定的硬件知识，需要设置引脚的方向、数值
IMX6ULL 使用的 GPIO5_3 引脚编号是 131，可以如下操纵：
写GPIO：
  1. echo 131 > /sys/class/gpio/export
  2. echo out > /sys/class/gpio/gpio131/direction
  3. echo 1 > /sys/class/gpio/gpio131/value
  4. echo 131 > /sys/class/gpio/unexport  
复制代码
读GPIO：
  1. echo 131 > /sys/class/gpio/export
  2. echo in > /sys/class/gpio/gpio131/direction
  3. cat /sys/class/gpio/gpio131/value
  4. echo 131 > /sys/class/gpio/unexport
复制代码
② 使用驱动程序：
无需硬件知识，使用 open/read/write 接口调用驱动即可
把驱动程序 led_drv.ko、 led_test 通过 ADB 上传到开发板，然后执行如下下令可以看到灯亮、灭：
移除QT程序，否则它占用LED引脚导致无法安装驱动
  1. mv /etc/init.d/S99myqt /root
  3. reboot
  4. 重启后执行如下命令
  5. insmod /root/led_drv.ko
  6. ls /dev/100ask_led
  8. /root/led_test 0 on
  9. /root/led_test 0 off
复制代码
最简朴的驱动程序：led_drc.c
  1. #include "asm-generic/errno-base.h"
  2. #include "asm-generic/gpio.h"
  3. #include "asm/uaccess.h"
  4. #include <linux/module.h>
  5. #include <linux/poll.h>
  7. #include <linux/fs.h>
  8. #include <linux/errno.h>
  9. #include <linux/miscdevice.h>
  10. #include <linux/kernel.h>
  11. #include <linux/major.h>
  12. #include <linux/mutex.h>
  13. #include <linux/proc_fs.h>
  14. #include <linux/seq_file.h>
  15. #include <linux/stat.h>
  16. #include <linux/init.h>
  17. #include <linux/device.h>
  18. #include <linux/tty.h>
  19. #include <linux/kmod.h>
  20. #include <linux/gfp.h>
  21. #include <linux/gpio/consumer.h>
  22. #include <linux/platform_device.h>
  23. #include <linux/of_gpio.h>
  24. #include <linux/of_irq.h>
  25. #include <linux/interrupt.h>
  26. #include <linux/irq.h>
  27. #include <linux/slab.h>
  28. #include <linux/fcntl.h>
  29. #include <linux/timer.h>
  31. struct gpio_desc{
  32.         int gpio;
  33.         int irq;
  34.     char *name;
  35.     int key;
  36.         struct timer_list key_timer;
  37. } ;
  39. static struct gpio_desc gpios[2] = {
  40.     {131, 0, "led0", },
  41.     //{132, 0, "led1", },
  42. };
  44. /* 主设备号                                                                 */
  45. static int major = 0;
  46. static struct class *gpio_class;
  49. /* 实现对应的open/read/write等函数，填入file_operations结构体                   */
  50. static ssize_t gpio_drv_read (struct file *file, char __user *buf, size_t size, loff_t *offset)
  51. {
  52.         char tmp_buf[2];
  53.         int err;
  54.     int count = sizeof(gpios)/sizeof(gpios[0]);
  56.         if (size != 2)
  57.                 return -EINVAL;
  59.         err = copy_from_user(tmp_buf, buf, 1);
  61.         if (tmp_buf[0] >= count)
  62.                 return -EINVAL;
  64.         tmp_buf[1] = gpio_get_value(gpios[tmp_buf[0]].gpio);
  66.         err = copy_to_user(buf, tmp_buf, 2);
  67.        
  68.         return 2;
  69. }
  71. static ssize_t gpio_drv_write(struct file *file, const char __user *buf, size_t size, loff_t *offset)
  72. {
  73.     unsigned char ker_buf[2];
  74.     int err;
  76.     if (size != 2)
  77.         return -EINVAL;
  79.     err = copy_from_user(ker_buf, buf, size);
  80.    
  81.     if (ker_buf[0] >= sizeof(gpios)/sizeof(gpios[0]))
  82.         return -EINVAL;
  84.     gpio_set_value(gpios[ker_buf[0]].gpio, ker_buf[1]);
  85.     return 2;   
  86. }
  90. /* 定义自己的file_operations结构体                                              */
  91. static struct file_operations gpio_key_drv = {
  92.         .owner         = THIS_MODULE,
  93.         .read    = gpio_drv_read,
  94.         .write   = gpio_drv_write,
  95. };
  98. /* 在入口函数 */
  99. static int __init gpio_drv_init(void)
  100. {
  101.     int err;
  102.     int i;
  103.     int count = sizeof(gpios)/sizeof(gpios[0]);
  104.    
  105.         printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
  106.        
  107.         for (i = 0; i < count; i++)
  108.         {               
  109.                 /* set pin as output */
  110.                 err = gpio_request(gpios[i].gpio, gpios[i].name);
  111.                 if (err < 0) {
  112.                         printk("can not request gpio %s %d\n", gpios[i].name, gpios[i].gpio);
  113.                         return -ENODEV;
  114.                 }
  115.                
  116.                 gpio_direction_output(gpios[i].gpio, 1);
  117.         }
  119.         /* 注册file_operations         */
  120.         major = register_chrdev(0, "100ask_led", &gpio_key_drv);  /* /dev/gpio_desc */
  122.         gpio_class = class_create(THIS_MODULE, "100ask_led_class");
  123.         if (IS_ERR(gpio_class)) {
  124.                 printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
  125.                 unregister_chrdev(major, "100ask_led_class");
  126.                 return PTR_ERR(gpio_class);
  127.         }
  129.         device_create(gpio_class, NULL, MKDEV(major, 0), NULL, "100ask_led"); /* /dev/100ask_gpio */
  130.        
  131.         return err;
  132. }
  134. /* 有入口函数就应该有出口函数：卸载驱动程序时，就会去调用这个出口函数
  135. */
  136. static void __exit gpio_drv_exit(void)
  137. {
  138.     int i;
  139.     int count = sizeof(gpios)/sizeof(gpios[0]);
  140.    
  141.         printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
  143.         device_destroy(gpio_class, MKDEV(major, 0));
  144.         class_destroy(gpio_class);
  145.         unregister_chrdev(major, "100ask_led");
  147.         for (i = 0; i < count; i++)
  148.         {
  149.                 gpio_free(gpios[i].gpio);               
  150.         }
  151. }
  154. /* 7. 其他完善：提供设备信息，自动创建设备节点                                     */
  156. module_init(gpio_drv_init);
  157. module_exit(gpio_drv_exit);
  159. MODULE_LICENSE("GPL");
复制代码
测试文件
  1. #include <stdlib.h>
  2. #include <sys/types.h>
  3. #include <sys/stat.h>
  4. #include <fcntl.h>
  5. #include <unistd.h>
  6. #include <stdio.h>
  7. #include <string.h>
  8. #include <poll.h>
  9. #include <signal.h>
  11. static int fd;
  14. //int led_on(int which);
  15. //int led_off(int which);
  16. //int led_status(int which);
  18. /*
  19. * ./led_test <0|1|2|..>  on
  20. * ./led_test <0|1|2|..>  off
  21. * ./led_test <0|1|2|..>
  22. */
  23. int main(int argc, char **argv)
  24. {
  25.         int ret;
  26.         char buf[2];
  28.         int i;
  29.        
  30.         /* 1. 判断参数 */
  31.         if (argc < 2)
  32.         {
  33.                 printf("Usage: %s <0|1|2|...> [on | off]\n", argv[0]);
  34.                 return -1;
  35.         }
  38.         /* 2. 打开文件 */
  39.         fd = open("/dev/100ask_led", O_RDWR);
  40.         if (fd == -1)
  41.         {
  42.                 printf("can not open file /dev/100ask_led\n");
  43.                 return -1;
  44.         }
  46.         if (argc == 3)
  47.         {
  48.                 /* write */
  49.                 buf[0] = strtol(argv[1], NULL, 0);
  51.                 if (strcmp(argv[2], "on") == 0)
  52.                         buf[1] = 0;
  53.                 else
  54.                         buf[1] = 1;
  55.                
  56.                 ret = write(fd, buf, 2);
  57.         }
  58.         else
  59.         {
  60.                 buf[0] = strtol(argv[1], NULL, 0);
  61.                 ret = read(fd, buf, 2);
  62.                 if (ret == 2)
  63.                 {
  64.                         printf("led %d status is %s\n", buf[0], buf[1] == 0 ? "on" : "off");
  65.                 }
  66.         }
  67.        
  68.         close(fd);
  69.        
  70.         return 0;
  71. }
复制代码
知识增补：
Linux 的 sysfs 文件体系用于管理和控制多种硬件装备和体系资源。sysfs 是一个虚拟文件体系，它将内核中的装备和驱动信息以文件的情势暴露给用户空间，允许用户通过文件操纵来设置和控制硬件；
优缺点对比
方法优点缺点sysfs简朴易用：不需要编写复杂的驱动代码，得当快速开发和调试。
无需编译内核：直接在用户空间操纵，无需修改内核代码服从较低：每次操纵都需要通过文件体系，服从不如直接操纵驱动。
功能有限：仅支持基本的 GPIO 操纵，无法实现复杂的硬件特性驱动高效：直接与硬件交互，服从更高。
功能强大：可以实现复杂的硬件特性（如定时触发、亮度控制等）。
体系集成：更得当嵌入式体系和需要高性能的场景开发复杂：需要编写内核驱动代码，开发难度较高。
需要编译内核：每次修改驱动都需要重新编译内核 2、操纵dht11

把驱动程序 dht11_drv.ko、 dht11_test 通过rfs上传到开发板，然后执行如下下令可以看到不停打印温湿度的值：
执行如下下令
  1. insmod /root/dht11_drv.ko
  2. ls /dev/mydht11 /root/dht11_test /dev/mydht11
复制代码

dht11_drv.c:
  1. #include "asm-generic/errno-base.h"
  2. #include "asm-generic/gpio.h"
  3. #include "linux/jiffies.h"
  4. #include <linux/module.h>
  5. #include <linux/poll.h>
  6. #include <linux/delay.h>
  7. #include <linux/fs.h>
  8. #include <linux/errno.h>
  9. #include <linux/miscdevice.h>
  10. #include <linux/kernel.h>
  11. #include <linux/major.h>
  12. #include <linux/mutex.h>
  13. #include <linux/proc_fs.h>
  14. #include <linux/seq_file.h>
  15. #include <linux/stat.h>
  16. #include <linux/init.h>
  17. #include <linux/device.h>
  18. #include <linux/tty.h>
  19. #include <linux/kmod.h>
  20. #include <linux/gfp.h>
  21. #include <linux/gpio/consumer.h>
  22. #include <linux/platform_device.h>
  23. #include <linux/of_gpio.h>
  24. #include <linux/of_irq.h>
  25. #include <linux/interrupt.h>
  26. #include <linux/irq.h>
  27. #include <linux/slab.h>
  28. #include <linux/fcntl.h>
  29. #include <linux/timer.h>
  31. struct gpio_desc{
  32.         int gpio;
  33.         int irq;
  34.     char *name;
  35.     int key;
  36.         struct timer_list key_timer;
  37. } ;
  39. static struct gpio_desc gpios[] = {
  40.     {115, 0, "dht11", },
  41. };
  43. /* 主设备号                                                                 */
  44. static int major = 0;
  45. static struct class *gpio_class;
  47. static u64 g_dht11_irq_time[84];
  48. static int g_dht11_irq_cnt = 0;
  50. /* 环形缓冲区 */
  51. #define BUF_LEN 128
  52. static char g_keys[BUF_LEN];
  53. static int r, w;
  55. struct fasync_struct *button_fasync;
  57. static irqreturn_t dht11_isr(int irq, void *dev_id);
  58. static void parse_dht11_datas(void);
  60. #define NEXT_POS(x) ((x+1) % BUF_LEN)
  62. static int is_key_buf_empty(void)
  63. {
  64.         return (r == w);
  65. }
  67. static int is_key_buf_full(void)
  68. {
  69.         return (r == NEXT_POS(w));
  70. }
  72. static void put_key(char key)
  73. {
  74.         if (!is_key_buf_full())
  75.         {
  76.                 g_keys[w] = key;
  77.                 w = NEXT_POS(w);
  78.         }
  79. }
  81. static char get_key(void)
  82. {
  83.         char key = 0;
  84.         if (!is_key_buf_empty())
  85.         {
  86.                 key = g_keys[r];
  87.                 r = NEXT_POS(r);
  88.         }
  89.         return key;
  90. }
  93. static DECLARE_WAIT_QUEUE_HEAD(gpio_wait);
  95. // static void key_timer_expire(struct timer_list *t)
  96. static void key_timer_expire(unsigned long data)
  97. {
  98.         // 解析数据, 放入环形buffer, 唤醒APP
  99.         parse_dht11_datas();
  100. }
  103. /* 实现对应的open/read/write等函数，填入file_operations结构体                   */
  104. static ssize_t dht11_read (struct file *file, char __user *buf, size_t size, loff_t *offset)
  105. {
  106.         int err;
  107.         char kern_buf[2];
  109.         if (size != 2)
  110.                 return -EINVAL;
  112.         g_dht11_irq_cnt = 0;
  114.         /* 1. 发送18ms的低脉冲 */
  115.         err = gpio_request(gpios[0].gpio, gpios[0].name);
  116.         gpio_direction_output(gpios[0].gpio, 0);
  117.         gpio_free(gpios[0].gpio);
  119.         mdelay(18);
  120.         gpio_direction_input(gpios[0].gpio);  /* 引脚变为输入方向, 由上拉电阻拉为1 */
  122.         /* 2. 注册中断 */
  123.         err = request_irq(gpios[0].irq, dht11_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, gpios[0].name, &gpios[0]);
  124.         mod_timer(&gpios[0].key_timer, jiffies + 20);       
  126.         /* 3. 休眠等待数据 */
  127.         wait_event_interruptible(gpio_wait, !is_key_buf_empty());
  129.         free_irq(gpios[0].irq, &gpios[0]);
  131.         //printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
  133.         /* 设置DHT11 GPIO引脚的初始状态: output 1 */
  134.         err = gpio_request(gpios[0].gpio, gpios[0].name);
  135.         if (err)
  136.         {
  137.                 printk("%s %s %d, gpio_request err\n", __FILE__, __FUNCTION__, __LINE__);
  138.         }
  139.         gpio_direction_output(gpios[0].gpio, 1);
  140.         gpio_free(gpios[0].gpio);
  143.         /* 4. copy_to_user */
  144.         kern_buf[0] = get_key();
  145.         kern_buf[1] = get_key();
  147.         printk("get val : 0x%x, 0x%x\n", kern_buf[0], kern_buf[1]);
  148.         if ((kern_buf[0] == (char)-1) && (kern_buf[1] == (char)-1))
  149.         {
  150.                 printk("get err val\n");
  151.                 return -EIO;
  152.         }
  154.         err = copy_to_user(buf, kern_buf, 2);
  155.        
  156.         return 2;
  157. }
  159. static int dht11_release (struct inode *inode, struct file *filp)
  160. {
  161.         return 0;
  162. }
  165. /* 定义自己的file_operations结构体                                              */
  166. static struct file_operations dht11_drv = {
  167.         .owner         = THIS_MODULE,
  168.         .read    = dht11_read,
  169.         .release = dht11_release,
  170. };
  172. static void parse_dht11_datas(void)
  173. {
  174.         int i;
  175.         u64 high_time;
  176.         unsigned char data = 0;
  177.         int bits = 0;
  178.         unsigned char datas[5];
  179.         int byte = 0;
  180.         unsigned char crc;
  182.         printk("g_dht11_irq_cnt = %d\n", g_dht11_irq_cnt);
  183.         /* 数据个数: 可能是81、82、83、84 */
  184.         if (g_dht11_irq_cnt < 81)
  185.         {
  186.                 /* 出错 */
  187.                 put_key(-1);
  188.                 put_key(-1);
  190.                 // 唤醒APP
  191.                 wake_up_interruptible(&gpio_wait);
  192.                 g_dht11_irq_cnt = 0;
  193.                 return;
  194.         }
  196.         // 解析数据
  197.         for (i = g_dht11_irq_cnt - 80; i < g_dht11_irq_cnt; i+=2)
  198.         {
  199.                 high_time = g_dht11_irq_time[i] - g_dht11_irq_time[i-1];
  201.                 data <<= 1;
  203.                 if (high_time > 50000) /* data 1 */
  204.                 {
  205.                         data |= 1;
  206.                 }
  208.                 bits++;
  210.                 if (bits == 8)
  211.                 {
  212.                         datas[byte] = data;
  213.                         data = 0;
  214.                         bits = 0;
  215.                         byte++;
  216.                 }
  217.         }
  219.         // 放入环形buffer
  220.         crc = datas[0] + datas[1] + datas[2] + datas[3];
  221.         if (crc == datas[4])
  222.         {
  223.                 put_key(datas[0]);
  224.                 put_key(datas[2]);
  225.         }
  226.         else
  227.         {
  228.                 printk("dht11 crc err\n");
  229.                 put_key(-1);
  230.                 put_key(-1);
  231.         }
  233.         g_dht11_irq_cnt = 0;
  234.         // 唤醒APP
  235.         wake_up_interruptible(&gpio_wait);
  236. }
  238. static irqreturn_t dht11_isr(int irq, void *dev_id)
  239. {
  240.         struct gpio_desc *gpio_desc = dev_id;
  241.         u64 time;
  242.        
  243.         /* 1. 记录中断发生的时间 */
  244.         time = ktime_get_ns();
  245.         g_dht11_irq_time[g_dht11_irq_cnt] = time;
  247.         /* 2. 累计次数 */
  248.         g_dht11_irq_cnt++;
  250.         /* 3. 次数足够: 解析数据, 放入环形buffer, 唤醒APP */
  251.         if (g_dht11_irq_cnt == 84)
  252.         {
  253.                 del_timer(&gpio_desc->key_timer);
  254.                 parse_dht11_datas();
  255.         }
  257.         return IRQ_HANDLED;
  258. }
  261. /* 在入口函数 */
  262. static int __init dht11_init(void)
  263. {
  264.     int err;
  265.     int i;
  266.     int count = sizeof(gpios)/sizeof(gpios[0]);
  267.    
  268.         printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
  269.        
  270.         for (i = 0; i < count; i++)
  271.         {               
  272.                 gpios[i].irq  = gpio_to_irq(gpios[i].gpio);
  274.                 /* 设置DHT11 GPIO引脚的初始状态: output 1 */
  275.                 err = gpio_request(gpios[i].gpio, gpios[i].name);
  276.                 gpio_direction_output(gpios[i].gpio, 1);
  277.                 gpio_free(gpios[i].gpio);
  279.                 setup_timer(&gpios[i].key_timer, key_timer_expire, (unsigned long)&gpios[i]);
  280.                  //timer_setup(&gpios[i].key_timer, key_timer_expire, 0);
  281.                 //gpios[i].key_timer.expires = ~0;
  282.                 //add_timer(&gpios[i].key_timer);
  283.                 //err = request_irq(gpios[i].irq, dht11_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "100ask_gpio_key", &gpios[i]);
  284.         }
  286.         /* 注册file_operations         */
  287.         major = register_chrdev(0, "100ask_dht11", &dht11_drv);  /* /dev/gpio_desc */
  289.         gpio_class = class_create(THIS_MODULE, "100ask_dht11_class");
  290.         if (IS_ERR(gpio_class)) {
  291.                 printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
  292.                 unregister_chrdev(major, "100ask_dht11");
  293.                 return PTR_ERR(gpio_class);
  294.         }
  296.         device_create(gpio_class, NULL, MKDEV(major, 0), NULL, "mydht11"); /* /dev/mydht11 */
  297.        
  298.         return err;
  299. }
  301. /* 有入口函数就应该有出口函数：卸载驱动程序时，就会去调用这个出口函数
  302. */
  303. static void __exit dht11_exit(void)
  304. {
  305.     int i;
  306.     int count = sizeof(gpios)/sizeof(gpios[0]);
  307.    
  308.         printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
  310.         device_destroy(gpio_class, MKDEV(major, 0));
  311.         class_destroy(gpio_class);
  312.         unregister_chrdev(major, "100ask_dht11");
  314.         for (i = 0; i < count; i++)
  315.         {
  316.                 //free_irq(gpios[i].irq, &gpios[i]);
  317.                 //del_timer(&gpios[i].key_timer);
  318.         }
  319. }
  322. /* 7. 其他完善：提供设备信息，自动创建设备节点                                     */
  324. module_init(dht11_init);
  325. module_exit(dht11_exit);
  327. MODULE_LICENSE("GPL");
复制代码
dht11_test.c
  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <unistd.h>
  5. #include <stdio.h>
  6. #include <string.h>
  7. #include <poll.h>
  8. #include <signal.h>
  10. static int fd;
  12. /*
  13. * ./button_test /dev/mydht11
  14. *
  15. */
  16. int main(int argc, char **argv)
  17. {
  18.         char buf[2];
  19.         int ret;
  21.         int i;
  22.        
  23.         /* 1. 判断参数 */
  24.         if (argc != 2)
  25.         {
  26.                 printf("Usage: %s <dev>\n", argv[0]);
  27.                 return -1;
  28.         }
  30.         /* 2. 打开文件 */
  31.         fd = open(argv[1], O_RDWR | O_NONBLOCK);
  32.         if (fd == -1)
  33.         {
  34.                 printf("can not open file %s\n", argv[1]);
  35.                 return -1;
  36.         }
  38.         while (1)
  39.         {
  40.                 if (read(fd, buf, 2) == 2)
  41.                 {
  42.                         printf("get Humidity: %d, Temperature : %d\n", buf[0], buf[1]);
  43.                         sleep(1);
  44.                 }
  45.         }
  47.         //sleep(30);
  49.         close(fd);
  50.        
  51.         return 0;
  52. }
复制代码
三、使用JsonRPC实现前后台分离

对于比较复杂的程序，前台界面显示、后台程序由不同的团队进行开发，两边定义好交互的接口即可。这样，前台、后台程序可以分别独立开发，降低相互之间的依赖。好比：
① 当更改硬件，好比更换LED引脚时，前台程序无需改变，只需要修改后台程序
② 想调整界面时，只需要修改前台程序，无需修改后台程序
前台程序、后台程序分别属于不同的“进程”，它们之间的交互需要通过“进程间通讯”来实现，好比：网络通讯、管道、共享内存等等。
本课程使用基于网络通讯的“JsonRPC远程调用”来实现前后台程序的交互：

   详细内容见详细设置流程参考韦东山老师文档《嵌入式Linux应用开发实行班(快速入门)》，这里只做知识性总结归纳
  知识增补：
1、RPC先容

RPC（远程过程调用）是一种用于实现分布式体系中不同进程或不同计算机之间通讯的技能。RPC 的焦点思想是允许我们像调用当地函数一样调用远程计算机上的函数，使得分布式体系的开发变得更加简朴和高效。
JsonRPC是一种基于JSON（JavaScript Object Notation）的轻量级远程过程调用协议。与其他RPC协议相比，JsonRPC使用简朴的文本格式进行通讯，易于阅读和编写，广泛应用于Web服务和分布式体系中。除了JsonRPC，另有其他一些常见的RPC协议，例如：


  • XML-RPC：使用XML作为通讯格式的RPC协议。
  • SOAP：基于XML的通讯协议，支持多种传输协议。
  • gRPC：由Google开发的高性能、开源的RPC框架，支持多种编程语言和传输协议。
JsonRPC协议定义了一种简朴的哀求-相应模子，通讯两边通过发送和接收JSON格式的消息进行交互。
2、JSON格式

JSON（JavaScript Object Notation， JavaScript 对象表示法）是基于 ECMAScript 的一个子集设计的，是一种开放尺度的文件格式和数据互换格式，它易于人阅读和编写，同时也易于呆板解析和生成。 JSON 独立于语言设计，很多编程语言都支持 JSON 格式的数据互换。 JSON 是一种常用的数据格式，在电子数据互换中有多种用途，包罗与服务器之间的Web 应用程序的数据互换。其简洁和清晰的条理结构有效地提升了网络传输服从，使其成为理想的数据互换语言。其文件通常使用扩展名.json 。
  1. 例子：
  2. JSON解析："{"method": "add", "params": [2,4], "id": "2" }"
  3. 或者
  4. {
  5.     "title":"JSON Example",
  6.     "author": {
  7.         "name":"John Doe",
  8.         "age": 35,
  9.         "isVerified":true
  10.     },
  11.     "tags":["json", "syntax", "example"],
  12.     "rating": 4.5,
  13.     "isPublished":false,
  14.     "comments": null
  15. }
复制代码
3、JsonRPC哀求相应示例

哀求示例
一个JsonRPC哀求由以下几个部分构成：
  1. {
  2.   "jsonrpc": "2.0",
  3.   "method": "methodName",
  4.   "params": [param1, param2, ...],
  5.   "id": 1
  6. }
复制代码


  • jsonrpc：指定JsonRPC版本，通常为"2.0"。
  • method：指定要调用的远程方法名。
  • params：包罗要传递给远程方法的参数列表。
  • id：哀求的唯一标识符，用于将哀求和相应进行匹配。
相应示例
一个JsonRPC相应由以下几个部分构成：
  1. {
  2.   "jsonrpc": "2.0",
  3.   "result": "resultValue",
  4.   "error": {
  5.    "code": 100, "message": "errorMessage"},
  6.   "id": 1
  7. }
复制代码


  • jsonrpc：指定JsonRPC版本，通常为"2.0"。
  • result：包罗远程方法调用的效果值。
  • error：包罗错误信息，如果哀求执行过程中发生错误。
  • id：与哀求中的标识符相匹配，用于将相应与哀求进行匹配。
成功和失败相应示例
成功的JsonRPC相应示例：
  1. {
  2.   "jsonrpc": "2.0",
  3.   "result": "Hello, world!",
  4.   "id": 1
  5. }
复制代码
失败的JsonRPC相应示例：
  1. {
  2.   "jsonrpc": "2.0",
  3.   "error": {
  4.       "code": -32601,
  5.       "message": "Method not found"},
  6.   "id": 1
  7. }
复制代码
参数的数据类型
JsonRPC支持以下基本数据类型作为参数和效果值：


  • 字符串（String）
  • 数字（Number）
  • 布尔值（Boolean）
  • 数组（Array）
  • 对象（Object）
  • 空值（Null）
当参数或者返回效果中包罗字节数组的时候需要注意，由于JSON是一种文本格式，以是在序列化和反序列化字节数组时，会将其转换为Base64编码的字符串。这种转换会增加数据存储的巨细和处理时间。因此，对于大型字节数组，传递原始二进制数据的方式大概会更高效，而不是通过JSON进行编码和解码。在这种情况下，其他二进制传输协议（如gRPC或自定义的二进制协议）大概更得当处理字节数组的传递。
4、 基于JsonRPC分离前后端

cJSON 是由 Dave Gamble 创建的开源 JSON 处理库，实用于需要轻量级 JSON 解析和生成的场景。这里我们使用开源的cJOSN，需要编译 libev 库、编译 jsonrpc 库 ，而且将其添加到交错编译链 。
这里主要讲后端服务器操纵硬件，通过JsonRPC通讯，向前端qtAPP提供服务（控制LED、读取温湿度的值）。

rpc_server.c:
  1. #include <jsonrpc-c.h>
  2. #include <sys/types.h>
  3. #include <sys/stat.h>
  4. #include <fcntl.h>
  5. #include <sys/socket.h>
  6. #include <string.h>
  7. #include <netinet/in.h>
  8. #include <arpa/inet.h>
  9. #include <unistd.h>
  10. #include <stdio.h>
  11. #include <errno.h>
  12. #include <stdlib.h>
  13. #include "rpc.h"
  14. #include "led.h"
  15. #include "dht11.h"
  17. static struct jrpc_server my_server;
  19. /* 参数: {"params" : [0|1]} */
  20. cJSON * server_led_control(jrpc_context * ctx, cJSON * params, cJSON *id) {
  21.     cJSON * status = cJSON_GetArrayItem(params,0);
  22.     led_control(status->valueint);       
  23.     return cJSON_CreateNumber(0);
  24. }
  26. /* 参数: {"params" : null} */
  27. cJSON * server_dht11_read(jrpc_context * ctx, cJSON * params, cJSON *id) {
  28.     int array[2];
  30.     array[0] = array[1] = 0;
  31.     while (0 != dht11_read((char *)&array[0], (char *)&array[1]));
  33.     return cJSON_CreateIntArray(array, 2);
  34. }
  36. int RPC_Server_Init(void)
  37. {
  38.     int err;
  39.    
  40.     err = jrpc_server_init(&my_server, PORT);
  41.     if (err)
  42.     {
  43.         printf("jrpc_server_init err : %d\n", err);
  44.     }
  45.    
  46.     jrpc_register_procedure(&my_server, server_led_control, "led_control", NULL );
  47.     jrpc_register_procedure(&my_server, server_dht11_read, "dht11_read", NULL );
  49.     jrpc_server_run(&my_server);
  50.     jrpc_server_destroy(&my_server);
  52.     return 0;
  53. }
  55. int main(int argc, char **argv)
  56. {
  57.     //初始化硬件（open设备节点）
  58.     led_init();
  59.     dht11_init();
  60.     //启动服务端
  61.     RPC_Server_Init();   
  62.     return 0;
  63. }
复制代码
前端qt客户端调用：rpc_client.cpp
  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <sys/socket.h>
  5. #include <string.h>
  6. #include <netinet/in.h>
  7. #include <arpa/inet.h>
  8. #include <unistd.h>
  9. #include <stdio.h>
  10. #include <errno.h>
  11. #include <stdlib.h>
  12. #include "cJSON.h"
  13. #include "rpc.h"
  15. static int g_iSocketClient;
  17. //发送消息以使用客户端的“led_control”
  18. int rpc_led_control(int on)
  19. {
  20.     char buf[100];
  21.     int iLen;
  22.     int ret = -1;
  24.     int iSocketClient = g_iSocketClient;
  26.     sprintf(buf, "{"method": "led_control", "params": [%d], "id": "2" }", on);
  27.     iLen = send(iSocketClient, buf, strlen(buf), 0);
  28.     if (iLen ==  strlen(buf))
  29.     {
  30.         while (1)
  31.         {
  32.             iLen = read(iSocketClient, buf, sizeof(buf));
  33.             buf[iLen] = 0;
  34.             if (iLen == 1 && (buf[0] == '\r' || buf[0] == '\n'))
  35.                 continue;
  36.             else
  37.                 break;
  38.         }
  40.         if (iLen > 0)
  41.         {
  42.             cJSON *root = cJSON_Parse(buf);
  43.             cJSON *result = cJSON_GetObjectItem(root, "result");
  44.             ret = result->valueint;
  45.             cJSON_Delete(root);
  46.             return ret;
  47.         }
  48.         else
  49.         {
  50.             printf("read rpc reply err : %d\n", iLen);
  51.             return -1;
  52.         }
  53.     }
  54.     else
  55.     {
  56.         printf("send rpc request err : %d, %s\n", iLen, strerror(errno));
  57.         return -1;
  58.     }
  59. }
  61. //发送消息以使用客户端的“dht11_read”
  62. int rpc_dht11_read(char *humi, char *temp)
  63. {
  64.     char buf[300];
  65.     int iLen;
  67.     int iSocketClient = g_iSocketClient;
  69.     sprintf(buf, "{"method": "dht11_read"," \
  70.                    ""params": [0], "id": "2" }");
  72.     iLen = send(iSocketClient, buf, strlen(buf), 0);
  73.     if (iLen ==  strlen(buf))
  74.     {
  75.         while (1)
  76.         {
  77.             iLen = read(iSocketClient, buf, sizeof(buf));
  78.             buf[iLen] = 0;
  79.             if (iLen == 1 && (buf[0] == '\r' || buf[0] == '\n'))
  80.                 continue;
  81.             else
  82.                 break;
  83.         }
  85.         if (iLen > 0)
  86.         {
  87.             cJSON *root = cJSON_Parse(buf);
  88.             cJSON *result = cJSON_GetObjectItem(root, "result");
  89.             if (result)
  90.             {
  91.                 cJSON * a = cJSON_GetArrayItem(result,0);
  92.                 cJSON * b = cJSON_GetArrayItem(result,1);
  94.                 *humi = a->valueint;
  95.                 *temp = b->valueint;
  97.                 cJSON_Delete(root);
  98.                 return 0;
  99.             }
  100.             else
  101.             {
  102.                 cJSON_Delete(root);
  103.                 return -1;
  104.             }
  105.         }
  106.         else
  107.         {
  108.             printf("read rpc reply err : %d\n", iLen);
  109.             return -1;
  110.         }
  111.     }
  112.     else
  113.     {
  114.         printf("send rpc request err : %d, %s\n", iLen, strerror(errno));
  115.         return -1;
  116.     }
  117. }
  119. /* 连接RPC Server
  120. * 返回值: (>0)socket, (-1)失败
  121. */
  122. int RPC_Client_Init(void)
  123. {
  124.     int iSocketClient;
  125.     struct sockaddr_in tSocketServerAddr;
  126.     int iRet;
  128.     iSocketClient = socket(AF_INET, SOCK_STREAM, 0);
  130.     tSocketServerAddr.sin_family      = AF_INET;
  131.     tSocketServerAddr.sin_port        = htons(PORT);
  132.     inet_aton("127.0.0.1", &tSocketServerAddr.sin_addr);
  133.     memset(tSocketServerAddr.sin_zero, 0, 8);
  136.     iRet = connect(iSocketClient, (const struct sockaddr *)&tSocketServerAddr, sizeof(struct sockaddr));
  137.     if (-1 == iRet)
  138.     {
  139.         printf("connect error!\n");
  140.         return -1;
  141.     }
  143.     g_iSocketClient = iSocketClient;
  144.     return iSocketClient;
  145. }
复制代码
四、使用MQTT协议毗连OneNet实现远程控制

   这部分参考：【嵌入式linux开发】智能家居入门6：最新ONENET，物联网开放平台（QT、微信小程序、MQTT协议、ONENET云平台、旭日x3派）_onenet云端-CSDN博客
  ONENET云平台创建产物与装备参考下方视频：
   https://player.youku.com/embed/XNjQxNTE0OTAyNA==
  需要注意的点：
①数据协议：这里选择的是OneJson，当然也可以选择数据流，但是它们对应的发送数据和接收数据的topic是不一样的，以是如果想省事直接使用本文代码，那就选择OneJson。

②新版三元组：
按照视频创建完毕后，进入装备管理的详情中，可以看到后续会用到的三个参数：

1、测试前的准备

①token：
产物与装备创建完成之后，按照文档指示，需要计算token，在毗连时会用到：

这里的clienid和username就是前面截图中包罗的两个参数：装备名称、产物ID，这里的password就是使用官方软件计算生成的token。接下来视频演示如何计算token：
重点如下：

纠错：上图中的时间过小，在后面多加任意一个数字既可：2810295937232。
②OneJson数据协议对应的发布、订阅topic：
文档中有明确给出OneJson数据协议（物模子）的发布和订阅topic，如果数据协议选择数据流的小伙伴，在文档的这个界面今后翻翻就可以看到对应的。

在连上服务器之后，对这两个topic操纵就可以上传和接收数据啦！
2、测试

下载客户端软件，提取码：q1a1，这是DS小龙哥开源的，填入自己的信息：

①数据上传测试：
点击登录即可毗连上服务器，然后点击发布主题就可以把数据发布到特定的物模子中，可以在onenet云平台中观察是否成功：

②数据下发测试：
onenet中进入装备调试界面，将fan_ctl设置为true，然后点击属性渴望值设置。客户端软件同样毗连服务器之后，点击订阅主题，观察是否收到服务器下发的消息：


这样双向测试就算完成了，接下来就是下位机与上位机的代码简介。
使用的库函数代码，代码放在工程中，后续调用里面的函数实现mqtt通讯：

五、QT APP编写

使用QtCreater工具简朴设计UI，重点是Qt的信号与槽函数的设计！！！
学到这里，可以去增补一下从c过渡到c++的基本语法，以及C++面向对象设计语法；
参考教程：
   【正点原子】嵌入式Qt5 C++开发视频_哔哩哔哩_bilibili
  C语言 转 C++ 简朴教程_哔哩哔哩_bilibili
  

1、代码

mainwindow.h
  1. #include "mainwindow.h"
  2. #include "ui_mainwindow.h"
  3. #include <QDebug>
  4. #include "rpc_client.h"
  5. #include "mqtt.h"
  6. #include "dht11_thread.h"
  8. MainWindow::MainWindow(QWidget *parent)
  9.     : QMainWindow(parent)
  10.     , ui(new Ui::MainWindow)
  11. {
  12.     ui->setupUi(this);
  14.     labelHumi = this->findChild<QLabel*>("label_4");//湿度
  15.     labelTemp = this->findChild<QLabel*>("label_3");//温度
  17.     //温湿度线程
  18.     // 创建线程对象并连接信号槽
  20. //    connect(dhtThread, SIGNAL(updateData(char,char)),this,SLOT(onUpdateData(char,char)));
  22.     /****************************** 连接服务器 ******************************************/
  23.     mqttClient = new MQTT_WorkClass();
  24.     // 设置MQTT服务器的地址和其他参数
  25.     mqttClient->Set_MQTT_Addr(serverIp, serverPort, clientId, username, password);
  26.     // 连接到MQTT服务器
  27.     mqttClient->run();
  29.     /******************************* 订阅主题 *******************************************/
  30.     mqttClient->slot_SubscribeTopic(topicToSubscribe);
  32.     /****************************** 信号与槽连接 *****************************************/
  33.     //断线重连槽函数
  34.     connect(mqttClient,SIGNAL(MQTT_ConnectState(bool)),this,SLOT(reconnect(bool)));
  35.     //接收到服务器下发数据的重写槽函数
  36.     connect(mqttClient,SIGNAL(ReceiveWechatData(QByteArray)),this,SLOT(receiveWechatData(QByteArray)));
  37. }
  39. /************************************槽函数**********************************************/
  40. //上报温湿度
  41. void MainWindow::onUpdateData(char humidity, char temperature)
  42. {
  43.     qDebug() << "Humidity:" << humidity << "Temperature:" << temperature<<endl;
  45.     labelHumi->setText(QString("%1%").arg((int)humidity));
  46.     labelTemp->setText(QString("%1°C").arg((int)temperature));
  48.     /**** 发布消息到主题 ****/
  49.     QMap<QString, double> dataMap;
  50.     dataMap["temp"] = (double)temperature; // 温度
  51.     dataMap["humi"] = (double)humidity;    //湿度
  53.     // 调用函数创建JSON对象
  54.     QJsonObject rootObject = createJsonObj(dataMap);
  55.     //将QJsonObject转换为QString
  56.     QString jsonString = convertObjectToJsonString(rootObject);
  57.     mqttClient->slot_PublishData(topicToPublish, jsonString);
  58.     qDebug() << "数据上传成功" << endl;
  59. }
  62. //断线重连槽函数
  63. void MainWindow::reconnect(bool)
  64. {
  65.     mqttClient = new MQTT_WorkClass();
  66.     // 设置MQTT服务器的地址和其他参数
  67.     mqttClient->Set_MQTT_Addr(serverIp, serverPort, clientId, username, password);
  68.     // 连接到MQTT服务器
  69.     mqttClient->run();
  71.     // 订阅主题
  72.     mqttClient->slot_SubscribeTopic(topicToSubscribe);
  73. }
  75. //解析服务器下发数据，槽函数
  76. void MainWindow::receiveWechatData(QByteArray data)
  77. {
  78.     //qDebug()<<"读取服务器发过来的数据:"<< data;
  79.     // 找到JSON对象的起始位置（第一个'{'符号）
  80.     int startPos = data.indexOf('{');
  81.     if (startPos != -1) {
  82.         // 删除起始位置之前的所有字符
  83.         data = data.mid(startPos);
  84.     } else {
  85.         qDebug() << "未找到JSON对象的起始位置";
  86.         //return -1; // 如果找不到起始位置，返回错误代码
  87.     }
  88.     parseJsonAndAction(data);
  89. }
  92. //将QJsonObject转换为QString，函数
  93. QString MainWindow::convertObjectToJsonString(const QJsonObject& object) {
  94.     // 将QJsonObject转换为QJsonDocument
  95.     QJsonDocument jsonDoc(object);
  97.     // 将QJsonDocument转换为QString，使用Compact模式
  98.     return jsonDoc.toJson(QJsonDocument::Compact);
  99. }
  101. //组织上传数据，函数
  102. QJsonObject MainWindow::createJsonObj(const QMap<QString, double>& dataMap) {
  103.     QJsonObject rootObject;
  105.     // 设置id字段
  106.     rootObject["id"] = "123";
  108.     // 创建params对象
  109.     QJsonObject paramsObject;
  111.     // 遍历数据映射，添加每个数据字段
  112.     for (auto it = dataMap.constBegin(); it != dataMap.constEnd(); ++it) {
  113.         QJsonObject valueObj;
  114.         valueObj["value"] = it.value(); // 设置数值
  115.         paramsObject[it.key()] = valueObj; // 添加到params对象
  116.     }
  118.     // 将params对象添加到rootObject
  119.     rootObject["params"] = paramsObject;
  121.     return rootObject;
  122. }
  124. //解析服务器下发指令并动作函数
  125. void MainWindow::parseJsonAndAction(const QByteArray& jsonData) {
  126.     // 将QByteArray转换为QJsonDocument
  127.     QJsonDocument jsonDoc = QJsonDocument::fromJson(jsonData);
  128.     if (jsonDoc.isNull()) {
  129.         qDebug() << "JSON解析失败";
  130.         return;
  131.     }
  133.     // 确保这是一个对象
  134.     if (!jsonDoc.isObject()) {
  135.         qDebug() << "JSON不是一个对象";
  136.         return;
  137.     }
  139.     // 获取JSON对象
  140.     QJsonObject jsonObject = jsonDoc.object();
  142.     // 进入params对象
  143.     if (jsonObject.contains("params"))
  144.     {
  145.         QJsonObject paramsObject = jsonObject["params"].toObject();
  146.         QDateTime currentDateTime = QDateTime::currentDateTime();
  147.         // 格式化日期时间为字符串，例如："2024-08-16 18:32:10"
  148.         QString dateTimeStr = currentDateTime.toString("yyyy-MM-dd HH:mm:ss");
  150.         // 提取led_ctl的值
  151.         if (paramsObject.contains("led_ctl"))
  152.         {
  153.             bool ledCtlValue = paramsObject["led_ctl"].toBool();
  154.             qDebug() << "led_ctl的值:" << ledCtlValue;
  155.             if(ledCtlValue == 0)
  156.             {
  157.                 QString message = dateTimeStr + " - 手机控制关闭客厅灯";
  158.                 ui->textBrowser->append(message);
  159.                 ui->radioButton->setText("客厅灯|离线");
  160.                 ui->radioButton->setChecked(0);
  162.                 rpc_led_control(0);
  164.             }
  165.             else if(ledCtlValue == 1)
  166.             {
  167.                 QString message = dateTimeStr + " - 手机控制打开客厅灯";
  168.                 ui->textBrowser->append(message);
  169.                 ui->radioButton->setText("客厅灯|在线");
  170.                 ui->radioButton->setChecked(1);
  172.                 rpc_led_control(1);
  173.             }
  174.         } else
  175.         {
  176.             qDebug() << "params中不包含led_ctl";
  177.         }
  178.     }
  179.     else
  180.     {
  181.         qDebug() << "JSON对象中不包含params";
  182.     }
  183. }
  187. MainWindow::~MainWindow()
  188. {
  189.     delete ui;
  190. }
  193. void MainWindow::on_pushButton_clicked()
  194. {
  195.     static int status = 1;
  197.     if (status)
  198.         qDebug()<<"LED clicked on";
  200.     else
  201.         qDebug()<<"LED clicked off";
  204.     rpc_led_control(status);
  205.     status = !status;
  206. }
复制代码
mainwindow.cpp
  1. #include "mainwindow.h"
  2. #include "ui_mainwindow.h"
  3. #include <QDebug>
  4. #include "rpc_client.h"
  5. #include "mqtt.h"
  6. #include "dht11_thread.h"
  8. MainWindow::MainWindow(QWidget *parent)
  9.     : QMainWindow(parent)
  10.     , ui(new Ui::MainWindow)
  11. {
  12.     ui->setupUi(this);
  14.     labelHumi = this->findChild<QLabel*>("label_4");//湿度
  15.     labelTemp = this->findChild<QLabel*>("label_3");//温度
  17.     //温湿度线程
  18.     // 创建线程对象并连接信号槽
  20. //    connect(dhtThread, SIGNAL(updateData(char,char)),this,SLOT(onUpdateData(char,char)));
  22.     /****************************** 连接服务器 ******************************************/
  23.     mqttClient = new MQTT_WorkClass();
  24.     // 设置MQTT服务器的地址和其他参数
  25.     mqttClient->Set_MQTT_Addr(serverIp, serverPort, clientId, username, password);
  26.     // 连接到MQTT服务器
  27.     mqttClient->run();
  29.     /******************************* 订阅主题 *******************************************/
  30.     mqttClient->slot_SubscribeTopic(topicToSubscribe);
  32.     /****************************** 信号与槽连接 *****************************************/
  33.     //断线重连槽函数
  34.     connect(mqttClient,SIGNAL(MQTT_ConnectState(bool)),this,SLOT(reconnect(bool)));
  35.     //接收到服务器下发数据的重写槽函数
  36.     connect(mqttClient,SIGNAL(ReceiveWechatData(QByteArray)),this,SLOT(receiveWechatData(QByteArray)));
  37. }
  39. /************************************槽函数**********************************************/
  40. //上报温湿度
  41. void MainWindow::onUpdateData(char humidity, char temperature)
  42. {
  43.     qDebug() << "Humidity:" << humidity << "Temperature:" << temperature<<endl;
  45.     labelHumi->setText(QString("%1%").arg((int)humidity));
  46.     labelTemp->setText(QString("%1°C").arg((int)temperature));
  48.     /**** 发布消息到主题 ****/
  49.     QMap<QString, double> dataMap;
  50.     dataMap["temp"] = (double)temperature; // 温度
  51.     dataMap["humi"] = (double)humidity;    //湿度
  53.     // 调用函数创建JSON对象
  54.     QJsonObject rootObject = createJsonObj(dataMap);
  55.     //将QJsonObject转换为QString
  56.     QString jsonString = convertObjectToJsonString(rootObject);
  57.     mqttClient->slot_PublishData(topicToPublish, jsonString);
  58.     qDebug() << "数据上传成功" << endl;
  59. }
  62. //断线重连槽函数
  63. void MainWindow::reconnect(bool)
  64. {
  65.     mqttClient = new MQTT_WorkClass();
  66.     // 设置MQTT服务器的地址和其他参数
  67.     mqttClient->Set_MQTT_Addr(serverIp, serverPort, clientId, username, password);
  68.     // 连接到MQTT服务器
  69.     mqttClient->run();
  71.     // 订阅主题
  72.     mqttClient->slot_SubscribeTopic(topicToSubscribe);
  73. }
  75. //解析服务器下发数据，槽函数
  76. void MainWindow::receiveWechatData(QByteArray data)
  77. {
  78.     //qDebug()<<"读取服务器发过来的数据:"<< data;
  79.     // 找到JSON对象的起始位置（第一个'{'符号）
  80.     int startPos = data.indexOf('{');
  81.     if (startPos != -1) {
  82.         // 删除起始位置之前的所有字符
  83.         data = data.mid(startPos);
  84.     } else {
  85.         qDebug() << "未找到JSON对象的起始位置";
  86.         //return -1; // 如果找不到起始位置，返回错误代码
  87.     }
  88.     parseJsonAndAction(data);
  89. }
  92. //将QJsonObject转换为QString，函数
  93. QString MainWindow::convertObjectToJsonString(const QJsonObject& object) {
  94.     // 将QJsonObject转换为QJsonDocument
  95.     QJsonDocument jsonDoc(object);
  97.     // 将QJsonDocument转换为QString，使用Compact模式
  98.     return jsonDoc.toJson(QJsonDocument::Compact);
  99. }
  101. //组织上传数据，函数
  102. QJsonObject MainWindow::createJsonObj(const QMap<QString, double>& dataMap) {
  103.     QJsonObject rootObject;
  105.     // 设置id字段
  106.     rootObject["id"] = "123";
  108.     // 创建params对象
  109.     QJsonObject paramsObject;
  111.     // 遍历数据映射，添加每个数据字段
  112.     for (auto it = dataMap.constBegin(); it != dataMap.constEnd(); ++it) {
  113.         QJsonObject valueObj;
  114.         valueObj["value"] = it.value(); // 设置数值
  115.         paramsObject[it.key()] = valueObj; // 添加到params对象
  116.     }
  118.     // 将params对象添加到rootObject
  119.     rootObject["params"] = paramsObject;
  121.     return rootObject;
  122. }
  124. //解析服务器下发指令并动作函数
  125. void MainWindow::parseJsonAndAction(const QByteArray& jsonData) {
  126.     // 将QByteArray转换为QJsonDocument
  127.     QJsonDocument jsonDoc = QJsonDocument::fromJson(jsonData);
  128.     if (jsonDoc.isNull()) {
  129.         qDebug() << "JSON解析失败";
  130.         return;
  131.     }
  133.     // 确保这是一个对象
  134.     if (!jsonDoc.isObject()) {
  135.         qDebug() << "JSON不是一个对象";
  136.         return;
  137.     }
  139.     // 获取JSON对象
  140.     QJsonObject jsonObject = jsonDoc.object();
  142.     // 进入params对象
  143.     if (jsonObject.contains("params"))
  144.     {
  145.         QJsonObject paramsObject = jsonObject["params"].toObject();
  146.         QDateTime currentDateTime = QDateTime::currentDateTime();
  147.         // 格式化日期时间为字符串，例如："2024-08-16 18:32:10"
  148.         QString dateTimeStr = currentDateTime.toString("yyyy-MM-dd HH:mm:ss");
  150.         // 提取led_ctl的值
  151.         if (paramsObject.contains("led_ctl"))
  152.         {
  153.             bool ledCtlValue = paramsObject["led_ctl"].toBool();
  154.             qDebug() << "led_ctl的值:" << ledCtlValue;
  155.             if(ledCtlValue == 0)
  156.             {
  157.                 QString message = dateTimeStr + " - 手机控制关闭客厅灯";
  158.                 ui->textBrowser->append(message);
  159.                 ui->radioButton->setText("客厅灯|离线");
  160.                 ui->radioButton->setChecked(0);
  162.                 rpc_led_control(0);
  164.             }
  165.             else if(ledCtlValue == 1)
  166.             {
  167.                 QString message = dateTimeStr + " - 手机控制打开客厅灯";
  168.                 ui->textBrowser->append(message);
  169.                 ui->radioButton->setText("客厅灯|在线");
  170.                 ui->radioButton->setChecked(1);
  172.                 rpc_led_control(1);
  173.             }
  174.         } else
  175.         {
  176.             qDebug() << "params中不包含led_ctl";
  177.         }
  178.     }
  179.     else
  180.     {
  181.         qDebug() << "JSON对象中不包含params";
  182.     }
  183. }
  187. MainWindow::~MainWindow()
  188. {
  189.     delete ui;
  190. }
  193. void MainWindow::on_pushButton_clicked()
  194. {
  195.     static int status = 1;
  197.     if (status)
  198.         qDebug()<<"LED clicked on";
  200.     else
  201.         qDebug()<<"LED clicked off";
  204.     rpc_led_control(status);
  205.     status = !status;
  206. }
复制代码
dht11_thread.h
  1. #ifndef DHT11_THREAD_H
  2. #define DHT11_THREAD_H
  4. #include <QMainWindow>
  5. #include <QThread>
  6. #include <QLabel>
  9. class MainWindow;
  11. // 1. 创建继承自QThread的子类
  12. class DHT11Thread : public QThread {
  13.     Q_OBJECT
  15. public:
  16.     explicit DHT11Thread(QObject *parent = nullptr) : QThread(parent){}
  17.     void run() override ;
  19. signals:
  20.     void updateData(char humidity, char temperature);
  21. };
  24. #endif // DHT11_THREAD_H
复制代码
dht11_thread.c
  1. #include <QThread>
  2. #include <QDebug>
  3. #include "dht11_thread.h"
  4. #include "rpc_client.h"
  5. #include "stdio.h"
  9. // 2. 重写run()函数，这里是线程要执行的代码
  10. void DHT11Thread::run()
  11. {
  12.     char humi;
  13.     char temp;
  15.     while(1) {
  16.         if (0 == rpc_dht11_read(&humi, &temp))
  17.         {
  18.             emit updateData(humi, temp);
  19.             msleep(2000); // 线程休眠2秒
  20.         }
  21.     }
  22. }
复制代码
main.cpp
  1. #include "mainwindow.h"
  2. #include "rpc_client.h"
  3. #include <QApplication>
  4. #include "dht11_thread.h"
  6. int main(int argc, char *argv[])
  7. {
  9.     RPC_Client_Init();
  10.     DHT11Thread *dhtThread = new DHT11Thread();
  11.     dhtThread->start();
  13.     QApplication a(argc, argv);
  14.     MainWindow w;
  17.     QObject::connect(dhtThread, SIGNAL(updateData(char, char)),
  18.                          &w, SLOT(onUpdateData(char, char)));
  19.     w.show();
  20.     return a.exec();
  21. }
复制代码
记得在.pro文件里面添加交错编译工具链的include、lib等信息；以及添加使用的Qt模块；
  1. QT      += core gui network widgets concurrent
  3. SOURCES += \
  4.     MQTT.cpp \
  5.     cJSON.c \
  6.     dht11_thread.cpp \
  7.     main.cpp \
  8.     mainwindow.cpp \
  9.     rpc_client.cpp
  11. HEADERS += \
  12.     cJSON.h \
  13.     dht11_thread.h \
  14.     mainwindow.h \
  15.     mqtt.h \
  16.     rpc.h \
  17.     rpc_client.h
  19. FORMS += \
  20.     mainwindow.ui
  22. INCLUDEPATH += /home/book/100ask_imx6ull-sdk/ToolChain/arm-buildroot-linux-gnueabihf_sdkbuildroot/arm-buildroot-linux-gnueabihf/sysroot/usr/include
复制代码
2、APP开机自启动相关设置

   这一部分如果想深入，需要学习一下Linux下 Shell脚本语言：这大概是B站讲的最好的Linux Shell脚本教程，3h打通Linux-shell全套教程，从入门到精通完整版_哔哩哔哩_bilibili
  创建一个文件： /etc/init.d/rCS;这个文件是一个初始化脚本，用于在体系启动时加载内核模块并执行其他初始化脚本。
  1. #!/bin/sh
  2. #("是一个 shebang 行，用于指定脚本文件的解释器。它告诉系统使用 /bin/sh 来执行脚本中的命令。")
  4. #加载驱动
  5. insmod  /root/led_drv.ko
  6. insmod  /root/dht11_drv.ko
  8. # Start all init scripts in /etc/init.d
  9. # executing them in numerical order.
  11. # 是一个启动画面程序，通常用于显示启动进度
  12. psplash -n &
  13. # 遍历 /etc/init.d/ 目录下所有以 S 开头的文件（通常是初始化脚本）。
  14. # 根据文件扩展名（如 .sh）或文件类型，执行这些脚本的 start 方法。
  15. # 如果脚本是 shell 脚本（以 .sh 结尾），则直接在当前 shell 中执行。
  16. # 如果是其他类型的脚本，则在子进程中执行。
  17. for i in /etc/init.d/S??* ;do
  19.      # Ignore dangling symlinks (if any).
  20.      [ ! -f "$i" ] && continue
  22.      case "$i" in
  23.         *.sh)
  24.             # Source shell script for speed.
  25.             (
  26.                 trap - INT QUIT TSTP
  27.                 set start
  28.                 . $i
  29.             )
  30.             ;;
  31.         *)
  32.             # No sh extension, so fork subprocess.
  33.             $i start
  34.             ;;
  35.     esac
  36. done
  38. # 这行代码的作用是根据 /etc/hostname 文件的内容设置系统的主机名。
  39. /bin/hostname -F /etc/hostname
复制代码
创建一个文件： /etc/init.d/S99myqt ，这个文件是一个详细的初始化脚本，用于启动你的应用程序 myapp 和 rpc_server。
  1. #!/bin/sh
  3. start() {
  4. #禁止LCD黑屏
  5. echo -e "\033[9;0]" > /dev/tty0
  6. #设置QT运行环境
  7. export QT_QPA_GENERIC_PLUGINS=tslib:/dev/input/event1
  8. export QT_QPA_PLATFORM=linuxfb:fb=/dev/fb0
  9. export QT_QPA_FONTDIR=/usr/lib/fonts/
  11. psplash-write "PROGRESS 95"
  12. psplash-write "QUIT"
  13. /root/rpc_server &
  14. sleep 5
  15. /root/myapp  &
  16. }
  18. stop() {
  19.     killall myapp
  20. }
  22. case "$1" in
  23.     start)
  24.         start
  25.         ;;
  26.     stop)
  27.         stop
  28.         ;;
  29.     *)
  30.         echo "Usage: $0 {start| stop|restart}"
  31.         exit 1
  32. esac
  34. exit $?
复制代码
看到这里有几个疑问：为什么开发板会开机启动自动运行你的程序
System V（缩写为 SysV）在大多数 Linux 发行版中使用最广泛,在 systemv中，在内核加载后运行的第 1 个程序被称为 init 程序。 Init 做一些事情，其中之一就是加载一系列脚本来启动各种体系服务，例如网络， ssh 守护程序等。 systemv 的题目在于它需要仔细调整。假设您有一个要在启动时运行的网络文件体系（ NFS）客户端。在网络正常工作之前运行 NFS 没有任何意义。因此，您必须等待网络已经正常工作，才能启动 systemv。 Systemv init 这样做的方法是为服务启动设置严格的次序。每个服务都分配有一个优先级编号， init 会按优先级次序启动服务。
在基于 SysVinit 的 Linux 体系中，所有 System V 初始化脚本都存储在/etc/rc.d/init.d/或/etc/init.d目录中。这些脚本用于控制体系的启动和关闭 。这些脚本在体系启动时按次序执行，以完成体系的初始化工作。
脚本名称以 S 开头，表示这是一个启动脚本。脚本名称中的数字（如 S99）决定了执行次序。数字越大，执行越靠后。例如：


  • S01script 会在 S02script 之前执行。
  • S99myqt 是末了执行的脚本之一。
/etc/init.d/rCS 脚本负责执行 /etc/init.d/ 目录下所有以 S 开头的脚本。它会按次序执行这些脚本，完成体系的初始化。上面提到按照次序执行脚本的这个工作就是由rCS脚本来完成。
**注意：**从ubuntu通过rfs将文件传输到单板以后，记得讲个文件添加可执行权限
  1. chmod +x /root/rpc_server
  2. chmod +x /root/myapp
  4. chmod +x /etc/init.d/rcS
  5. chmod +x /etc/init.d/S99myqt
复制代码
3、单板毗连WIFI

参考韦东山教程，在目录：/home/book/100ask_imx6ull-sdk/Linux-4.9.88/drivers/net/wireless/rtl8723BU ，获得得当当前Linux体系，得当当前开发板上板载网卡型号的网卡驱动文件（你没有的话需要自己去搜索资料弄到合适的网卡驱动文件）。编译驱动文件，获得xxx.ko文件，复制该文件到开发板，然后在开发板安装驱动。经过开发板的wifi毗连工具相关设置以后，就可以毗连上WiFi了。
①、编译驱动要修改Makefile文件


我们如今在.ko的路径下，由于已经改好了Makefile文件了，那就直接输入 make 编译，得到.ko文件。然后通过你自己的方式将.ko文件发送到开发板，并在开发板装insmod 装载 .ko驱动文件。
  1. //进入开发板
  2. //刷新一下系统环境变量
  3. source /etc/profile
  6. //关闭有线网卡
  7. ifconfig eth0 down
  10. //打开无线网卡也就是rtl8723bu
  11. ifconfig wlan0 up
  14. //WiFi连接配置设置，路径不可改
  15. vi /etc/wpa_supplicant.conf
  18. //修改wpa_supplicant.conf的内容如下：
  19. ctrl_interface=/var/run/wpa_supplicant
  20. ap_scan=1
  21. network={
  22.         ssid="Play_434_2.4G"  //wifi名称 ，这一行前面用tab代替空格
  23.         psk="434434434"       //wifi密码 ，这一行前面用tab代替空格
  24. }
  27. //配置udhcpc使其分配到动态ip后并配置到rtl8723bu网卡上
  28. //在Ubuntu上，使用本系统的busybox的udhcpc配置文件
  29. cd /home/book/100ask_imx6ull-sdk/Busybox_1.30.0/examples/udhcp
  30. cp simple.script /home/book/nfs_rootfs       //Ubuntu挂载在开发板上的nfs路径
  33. //在开发板上将simple.script更改名称并放在特定路径
  34. mv /mnt/simple.script /usr/share/udhcpc/default.script
  35. chmod 755 /usr/share/udhcpc/default.script
  38. //启动wpa_supplicant应用
  39. // 1 较新Linux系统使用以下这行
  40. wpa_supplicant -Dnl80211  -c /etc/wpa_supplicant.conf -i wlan0 &
  42. // 2 较老Linux系统使用以下这行
  43. wpa_supplicant -D wext -c /etc/wpa_supplicant.conf -i wlan0 &
  46. //搜索wifi并根据刚才的配置进行wifi连接
  47. udhcpc -i wlan0
  50. //使系统支持域名解析
  51. echo "nameserver 8.8.8.8" >> /etc/resolv.conf
复制代码
开发板开机自动毗连WiFi,看到了嘛，我们还是修改rCS，来设置开机启动时的工作。
  1. //在开发板上
  2. vi /etc/init.d/rcS
  5. //在该文件中的文末输入的代码效果相当于在shell中输入命令一样
  6. //输入以下命令
  7. source /etc/profile                                                       //刷新环境变量
  8. insmod /opt/gpio_driver.ko
  9. insmod /opt/8723bu.ko                                                     //安装网卡驱动
  10. ifconfig eth0 down                                                        //关闭有线网卡
  11. ifconfig wlan0 up                                                         //打开无线网卡
  12. wpa_supplicant -Dnl80211  -c /etc/wpa_supplicant.conf -i wlan0 &          //打开wifi工具
  13. udhcpc -i wlan0                                                           //连接wifi
  14. echo "nameserver 8.8.8.8" >> /etc/resolv.conf                             //解析域名功能配置
  15. cd /opt                                                                   //进入我的Qt目录
  16. /opt/1armQtProject &                                                      //执行QT程序
复制代码
六、项目效果

项目较为简朴，为期5天即可完成。但从理论走向实践，学了那么多东西，用不到很快就忘记了。
   “嵌入式开发中，底子知识太多了，学完 ABCDEFG，你都没办法做出一个最简朴的产物” --韦东山老师
  一次项目作为入门，作为框架，开启新阶段的学习。
继续沉淀。


   注：参考资料均已备注，如有侵权，立即删除。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

耶耶耶耶耶

论坛元老
这个人很懒什么都没写!

楼主热帖

标签云

AI 运维 CIO 存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表