Smart Home Fire Detector Iot Project

Made by ElijahMaluleke / Artificial intelligence / Environmental Sensing / Fire & Pyrotechnics / Home Automation / IoT

About the project

This is a Smart Home Fire Detector IoT project that sends temperature and air quality index to AWS IoT Core every 60 seconds. The IoT Core writes this data to Amazon Timestream. If the temperature is above 35 degrees and AQI is more than 200, it triggers the alarm.

Project info

Difficulty: Moderate

Platforms: Amazon Web Services, Linux Arm, Arm, MQTT, Nordic Semiconductor

Estimated time: 1 month

License: GNU General Public License, version 3 or later (GPL3+)

Items used in this project

Hardware components

	Power transformer, chassis mount, 24VA, 24V @ 1A or 12V @ 2A	x 1
	12V 1A Fixed Voltage Regulator	x 1
	5V 1A Fixed Voltage Regulator	x 1
	3,3V 500mA Fixed Voltage Regulator	x 1
	1N4007 Diodes	x 13
	1n4148 Signal Diode	x 1
	2N2222A NPN Transistor	x 1
	5mm Red LED	x 2
	100uf 16v Electrolytic Capacitors	x 4
	680uf 35 Electrolytic Capacitor	x 1
	Resistor 1k Ohm 1/4 Watt	x 2
	100 Ohm Resistor 1/4 Watt	x 1
	2 Way Terminal Block	x 1
	4 Way Header Male	x 1
	USB Female Type B Connector	x 1
	3-pin Plug	x 1
	100mA Fast Blow Fuse	x 1
	12V 20W Siren Horn	x 1
	4cm x 5cm Strip Board	x 1
	4.5 Hex 5.0mm Spacers	x 6
	Sensor Tool W nRF52840 & nRF9160	x 1
	Pos Adj Reg; 3-Term Dual Gauge Heat Sink	x 3
	USB Cable A/MicroB - 3ft	x 1
	DC12V 10A/125VAC,28VDC Relay	x 1

View all

Software apps and online services

	SEGGER Embedded Studio
	Zephyr RTOS
	Amazon Web Services (AWS)

Hand tools and fabrication machines

	230VAC 30W Soldering Iron	x 1
	Long Nose	x 1
	Side Cutter	x 1
	8 Core Wire x 30cm	x 1
	Star Screw Driver	x 1
	60mm x 50mm Plastic Base	x 1
	Battery Powered Drill	x 1

Story

Even though the number of deaths due to house fires has decreased drastically worldwide, damage to property is of concern. A Smart Home Fire Detector IoT project is an IoT device that sends telemetry data to Amazon Web Services (AWS) IoT Core service. It sends temperature and air quality index every 60 seconds. The AWS IoT Core service writes this data to Amazon Timestream Database Table. If the temperature rises above 35 degrees Celsius and the air quality index is more than 200, the Nordic Thingy:91 triggers the alarm and AWS IoT Core service sends a message to AWS Simple Notification Service (SNS) topic. The AWS SNS then sends an SMS and email to the homeowners informing them of the situation in their homes. The collected data is analyzed and visualized using AWS QuickInsights.

How it works

Hardware Components

The heart of this IoT project is the NordicThingy:91 Cellular IoT Prototyping Plartform. It has the following four main hardware components:

Nordic Thingy:91

Zephyr RTOS is the Real-Time Operating System that runs on the nRF9160 (System in Package). This is an Open Source Linux RTOS that is specifically aimed at memory-constrained IoT devices.

Power Supply + Siren Controller

12V 1A Transformer

12V 20W Siren Horn

It uses this siren to alert the people in the house that the environmental condition is unhealthy and hazardous and that they attend to the house and see what's wrong.

Software and online services

The nRF Connect SDK comes bundled with apps that are used to write, build and flash the Thingy:91. In my case, I used SEGGER Embedded Studio to write and compile the application code. I used the nRF Connect Programmer app to flash the board and the nRF Connect LTE Link Monitor as a Console Logs.

nRF Connect Desktop

SEGGER Embedded Studio app

Programmer app

LTE Link Monitor app

AWS IoT Core

The Smart Home Fire Detector IoT project sends temperature and air quality index to this AWS service.

Amazon Timestream

The AWS IoT Core writes telemetry data to this Amazo Timestream Database every 60 seconds.

Schematics, diagrams and documents

Code

main.c

/*
 * Copyright (c) 2020 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */

#include <zephyr.h>
#include <stdio.h>
#include <stdlib.h>
#if defined(CONFIG_NRF_MODEM_LIB)
#include <modem/lte_lc.h>
#include <modem/nrf_modem_lib.h>
#include <modem/modem_info.h>
#include <nrf_modem.h>
#endif
#include <net/aws_iot.h>
#include <sys/reboot.h>
#include <date_time.h>
#include <dfu/mcuboot.h>
#include <cJSON.h>
#include <cJSON_os.h>
#include <device.h>
#include <devicetree.h>
#include <drivers/gpio.h>

#define LED_STATE 0
#define SIREN_STATE 1 

/* 1000 msec = 1 sec */
#define SLEEP_TIME_MS   20000
/* 1000 msec = 1 sec */
#define SIREN_SLEEP_TIME_MS   1000

/* The devicetree node identifier for the "led0" alias. */
#define LED0_NODE DT_ALIAS(led0)

#if DT_NODE_HAS_STATUS(LED0_NODE, okay)
#define LED0	DT_GPIO_LABEL(LED0_NODE, gpios)
#define PIN	DT_GPIO_PIN(LED0_NODE, gpios)
#define FLAGS	DT_GPIO_FLAGS(LED0_NODE, gpios)
#else
/* A build error here means your board isn't set up to blink an LED. */
#error "Unsupported board: led0 devicetree alias is not defined"
#define LED0	""
#define PIN	0
#define FLAGS	0
#endif

//#define MY_BME680 DT_PATH(soc, peripheral_40000000_PARENT)

bool led_is_on = true;
float temperature = 0;
int16_t airquality = 0;

BUILD_ASSERT(!IS_ENABLED(CONFIG_LTE_AUTO_INIT_AND_CONNECT),
		"This sample does not support LTE auto-init and connect");

#define APP_TOPICS_COUNT CONFIG_AWS_IOT_APP_SUBSCRIPTION_LIST_COUNT

static struct k_work_delayable shadow_update_work;
static struct k_work_delayable connect_work;
static struct k_work shadow_update_version_work;

static bool cloud_connected;

K_SEM_DEFINE(lte_connected, 0, 1);

const struct device *dev;
void gpio_siren_led_on_off(char state, bool led_siren);
void gpio_init(void);

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
static int json_add_obj(cJSON *parent, const char *str, cJSON *item)
{
	cJSON_AddItemToObject(parent, str, item);

	return 0;
}

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
static int json_add_str(cJSON *parent, const char *str, const char *item)
{
	cJSON *json_str;

	json_str = cJSON_CreateString(item);
	if (json_str == NULL) {
		return -ENOMEM;
	}

	return json_add_obj(parent, str, json_str);
}

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
static int json_add_number(cJSON *parent, const char *str, double item)
{
	cJSON *json_num;

	json_num = cJSON_CreateNumber(item);
	if (json_num == NULL) {
		return -ENOMEM;
	}

	return json_add_obj(parent, str, json_num);
}

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
static int shadow_update(bool version_number_include)
{
	int err;
	char *message;
	int64_t message_ts = 0;
	int16_t bat_voltage = 0;
        
        temperature = 25.0;
        airquality = 100;
        gpio_siren_led_on_off(SIREN_STATE, false);
        gpio_siren_led_on_off(LED_STATE, true);
	err = date_time_now(&message_ts);
	if (err) {
		printk("date_time_now, error: %d\n", err);
		return err;
	}

#if defined(CONFIG_NRF_MODEM_LIB)
	/* Request battery voltage data from the modem. */
	err = modem_info_short_get(MODEM_INFO_BATTERY, &bat_voltage);
	if (err != sizeof(bat_voltage)) {
		printk("modem_info_short_get, error: %d\n", err);
		return err;
	}
#endif

	cJSON *root_obj = cJSON_CreateObject();
	cJSON *state_obj = cJSON_CreateObject();
	cJSON *reported_obj = cJSON_CreateObject();

	if (root_obj == NULL || state_obj == NULL || reported_obj == NULL) {
		cJSON_Delete(root_obj);
		cJSON_Delete(state_obj);
		cJSON_Delete(reported_obj);
		err = -ENOMEM;
		return err;
	}

	if (version_number_include) {
		err = json_add_str(reported_obj, "app_version",
				    CONFIG_APP_VERSION);
	} else {
		err = 0;
	}

	err += json_add_number(reported_obj, "battery_voltage", bat_voltage);
	err += json_add_number(reported_obj, "time_stamp", message_ts);
        err += json_add_number(reported_obj, "temperature", temperature);
        err += json_add_number(reported_obj, "airquality", airquality);
	err += json_add_obj(state_obj, "reported", reported_obj);
	err += json_add_obj(root_obj, "state", state_obj);

	if (err) {
		printk("json_add, error: %d\n", err);
		goto cleanup;
	}

	message = cJSON_Print(root_obj);
	if (message == NULL) {
		printk("cJSON_Print, error: returned NULL\n");
		err = -ENOMEM;
		goto cleanup;
	}

	struct aws_iot_data tx_data = {
		.qos = MQTT_QOS_0_AT_MOST_ONCE,
		.topic.type = AWS_IOT_SHADOW_TOPIC_UPDATE,
		.ptr = message,
		.len = strlen(message)
	};

	printk("Publishing: %s to AWS IoT broker\n", message);

	err = aws_iot_send(&tx_data);
	if (err) {
		printk("aws_iot_send, error: %d\n", err);
	}

	cJSON_FreeString(message);
        k_msleep(SIREN_SLEEP_TIME_MS);
        gpio_siren_led_on_off(SIREN_STATE, true);
        gpio_siren_led_on_off(LED_STATE, false);

cleanup:

	cJSON_Delete(root_obj);

	return err;
}

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
static void connect_work_fn(struct k_work *work)
{
	int err;

	if (cloud_connected) {
		return;
	}

	err = aws_iot_connect(NULL);
	if (err) {
		printk("aws_iot_connect, error: %d\n", err);
	}

	printk("Next connection retry in %d seconds\n",
	       CONFIG_CONNECTION_RETRY_TIMEOUT_SECONDS);

	k_work_schedule(&connect_work,
			K_SECONDS(CONFIG_CONNECTION_RETRY_TIMEOUT_SECONDS));
}

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
static void shadow_update_work_fn(struct k_work *work)
{
	int err;

	if (!cloud_connected) {
		return;
	}

	err = shadow_update(false);
	if (err) {
		printk("shadow_update, error: %d\n", err);
	}


	printk("Next data publication in %d seconds\n",
	       CONFIG_PUBLICATION_INTERVAL_SECONDS);

	k_work_schedule(&shadow_update_work,
			K_SECONDS(CONFIG_PUBLICATION_INTERVAL_SECONDS));
}

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
static void shadow_update_version_work_fn(struct k_work *work)
{
	int err;

	err = shadow_update(true);
	if (err) {
		printk("shadow_update, error: %d\n", err);
	}
}

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
static void print_received_data(const char *buf, const char *topic,
				size_t topic_len)
{
	char *str = NULL;
	cJSON *root_obj = NULL;

	root_obj = cJSON_Parse(buf);
	if (root_obj == NULL) {
		printk("cJSON Parse failure");
		return;
	}

	str = cJSON_Print(root_obj);
	if (str == NULL) {
		printk("Failed to print JSON object");
		goto clean_exit;
	}

	printf("Data received from AWS IoT console:\nTopic: %.*s\nMessage: %s\n",
	       topic_len, topic, str);

	cJSON_FreeString(str);

clean_exit:
	cJSON_Delete(root_obj);
}

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
void aws_iot_event_handler(const struct aws_iot_evt *const evt)
{
	switch (evt->type) {
	case AWS_IOT_EVT_CONNECTING:
		printk("AWS_IOT_EVT_CONNECTING\n");
		break;
	case AWS_IOT_EVT_CONNECTED:
		printk("AWS_IOT_EVT_CONNECTED\n");

		cloud_connected = true;
		/* This may fail if the work item is already being processed,
		 * but in such case, the next time the work handler is executed,
		 * it will exit after checking the above flag and the work will
		 * not be scheduled again.
		 */
		(void)k_work_cancel_delayable(&connect_work);

		if (evt->data.persistent_session) {
			printk("Persistent session enabled\n");
		}

#if defined(CONFIG_NRF_MODEM_LIB)
		/** Successfully connected to AWS IoT broker, mark image as
		 *  working to avoid reverting to the former image upon reboot.
		 */
		boot_write_img_confirmed();
#endif

		/** Send version number to AWS IoT broker to verify that the
		 *  FOTA update worked.
		 */
		k_work_submit(&shadow_update_version_work);

		/** Start sequential shadow data updates.
		 */
		k_work_schedule(&shadow_update_work,
				K_SECONDS(CONFIG_PUBLICATION_INTERVAL_SECONDS));

#if defined(CONFIG_NRF_MODEM_LIB)
		int err = lte_lc_psm_req(true);
		if (err) {
			printk("Requesting PSM failed, error: %d\n", err);
		}
                else{
                  printk("Requesting PSM OK\n");
                }
#endif
		break;
	case AWS_IOT_EVT_READY:
		printk("AWS_IOT_EVT_READY\n");
		break;
	case AWS_IOT_EVT_DISCONNECTED:
		printk("AWS_IOT_EVT_DISCONNECTED\n");
		cloud_connected = false;
		/* This may fail if the work item is already being processed,
		 * but in such case, the next time the work handler is executed,
		 * it will exit after checking the above flag and the work will
		 * not be scheduled again.
		 */
		(void)k_work_cancel_delayable(&shadow_update_work);
		k_work_schedule(&connect_work, K_NO_WAIT);
		break;
	case AWS_IOT_EVT_DATA_RECEIVED:
		printk("AWS_IOT_EVT_DATA_RECEIVED\n");
		print_received_data(evt->data.msg.ptr, evt->data.msg.topic.str,
				    evt->data.msg.topic.len);
		break;
	case AWS_IOT_EVT_FOTA_START:
		printk("AWS_IOT_EVT_FOTA_START\n");
		break;
	case AWS_IOT_EVT_FOTA_ERASE_PENDING:
		printk("AWS_IOT_EVT_FOTA_ERASE_PENDING\n");
		printk("Disconnect LTE link or reboot\n");
#if defined(CONFIG_NRF_MODEM_LIB)
		err = lte_lc_offline();
		if (err) {
			printk("Error disconnecting from LTE\n");
		}
                else{
                  printk("Disconnecting from LTE OK\n");
                }
#endif
		break;
	case AWS_IOT_EVT_FOTA_ERASE_DONE:
		printk("AWS_FOTA_EVT_ERASE_DONE\n");
		printk("Reconnecting the LTE link");
#if defined(CONFIG_NRF_MODEM_LIB)
		err = lte_lc_connect();
		if (err) {
			printk("Error connecting to LTE\n");
		}

#endif
		break;
	case AWS_IOT_EVT_FOTA_DONE:
		printk("AWS_IOT_EVT_FOTA_DONE\n");
		printk("FOTA done, rebooting device\n");
		aws_iot_disconnect();
		sys_reboot(0);
		break;
	case AWS_IOT_EVT_FOTA_DL_PROGRESS:
		printk("AWS_IOT_EVT_FOTA_DL_PROGRESS, (%d%%)",
		       evt->data.fota_progress);
	case AWS_IOT_EVT_ERROR:
		printk("AWS_IOT_EVT_ERROR, %d\n", evt->data.err);
		break;
	case AWS_IOT_EVT_FOTA_ERROR:
		printk("AWS_IOT_EVT_FOTA_ERROR");
		break;
	default:
		printk("Unknown AWS IoT event type: %d\n", evt->type);
		break;
	}
}

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
static void work_init(void)
{
	k_work_init_delayable(&shadow_update_work, shadow_update_work_fn);
	k_work_init_delayable(&connect_work, connect_work_fn);
	k_work_init(&shadow_update_version_work, shadow_update_version_work_fn);
}

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
#if defined(CONFIG_NRF_MODEM_LIB)
static void lte_handler(const struct lte_lc_evt *const evt)
{
	switch (evt->type) {
	case LTE_LC_EVT_NW_REG_STATUS:
		if ((evt->nw_reg_status != LTE_LC_NW_REG_REGISTERED_HOME) &&
		     (evt->nw_reg_status != LTE_LC_NW_REG_REGISTERED_ROAMING)) {
			break;
		}

		printk("Network registration status: %s\n",
			evt->nw_reg_status == LTE_LC_NW_REG_REGISTERED_HOME ?
			"Connected - home network" : "Connected - roaming");

		k_sem_give(&lte_connected);
		break;
	case LTE_LC_EVT_PSM_UPDATE:
		printk("PSM parameter update: TAU: %d, Active time: %d\n",
			evt->psm_cfg.tau, evt->psm_cfg.active_time);
		break;
	case LTE_LC_EVT_EDRX_UPDATE: {
		char log_buf[60];
		ssize_t len;

		len = snprintf(log_buf, sizeof(log_buf),
			       "eDRX parameter update: eDRX: %f, PTW: %f",
			       evt->edrx_cfg.edrx, evt->edrx_cfg.ptw);
		if (len > 0) {
			printk("%s\n", log_buf);
		}
		break;
	}
	case LTE_LC_EVT_RRC_UPDATE:
		printk("RRC mode: %s\n",
			evt->rrc_mode == LTE_LC_RRC_MODE_CONNECTED ?
			"Connected" : "Idle");
		break;
	case LTE_LC_EVT_CELL_UPDATE:
		printk("LTE cell changed: Cell ID: %d, Tracking area: %d\n",
			evt->cell.id, evt->cell.tac);
		break;
	default:
		break;
	}
}

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
static void modem_configure(void)
{
	int err;

	if (IS_ENABLED(CONFIG_LTE_AUTO_INIT_AND_CONNECT)) {
		/* Do nothing, modem is already configured and LTE connected. */
	} else {
		err = lte_lc_init_and_connect_async(lte_handler);
		if (err) {
			printk("Modem could not be configured, error: %d\n",
				err);
			return;
		}
                else{
                  printk("Modem configured\n");
                }
	}
}

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
static void nrf_modem_lib_dfu_handler(void)
{
	int err;

	err = nrf_modem_lib_get_init_ret();

	switch (err) {
	case MODEM_DFU_RESULT_OK:
		printk("Modem update suceeded, reboot\n");
		sys_reboot(SYS_REBOOT_COLD);
		break;
	case MODEM_DFU_RESULT_UUID_ERROR:
	case MODEM_DFU_RESULT_AUTH_ERROR:
		printk("Modem update failed, error: %d\n", err);
		printk("Modem will use old firmware\n");
		sys_reboot(SYS_REBOOT_COLD);
		break;
	case MODEM_DFU_RESULT_HARDWARE_ERROR:
	case MODEM_DFU_RESULT_INTERNAL_ERROR:
		printk("Modem update malfunction, error: %d, reboot\n", err);
		sys_reboot(SYS_REBOOT_COLD);
		break;
	default:
		break;
	}
}
#endif

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
static int app_topics_subscribe(void)
{
	int err;
	static char custom_topic[75] = "nRF9160/pub";
	static char custom_topic_2[75] = "SHFDIoT/pub";

	const struct aws_iot_topic_data topics_list[APP_TOPICS_COUNT] = {
		[0].str = custom_topic,
		[0].len = strlen(custom_topic),
		[1].str = custom_topic_2,
		[1].len = strlen(custom_topic_2)
	};

	err = aws_iot_subscription_topics_add(topics_list,
					      ARRAY_SIZE(topics_list));
	if (err) {
		printk("aws_iot_subscription_topics_add, error: %d\n", err);
	}
        else{
                printk("aws_iot_subscription_topics_added\n");
        }

	return err;
}

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
static void date_time_event_handler(const struct date_time_evt *evt)
{
	switch (evt->type) {
	case DATE_TIME_OBTAINED_MODEM:
		printk("DATE_TIME_OBTAINED_MODEM\n");
		break;
	case DATE_TIME_OBTAINED_NTP:
		printk("DATE_TIME_OBTAINED_NTP\n");
		break;
	case DATE_TIME_OBTAINED_EXT:
		printk("DATE_TIME_OBTAINED_EXT\n");
		break;
	case DATE_TIME_NOT_OBTAINED:
		printk("DATE_TIME_NOT_OBTAINED\n");
		break;
	default:
		break;
	}
}

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
void gpio_siren_led_on_off(char state, bool led_siren) {
	led_is_on = led_siren;
        switch(state) {
          case LED_STATE:
		if (led_is_on) {
                  gpio_pin_set(dev, PIN, (int)led_is_on);
                }
                else
                {
                  gpio_pin_set(dev, PIN, (int)led_is_on);
                }
		break;
	
        case SIREN_STATE:
		if (led_is_on) {
                  gpio_pin_set(dev, 16, (int)led_is_on);

                }
                else
                {
                  gpio_pin_set(dev, 16, (int)led_is_on);
                }
		break;
	
        default:
		break;          
        }
}

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
void gpio_init(void) {

	int ret;

	dev = device_get_binding(LED0);
	if (dev == NULL) {
		return;
	}

	ret = gpio_pin_configure(dev, PIN, GPIO_OUTPUT_ACTIVE | FLAGS);
	if (ret < 0) {
		return;
	}

        ret = gpio_pin_configure(dev, 16, GPIO_OUTPUT_ACTIVE | FLAGS);
	if (ret < 0) {
		return;
	}
}

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
void i2c_config(void) {
      //const struct device *i2c_dev = device_get_binding(DT_LABEL(MY_BME680));
      //const struct device *i2c_dev = DEVICE_DT_GET(MY_BME680);
      /* 
      if (!device_is_ready(i2c_dev)) {
              printk("The device is not ready\n");
              return;
      }
      else {
              printk("The device is ready\n");
              return;
      }*/
}

/********************************************************************************
 *                                                                              *
 ********************************************************************************/
void main(void)
{
	int err;

        gpio_init();
        gpio_siren_led_on_off(LED_STATE, true);
        gpio_siren_led_on_off(SIREN_STATE, true);
        i2c_config();
        k_msleep(SLEEP_TIME_MS);	
	printk("The AWS IoT sample started, version: %s\n", CONFIG_APP_VERSION);
        cJSON_Init();

#if defined(CONFIG_NRF_MODEM_LIB)
	nrf_modem_lib_dfu_handler();
#endif

	err = aws_iot_init(NULL, aws_iot_event_handler);
	if (err) {
		printk("AWS IoT library could not be initialized, error: %d\n",
		       err);
	}
        else{
          printk("AWS IoT library initialized\n");
        }

	/** Subscribe to customizable non-shadow specific topics
	 *  to AWS IoT backend.
	 */
	err = app_topics_subscribe();
	if (err) {
		printk("Adding application specific topics failed, error: %d\n",
			err);
	}
        else{
          printk("Added application specific topics\n");
        }

	work_init();
#if defined(CONFIG_NRF_MODEM_LIB)
	modem_configure();

	err = modem_info_init();
	if (err) {
		printk("Failed initializing modem info module, error: %d\n",
			err);
	}
        else{
          printk("Initialized modem info module\n");
        }

	k_sem_take(&lte_connected, K_FOREVER);
#endif


	date_time_update_async(date_time_event_handler);
	k_work_schedule(&connect_work, K_NO_WAIT);
}

Shop

Project Hub

Video

Blog

Shop home

3D printing

Single Board Computers

Development kits

Sensors

Internet of things

Robotics

Accessories

Product of the Week

Electromaker Educator

The Electromaker Show

The Electromaker Podcast

Smart Home Fire Detector Iot Project

About the project

Project info