Diff: main.cpp

Revision:

73:fbc0212c2eaf

Parent:

71:ec259c9b02ea

Child:

74:bf6d9bd511bd

--- a/main.cpp	Mon Mar 13 13:45:12 2017 +0000
+++ b/main.cpp	Tue Mar 14 05:43:50 2017 +0000
@@ -25,34 +25,17 @@
 #include "security.h"
 
 #include "mbed.h"
+#include "DisplayBace.h"
+#include "rtos.h"
+#include "LCD_shield_config_4_3inch.h"
+#include "recognition_proc.h"
+#include "touch_proc.h"
 
 // easy-connect compliancy, it has 2 sets of wifi pins we have only one
 #define MBED_CONF_APP_ESP8266_TX MBED_CONF_APP_WIFI_TX
 #define MBED_CONF_APP_ESP8266_RX MBED_CONF_APP_WIFI_RX
-#include "easy-connect/easy-connect.h"
+#include "easy-connect.h"
 
-#ifdef TARGET_STM
-#define RED_LED (LED3)
-#define GREEN_LED (LED1)
-#define BLUE_LED (LED2)
-#define LED_ON (1)		     
-#else // !TARGET_STM
-#define RED_LED (LED1)
-#define GREEN_LED (LED2)
-#define BLUE_LED (LED3)			     
-#define LED_ON (0) 
-#endif // !TARGET_STM
-#define LED_OFF (!LED_ON)
-
-// Status indication
-DigitalOut red_led(RED_LED);
-DigitalOut green_led(GREEN_LED);
-DigitalOut blue_led(BLUE_LED);
-
-Ticker status_ticker;
-void blinky() {
-    green_led = !green_led;
-}
 
 // These are example resource values for the Device Object
 struct MbedClientDevice device = {
@@ -65,34 +48,18 @@
 // Instantiate the class which implements LWM2M Client API (from simpleclient.h)
 MbedClient mbed_client(device);
 
-
-// In case of K64F board , there is button resource available
-// to change resource value and unregister
-#ifdef TARGET_K64F
-// Set up Hardware interrupt button.
-InterruptIn obs_button(SW2);
-InterruptIn unreg_button(SW3);
-#else
-//In non K64F boards , set up a timer to simulate updating resource,
-// there is no functionality to unregister.
-Ticker timer;
-#endif
+static DisplayBase Display;
+static DigitalOut  lcd_pwon(P7_15);
+static DigitalOut  lcd_blon(P8_1);
+static PwmOut      lcd_cntrst(P8_15);
+static Thread      recognitionTask;
+static Thread      touchTask;
+static char send_cloud_buf_last[1024 * 4];
 
-/*
- * Arguments for running "blink" in it's own thread.
- */
-class BlinkArgs {
-public:
-    BlinkArgs() {
-        clear();
-    }
-    void clear() {
-        position = 0;
-        blink_pattern.clear();
-    }
-    uint16_t position;
-    std::vector<uint32_t> blink_pattern;
-};
+// LED Output
+DigitalOut led1(LED1);
+DigitalOut led2(LED2);
+DigitalOut led3(LED3);
 
 /*
  * The Led contains one property (pattern) and a function (blink).
@@ -106,6 +73,14 @@
         led_object = M2MInterfaceFactory::create_object("3201");
         M2MObjectInstance* led_inst = led_object->create_object_instance();
 
+        // 5855 = Multi-state output
+        M2MResource* color_res = led_inst->create_dynamic_resource("5855", "Color",
+            M2MResourceInstance::STRING, false);
+        // read and write
+        color_res->set_operation(M2MBase::GET_PUT_ALLOWED);
+        // set red as initial color
+        color_res->set_value((const uint8_t*)"red", 3);
+        
         // 5853 = Multi-state output
         M2MResource* pattern_res = led_inst->create_dynamic_resource("5853", "Pattern",
             M2MResourceInstance::STRING, false);
@@ -121,209 +96,205 @@
         led_res->set_operation(M2MBase::POST_ALLOWED);
         // when a POST comes in, we want to execute the led_execute_callback
         led_res->set_execute_function(execute_callback(this, &LedResource::blink));
-        // Completion of execute function can take a time, that's why delayed response is used
-        led_res->set_delayed_response(true);
-        blink_args = new BlinkArgs();
-    }
-
-    ~LedResource() {
-        delete blink_args;
     }
 
     M2MObject* get_object() {
         return led_object;
     }
 
-    void blink(void *argument) {
+    void blink(void *) {
         // read the value of 'Pattern'
-        status_ticker.detach();
-        green_led = LED_OFF;
-
         M2MObjectInstance* inst = led_object->object_instance();
         M2MResource* res = inst->resource("5853");
-        // Clear previous blink data
-        blink_args->clear();
+        // read the value of 'Color'
+        M2MObjectInstance* instC = led_object->object_instance();
+        M2MResource* resC = instC->resource("5855");
 
         // values in mbed Client are all buffers, and we need a vector of int's
         uint8_t* buffIn = NULL;
         uint32_t sizeIn;
         res->get_value(buffIn, sizeIn);
+        
+        uint8_t* cbuffIn = NULL;
+        uint32_t csizeIn;
+        resC->get_value(cbuffIn, csizeIn);
 
         // turn the buffer into a string, and initialize a vector<int> on the heap
         std::string s((char*)buffIn, sizeIn);
-        free(buffIn);
-        printf("led_execute_callback pattern=%s\n", s.c_str());
+        std::vector<uint32_t>* v = new std::vector<uint32_t>;
+
+        printf("led_execute_callback pattern=%s\r\n", s.c_str());
 
         // our pattern is something like 500:200:500, so parse that
         std::size_t found = s.find_first_of(":");
         while (found!=std::string::npos) {
-            blink_args->blink_pattern.push_back(atoi((const char*)s.substr(0,found).c_str()));
+
+            v->push_back(atoi((const char*)s.substr(0,found).c_str()));
             s = s.substr(found+1);
             found=s.find_first_of(":");
             if(found == std::string::npos) {
-                blink_args->blink_pattern.push_back(atoi((const char*)s.c_str()));
+                v->push_back(atoi((const char*)s.c_str()));
             }
         }
-        // check if POST contains payload
-        if (argument) {
-            M2MResource::M2MExecuteParameter* param = (M2MResource::M2MExecuteParameter*)argument;
-            String object_name = param->get_argument_object_name();
-            uint16_t object_instance_id = param->get_argument_object_instance_id();
-            String resource_name = param->get_argument_resource_name();
-            int payload_length = param->get_argument_value_length();
-            uint8_t* payload = param->get_argument_value();
-            printf("Resource: %s/%d/%s executed\n", object_name.c_str(), object_instance_id, resource_name.c_str());
-            printf("Payload: %.*s\n", payload_length, payload);
+
+        int position = 0;
+        while (1) {
+            do_blink(cbuffIn);
+            if (position >= v->size()) {
+                break;
+            }
+            // how long do we need to wait before the next blink?
+            Thread::wait(v->at(position));
+            position++;
         }
-        // do_blink is called with the vector, and starting at -1
-        blinky_thread.start(callback(this, &LedResource::do_blink));
+        free(buffIn);
+        free(cbuffIn);
+        delete v;
     }
 
 private:
     M2MObject* led_object;
-    Thread blinky_thread;
-    BlinkArgs *blink_args;
-    void do_blink() {
-        for (;;) {
-            // blink the LED
-            red_led = !red_led;
-            // up the position, if we reached the end of the vector
-            if (blink_args->position >= blink_args->blink_pattern.size()) {
-                // send delayed response after blink is done
-                M2MObjectInstance* inst = led_object->object_instance();
-                M2MResource* led_res = inst->resource("5850");
-                led_res->send_delayed_post_response();
-                red_led = LED_OFF;
-                status_ticker.attach_us(blinky, 250000);
-                return;
-            }
-            // Wait requested time, then continue prosessing the blink pattern from next position.
-            Thread::wait(blink_args->blink_pattern.at(blink_args->position));
-            blink_args->position++;
+
+    void do_blink(uint8_t* color) {
+        if (!strcmp((char *)color, "red")) {
+            // blink the LED in red color
+            led1 = !led1;
+        }
+        else if (!strcmp((char *)color, "green")) {
+            // blink in green color
+            led2 = !led2;
+        }
+        else if (!strcmp((char *)color, "blue")) {
+            // blink in blue color
+            led3 = !led3;
+        }
+        else if (!strcmp((char *)color, "cyan")) {
+            // blink in cyan color
+            led2 = !led2;
+            led3 = !led3;
+        }
+        else if (!strcmp((char *)color, "yellow")) {
+            // blink in yellow color
+            led1 = !led1;
+            led2 = !led2;
+        }
+        else if (!strcmp((char *)color, "magenta")) {
+            // blink in magenta color
+            led1 = !led1;
+            led3 = !led3;
+        }            
+        else if (!strcmp((char *)color, "white")) {
+            // blink in white color
+            led1 = !led1;
+            led2 = !led2;
+            led3 = !led3;
+        }
+        else {
+            // no operation
         }
     }
 };
 
 /*
- * The button contains one property (click count).
- * When `handle_button_click` is executed, the counter updates.
+ * The HVC contains a function (send string).
+ * When `handle_string_send` is executed, the string after decoding is sent.
  */
-class ButtonResource {
+class HVCResource {
 public:
-    ButtonResource(): counter(0) {
-        // create ObjectID with metadata tag of '3200', which is 'digital input'
-        btn_object = M2MInterfaceFactory::create_object("3200");
-        M2MObjectInstance* btn_inst = btn_object->create_object_instance();
-        // create resource with ID '5501', which is digital input counter
-        M2MResource* btn_res = btn_inst->create_dynamic_resource("5501", "Button",
-            M2MResourceInstance::INTEGER, true /* observable */);
+    HVCResource() {
+        // create ObjectID with metadata tag of '3202', which is 'send string'
+        hvc_object = M2MInterfaceFactory::create_object("3202");
+        M2MObjectInstance* hvc_inst = hvc_object->create_object_instance();
+        // create resource with ID '5700', which is 'send string'
+        M2MResource* hvc_res = hvc_inst->create_dynamic_resource("5700", "hvc",
+            M2MResourceInstance::STRING, true);
         // we can read this value
-        btn_res->set_operation(M2MBase::GET_ALLOWED);
+        hvc_res->set_operation(M2MBase::GET_ALLOWED);
         // set initial value (all values in mbed Client are buffers)
         // to be able to read this data easily in the Connector console, we'll use a string
-        btn_res->set_value((uint8_t*)"0", 1);
+        hvc_res->set_value((uint8_t*)"0", 1);
     }
 
-    ~ButtonResource() {
+    ~HVCResource() {
     }
 
     M2MObject* get_object() {
-        return btn_object;
+        return hvc_object;
     }
 
     /*
-     * When you press the button, we read the current value of the click counter
-     * from mbed Device Connector, then up the value with one.
+     * When you success the decode process of barcode, we send the string after decoding to mbed Device Connector.
      */
-    void handle_button_click() {
-        if (mbed_client.register_successful()) {
-            M2MObjectInstance* inst = btn_object->object_instance();
-            M2MResource* res = inst->resource("5501");
+    void handle_string_send(char * addr, int size) {
+        M2MObjectInstance* inst = hvc_object->object_instance();
+        M2MResource* res = inst->resource("5700");
 
-            // up counter
-            counter++;
-    #ifdef TARGET_K64F
-            printf("handle_button_click, new value of counter is %d\n", counter);
-    #else
-            printf("simulate button_click, new value of counter is %d\n", counter);
-    #endif
-            // serialize the value of counter as a string, and tell connector
-            char buffer[20];
-            int size = sprintf(buffer,"%d",counter);
-            res->set_value((uint8_t*)buffer, size);
-        } else {
-            printf("simulate button_click, device not registered\n");
-        }
+        printf("%s\r\n", addr);
+
+        // tell the string to connector
+        res->set_value((uint8_t *)addr, size);
     }
 
 private:
-    M2MObject* btn_object;
-    uint16_t counter;
-};
-
-class BigPayloadResource {
-public:
-    BigPayloadResource() {
-        big_payload = M2MInterfaceFactory::create_object("1000");
-        M2MObjectInstance* payload_inst = big_payload->create_object_instance();
-        M2MResource* payload_res = payload_inst->create_dynamic_resource("1", "BigData",
-            M2MResourceInstance::STRING, true /* observable */);
-        payload_res->set_operation(M2MBase::GET_PUT_ALLOWED);
-        payload_res->set_value((uint8_t*)"0", 1);
-        payload_res->set_incoming_block_message_callback(
-                    incoming_block_message_callback(this, &BigPayloadResource::block_message_received));
-        payload_res->set_outgoing_block_message_callback(
-                    outgoing_block_message_callback(this, &BigPayloadResource::block_message_requested));
-    }
-
-    M2MObject* get_object() {
-        return big_payload;
-    }
-
-    void block_message_received(M2MBlockMessage *argument) {
-        if (argument) {
-            if (M2MBlockMessage::ErrorNone == argument->error_code()) {
-                if (argument->is_last_block()) {
-                    printf("Last block received\n");
-                }
-                printf("Block number: %d\n", argument->block_number());
-                // First block received
-                if (argument->block_number() == 0) {
-                    // Store block
-                // More blocks coming
-                } else {
-                    // Store blocks
-                }
-            } else {
-                printf("Error when receiving block message!  - EntityTooLarge\n");
-            }
-            printf("Total message size: %" PRIu32 "\n", argument->total_message_size());
-        }
-    }
-
-    void block_message_requested(const String& resource, uint8_t *&/*data*/, uint32_t &/*len*/) {
-        printf("GET request received for resource: %s\n", resource.c_str());
-        // Copy data and length to coap response
-    }
-
-private:
-    M2MObject*  big_payload;
+    M2MObject* hvc_object;
 };
 
 // Network interaction must be performed outside of interrupt context
 Semaphore updates(0);
-volatile bool registered = false;
-volatile bool clicked = false;
 osThreadId mainThread;
 
-void unregister() {
-    registered = false;
-    updates.release();
+HVCResource hvc_resource;
+volatile bool sent = false;
+Timer send_timer;
+
+void HVCSendData(char * addr, int size) {
+    if (send_timer.read_ms() > 500) {
+        if (memcmp(send_cloud_buf_last, addr, sizeof(send_cloud_buf_last)) != 0) {
+            memcpy(send_cloud_buf_last, addr, sizeof(send_cloud_buf_last));
+            send_timer.reset();
+            hvc_resource.handle_string_send(addr, size);
+            sent = true;
+            updates.release();
+        }
+    }
+}
+
+// LCD
+static void IntCallbackFunc_LoVsync(DisplayBase::int_type_t int_type) {
+    /* Interrupt callback function for Vsync interruption */
+    touch_lcd_int(int_type);
 }
 
-void button_clicked() {
-    clicked = true;
-    updates.release();
+static void Init_LCD_Display(void) {
+    DisplayBase::graphics_error_t error;
+    DisplayBase::lcd_config_t lcd_config;
+    PinName lvds_pin[8] = {
+        /* data pin */
+        P5_7, P5_6, P5_5, P5_4, P5_3, P5_2, P5_1, P5_0
+    };
+
+    lcd_pwon = 0;
+    lcd_blon = 0;
+    Thread::wait(100);
+    lcd_pwon = 1;
+    lcd_blon = 1;
+
+    Display.Graphics_Lvds_Port_Init(lvds_pin, 8);
+
+    /* Graphics initialization process */
+    lcd_config = LcdCfgTbl_LCD_shield;
+    error = Display.Graphics_init(&lcd_config);
+    if (error != DisplayBase::GRAPHICS_OK) {
+        printf("Line %d, error %d\n", __LINE__, error);
+        mbed_die();
+    }
+
+    /* Interrupt callback function setting (Vsync signal output from scaler 0) */
+    error = Display.Graphics_Irq_Handler_Set(DisplayBase::INT_TYPE_S0_LO_VSYNC, 0, IntCallbackFunc_LoVsync);
+    if (error != DisplayBase::GRAPHICS_OK) {
+        printf("Line %d, error %d\n", __LINE__, error);
+        mbed_die();
+    }
 }
 
 // Entry point to the program
@@ -332,6 +303,19 @@
     unsigned int seed;
     size_t len;
 
+    /* Initialization of LCD */
+    Init_LCD_Display();
+
+    /* Start recognition processing */
+    recognitionTask.start(callback(recognition_task, &Display));
+
+    /* Start touch panel processing */
+    touchTask.start(callback(touch_task, &Display));
+
+    /* Backlight on */
+    Thread::wait(200);
+    lcd_cntrst.write(1.0);
+
 #ifdef MBEDTLS_ENTROPY_HARDWARE_ALT
     // Used to randomize source port
     mbedtls_hardware_poll(NULL, (unsigned char *) &seed, sizeof seed, &len);
@@ -351,13 +335,8 @@
 #endif
 
     srand(seed);
-    red_led = LED_OFF;
-    blue_led = LED_OFF;
-
-    status_ticker.attach_us(blinky, 250000);
     // Keep track of the main thread
     mainThread = osThreadGetId();
-
     printf("\nStarting mbed Client example in ");
 #if defined (MESH) || (MBED_CONF_LWIP_IPV6_ENABLED==true)
     printf("IPv6 mode\n");
@@ -374,22 +353,8 @@
     }
 
     // we create our button and LED resources
-    ButtonResource button_resource;
     LedResource led_resource;
-    BigPayloadResource big_payload_resource;
 
-#ifdef TARGET_K64F
-    // On press of SW3 button on K64F board, example application
-    // will call unregister API towards mbed Device Connector
-    //unreg_button.fall(&mbed_client,&MbedClient::test_unregister);
-    unreg_button.fall(&unregister);
-
-    // Observation Button (SW2) press will send update of endpoint resource values to connector
-    obs_button.fall(&button_clicked);
-#else
-    // Send update of endpoint resource values to connector every 15 seconds periodically
-    timer.attach(&button_clicked, 15.0);
-#endif
 
     // Create endpoint interface to manage register and unregister
     mbed_client.create_interface(MBED_SERVER_ADDRESS, network);
@@ -403,32 +368,22 @@
 
     // Add objects to list
     object_list.push_back(device_object);
-    object_list.push_back(button_resource.get_object());
     object_list.push_back(led_resource.get_object());
-    object_list.push_back(big_payload_resource.get_object());
+    object_list.push_back(hvc_resource.get_object());
 
     // Set endpoint registration object
     mbed_client.set_register_object(register_object);
 
     // Register with mbed Device Connector
     mbed_client.test_register(register_object, object_list);
-    registered = true;
-
-    while (true) {
+    send_timer.start();
+    while (1) {
         updates.wait(25000);
-        if(registered) {
-            if(!clicked) {
-                mbed_client.test_update_register();
-            }
-        }else {
-            break;
+        if(!sent) {
+            mbed_client.test_update_register();
         }
-        if(clicked) {
-            clicked = false;
-            button_resource.handle_button_click();
-        }
+        sent = false;
     }
 
     mbed_client.test_unregister();
-    status_ticker.detach();
 }