From 1ee7df8078b082e9cbc956dc9d7a1dcee48bd1aa Mon Sep 17 00:00:00 2001 From: Nigreon Date: Sun, 21 Jul 2024 01:24:01 +0200 Subject: [PATCH] Add BH1750 sensor --- src/bh1750.c | 50 +++++ src/bh1750.h | 3 + src/main.c | 289 +++++++++++++++++-------- src/sds011.c | 21 +- zephyr/boards/nrf52dk_nrf52832.overlay | 5 + zephyr/prj.conf | 11 +- 6 files changed, 279 insertions(+), 100 deletions(-) create mode 100644 src/bh1750.c create mode 100644 src/bh1750.h diff --git a/src/bh1750.c b/src/bh1750.c new file mode 100644 index 0000000..1ea5311 --- /dev/null +++ b/src/bh1750.c @@ -0,0 +1,50 @@ +#include +LOG_MODULE_REGISTER(bh1750); + +#include +#include +#include +#include + +#include + +#include + +#include "bh1750.h" + +#if !DT_HAS_COMPAT_STATUS_OKAY(rohm_bh1750) +#error "No rohm,bh1750 compatible node found in the device tree" +#endif + +const struct device *const bh = DEVICE_DT_GET_ANY(rohm_bh1750); + +int bh1750_setup() +{ + + if (!device_is_ready(bh) || bh1750_probe()) { + printk("Device %s is not ready.\n", bh->name); + return -1; + } + + return 0; +}; + +int bh1750_probe() +{ + if(sensor_sample_fetch(bh)) + { + printk("Failed to fetch sample from BH1750 device\n"); + return -1; + } + return 0; +} + +double bh1750_ReadLight() +{ + struct sensor_value lux; + sensor_channel_get(bh, SENSOR_CHAN_LIGHT, &lux); + + + return sensor_value_to_double(&lux); +} + diff --git a/src/bh1750.h b/src/bh1750.h new file mode 100644 index 0000000..f397886 --- /dev/null +++ b/src/bh1750.h @@ -0,0 +1,3 @@ +int bh1750_setup(); +int bh1750_probe(); +double bh1750_ReadLight(); diff --git a/src/main.c b/src/main.c index 4507fd8..7f6ab25 100644 --- a/src/main.c +++ b/src/main.c @@ -14,6 +14,7 @@ #include #include #include +//#include #include @@ -27,6 +28,7 @@ #include #include #include +#include #include @@ -37,6 +39,7 @@ LOG_MODULE_REGISTER(main); #include "sht4x.h" #include "bmp180.h" #include "sds011.h" +#include "bh1750.h" #include "hal/nrf_gpiote.h" static K_FIFO_DEFINE(fifo_adv_data); @@ -44,11 +47,12 @@ static K_FIFO_DEFINE(fifo_adv_data); static K_SEM_DEFINE(ble_init_ok, 0, 1); static K_SEM_DEFINE(adv_send_ok, 0, 1); -#define BTHOME_MAXELT 9 -enum captor_type { BATTERY, BATTERYVDD, TEMPERATURE, PRESSURE, VOLTAGE, VOLTAGEVDD, PM25, PM10, HUMIDITY }; -uint8_t eltid[BTHOME_MAXELT] = { 0x01, 0x01, 0x02, 0x04, 0x0c, 0x0c, 0x0d, 0x0e, 0x2e }; -uint8_t eltsize[BTHOME_MAXELT] = { 1, 1, 2, 3, 2, 2, 2, 2, 1}; -uint8_t eltenabled[BTHOME_MAXELT] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; +#define BTHOME_MAXELT 10 +enum captor_type { BATTERY, BATTERYVDD, TEMPERATURE, PRESSURE, ILLUMINANCE, VOLTAGE, VOLTAGEVDD, PM25, PM10, HUMIDITY }; +uint8_t eltid[BTHOME_MAXELT] = { 0x01, 0x01, 0x02, 0x04, 0x05, 0x0c, 0x0c, 0x0d, 0x0e, 0x2e }; +uint8_t eltsize[BTHOME_MAXELT] = { 1, 1, 2, 3, 3, 2, 2, 2, 2, 1}; +uint8_t eltenabled[BTHOME_MAXELT] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; +uint8_t eltenabled2[BTHOME_MAXELT] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; struct bthome_adv_t { void *fifo_reserved; @@ -59,11 +63,17 @@ struct bthome_adv_t { uint32_t data_u32; }; +uint8_t mfg_bthome_tosend = 1; + static uint8_t mfg_bthome_data[28]; uint8_t mfg_bthome_sizetosend = 0; uint8_t mfg_bthome_numelt = 0; uint8_t bthome_datapos[BTHOME_MAXELT]; - //uint8_t bthome_datapos[] = { 4, 6, 9, 12, 14, 18, 21 }; + + static uint8_t mfg_bthome_data2[28]; + uint8_t mfg_bthome_sizetosend2 = 0; + uint8_t mfg_bthome_numelt2 = 0; + uint8_t bthome_datapos2[BTHOME_MAXELT]; @@ -122,8 +132,8 @@ struct k_work_q workqueue_i2c; */ { 10000, 2800 }, - { 90, 2600 }, - { 50, 2440 }, + { 9000, 2600 }, + { 5000, 2440 }, { 0, 2300 }, }; @@ -195,10 +205,11 @@ struct k_work_q workqueue_i2c; struct bt_data ad[] = { - //BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)), + BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)), BT_DATA(BT_DATA_SVC_DATA16, mfg_bthome_data, mfg_bthome_sizetosend), }; - err = bt_le_adv_start(BT_LE_ADV_PARAM(BT_LE_ADV_OPT_USE_IDENTITY | BT_LE_ADV_OPT_USE_NAME, BT_GAP_ADV_SLOW_INT_MIN,BT_GAP_ADV_SLOW_INT_MAX, NULL), ad, ARRAY_SIZE(ad), NULL, 0); +// err = bt_le_adv_start(BT_LE_ADV_PARAM(BT_LE_ADV_OPT_USE_IDENTITY | BT_LE_ADV_OPT_USE_NAME, BT_GAP_ADV_SLOW_INT_MIN,BT_GAP_ADV_SLOW_INT_MAX, NULL), ad, ARRAY_SIZE(ad), NULL, 0); + err = bt_le_adv_start(BT_LE_ADV_PARAM(BT_LE_ADV_OPT_USE_IDENTITY, BT_GAP_ADV_SLOW_INT_MIN,BT_GAP_ADV_SLOW_INT_MAX, NULL), ad, ARRAY_SIZE(ad), NULL, 0); if (err) { printk("Advertising failed to start (err %d)\n", err); return; @@ -300,6 +311,50 @@ void mfg_bthome_build() } } +void mfg_bthome_build2() +{ + for(int i = 0; i < BTHOME_MAXELT; i++) + { + if(eltenabled2[i] == 1) + { + mfg_bthome_numelt2++; + mfg_bthome_data2[mfg_bthome_sizetosend2] = eltid[i]; + bthome_datapos2[i] = mfg_bthome_sizetosend2; + mfg_bthome_sizetosend2 = mfg_bthome_sizetosend2 + eltsize[i] + 1; + } + } +} + static void work_publish_adv_handler(struct k_work *work) + { + struct bt_data ad[] = { + BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)), + BT_DATA(BT_DATA_SVC_DATA16, mfg_bthome_data, mfg_bthome_sizetosend), + }; + struct bt_data ad2[] = { + BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)), + BT_DATA(BT_DATA_SVC_DATA16, mfg_bthome_data2, mfg_bthome_sizetosend2), + }; + if(mfg_bthome_tosend == 1) { + printk("Update ADV2\n"); + bt_le_adv_update_data(ad2, ARRAY_SIZE(ad2), NULL, 0); + mfg_bthome_tosend = 2; + } else { + printk("Update ADV1\n"); + bt_le_adv_update_data(ad, ARRAY_SIZE(ad), NULL, 0); + mfg_bthome_tosend = 1; + + } + +} + K_WORK_DEFINE(work_publish_adv, work_publish_adv_handler); + +void timer_publish_adv_handler(struct k_timer *stm) +{ + k_work_submit(&work_publish_adv); + } + K_TIMER_DEFINE(timer_publish_adv, timer_publish_adv_handler, NULL); + + void publish_adv_thread() { bool adv_activate = false; @@ -324,20 +379,21 @@ uint8_t eltreceived[BTHOME_MAXELT] = { 0, 0, 0, 0, 0, 0, 0 }; numeltreceived++; eltreceived[request->type] = 1; } + //LOG_INF("Fill BT for type %d", request->type); if(request->type == VOLTAGE) { - mfg_bthome_data[bthome_datapos[VOLTAGE]+2] = request->data_u16 >> 8; - mfg_bthome_data[bthome_datapos[VOLTAGE]+1] = request->data_u16; + mfg_bthome_data2[bthome_datapos2[VOLTAGE]+2] = request->data_u16 >> 8; + mfg_bthome_data2[bthome_datapos2[VOLTAGE]+1] = request->data_u16; } else if(request->type == BATTERY) { - mfg_bthome_data[bthome_datapos[BATTERY]+1] = request->data_u8; + mfg_bthome_data2[bthome_datapos2[BATTERY]+1] = request->data_u8; } else if(request->type == VOLTAGEVDD) { - mfg_bthome_data[bthome_datapos[VOLTAGEVDD]+2] = request->data_u16 >> 8; - mfg_bthome_data[bthome_datapos[VOLTAGEVDD]+1] = request->data_u16; + mfg_bthome_data2[bthome_datapos2[VOLTAGEVDD]+2] = request->data_u16 >> 8; + mfg_bthome_data2[bthome_datapos2[VOLTAGEVDD]+1] = request->data_u16; } else if(request->type == BATTERYVDD) { - mfg_bthome_data[bthome_datapos[BATTERYVDD]+1] = request->data_u8; + mfg_bthome_data2[bthome_datapos2[BATTERYVDD]+1] = request->data_u8; } else if(request->type == TEMPERATURE) { mfg_bthome_data[bthome_datapos[TEMPERATURE]+2] = request->data_s16 >> 8; @@ -350,6 +406,11 @@ uint8_t eltreceived[BTHOME_MAXELT] = { 0, 0, 0, 0, 0, 0, 0 }; mfg_bthome_data[bthome_datapos[PRESSURE]+3] = request->data_u32 >> 16; mfg_bthome_data[bthome_datapos[PRESSURE]+2] = request->data_u32 >> 8; mfg_bthome_data[bthome_datapos[PRESSURE]+1] = request->data_u32; + } else if(request->type == ILLUMINANCE) + { + mfg_bthome_data[bthome_datapos[ILLUMINANCE]+3] = request->data_u32 >> 16; + mfg_bthome_data[bthome_datapos[ILLUMINANCE]+2] = request->data_u32 >> 8; + mfg_bthome_data[bthome_datapos[ILLUMINANCE]+1] = request->data_u32; } else if(request->type == PM25) { mfg_bthome_data[bthome_datapos[PM25]+2] = request->data_u16 >> 8; @@ -362,60 +423,74 @@ uint8_t eltreceived[BTHOME_MAXELT] = { 0, 0, 0, 0, 0, 0, 0 }; k_free(request); } + if(numeltreceived == (mfg_bthome_numelt + mfg_bthome_numelt2)) { + if(adv_activate == false) + { + bt_ready(); + adv_activate = true; + k_timer_start(&timer_publish_adv, K_SECONDS(150), K_SECONDS(150)); + } + } + /* if(numeltreceived == mfg_bthome_numelt) { - //LOG_HEXDUMP_INF(mfg_bthome_data, mfg_bthome_sizetosend, "mfg_bthome_data"); - //printk("Send ADV Size %d\n", mfg_bthome_sizetosend); if(adv_activate == false) { bt_ready(); adv_activate = true; } else { + printk("Update ADV\n"); struct bt_data ad[] = { - //BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)), BT_DATA(BT_DATA_SVC_DATA16, mfg_bthome_data, mfg_bthome_sizetosend), }; bt_le_adv_update_data(ad, ARRAY_SIZE(ad), NULL, 0); - printk("Update ADV\n"); - //k_msleep(50); } } + */ } } K_THREAD_DEFINE(publish_adv_thread_id, STACKSIZE, publish_adv_thread, NULL, NULL, NULL, PRIORITY, 0, 0); +/*void print_heap_info(void) +{ +extern struct k_heap _system_heap; +struct sys_memory_stats stats; + sys_heap_runtime_stats_get(&_system_heap.heap, &stats); + + printk("\n"); + printk("INFO: Allocated Heap = %zu\n", stats.allocated_bytes); + printk("INFO: Free Heap = %zu\n", stats.free_bytes); + printk("INFO: Max Allocated Heap = %zu\n", stats.max_allocated_bytes); + printk("\n"); + + return; +}*/ + static void work_battery_handler(struct k_work *work) { - struct bthome_adv_t bthome_adv; - size_t size = sizeof(struct bthome_adv_t); - bthome_adv.type = VOLTAGE; + struct bthome_adv_t *bthome_adv_voltage = k_malloc(sizeof(*bthome_adv_voltage)); + bthome_adv_voltage->type = VOLTAGE; battery_setup(); - bthome_adv.data_u16 = (uint16_t) battery_sample(); - char *mem_ptr = k_malloc(size); - memcpy(mem_ptr, &bthome_adv, size); - k_fifo_put(&fifo_adv_data, mem_ptr); + bthome_adv_voltage->data_u16 = (uint16_t) battery_sample(); + k_fifo_put(&fifo_adv_data, bthome_adv_voltage); - bthome_adv.type = BATTERY; - bthome_adv.data_u8 = round(battery_level_pptt(bthome_adv.data_u16, battery_levels)/100); - char *mem_ptr2 = k_malloc(size); - memcpy(mem_ptr2, &bthome_adv, size); - k_fifo_put(&fifo_adv_data, mem_ptr2); - k_sem_give(&adv_send_ok); - printk("Battery: %d mV (%d%%)\n",bthome_adv.data_u16, bthome_adv.data_u8); + struct bthome_adv_t *bthome_adv_battery = k_malloc(sizeof(*bthome_adv_battery)); + bthome_adv_battery->type = BATTERY; + bthome_adv_battery->data_u8 = round(battery_level_pptt(bthome_adv_voltage->data_u16, battery_levels)/100); + k_fifo_put(&fifo_adv_data, bthome_adv_battery); + printk("Battery: %d mV (%d%%)\n",bthome_adv_voltage->data_u16, bthome_adv_battery->data_u8); - bthome_adv.type = VOLTAGEVDD; + struct bthome_adv_t *bthome_adv_voltagevdd = k_malloc(sizeof(*bthome_adv_voltagevdd)); + bthome_adv_voltagevdd->type = VOLTAGEVDD; batteryvdd_setup(); - bthome_adv.data_u16 = (uint16_t) batteryvdd_sample(); - char *mem_ptr3 = k_malloc(size); - memcpy(mem_ptr3, &bthome_adv, size); - k_fifo_put(&fifo_adv_data, mem_ptr3); + bthome_adv_voltagevdd->data_u16 = (uint16_t) batteryvdd_sample(); + k_fifo_put(&fifo_adv_data, bthome_adv_voltagevdd); - bthome_adv.type = BATTERYVDD; - bthome_adv.data_u8 = round(battery_level_pptt(bthome_adv.data_u16, battery_nimh_levels)/100); - char *mem_ptr4 = k_malloc(size); - memcpy(mem_ptr4, &bthome_adv, size); - k_fifo_put(&fifo_adv_data, mem_ptr4); + struct bthome_adv_t *bthome_adv_batteryvdd = k_malloc(sizeof(*bthome_adv_batteryvdd)); + bthome_adv_batteryvdd->type = BATTERYVDD; + bthome_adv_batteryvdd->data_u8 = round(battery_level_pptt(bthome_adv_voltagevdd->data_u16, battery_nimh_levels)/100); + k_fifo_put(&fifo_adv_data, bthome_adv_batteryvdd); + printk("Battery VDD: %d mV (%d%%)\n",bthome_adv_voltagevdd->data_u16, bthome_adv_batteryvdd->data_u8); k_sem_give(&adv_send_ok); - printk("Battery VDD: %d mV (%d%%)\n",bthome_adv.data_u16, bthome_adv.data_u8); } K_WORK_DEFINE(work_battery, work_battery_handler); @@ -427,22 +502,20 @@ void timer_battery_handler(struct k_timer *stm) static void work_temperature_handler(struct k_work *work) { - struct bthome_adv_t bthome_adv; + struct bthome_adv_t *bthome_adv_temperature = k_malloc(sizeof(*bthome_adv_temperature)); sht4x_probe(); - bthome_adv.type = TEMPERATURE; - bthome_adv.data_s16 = (int16_t)(sht4x_ReadTempeature()*100); - size_t size = sizeof(struct bthome_adv_t); - char *mem_ptr = k_malloc(size); - memcpy(mem_ptr, &bthome_adv, size); - k_fifo_put(&fifo_adv_data, mem_ptr); - printk("Temperature: %d°\n",bthome_adv.data_s16); - bthome_adv.type = HUMIDITY; - bthome_adv.data_u8 = (uint8_t)(sht4x_ReadHumidity()); - char *mem_ptr2 = k_malloc(size); - memcpy(mem_ptr2, &bthome_adv, size); - k_fifo_put(&fifo_adv_data, mem_ptr2); + bthome_adv_temperature->type = TEMPERATURE; + bthome_adv_temperature->data_s16 = (int16_t)(sht4x_ReadTempeature()*100); + k_fifo_put(&fifo_adv_data, bthome_adv_temperature); + printk("Temperature: %d°\n",bthome_adv_temperature->data_s16); + + + struct bthome_adv_t *bthome_adv_humidity = k_malloc(sizeof(*bthome_adv_humidity)); + bthome_adv_humidity->type = HUMIDITY; + bthome_adv_humidity->data_u8 = (uint8_t)(sht4x_ReadHumidity()); + k_fifo_put(&fifo_adv_data, bthome_adv_humidity); k_sem_give(&adv_send_ok); - printk("Humidity: %d pc \n",bthome_adv.data_u8); + printk("Humidity: %d pc \n",bthome_adv_humidity->data_u8); } K_WORK_DEFINE(work_temperature, work_temperature_handler); @@ -454,42 +527,50 @@ void timer_temperature_handler(struct k_timer *stm) static void work_pressure_handler(struct k_work *work) { - struct bthome_adv_t bthome_adv; - bthome_adv.type = PRESSURE; - bthome_adv.data_u32 = bmp180_readPressure(); - size_t size = sizeof(struct bthome_adv_t); - char *mem_ptr = k_malloc(size); - memcpy(mem_ptr, &bthome_adv, size); - k_fifo_put(&fifo_adv_data, mem_ptr); + struct bthome_adv_t *bthome_adv_pressure = k_malloc(sizeof(*bthome_adv_pressure)); + bthome_adv_pressure->type = PRESSURE; + bthome_adv_pressure->data_u32 = bmp180_readPressure(); + k_fifo_put(&fifo_adv_data, bthome_adv_pressure); k_sem_give(&adv_send_ok); - printk("Pressure: %d Pa \n",bthome_adv.data_u32); + printk("Pressure: %d Pa \n",bthome_adv_pressure->data_u32); } K_WORK_DEFINE(work_pressure, work_pressure_handler); - - void timer_pressure_handler(struct k_timer *stm) { k_work_submit_to_queue(&workqueue_i2c, &work_pressure); } K_TIMER_DEFINE(timer_pressure, timer_pressure_handler, NULL); +static void work_illuminance_handler(struct k_work *work) + { + struct bthome_adv_t *bthome_adv_illuminance = k_malloc(sizeof(*bthome_adv_illuminance)); + bh1750_probe(); + bthome_adv_illuminance->type = ILLUMINANCE; + bthome_adv_illuminance->data_u32 = (uint32_t) (bh1750_ReadLight()*100); + k_fifo_put(&fifo_adv_data, bthome_adv_illuminance); + k_sem_give(&adv_send_ok); + printk("Illuminance: %d lux \n",bthome_adv_illuminance->data_u32); + } + K_WORK_DEFINE(work_illuminance, work_illuminance_handler); +void timer_illuminance_handler(struct k_timer *stm) +{ + k_work_submit_to_queue(&workqueue_i2c, &work_illuminance); +} + K_TIMER_DEFINE(timer_illuminance, timer_illuminance_handler, NULL); + static void work_pms_handler(struct k_work *work) { sds011_probe(); - struct bthome_adv_t bthome_adv; - bthome_adv.type = PM25; - bthome_adv.data_u16 = sds011_ReadPM25(); - size_t size = sizeof(struct bthome_adv_t); - char *mem_ptr = k_malloc(size); - memcpy(mem_ptr, &bthome_adv, size); - k_fifo_put(&fifo_adv_data, mem_ptr); - printk("PM25: %d\n",bthome_adv.data_u16); - bthome_adv.type = PM10; - bthome_adv.data_u16 = sds011_ReadPM10(); - char *mem_ptr2 = k_malloc(size); - memcpy(mem_ptr2, &bthome_adv, size); - k_fifo_put(&fifo_adv_data, mem_ptr2); - printk("PM10: %d\n",bthome_adv.data_u16); + struct bthome_adv_t *bthome_adv_pm25 = k_malloc(sizeof(*bthome_adv_pm25)); + bthome_adv_pm25->type = PM25; + bthome_adv_pm25->data_u16 = sds011_ReadPM25(); + k_fifo_put(&fifo_adv_data, bthome_adv_pm25); + printk("PM25: %d\n",bthome_adv_pm25->data_u16); + struct bthome_adv_t *bthome_adv_pm10 = k_malloc(sizeof(*bthome_adv_pm10)); + bthome_adv_pm10->type = PM10; + bthome_adv_pm10->data_u16 = sds011_ReadPM10(); + k_fifo_put(&fifo_adv_data, bthome_adv_pm10); + printk("PM10: %d\n",bthome_adv_pm10->data_u16); k_sem_give(&adv_send_ok); } K_WORK_DEFINE(work_pms, work_pms_handler); @@ -503,7 +584,7 @@ void timer_pms_handler(struct k_timer *stm) int main(void) { - printk("Hello, It's TuxOutdooor\n"); + LOG_WRN("Hello, It's TuxOutdooor"); int err; // bt_passkey_set(192847); @@ -512,6 +593,12 @@ void timer_pms_handler(struct k_timer *stm) mfg_bthome_data[2]=0x40; mfg_bthome_sizetosend=3; + mfg_bthome_data2[0]=0xd2; + mfg_bthome_data2[1]=0xfc; + mfg_bthome_data2[2]=0x40; + mfg_bthome_sizetosend2=3; + + for(int i = 0; i < BTHOME_MAXELT; i++) { bthome_datapos[i] = 255; @@ -537,6 +624,7 @@ k_work_queue_start(&workqueue_i2c, stack_wq_i2c, K_THREAD_STACK_SIZEOF(stack_wq_ k_work_queue_init(&workqueue_pms); k_work_queue_start(&workqueue_pms, stack_wq_pms, K_THREAD_STACK_SIZEOF(stack_wq_pms), PRIORITY, NULL); + k_msleep(250); if(sht4x_setup() == 0) { printk("SHT4x enabled\n"); @@ -548,7 +636,8 @@ k_work_queue_start(&workqueue_pms, stack_wq_pms, K_THREAD_STACK_SIZEOF(stack_wq_ printk("SHT4x disabled\n"); } - k_msleep(50); + k_msleep(250); + if(bmp180_setup() == 0) { printk("BMP180 enabled\n"); @@ -559,7 +648,9 @@ k_work_queue_start(&workqueue_pms, stack_wq_pms, K_THREAD_STACK_SIZEOF(stack_wq_ printk("BMP180 disabled\n"); } - k_msleep(50); + + k_msleep(250); + if(sds011_setup() == 0) { printk("SDS011 enabled\n"); k_work_submit_to_queue(&workqueue_pms, &work_pms); @@ -569,18 +660,28 @@ k_work_queue_start(&workqueue_pms, stack_wq_pms, K_THREAD_STACK_SIZEOF(stack_wq_ } else { printk("SDS011 disabled\n"); } - - - k_msleep(50); + k_msleep(2000); + + if(bh1750_setup() == 0) { + printk("BH1750 enabled\n"); + k_work_submit_to_queue(&workqueue_i2c, &work_illuminance); + k_timer_start(&timer_illuminance, K_SECONDS(300), K_SECONDS(300)); + eltenabled[ILLUMINANCE] = 1; + } else { + printk("BH1750 disabled\n"); + } + + k_msleep(250); k_work_submit(&work_battery); k_timer_start(&timer_battery, K_SECONDS(3600), K_SECONDS(3600)); - eltenabled[BATTERY] = 1; - eltenabled[VOLTAGE] = 1; - eltenabled[BATTERYVDD] = 1; - eltenabled[VOLTAGEVDD] = 1; + eltenabled2[BATTERY] = 1; + eltenabled2[VOLTAGE] = 1; + eltenabled2[BATTERYVDD] = 1; + eltenabled2[VOLTAGEVDD] = 1; mfg_bthome_build(); + mfg_bthome_build2(); k_sem_give(&ble_init_ok); /* for(;;) diff --git a/src/sds011.c b/src/sds011.c index 7500116..f8e5ea5 100644 --- a/src/sds011.c +++ b/src/sds011.c @@ -1,6 +1,7 @@ #include #include #include +#include #include "sds011.h" @@ -33,6 +34,10 @@ static K_FIFO_DEFINE(fifo_pms); #define WARMUPTIME_SDS_MS 15000 #define READINGTIME_SDS_MS 5000 +#define GPIO_PORT DT_NODELABEL(gpio0) +#define GPIO_PIN 22 +const struct device *devgpio = DEVICE_DT_GET(GPIO_PORT); + uint16_t sds_pm10; uint16_t sds_pm25; @@ -49,7 +54,7 @@ uint32_t getTsSDS() void send_uart_cmd(uint8_t *buf) { //int msg_len = strlen(buf); - printk("Send to uart\n"); + //printk("Send to uart\n"); for (int i = 0; i < 19; i++) { uart_poll_out(uart_dev, buf[i]); @@ -118,11 +123,15 @@ int sds011_setup() } uart_irq_rx_enable(uart_dev); - send_uart_cmd(SDS_WAKEUPCMD); - k_msleep(2000); + gpio_pin_configure(devgpio, GPIO_PIN, GPIO_OUTPUT | GPIO_OPEN_DRAIN); + + gpio_pin_set(devgpio, GPIO_PIN, 0); + //send_uart_cmd(SDS_WAKEUPCMD); + k_msleep(5000); if(uart_data_received == true) { return 0; } else { + gpio_pin_set(devgpio, GPIO_PIN, 1); return -1; } } @@ -132,7 +141,8 @@ int sds011_setup() int sds011_probe() { uint32_t ts_start_measure; - send_uart_cmd(SDS_WAKEUPCMD); + gpio_pin_set(devgpio, GPIO_PIN, 0); + //send_uart_cmd(SDS_WAKEUPCMD); pms_warming = true; pms_enable = true; k_msleep(WARMUPTIME_SDS_MS); @@ -175,17 +185,18 @@ int sds011_probe() printk("p10: %d p25: %d\n", pm10_serial, pm25_serial); } - k_free(pms_data_read); } else { send_uart_cmd(SDS_SLEEPCMD); pms_enable = false; } + k_free(pms_data_read); } else { break; } } + gpio_pin_set(devgpio, GPIO_PIN, 1); if (sds_val_count > 2) { sds_pm10_sum = sds_pm10_sum - sds_pm10_min - sds_pm10_max; diff --git a/zephyr/boards/nrf52dk_nrf52832.overlay b/zephyr/boards/nrf52dk_nrf52832.overlay index e0f15cb..f814281 100644 --- a/zephyr/boards/nrf52dk_nrf52832.overlay +++ b/zephyr/boards/nrf52dk_nrf52832.overlay @@ -32,6 +32,11 @@ reg = <0x44>; repeatability = <2>; }; + bh1750@23 { + status = "okay"; + compatible = "rohm,bh1750"; + reg = <0x23>; + }; }; &i2c1 { diff --git a/zephyr/prj.conf b/zephyr/prj.conf index da4a0e1..6305d8d 100644 --- a/zephyr/prj.conf +++ b/zephyr/prj.conf @@ -29,13 +29,22 @@ CONFIG_UART_CONSOLE=n CONFIG_RTT_CONSOLE=y CONFIG_STDOUT_CONSOLE=y +#CONFIG_THREAD_ANALYZER=y +#CONFIG_THREAD_ANALYZER_USE_PRINTK=y +#CONFIG_THREAD_ANALYZER_AUTO=y +#CONFIG_THREAD_ANALYZER_AUTO_INTERVAL=5 +#CONFIG_THREAD_NAME=y +#CONFIG_DEBUG_INFO=y + CONFIG_ADC=y CONFIG_GPIO=y CONFIG_SERIAL=y CONFIG_UART_INTERRUPT_DRIVEN=y CONFIG_BOARD_ENABLE_DCDC=n -CONFIG_HEAP_MEM_POOL_SIZE=512 +CONFIG_HEAP_MEM_POOL_SIZE=2048 +#CONFIG_SYS_HEAP_RUNTIME_STATS=y + CONFIG_NEWLIB_LIBC=y CONFIG_NEWLIB_LIBC_NANO=y