// CD74HC4067 // 16-Channel Analog Multiplexer // Demultiplexing not implemented for this simulation. // https://www.ti.com/lit/ds/symlink/cd74hc4067.pdf #include // Libraries for MQTT client and WiFi connection #include #include // Azure IoT SDK for C includes #include #include #include // Additional sample headers #include "AzIoTSasToken.h" #include "SerialLogger.h" #include "iot_configs.h" // Json library header #include #define S0 18 #define S1 19 #define S2 22 #define S3 23 #define COM 34 #define NP_PIN 4 #define NUMPIXELS 16 Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, NP_PIN, NEO_GRB + NEO_KHZ800); const uint8_t controlPins[] = { S0, S1, S2, S3 }; #define AZURE_SDK_CLIENT_USER_AGENT "c/" AZ_SDK_VERSION_STRING "(ard;esp32)" // Utility macros and defines #define sizeofarray(a) (sizeof(a) / sizeof(a[0])) #define NTP_SERVERS "pool.ntp.org", "time.nist.gov" #define MQTT_QOS1 1 #define DO_NOT_RETAIN_MSG 0 #define SAS_TOKEN_DURATION_IN_MINUTES 60 #define UNIX_TIME_NOV_13_2017 1510592825 #define PST_TIME_ZONE -8 #define PST_TIME_ZONE_DAYLIGHT_SAVINGS_DIFF 1 #define GMT_OFFSET_SECS (PST_TIME_ZONE * 3600) #define GMT_OFFSET_SECS_DST ((PST_TIME_ZONE + PST_TIME_ZONE_DAYLIGHT_SAVINGS_DIFF) * 3600) const uint8_t muxChannels [16][4] = { {0,0,0,0}, {1,0,0,0}, {0,1,0,0}, {1,1,0,0}, {0,0,1,0}, {1,0,1,0}, {0,1,1,0}, {1,1,1,0}, {0,0,0,1}, {1,0,0,1}, {0,1,0,1}, {1,1,0,1}, {0,0,1,1}, {1,0,1,1}, {0,1,1,1}, {1,1,1,1} }; float readMux(int channel) { for(int i = 0; i < 4; i ++) { digitalWrite(controlPins[i], muxChannels[channel][i]); } delay(10); return analogRead(COM); } // Translate iot_configs.h defines into variables used by the sample static const char* ssid = IOT_CONFIG_WIFI_SSID; static const char* password = IOT_CONFIG_WIFI_PASSWORD; static const char* host = IOT_CONFIG_IOTHUB_FQDN; static const char* mqtt_broker_uri = "mqtts://" IOT_CONFIG_IOTHUB_FQDN; static const char* device_id = IOT_CONFIG_DEVICE_ID; static const int mqtt_port = AZ_IOT_DEFAULT_MQTT_CONNECT_PORT; // Memory allocated for the sample's variables and structures. static esp_mqtt_client_handle_t mqtt_client; static az_iot_hub_client client; static char mqtt_client_id[128]; static char mqtt_username[128]; static char mqtt_password[200]; static uint8_t sas_signature_buffer[256]; static unsigned long next_telemetry_send_time_ms = 0; static char telemetry_topic[128]; static char telemetry_payload[1024]; static uint32_t telemetry_send_count = 0; #define INCOMING_DATA_BUFFER_SIZE 128 static char incoming_data[INCOMING_DATA_BUFFER_SIZE]; static AzIoTSasToken sasToken( &client, AZ_SPAN_FROM_STR(IOT_CONFIG_DEVICE_KEY), AZ_SPAN_FROM_BUFFER(sas_signature_buffer), AZ_SPAN_FROM_BUFFER(mqtt_password)); static void connectToWiFi() { Logger.Info("Connecting to WIFI SSID " + String(ssid)); WiFi.mode(WIFI_STA); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(""); Logger.Info("WiFi connected, IP address: " + WiFi.localIP().toString()); } static void initializeTime() { Logger.Info("Setting time using SNTP"); configTime(GMT_OFFSET_SECS, GMT_OFFSET_SECS_DST, NTP_SERVERS); time_t now = time(NULL); while (now < UNIX_TIME_NOV_13_2017) { delay(500); Serial.print("."); now = time(nullptr); } Serial.println(""); Logger.Info("Time initialized!"); } static esp_err_t mqtt_event_handler(esp_mqtt_event_handle_t event) { switch (event->event_id) { int i, r; case MQTT_EVENT_ERROR: Logger.Info("MQTT event MQTT_EVENT_ERROR"); break; case MQTT_EVENT_CONNECTED: Logger.Info("MQTT event MQTT_EVENT_CONNECTED"); r = esp_mqtt_client_subscribe(mqtt_client, AZ_IOT_HUB_CLIENT_C2D_SUBSCRIBE_TOPIC, 1); if (r == -1) { Logger.Error("Could not subscribe for cloud-to-device messages."); } else { Logger.Info("Subscribed for cloud-to-device messages; message id:" + String(r)); } break; case MQTT_EVENT_DISCONNECTED: Logger.Info("MQTT event MQTT_EVENT_DISCONNECTED"); break; case MQTT_EVENT_SUBSCRIBED: Logger.Info("MQTT event MQTT_EVENT_SUBSCRIBED"); break; case MQTT_EVENT_UNSUBSCRIBED: Logger.Info("MQTT event MQTT_EVENT_UNSUBSCRIBED"); break; case MQTT_EVENT_PUBLISHED: Logger.Info("MQTT event MQTT_EVENT_PUBLISHED"); break; case MQTT_EVENT_DATA: Logger.Info("MQTT event MQTT_EVENT_DATA"); for (i = 0; i < (INCOMING_DATA_BUFFER_SIZE - 1) && i < event->topic_len; i++) { incoming_data[i] = event->topic[i]; } incoming_data[i] = '\0'; Logger.Info("Topic: " + String(incoming_data)); for (i = 0; i < (INCOMING_DATA_BUFFER_SIZE - 1) && i < event->data_len; i++) { incoming_data[i] = event->data[i]; } incoming_data[i] = '\0'; Logger.Info("Data: " + String(incoming_data)); break; case MQTT_EVENT_BEFORE_CONNECT: Logger.Info("MQTT event MQTT_EVENT_BEFORE_CONNECT"); break; default: Logger.Error("MQTT event UNKNOWN"); break; } return ESP_OK; } static void initializeIoTHubClient() { az_iot_hub_client_options options = az_iot_hub_client_options_default(); options.user_agent = AZ_SPAN_FROM_STR(AZURE_SDK_CLIENT_USER_AGENT); if (az_result_failed(az_iot_hub_client_init( &client, az_span_create((uint8_t*)host, strlen(host)), az_span_create((uint8_t*)device_id, strlen(device_id)), &options))) { Logger.Error("Failed initializing Azure IoT Hub client"); return; } size_t client_id_length; if (az_result_failed(az_iot_hub_client_get_client_id( &client, mqtt_client_id, sizeof(mqtt_client_id) - 1, &client_id_length))) { Logger.Error("Failed getting client id"); return; } if (az_result_failed(az_iot_hub_client_get_user_name( &client, mqtt_username, sizeofarray(mqtt_username), NULL))) { Logger.Error("Failed to get MQTT clientId, return code"); return; } Logger.Info("Client ID: " + String(mqtt_client_id)); Logger.Info("Username: " + String(mqtt_username)); } static int initializeMqttClient() { if (sasToken.Generate(SAS_TOKEN_DURATION_IN_MINUTES) != 0) { Logger.Error("Failed generating SAS token"); return 1; } esp_mqtt_client_config_t mqtt_config; memset(&mqtt_config, 0, sizeof(mqtt_config)); mqtt_config.uri = mqtt_broker_uri; mqtt_config.port = mqtt_port; mqtt_config.client_id = mqtt_client_id; mqtt_config.username = mqtt_username; mqtt_config.password = (const char*)az_span_ptr(sasToken.Get()); mqtt_config.keepalive = 30; mqtt_config.disable_clean_session = 0; mqtt_config.disable_auto_reconnect = false; mqtt_config.event_handle = mqtt_event_handler; mqtt_config.user_context = NULL; mqtt_config.cert_pem = (const char*)ca_pem; mqtt_client = esp_mqtt_client_init(&mqtt_config); if (mqtt_client == NULL) { Logger.Error("Failed creating mqtt client"); return 1; } esp_err_t start_result = esp_mqtt_client_start(mqtt_client); if (start_result != ESP_OK) { Logger.Error("Could not start mqtt client; error code:" + start_result); return 1; } else { Logger.Info("MQTT client started"); return 0; } } /* * @brief Gets the number of seconds since UNIX epoch until now. * @return uint32_t Number of seconds. */ static uint32_t getEpochTimeInSecs() { return (uint32_t)time(NULL); } static void establishConnection() { connectToWiFi(); initializeTime(); initializeIoTHubClient(); (void)initializeMqttClient(); } static az_span getTelemetryPayload(DynamicJsonDocument doc) { serializeJson(doc, telemetry_payload, sizeof(telemetry_payload)); return az_span_create_from_str(telemetry_payload); } static void sendTelemetry(int slotNo, int status) { Logger.Info("Sending telemetry ..."); // The topic could be obtained just once during setup, // however if properties are used the topic need to be generated again to reflect the // current values of the properties. if (az_result_failed(az_iot_hub_client_telemetry_get_publish_topic( &client, NULL, telemetry_topic, sizeof(telemetry_topic), NULL))) { Logger.Error("Failed az_iot_hub_client_telemetry_get_publish_topic"); return; } DynamicJsonDocument doc(512); JsonArray array = doc.to(); JsonObject item = array.createNestedObject(); item["name"] = "Temp 1"; item["interface"] = "1-wire"; item["address"] = 12345; item["type"] = "DS18B20"; item.createNestedObject("properties"); item["is_fault"] = false; item["data"] = "test_value"; item["spot"] = slotNo; item["occupancy"] = status; az_span telemetry = getTelemetryPayload(doc); Logger.Debug(String((char *) az_span_ptr(telemetry))); if (esp_mqtt_client_publish( mqtt_client, telemetry_topic, (const char*)az_span_ptr(telemetry), az_span_size(telemetry), MQTT_QOS1, DO_NOT_RETAIN_MSG) == 0) { Logger.Error("Failed publishing"); } else { Logger.Info("Message published successfully"); } } void setup() { pinMode(S0, OUTPUT); pinMode(S1, OUTPUT); pinMode(S2, OUTPUT); pinMode(S3, OUTPUT); pixels.begin(); Serial.begin(9600); Serial.println(F("DHTxx test!")); establishConnection(); } void loop() { pixels.clear(); for(int i = 0; i < 16; ++i) { if (readMux(i) > 1500) { pixels.setPixelColor(i, pixels.Color(0, 150, 0)); Serial.println(i); } } pixels.show(); if (WiFi.status() != WL_CONNECTED) { connectToWiFi(); } else if (sasToken.IsExpired()) { Logger.Info("SAS token expired; reconnecting with a new one."); (void)esp_mqtt_client_destroy(mqtt_client); initializeMqttClient(); } else if (millis() > next_telemetry_send_time_ms) { for(int i = 0; i < 16; ++i) { if (readMux(i) > 1500) { sendTelemetry(i, 1); } else { sendTelemetry(i, 0); } } next_telemetry_send_time_ms = millis() + TELEMETRY_FREQUENCY_MILLISECS; } }