Revision 26:8e49e7ebefa7, committed 2019-03-07

Comitter:

Osamu Koizumi

Date:

Thu Mar 07 10:43:02 2019 +0900

Parent:

25:a4819ccd9c94

Child:

27:4836133b831c

Commit message:

Added Grove sensors.

Changed in this revision

--- a/main.cpp	Thu Mar 07 10:42:17 2019 +0900
+++ b/main.cpp	Thu Mar 07 10:43:02 2019 +0900
@@ -20,6 +20,9 @@
 #include "simple-mbed-cloud-client.h"
 #include "FATFileSystem.h"
 
+// To enable the GROVE sensors, uncomment the next line.
+//#define ENABLE_GROVE
+
 // An event queue is a very useful structure to debounce information between contexts (e.g. ISR and normal threads)
 // This is great because things such as network operations are illegal in ISR, so updating a resource in a button's fall() function is not allowed
 EventQueue eventQueue;
@@ -32,12 +35,17 @@
 // Default network interface object
 NetworkInterface *net;
  
-InterruptIn sw2(SW2);
-DigitalOut led2(LED2);
+InterruptIn sw2(SW2);     // A button on the board.
+DigitalOut led2(LED2);    // LED on the board.
 
 // Declaring pointers for access to Mbed Cloud Client resources outside of main()
 MbedCloudClientResource *button_res;
 MbedCloudClientResource *pattern_res;
+#ifdef ENABLE_GROVE
+MbedCloudClientResource *temperature_res;
+MbedCloudClientResource *illuminance_res;
+MbedCloudClientResource *buzzer_res;
+#endif // ENABLE_GROVE
 
 static bool button_pressed = false;
 static int button_count = 0;
@@ -88,6 +96,23 @@
 }
 
 /**
+ * POST handler. Beeps buzzer for a certain time when any data comes.
+ */
+ #ifdef ENABLE_GROVE
+void buzzer_callback(MbedCloudClientResource *resource, const uint8_t *buffer, uint16_t size) {
+    const int BUZZER_ON = 1;            // Polarity of the digital pin to beep the buzzer.
+    const int BUZZER_OFF = 0;           // Polarity of the digital pin to stop the buzzer.
+    const int SOUND_DURATION = 500;     // Duration
+    static DigitalOut buzzer(D3, BUZZER_OFF);  // Buzzer must be connected to D3.
+    printf("POST received. Going to beep the buzzer for %d ms.\n", SOUND_DURATION);
+
+    buzzer = BUZZER_ON;
+    ThisThread::sleep_for(SOUND_DURATION);
+    buzzer = BUZZER_OFF;
+}
+#endif // ENABLE_GROVE
+
+/**
  * Notification callback handler
  * @param resource The resource that triggered the callback
  * @param status The delivery status of the notification
@@ -104,10 +129,59 @@
     printf("Connected to Mbed Cloud. Endpoint Name: %s\n", endpoint->internal_endpoint_name.c_str());
 }
 
+/**
+ * Get the sensor values.
+ */
+#ifdef ENABLE_GROVE
+void update_sensors() {
+    // Get temperature sensor value.
+    // See how to covert AD value to temperature:
+    // http://wiki.seeedstudio.com/Grove-Temperature_Sensor_V1.2/
+    // Conversion formula contains redundancy, but not corrected here.
+    const int B = 4275;      // B value of the thermistor
+    const int R0 = 100000;   // R0 = 100k
+    static AnalogIn adc_temperature(A0);  // temperature sensor must be connected to A0
+    float a = adc_temperature.read()*1023.0;
+    float R = 1023.0/a-1.0;
+    R = R0*R;
+
+    float temperature = 1.0/(log(R/R0)/B+1/298.15) - 273.15;
+
+    // Get ambient light luminosity.
+    // http://wiki.seeedstudio.com/Grove-Light_Sensor/
+    static AnalogIn adc_illuminance(A1);
+    uint16_t illuminance = adc_illuminance.read_u16();
+
+    // Set the obtained sensor values.
+    temperature_res->set_value(temperature);
+    illuminance_res->set_value(illuminance);
+
+    printf("Sensor values: temperature %4.1f C, illuminance %d\n", temperature, illuminance);
+}
+#endif // ENABLE_GROVE
+
+
 int main(void) {
     printf("Starting Simple Mbed Cloud Client example\n");
     printf("Connecting to the network using Ethernet...\n");
 
+    // Setup the button 
+    sw2.mode(PullUp);
+    // If the SW2 button on the board is pushed at the init, format the storage.
+    // Note that the polarity of SW2 is active low. i.e. 0 is pushed.
+    if(sw2 == 0) {
+        printf("SW2 is being pushed. Format storage...");
+        if(fs.format(bd) != 0) {
+            printf("Failed to format the storage.");
+            return -1;
+        } else {
+            printf("The starage was formatted. Program stops here.\n");
+            // Turn on the blue LED to inform the storage was formatted successfully.
+            DigitalOut tmp(LED_BLUE, 1);
+            return 0;
+        }
+    }
+
     // Connect to the internet (DHCP is expected to be on)
     net = NetworkInterface::get_default_instance();
 
@@ -144,6 +218,22 @@
     blink_res->methods(M2MMethod::POST);
     blink_res->attach_post_callback(blink_callback);
 
+#ifdef ENABLE_GROVE
+    temperature_res = client.create_resource("3303/0/5700", "temperature");
+    temperature_res->set_value(0.0f);
+    temperature_res->methods(M2MMethod::GET);
+    temperature_res->observable(true);
+
+    illuminance_res = client.create_resource("3301/0/5700", "illuminance");
+    illuminance_res->set_value(0.0f);
+    illuminance_res->methods(M2MMethod::GET);
+    illuminance_res->observable(true);
+    
+    buzzer_res = client.create_resource("3201/1/5550", "buzzer");
+    buzzer_res->methods(M2MMethod::POST);
+    buzzer_res->attach_post_callback(buzzer_callback);
+#endif // ENABLE_GROVE
+
     printf("Initialized Mbed Cloud Client. Registering...\n");
 
     // Callback that fires when registering is complete
@@ -151,14 +241,19 @@
 
     // Register with Mbed Cloud
     client.register_and_connect();
-
-    // Setup the button 
-      sw2.mode(PullUp);
     
     // The button fall handler is placed in the event queue so it will run in
     // thread context instead of ISR context, which allows safely updating the cloud resource         
-      sw2.fall(eventQueue.event(&button_press));
-      button_count = 0;
+    sw2.fall(eventQueue.event(&button_press));
+    // The button connected to the GROVE shield acts the same as SW2.
+    InterruptIn extBtn(D2);
+    extBtn.fall(eventQueue.event(&button_press));
+    button_count = 0;
+
+#ifdef ENABLE_GROVE
+    Ticker timer;
+    timer.attach(eventQueue.event(update_sensors), 3.0);
+#endif /* ENABLE_SENSORS */
 
     // Start the event queue in a separate thread so the main thread continues
     thread1.start(callback(&eventQueue, &EventQueue::dispatch_forever));