Spark One - Home Assistant [RT-Thread]

御坂10032号

Spark One - Home Assistant [RT-Thread] [Copy link]

**Introduction** >This DIY project aims to integrate the onboard peripherals of Spark-1 into Home Assistant, so that users can view the indoor humidity, temperature, light intensity and control lights in real time on mobile phones or web pages. At the same time, >automatic operations can be realized on HA. For example, when the light intensity is greater than 50Lux, the light can be automatically turned off or on. Demo video: <a href="https://www.bilibili.com/video/BV1PyYFeSEWV/?spm_id_from=333.999.0.0&vd_source=fa81ee8dac5a78e9ccb692c6642f6fe2">click to jump</a>

## Main program analysis** Dependent modules** | Module name| Description| |------------|-------------------------------| | RW007 | (Software package) Provides WIFI connection| | AHT10 | (Software package) Humidity and temperature sensor| | Anxinke VC01 | Offline voice module, serial port output| | Kawali MQTT | (Software package) MQTT client, providing MQTT connection based on WIFI| | CJSON | (Software package) JSON parsing implemented in C language| | AP3216C | (Software package) Provides distance and light intensity detection| | RT-Thread | RTOS | **Core file description** | Module name| Description| |-------------|-----------------------------| | [aht_10.c](applications%2Faht_10.c) | Responsible for temperature acquisition of AHT10 humidity and temperature sensor (producer) | | [mqtt_client.c](applications%2Fmqtt_client.c) | Responsible for MQTT connection and message publishing and subscription (consumer and producer) | | [usart3.c](applications%2Fusart3.c) | Responsible for receiving and parsing VC01 serial port data packets Uart3 | | [wifi_connection.c](applications%2Fwifi_connection.c) | Responsible for wifi connection | | [drv_matrix_led.c](board%2Fports%2Fled_matrix%2Fdrv_matrix_led.c) | Onboard support package for lighting up the LED matrix | | [ap3216c.c](packages%2Fap3216c-latest%2Fap3216c.c) | Used for distance and light intensity detection | **Implementation steps** 1- Create message queues for humidity, temperature and light intensity for communication between MQTT consumers (publishing messages) and producers (humidity, temperature and light intensity sensors) 2- In the main thread, start the WIFI connection (RW007) ` wifi_connection(NULL);` **[wifi_connection.c](applications%2Fwifi_connection.c)** ```c #include "wifi_connection.h" #include<msh.h>

#define WIFI_SSID "ImmortalWrt" /*WIFI name*/ #define WIFI_PASSWORD "mazha1997" /*WIFI password*/ void wifi_connection(void *args) { char wifi_scan_command[] = "wifi scan"; char wifi_connection_command[] = "wifi join " WIFI_SSID " " WIFI_PASSWORD; msh_exec(wifi_scan_command, rt_strlen(wifi_scan_command)); msh_exec(wifi_connection_command, rt_strlen(wifi_connection_command)); } ``` 3- Start the thread of serial port 3 and wait for VC01 to send data. If data is received, call the function of drv_matrix_led.h to turn on or off the LED light `uart3_entry_point();` ```c #include<string.h>
#include "usart3.h" #include "drv_matrix_led.h" #define SAMPLE_UART_NAME "uart3" /* Semaphore for receiving messages*/ static struct rt_semaphore rx_sem; static rt_device_t serial; /* Receive data callback function*/ static rt_err_t uart_input(rt_device_t dev, rt_size_t size) { rt_sem_release(&rx_sem); return RT_EOK; } static void serial_thread_entry(void *parameter) { char ch; while (1) { /* Read a byte of data from the serial port. If not read, wait for the receiving semaphore*/ while (rt_device_read(serial, -1, &ch, 1) != 1) { /* Block and wait for the receiving semaphore. Read data again after the semaphore*/ rt_sem_take(&rx_sem, RT_WAITING_FOREVER); } /* Print the received bytes*/ rt_kprintf("Received: %x\n", ch); /* The read data is output through the serial port in a staggered manner*/ if (ch == 1) { // corresponding to '\001' turn_on_red_led(); } else if (ch == 2) { // corresponding to '\002' // blue turn_on_blue_led(); } else if (ch == 3) { // corresponding to '\003' // green turn_on_green_led(); } else if (ch == 4) { // corresponding to '\004' led_matrix_rst(); } else if (ch == 5) { // corresponding to '\005' // turn on the water pump} else if (ch == 6) { // corresponding to '\006' // turn off the water pump} ch = ch + 1; rt_device_write(serial, 0, &ch, 1); } } int uart3_entry_point() { rt_err_t ret = RT_EOK; char uart_name[8] = SAMPLE_UART_NAME; /* Find the serial device in the system*/ serial = rt_device_find(uart_name); if (!serial) { rt_kprintf("find %s failed!\n", uart_name); return RT_ERROR; } rt_kprintf("fond %s serial!\n", uart_name); /* Initialize semaphore*/ rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO); /* Open the serial device in interrupt receive and polling send mode*/ rt_device_open(serial, RT_DEVICE_FLAG_INT_RX); /* Set the receive callback function*/ rt_device_set_rx_indicate(serial, uart_input); /* Send string*/ /* Create serial thread*/ rt_thread_t thread = rt_thread_create("serial", serial_thread_entry, RT_NULL, 1024, 25, 10); /* Start thread if creation is successful*/ if (thread != RT_NULL) { rt_thread_startup(thread); } else { ret = RT_ERROR; } return ret; } MSH_CMD_EXPORT(uart3_entry_point, uart device dma sample); ``` 4- Start MQTT server` ka_mqtt();` ```C #include<stdio.h>
#include<stdint.h>
#include<rtthread.h>
#include<rtdevice.h>
#include<board.h>
#include "mqttclient.h" #include<msh.h>
#include "cJSON.h" #include "drv_matrix_led.h" #ifndef KAWAII_MQTT_HOST #define KAWAII_MQTT_HOST "jiejie01.top" #endif #ifndef KAWAII_MQTT_PORT #define KAWAII_MQTT_PORT "1883" #endif #ifndef KAWAII_MQTT_CLIENTID #define KA WAII_MQTT_CLIENTID "rtthread001" #endif # ifndef KAWAII_MQTT_USERNAME #define KAWAII_MQTT_USERNAME "rt-thread" #endif #ifndef KAWAII_MQTT_PASSWORD #define KAWAII_MQTT_PASSWORD "rt-thread" #endif #ifndef KAWAII_MQTT_SUBTOPIC #define KAWAII_MQTT_SUBTOPIC "rtt-sub" #endif #ifndef KAWAII_MQTT_PUBTOPIC #define KAWAII_MQTT_PUBTOPIC "rtt-pub" #endif mqtt_client_t *client = NULL; rt_sem_t sem_mqtt_connection = RT_NULL; extern rt_mq_t mq; extern rt_mq_t lux_mq; extern rt _mq_t rgb_mq; static void sub_topic_handle1(void *client , message_data_t *msg) { (void) client; RGBColor_TypeDef rgb; rgb.R = 255; rgb.G = 255; rgb.B = 255; cJSON *json = cJSON_Parse(msg->message->payload); //Get Switch status cJSON *name = cJSON_GetObjectItem(json, "state"); // Get the color object cJSON *color = cJSON_GetObjectItem(json, "color"); if (color != NULL) { // Get the r, g, b properties cJSON *r = cJSON_GetObjectItem(color, "r "); cJSON *g = cJSON_GetObjectItem(color, "g"); cJSON *b = cJSON_GetObjectItem(color, "b"); // Check if r, g, b attributes exist and print their values if (r != NULL && cJSON_IsNumber(r)) { rgb.R = r->valueint; rt_kprintf("r: %d\n", r->valueint); } else { rt_kprintf("The attribute 'r' does not exist or is not a number.\n"); } if (g != NULL && cJSON_IsNumber(g)) { rgb.G = g->valueint; rt_kprintf("g: %d\n", g->valueint); } else { rt_kprintf("The attribute 'g' does not exist or is not a number.\n"); } if (b != NULL && cJSON_IsNumber(b)) { rgb.B = b->valueint; rt_kprintf("b: %d\n", b->valueint); } else { rt_kprintf("The attribute 'b' does not exist or is not a number.\n"); } } cJSON_Delete(json); turn_on_led(rgb, name->valuestring); } static void sub_topic_handle2(void *client, message_data_t *msg) { (void) client; KAWAII_MQTT_LOG_I("---- -------------------------------------------------- --------------------------"); KAWAII_MQTT_LOG_I("%s:%d %s()...\ntopic: %s\nmessage:%s", __FILE__, __LINE__, __FUNCTION__, msg->topic_name,(char *) msg->message->payload); KAWAII_MQTT_LOG_I("---------------------------------- --------------------------------------------------" ); } static void mqtt_connection(void *parameter) { client = NULL; rt_thread_delay(6000); mqtt_log_init(); client = mqtt_lease(); mqtt_set_host(client, KAWAII_MQTT_HOST); mqtt_set_port(client, KAWAII_MQTT_PORT); mqtt_set_user_ name(client, KAWAII_MQTT_USERNAME ); mqtt_set_password(client, KAWAII_MQTT_PASSWORD); mqtt_set_client_id(client, KAWAII_MQTT_CLIENTID); mqtt_set_clean_session(client, 1); KAWAII_MQTT_LOG_I("The ID of the Kawaii client is: %s \r\n", KAWAII_MQTT_CLIENTID); int index = mqtt_connect(client); if (index == KAWAII_MQTT_CONNECT_FAILED_ERROR) { //Try to reconnect once rt_kprintf("connection failed! re-connecting....\r\n"); index = mqtt_connect(client); if (index == KAWAII_MQTT_CONNECT_FAILED_ERROR) { char command[] = "reboot"; rt_kprintf("connection failed ! rebooting.... .\r\n"); msh_exec(command, rt_strlen(command)); } } rt_sem_release(sem_mqtt_connection); mqtt_subscribe(client, "home/rgb1/set", QOS0, sub_topic_handle1); mqtt_subscribe(client, "home/bedroom/switch1/set", QOS0, sub_topic_handle2); } static void temperature_humidity_publish(void *parameter) { char payload[PACKAGE_SIZE]; while (1) { if (rt_mq_recv(mq , &payload, sizeof(payload), 1000) > 0) { mqtt_message_t msg; memset(&msg, 0, sizeof(msg)); msg.qos = QOS1; // msg.payload points directly to the received payload msg.payload = (void *) payload; mqtt_publish(client, "office/sensor1", &msg); } } } static void lux_publish_task(void *parameter) { char payload[LUX_PACKAGE_SIZE]; // Buffer to hold the string representation of the receive value while (1) { if (rt_mq_recv(lux_mq, &payload, sizeof(payload), 1000) > 0) { mqtt_message_t msg; memset(&msg, 0, sizeof(msg)); msg.qos = QOS1; // msg.payload points directly to the received payload msg.payload = (void *) payload; mqtt_publish(client, "hah", &msg); } } } int ka_mqtt( void) { rt_thread_t tid_mqtt, second_publish, lux_publish; sem_mqtt_connection = rt_sem_create("mqtt_connection", 1, RT_IPC_FLAG_FIFO); rt_sem_take(sem_mqtt_connection, RT_WAITING_FOREVER); tid_mqtt = rt_thread_create("mqtt_connection_task", mqtt_connection, RT_NULL, 2048, 17, 10); if (tid_mqtt == RT_NULL) { return -RT_ERR OR; } rt_thread_startup(tid_mqtt); rt_sem_take(sem_mqtt_connection , RT_WAITING_FOREVER); second_publish = rt_thread_create("temp_hum_publish_task", temperature_humidity_publish, RT_NULL, 2048, 17,10); if (second_publish == RT_NULL) { return -RT_ERROR; } rt_thread_startup(second_publish); rt_sem_release(sem_mqtt_connection); lux_publish = rt_thread_create("lux_publish_task", lux_publish_task, RT_NULL, 2048, 17, 10); if (lux_publish == RT_NULL) { return -RT_ERROR; } rt_thread_startup(lux_publish); return RT_EOK; } MSH_CMD_EXPORT(ka_mqtt, Kawaii MQTT client test program); ```` 5- Start the wet temperature Task and light intensity Task **Start the wet temperature Task** ` rt_thread_t thread = rt_thread_create("aht_10_task", AHT_test_entry, RT_NULL, 2048, 24, 10); rt_thread_startup(thread); ` ```c #include "aht_10.h" #include "mqttclient.h" //I2C_BUS device pointer, used to find and record the I2C bus mounted by AHT later struct rt_i2c_bus_device *i2c_bus = RT_NULL; extern rt_mailbox_t mailbox; extern rt_mq_t mq; //Null parameter of AHT command rt_uint8_t Parm_Null[2] = {0, 0}; //Write command (host transmits data to slave) rt_err_t write_reg(struct rt_i2c_bus_device *Device, rt_uint8_t reg, rt_uint8_t *data) { //Data to be written //The reason why the array size is 3: buf[0]--command (i.e. AHT_CALIBRATION_CMD, AHT_NORMAL_CMD, AHT_GET_DATA_CMD above // buf[1]/buf[2] are the parameters following the command, AHT Some commands need to be followed by parameters, please refer to the data manual for details rt_uint8_t buf[3]; //Record array size rt_uint8_t buf_size; //I2C transmission data structure struct rt_i2c_msg msgs; buf[0] = reg; if (data ! = RT_NULL) { buf[1] = data[0]; buf[2] = data[1]; buf_size = 3; } else { buf_size = 1; } msgs.addr = AHT_ADDR; //The address to which the message is to be sent: That is, AHT address msgs.flags = RT_I2C_WR; //Message flags: read or write, whether to ignore ACK response, whether to send stop bit, whether to send start bit (for splicing data)... msgs.buf = buf; //Message buffer : Array to be sent/received msgs.len = buf_size; //Message buffer size: size of the array to be sent/received if (rt_i2c_transfer(Device, &msgs, 1) == 1) { return RT_EOK; } else { return RT_ERROR; } } //Read data (slave returns data to host) rt_err_t read_reg(struct rt_i2c_bus_device *Device, rt_uint8_t len, rt_uint8_t *buf) { struct rt_i2c_msg msgs; msgs.addr = AHT_ADDR; //Address to which the message is to be sent : That is, AHT address msgs.flags = RT_I2C_RD; //Message flags: read or write, whether to ignore ACK response, whether to send stop bit, whether to send start bit (for splicing data)... msgs.buf = buf; //Message Buffer: array to be sent/received msgs.len = len; //Message buffer size: size of the array to be sent/received //Transfer function, introduced above if (rt_i2c_transfer(Device, &msgs, 1) = = 1) { return RT_EOK; } else { return RT_ERROR; } } //Read the temperature and humidity data of AHT void read_temp_humi(float *Temp_Data, float *Humi_Data) { //According to the data sheet, we can see that we need to read the data once The array size to be used is 6 rt_uint8_t Data[6]; write_reg(i2c_bus, AHT_GET_DATA_CMD, Parm_Null); //Send a read command to let AHT collect data rt_thread_mdelay(500); //Wait for collection read_reg(i2c_bus, 6, Data); //Read data //Process data according to the data sheet *Humi_Data = (Data [1] << 12 | Data[2] << 4 | (Data[3] & 0xf0) >> 4) * 100.0 / (1 << 20); *Temp_Data = ((Data[3] & 0x0f) < < 16 | Data[4] << 8 | Data[5]) * 200.0 / (1 << 20) - 50; } //AHT initialization void AHT_Init(const char *name) { //Find AHT bus device i2c_bus = rt_i2c_bus_device_find(name); if (i2c_bus == RT_NULL) { rt_kprintf("Can't Find I2C_BUS Device"); //Cannot find bus device } else { write_reg(i2c_bus, AHT_NORMAL_CMD, Parm_Null); //Set to normal working mode rt_thread_mdelay(400); rt_uint8_t Temp[2]; //Parameters required by AHT_CALIBRATION_CMD Temp[0] = 0x08; Temp[1] = 0x00; write_reg(i2c_bus, AHT_CALIBRATION_CMD, Temp); rt_thread_mdelay(400); } } void AHT_test_entry(void *args) { float humidity, temperature; char payload[PACKAGE_SIZE]; AHT_Init(AHT_I2C_BUS_NAME); //Initialize the devicewhile (1) { read_temp_humi(&temperature, &humidity); //Read datasnprintf(payload, sizeof(payload), "{\"humidity\":%.1f,\"temperature\":%.1f}", humidity, temperature); rt_mq_send(mq, payload, sizeof(payload)); rt_thread_mdelay(1000); } } ``` **Start the light sensor** ` //Start the light sensorrt_thread_t thread3 = rt_thread_create("lux_task", task_entry, RT_NULL, 2048, 24, 10); rt_thread_startup(thread3); ` ```c /* * Copyright (c) 2006-2018, RT-Thread Development Team * * SPDX-License-Identifier: Apache-2.0 * * Change Logs: * Date Author Notes * 2018-08-20 Ernest Chen the first version */ # include "rt-thread/include/rtthread.h" #include "rt-thread/include/rthw.h" #include "rtdevice.h" #include "finsh.h" #include "stdio.h" #includeh" #include "stdio.h" #includeh" #include "stdio.h" #include<string.h>
#include "ap3216c.h" #ifdef PKG_USING_AP3216C #define DBG_ENABLE #define DBG_SECTION_NAME "ap3216c" #define DBG_LEVEL DBG_LOG #define DBG_COLOR #include "rt-thread/include/rtdbg.h" //System Register #define AP3216C_SYS_CONFIGURATION_REG 0x00 //default #define AP3216C_SYS_INT_STATUS_REG 0x01 #define AP3216C_SYS_INT_CLEAR_MANNER_REG 0x02 #define AP3216C_IR_DATA_L_REG 0x0A #define AP3216C_IR_DATA_H_REG 0x0B #define AP3216C_ALS_DATA_L_REG 0x 0C #define AP3216C_ALS_DATA_H_REG 0x0D #define AP3216C_PS_DATA_L_REG 0x0E #define AP3216C_PS_DATA_H_REG 0x0F //ALS Register #define AP3216C_ALS_CONFIGURATION_REG 0x10 //range 5:4, persist 3:0 #define AP3216C_ ALS_CALIBRATION_REG 0x19 #define AP3216C_ALS_THRESHOLD_LOW_L_REG 0x1A //bit 7:0 #define AP3216C_ALS_THRESHOLD_LOW_H_REG 0x1B / /bit 15:8 #define AP3216C_ALS_THRESHOLD_HIGH_L_REG 0x1C //bit 7:0 #define AP3216C_ALS_THRESHOLD_HIGH_H_REG 0x1D //bit 15:8 //PS Register #define AP3216C_PS_CONFIGURATION_REG 0x20 #define AP3216C_PS_LED_DRIVER_REG 0x21 #define AP3216C_PS_INT_FORM_REG 0x22 #define AP3216C_PS_MEAN_TIME_REG 0x23 #define AP3216C_PS_LED_WAITING_TIME_REG 0x24 #define AP3216C_PS_CALIBRATION_L_REG 0x28 #define AP3216C_PS_CALIBRATION_H_REG 0x29 #define AP3216C_PS_THRESHOLD_LOW_L_REG 0x2A //bit 1:0 #define AP3216C_PS_THRESHOLD_LOW_H_REG 0x2B //bit 9:2 #define AP3216C_PS_THRESHOLD_HIGH_L_REG 0x2C //bit 1:0 #define AP3216C_PS_THRESHOLD_HIGH_H_REG 0x2D //bit 9:2 #define AP3216C_ADDR 0x1e /*0x3c=0x1e<<1*/ extern rt_mq_t lux_mq; static rt_err_t write_reg(struct rt_i2c_bus_device *bus, rt_uint8_t reg, rt_uint8_t data) { struct rt_i2c_msg msgs; rt_uint8_t temp[2]; temp[0] = reg; temp[1] = data; msgs.addr = AP3216C_ADDR; msgs.flags = RT_I2C_WR; msgs.buf = temp; msgs.len = 2; if (rt_i2c_transfer(bus, &msgs, 1) == 1) { return RT_EOK; } else { LOG_E("Writing command error"); return -RT_ERROR; } } static rt_err_t read_regs(struct rt_i2c_bus_device *bus, rt_uint8_t reg, rt_uint8_t len, rt_uint8_t *buf) { struct rt_i2c_msg msgs[2]; msgs[0].addr = AP3216C_ADDR; msgs[0].flags = RT_I2C_WR; msgs[0].buf =msgs[0].len = 1; msgs[1].addr = AP3216C_ADDR; msgs[1].flags = RT_I2C_RD; msgs[1].buf = buf; msgs[1] .len = len; if (rt_i2c_transfer(bus, msgs, 2) == 2) { return RT_EOK; } else { LOG_E("Reading command error"); return -RT_ERROR; } } rt_err_t ap3216c_reset_sensor(ap3216c_device_t dev) { if ( dev == RT_NULL) { return -RT_EINVAL; } write_reg(dev->i2c, AP3216C_SYS_CONFIGURATION_REG, AP3216C_MODE_SW_RESET); //reset rt_thread_mdelay(15); /* need to wait at least 10ms */ return RT_EOK; } /** * This function is convenient to getting data except including high and low data for this sensor. * note:after reading lower register first, reading higher add one.*/ static rt_uint32_t read_low_and_high(ap3216c_device_t dev, rt_uint8_t reg, rt_uint8_t len) { rt_uint32_t data; rt_uint8_t buf = 0; read_regs(dev->i2c, reg, len, &buf); //low data = buf; read_regs(dev-> i2c, reg + 1, len, &buf); //high data = data + (buf << len * 8); return data; } #ifdef AP3216C_USING_HW_INT /** * This function is only used to set threshold without filtering times * * @param dev the name of ap3216c device * @param cmd first register, and other cmd count by it. * @param threshold threshold and filtering times of als threshold */ static void set_threshold(ap3216c_device_t dev, ap3216c_cmd_t cmd, ap3216c_threshold_t threshold) { ap3216c_set_param(dev, cmd, (threshold.min & 0xff)); ap3216c_set_param(dev, (ap3216c_cmd_t)(cmd + 1), ( threshold.min >> 8)); ap3216c_set_param(dev, (ap3216c_cmd_t)(cmd + 2), (threshold.max & 0xff)); ap3216c_set_param(dev, (ap3216c_cmd_t)(cmd + 3), threshold.max >> 8); } static void ap3216c_hw_interrupt(void * args) { ap3216c_device_t dev = (ap3216c_device_t)args; if (dev->als_int_cb) { dev->als_int_cb(dev->als_int_cb); } if (dev->ps_int_cb) { dev->ps_int_cb(dev->ps_int_cb); } } static void ap3216c_int_init(ap3216c_device_t dev) { RT_ASSERT(dev); rt_pin_mode(AP3216C_INT_PIN, PIN_MODE_INPUT_PULLUP); rt_pin_attach_irq(AP3216C_INT_PIN, PIN_IRQ_MODE_FALLING, ap3216c_hw_interrupt, (void * )dev); rt_pin_irq_enable(AP3216C_INT_PIN, PIN_IRQ_ENABLE); } /** * This function registers als interrupt with callback function * * @param dev the name of ap3216c device * @param enabled enable or disenable als interrupt * @param threshold threshold and filtering times of als threshold * * @param int_cb callback function is defined by user. */ void ap3216c_int_als_cb(ap3216c_device_t dev, rt_bool_t enabled, ap3216c_threshold_t threshold, ap3216c_int_cb int_cb) { RT_ASSERT(dev); if (enabled) { dev->als_int_cb = set int_cb; _threshold(dev, AP3216C_ALS_LOW_THRESHOLD_L, threshold ); } else { dev->als_int_cb = RT_NULL; } } /** * This function registers ps interrupt with callback function * * @param dev the name of ap3216c device * @param enabled enable or disenable ps interrupt * @param threshold threshold and filtering times of ps threshold * * @param int_cb callback funtion is defined by user. */ void ap3216c_int_ps_cb(ap3216c_device_t dev, rt_bool_t enabled, ap3216c_threshold_t threshold, ap3216c_int_cb int_cb) { RT_ASSERT(dev); if (enabled) { dev->ps_int_cb = int_cb; set_threshold(dev, AP3216C_PS_ LOW_THRESHOLD_L, threshold); } else { dev->ps_int_cb = RT_NULL ; } } #endif /* AP3216C_USING_HW_INT */ /** * This function initializes ap3216c registered device driver * * @param dev the name of ap3216c device * * <a href="https://en.eeworld.com/bbs/home.php?mod=space&uid=784970" target="_blank">@return</a> the ap3216c device. */ ap3216c_device_t ap3216c_init(const char *i2c_bus_name) { ap3216c_device_t dev; RT_ASSERT(i2c_bus_name); dev = rt_calloc(1, sizeof(struct ap3216 c_device)); if (dev == RT_NULL) { LOG_E("Can't allocate memory for ap3216c device on '%s' ", i2c_bus_name); rt_free(dev); return RT_NULL; } dev->i2c = rt_i2c_bus_device_find(i2c_bus_name); if ( dev->i2c == RT_NULL) { LOG_E("Can't find ap3216c device on '%s'", i2c_bus_name); rt_free(dev); return RT_NULL; } dev->lock = rt_mutex_create("mutex_ap3216c", RT_IPC_FLAG_FIFO); if (dev->lock == RT_NULL) { LOG_E("Can 't create mutex for ap3216c device on '%s'", i2c_bus_name); rt_free(dev); return RT_NULL; } /* reset ap3216c */ ap3216c_reset_sensor(dev); ap3216c_set_param(dev, AP3216C_SYSTEM_MODE, AP3216C_MODE_ALS_AND_PS); #if def AP3216C_USING_HW_INT / * init interrupt mode */ ap3216c_int_init(dev); #endif /* AP3216C_USING_HW_INT */ return dev; } /** * This function releases memory and deletes mutex lock * * @param dev the pointer of device driver structure */ void ap3216c_deinit(ap3216c_device_t dev) { RT_ASSERT( dev); rt_mutex_delete(dev->lock); rt_free(dev); } /** * This function reads temperature by ap3216c sensor measurement * * @param dev the pointer of device driver structure * * @return the ambient light converted to float data. */ float ap3216c_read_ambient_light(ap3216c_device_t dev) { float brightness = 0.0; // default error data rt_err_t result; rt_uint32_t read_data; rt_uint8_t temp; RT_ASSERT(dev); result = rt_mutex_take(dev->lock, RT_WAITING_FOREVER); if (result == RT_EOK) { read_data = read_low_and_high(dev, AP3216C_ALS_DATA_L_REG, 1); ap3216c_get_param(dev, AP3216C_ALS_RANGE, &temp); if (temp == AP3216C_ALS_RANGE_20661) { brightness = 0.35 * read_data; //sensor ambient light converse to reality } else if (temp == AP3216C_ALS_RANGE_5162) { brightness = 0.0788 * read_data; //sensor ambient light converse to reality } else if (temp == AP3216C_ALS_RANGE_1291) {brightness = 0.0197 * read_data; //sensor ambient light converse to reality } else if (temp == AP3216C_ALS_RANGE_323) { brightness = 0.0049 * read_data; //sensor ambient light converse to reality } else { LOG_E("Failed to get range of ap3216c"); } } else { LOG_E("Failed to reading ambient light"); } rt_mutex_release(dev->lock) ; return brightness; } /** * This function reads temperature by ap3216c sensor measurement * * @param dev the pointer of device driver structure * * @return the proximity data. */ uint16_t ap3216c_read_ps_data(ap3216c_device_t dev) { rt_uint16_t proximity = 0; rt_err_t result; RT_ASSERT(dev); result = rt_mutex_take(dev->lock, RT_WAITING_FOREVER); if (result == RT_EOK) { rt_uint32_t read_data; read_data = read_low_and_high(dev, AP3216C_PS_DATA_L_REG, 1); //read two data if (1 == ((read_data >> 6) & 0x01 || (read_data >> 14) & 0x01)) { LOG_I("The data of PS is invalid for high intensive IR light "); } proximity = (read_data & 0x000f) + (((read_data >> 8) & 0x3f) << 4); //sensor proximity converse to reality } else { LOG_E("Failed to reading ps data "); } rt_mutex_release(dev->lock); return proximity; } /** * This function sets parameter of ap3216c sensor * * @param dev the pointer of device driver structure * @param cmd the parameter cmd of device * @param value for setting value in cmd register * * @return the setting parameter status,RT_EOK reprensents setting successfully. */ rt_err_t ap3216c_set_param(ap3216c_device_t dev, ap3216c_cmd_t cmd, rt_uint8_t value) { RT_ASSERT(dev); switch (cmd) { case AP3216C_SYSTEM_MODE: { if (value > AP3216C_MODE_ALS_AND_ PS_ONCE) { LOG_E("Setting system mode parameter is wrong !"); return -RT_ERROR; } /* default 000,power down */ write_reg(dev->i2c, AP3216C_SYS_CONFIGURATION_REG, value); break; } case AP3216C_INT_PARAM: { if (value > AP3216C_ALS_CLEAR_MANNER_BY_SOFTWARE) { LOG_E("Setting int parameter is wrong !"); return -RT_ERROR; } write_reg(dev->i2c, AP3216C_SYS_INT_CLEAR_MANNER_REG, value); break; } case AP3216C_ALS_RANGE: { rt_uint8_t args; if (!(value == AP3216C_ALS_RANGE_20661 || value == AP3216C_ALS_RANGE_5162 || value == AP3216C_ALS_RANGE_1291 || value == AP3216C_ALS_RANGE_323)) { LOG_E("Setting als dynamic range is wrong, please refer als_range"); return -RT_ERROR; } read_regs(dev->i2c, AP3216C_ALS_CONFIGURATION_ REG, 1, &args); args &= 0xcf; args |= value << 4; write_reg(dev->i2c, AP3216C_ALS_CONFIGURATION_REG, args); break; } case AP3216C_ALS_PERSIST:{ rt_uint8_t args = 0; if (value > 0x0f) { LOG_E("Setting als persist overflows "); return -RT_ERROR; } read_regs(dev->i2c, AP3216C_ALS_CONFIGURATION_REG, 1, &args); args &= 0xf0; args |= value; write_reg(dev->i2c, AP3216C_ALS_CONFIGURATION_REG, args); break; } case AP3216C_ALS_LOW_THRESHOLD_L: { write_reg(dev->i2c, AP3216C_ALS_THRESHOLD_LOW_L_REG, value); break; } case AP3216C_ALS_LOW_THRESHOLD_H: { write _reg(dev->i2c, AP3216C_ALS_THRESHOLD_LOW_H_REG, value); break; } case AP3216C_ALS_HIGH_THRESHOLD_L: { write_reg(dev->i2c, AP3216C_ALS_THRESHOLD_HIGH_L_REG, value); break; } case AP3216C_ALS_HIGH_THRESHOLD_H: { write_reg(dev->i2c, AP 3216C_ALS_THRESHOLD_HIGH_H_REG, value); break; } case AP3216C_PS_GAIN: { rt_uint8_t args = 0; if (value > 0x3) { LOG_E("Setting ps again overflows "); return -RT_ERROR; } read_regs(dev->i2c, AP3216C_PS_CONFIGURATION_REG, 1, &args); args &= 0xf3; args |= value; write_reg(dev->i2c, AP3216C_PS_CONFIGURATION_REG, args); break; } case AP3216C_PS_PERSIST: { rt_uint8_t args = 0; if (value > 0x3) { LOG_E("Setting ps persist overflows "); return -RT_ERROR; } read_regs(dev->i2c, AP3216C_PS_CONFIGURATION_REG, 1, &args); args &= 0xfc; args |= value; write_reg(dev->i2c, AP3216C_PS_CONFIGURATION_REG, args); break; } case AP3216C_PS_LOW_ THRESHOLD_L : { if (value > 0x3) { LOG_E("Setting ps low threshold of low bit is wrong !"); return -RT_ERROR; } write_reg(dev->i2c, AP3216C_PS_THRESHOLD_LOW_L_REG, value); break; } case AP3216C_PS_LOW_THRESHOLD_H: { write_reg(dev->i2c, AP3216C_PS_THRESHOLD_LOW_H_ REG, value ); break; } case AP3216C_PS_HIGH_THRESHOLD_L: { if (value > 0x3) { LOG_E("Setting ps high threshold of low bit is wrong !"); return -RT_ERROR; } write_reg(dev->i2c, AP3216C_PS_THRESHOLD_HIGH_L_REG, value); break ; } case AP3216C_PS_HIGH_THRESHOLD_H: { write_reg(dev->i2c, AP3216C_PS_THRESHOLD_HIGH_H_REG, value); break; } default: { return -RT_ERROR; } } return RT_EOK; } /** * This function gets parameter of ap3216c sensor * * @param dev the pointer of device driver structure * @param cmd the parameter cmd of device * @param value to get value in cmd register * * @return the getting parameter status,RT_EOK reprensents getting successfully. */ rt_err_t ap3216c_get_param(ap3216c_device_t dev, ap3216c_cmd_t cmd, rt_uint8_t *value) { RT_ASSERT(dev); switch (cmd) { case AP3216C_SYSTEM_MODE: { read_regs(dev->i2c, AP3216C_ SYS_CONFIGURATION_REG, 1, value); if (*value > AP3216C_MODE_ALS_AND_PS_ONCE) { LOG_E("Getting system mode parameter is wrong!"); return -RT_ERROR; } break; } case AP3216C_INT_PARAM: { read_regs(dev->i2c, AP3216C_SYS_INT_CLEAR_MANNER_REG, 1, value); if (*value > AP3216C_ALS_CLEAR_MANNER_BY_SOFTWARE) { LOG_E("Getting int parameter is wrong !"); return -RT_ERROR; } break; } case AP3216C_ALS_RANGE: { rt_uint8_t temp; read_regs(dev->i2c, AP3216C_ALS_CONFIGURATION_REG, 1, value); temp = (*value & 0xff) >> 4; if (!(temp == AP3216C_ALS_RANGE_20661 || temp == AP3216C_ALS_RANGE_5162 || temp == AP3216C_ALS_RANGE_1291 || temp == AP3216C_ALS_RANGE_323)) { LOG_E("Getting als dynamic range is wrong, please refer als_range"); return -RT_ERROR; } *value = temp; break; } case AP3216C_ALS_PERSIST: { rt_uint8_t temp; read_regs(dev->i2c, AP3216C_ALS_CONFIGURATION_REG, 1, value); temp = *value & 0x0f; if (temp > 0x0f ) { LOG_E("Getting als persist is wrong, please refer als_range"); return -RT_ERROR; } *value = temp; break; } case AP3216C_ALS_LOW_THRESHOLD_L: { read_regs(dev->i2c, AP3216C_ALS_THRESHOLD_LOW_L_REG, 1, value); break; } case AP3216C_ALS_LOW_THRESHOLD_H: { read_regs(dev->i2c, AP3216C_ALS_THRESHOLD_LOW_H_REG, 1, value); break; } case AP3216C_ALS_HIGH_THRESHOLD_L: { read_regs(dev->i2c, AP3216C_ALS_THRESHOLD_HIGH_L_REG, 1, value); break; } case AP3216C_ALS_HIGH_THRESHOLD_H: { read_regs( dev->i2c, AP3216C_ALS_THRESHOLD_HIGH_H_REG, 1, value); break ; } case AP3216C_PS_GAIN: { rt_uint8_t temp; read_regs(dev->i2c, AP3216C_PS_CONFIGURATION_REG, 1, &temp); *value = (temp & 0xc) >> 2; break; } case AP3216C_PS_PERSIST: { rt_uint8_t temp; read_regs(dev->i2c, AP3216C_PS_CONFIGURATION_REG, 1, &temp); *value = temp & 0x3; break; } case AP3216C_PS_LOW_THRESHOLD_L: { read_regs(dev->i2c, AP3216C_PS_THRESHOLD _LOW_L_REG, 1, value); if ( (*value & 0xff) > 0x3) { LOG_E("Getting ps low threshold of low bit is wrong !"); return -RT_ERROR; } break; } case AP3216C_PS_LOW_THRESHOLD_H:{ read_regs(dev->i2c, AP3216C_PS_THRESHOLD_LOW_H_REG, 1, value); break; } case AP3216C_PS_HIGH_THRESHOLD_L: { read_regs(dev->i2c, AP3216C_PS_THRESHOLD_HIGH_L_REG, 1, value); if ((*value & 0xff) > 3) { LOG_E( "Getting ps high threshold of low bit is wrong !"); return -RT_ERROR; } break; } case AP3216C_PS_HIGH_THRESHOLD_H: { read_regs(dev->i2c, AP3216C_PS_THRESHOLD_HIGH_H_REG, 1, value); break; } default: { return -RT_ERROR; } } return RT_EOK; } void ap3216c(int argc, char *argv[]) { static ap3216c_device_t dev = RT_NULL; if (argc > 1) { if (!strcmp(argv[1], "probe")) { if (argc > 2) { /* initialize the sensor when first probe */ if (!dev || strcmp(dev->i2c->parent.parent.name, argv[2])) { /* deinit the old device */ if (dev) { ap3216c_deinit( dev); } dev = ap3216c_init(argv[2]); } } else { rt_kprintf("ap3216c probe<dev_name> - probe sensor by given name\n"); } } else if (!strcmp(argv[1], "read")) { if (dev) { rt_uint16_t ps_data; float brightness; /* read the sensor */ ps_data = ap3216c_read_ps_data(dev); // if (ps_data == 0) // { // rt_kprintf("object is not proximity of sensor \n"); // } // else // { // rt_kprintf("ap3216c read current ps data : %d\n", ps_data); // } char payload[LUX_PACKAGE_SIZE]; brightness = ap3216c_read_ambient_light(dev); // rt_kprintf("ap3216c measure current brightness: %d.%d(lux) \n", (int)brightness, ((int)(10 * brightness) % 10)); snprintf(payload, sizeof(payload), "{\"psData\":%d,\"brightness\":%.1f}", ps_data, brightness); rt_mq_send(lux_mq,payload ,sizeof(payload)); } else { rt_kprintf("Please using 'ap3216c probe<dev_name>' first\n"); } } else { rt_kprintf("Unknown command. Please enter 'ap3216c' for help\n"); } } else { rt_kprintf("Usage:\n"); rt_kprintf("ap3216c probe<dev_name> - probe sensor by given name\n"); rt_kprintf("ap3216c read - read sensor ap3216c data\n"); } } void task_entry(void * args) { char *argv[] = { "ap3216c", "probe", "i2c2", NULL }; char *argv_read[] = { "ap3216c", "read", NULL }; ap3216c(3, argv); while(1) { ap3216c(2, argv_read); rt_thread_delay(200); } } MSH_CMD_EXPORT(ap3216c, ap3216c sensor function); #endif /* PKG_USING_AP3216C */ ``` ## Home assistant configuration **1- Configure humidity and temperature sensor entity ** >docker exec -it [container ID] /bin/bash Use vi to edit configuration.yaml. Add it in the lower-level node of MQTT. The following is to subscribe to the office/sensor1 topic, parse the temperature of the topic message as temperature, and parse humidity as humidity to display in Home Assistant```c sensor: - name: "Temperature" unique_id: temperature state_topic: "office/sensor1" suggested_display_precision: 1 unit_of_measurement: "..C" value_template: "{{ value_json.temperature }}" - name: "Humidity" unique_id: humidity state_topic: "office/sensor1" unit_of_measurement: "%" value_template: "{{ value_json.humidity }}" ``` Reload Home Assistant configuration 
<ignore_js_op>

<div class="tip tip_4 aimg_tip" id="aimg_830267_menu" style="position: absolute; display: none" disautofocus="true">
<div class="xs0">
<p><strong>reload-config.jpg</strong> <em class="xg1">(303.6 KB, downloads: 0)</em></p>
<p>
<a href="javascript:;" class="loginf" >download attach</a>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_830267" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=830267&handlekey=savephoto_830267">save to album</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>
 In Configuration -> Integration -> Entities. You can find them in the entity directory, named Temperature and Humidity 
<ignore_js_op>

<div class="tip tip_4 aimg_tip" id="aimg_830266_menu" style="position: absolute; display: none" disautofocus="true">
<div class="xs0">
<p><strong>humidity-temperature.jpg</strong> <em class="xg1">(223.77 KB, downloads: 0)</em></p>
<p>
<a href="javascript:;" class="loginf" >download attach</a>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_830266" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=830266&handlekey=savephoto_830266">save to album</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>
 In the dashboard, you can configure the corresponding humidity and temperature entities according to the order shown in the figure below. (The other ways to add cards are the same as this step. I will not repeat it later) 
<ignore_js_op>

<div class="tip tip_4 aimg_tip" id="aimg_830268_menu" style="position: absolute; display: none" disautofocus="true">
<div class="xs0">
<p><strong>steps.jpg</strong> <em class="xg1">(246.08 KB, downloads: 0)</em></p>
<p>
<a href="javascript:;" class="loginf" >download attach</a>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_830268" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=830268&handlekey=savephoto_830268">save to album</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>
 **2 - Configure light and distance sensor entities** Use vi to edit configuration.yaml. Add it under the sensor of the lower-level node of MQTT. ```c - name: "Distance" unique_id: distance state_topic: "hah" suggested_display_precision: 1 unit_of_measurement: "cm" value_template: "{{ value_json.psData }}" - name: "Lux" unique_id: lux state_topic: "hah" unit_of_measurement: "Lux" value_template: "{{ value_json.brightness }}" ``` 3 - Configure the RGB light. Use vi to edit configuration.yaml. Add a light node to the lower-level node of MQTT. ```c light: - schema: json unique_id: light optimistic: true name: mqtt_json_light_1 state_topic: "home/rgb122" command_topic: "home/rgb1/set" brightness: true supported_color_modes: ["rgb"] ``` ## MQTT To configure MQTT, you need to create the following Topic 1 - `home/rgb1/set` 2 - `hah` 3 - `office/sensor1`</dev_name></dev_name></dev_name></string.h></msh.h></board.h></rtdevice.h></rtthread.h></stdint.h></stdio.h></string.h></msh.h>

电子烂人

How do you allocate threads?

御坂10032号

Electronic rotten man posted on 2024-8-7 13:24 How do you allocate threads?

Are you talking about the thread's stack or how to create a thread?

电子烂人

Misaka 10032 posted on 2024-8-7 16:00 Are you talking about the thread stack or how to create a thread?

How do you handle the communication between threads? I don't understand this part.

御坂10032号

Electronic rotten man posted on 2024-8-7 19:17 How do you handle the communication between threads? I don't understand this part as a beginner

The message queue is used because the mailbox can only handle 32 bytes.

Spark One - Home Assistant [RT-Thread] [Copy link]

Latest reply

Comments

Comments

Comments