main.cpp

00001 #include "mbed.h"
00002 #include "MQTTEthernet.h"
00003 #include "MQTTClient.h"
00004 #include "MbedJSONValue.h"
00005 #include <string>
00006 #include "rtos.h"
00007 #include "FXOS8700Q.h"
00008 
00009 I2C i2c(PTE25, PTE24);
00010 
00011 FXOS8700QAccelerometer acc(i2c, FXOS8700CQ_SLAVE_ADDR1);
00012 FXOS8700QMagnetometer mag(i2c, FXOS8700CQ_SLAVE_ADDR1);
00013 motion_data_units_t acc_data, mag_data;
00014 
00015 DigitalOut red(LED_RED);
00016 DigitalOut green(LED_GREEN);
00017 DigitalOut blue(LED_BLUE);
00018 DigitalOut r1(PTB2);
00019 DigitalOut r2(PTB3);
00020 PwmOut led(PTD1);
00021 InterruptIn sw_left(SW3);
00022 InterruptIn sw_right(SW2);
00023 
00024 #define API_KEY         "7553e4b7-0930-4b72-b392-890ef25bde0a"
00025 #define PROJECT_ID      "5882"
00026 #define DEVICE_UUID     "ef51c7bf-105a-408d-ac63-c403d15f7668"              
00027 
00028 // Publishing topics
00029 char* pubTopic_acc_x      = "/a/"API_KEY"/p/"PROJECT_ID"/d/"DEVICE_UUID"/sensor/Accelerometer_X/data";
00030 char* pubTopic_acc_y      = "/a/"API_KEY"/p/"PROJECT_ID"/d/"DEVICE_UUID"/sensor/Accelerometer_Y/data";
00031 char* pubTopic_acc_z      = "/a/"API_KEY"/p/"PROJECT_ID"/d/"DEVICE_UUID"/sensor/Accelerometer_Z/data";
00032 
00033 char* pubTopic_mag_x      = "/a/"API_KEY"/p/"PROJECT_ID"/d/"DEVICE_UUID"/sensor/Magnetometer_X/data";
00034 char* pubTopic_mag_y      = "/a/"API_KEY"/p/"PROJECT_ID"/d/"DEVICE_UUID"/sensor/Magnetometer_Y/data";
00035 char* pubTopic_mag_z      = "/a/"API_KEY"/p/"PROJECT_ID"/d/"DEVICE_UUID"/sensor/Magnetometer_Z/data";
00036 
00037 char* pubTopic_sw_left      = "/a/"API_KEY"/p/"PROJECT_ID"/d/"DEVICE_UUID"/sensor/Button_left/data";
00038 char* pubTopic_sw_right      = "/a/"API_KEY"/p/"PROJECT_ID"/d/"DEVICE_UUID"/sensor/Button_right/data";
00039 
00040 // Subscription topics
00041 char* subTopic_RLED    = "/a/"API_KEY"/p/"PROJECT_ID"/d/"DEVICE_UUID"/actuator/Red/state";
00042 char* subTopic_GLED    = "/a/"API_KEY"/p/"PROJECT_ID"/d/"DEVICE_UUID"/actuator/Green/state";
00043 char* subTopic_BLED    = "/a/"API_KEY"/p/"PROJECT_ID"/d/"DEVICE_UUID"/actuator/Blue/state";
00044 
00045 char* subTopic_Relay1 = "/a/"API_KEY"/p/"PROJECT_ID"/d/"DEVICE_UUID"/actuator/Relay_1/state";
00046 char* subTopic_Relay2 = "/a/"API_KEY"/p/"PROJECT_ID"/d/"DEVICE_UUID"/actuator/Relay_2/state";
00047 
00048 char* subTopic_LED     = "/a/"API_KEY"/p/"PROJECT_ID"/d/"DEVICE_UUID"/actuator/LED/state";
00049 
00050 int send = 0;
00051 int pressed_left = 0;
00052 int pressed_right = 0;
00053 int state_left = 0;
00054 int state_right = 0;
00055 
00056 MbedJSONValue JSON;
00057 std::string value;
00058 
00059 void readSensors_thread(void const *args) {
00060     while(true) {
00061         Thread::wait(5000);
00062         
00063         // unit based results
00064         acc.getAxis(acc_data);
00065         mag.getAxis(mag_data);
00066         //printf("ACC: X=%1.4ff Y=%1.4ff Z=%1.4ff \t MAG: X=%4.1ff Y=%4.1ff Z=%4.1ff\r\n", acc_data.x, acc_data.y, acc_data.z, mag_data.x, mag_data.y, mag_data.z);
00067         
00068         send = 1;
00069     }
00070 }
00071 void messageArrived_RLED(MQTT::MessageData& md)
00072 {
00073     char *message = (char *)malloc(md.message.payloadlen);
00074     int state = 0;
00075     MbedJSONValue dhMessage;
00076     memcpy(message, md.message.payload, md.message.payloadlen);
00077     // printf("message: %s\n", message);
00078     
00079     parse(dhMessage, message);
00080     state = atoi(dhMessage["state"].get<std::string>().c_str());
00081     // printf("state: %d\n", state);
00082     
00083     red = !state;
00084     
00085     free(message);
00086 }
00087 
00088 void messageArrived_GLED(MQTT::MessageData& md)
00089 {
00090     char *message = (char *)malloc(md.message.payloadlen);
00091     int state = 0;
00092     MbedJSONValue dhMessage;
00093     memcpy(message, md.message.payload, md.message.payloadlen);
00094     // printf("message: %s\n", message);
00095     
00096     parse(dhMessage, message);
00097     state = atoi(dhMessage["state"].get<std::string>().c_str());
00098     // printf("state: %d\n", state);
00099     
00100     green = !state;
00101     
00102     free(message);
00103 }
00104 
00105 void messageArrived_BLED(MQTT::MessageData& md)
00106 {
00107     char *message = (char *)malloc(md.message.payloadlen);
00108     int state = 0;
00109     MbedJSONValue dhMessage;
00110     memcpy(message, md.message.payload, md.message.payloadlen);
00111     // printf("message: %s\n", message);
00112     
00113     parse(dhMessage, message);
00114     state = atoi(dhMessage["state"].get<std::string>().c_str());
00115     // printf("state: %d\n", state);
00116     
00117     blue = !state;
00118     
00119     free(message);
00120 }
00121 
00122 void messageArrived_LED(MQTT::MessageData& md)
00123 {
00124     char *message = (char *)malloc(md.message.payloadlen);
00125     int state = 0;
00126     MbedJSONValue dhMessage;
00127     memcpy(message, md.message.payload, md.message.payloadlen);
00128     // printf("message: %s\n", message);
00129     
00130     parse(dhMessage, message);
00131     state = atoi(dhMessage["state"].get<std::string>().c_str());
00132     // printf("state: %d\n", state);
00133     
00134     led = state/100.0f;
00135     
00136     free(message);
00137 }
00138 
00139 void messageArrived_Relay1(MQTT::MessageData& md)
00140 {
00141     char *message = (char *)malloc(md.message.payloadlen);
00142     int state = 0;
00143     MbedJSONValue dhMessage;
00144     memcpy(message, md.message.payload, md.message.payloadlen);
00145     // printf("message: %s\n", message);
00146     
00147     parse(dhMessage, message);
00148     state = atoi(dhMessage["state"].get<std::string>().c_str());
00149     // printf("state: %d\n", state);
00150     
00151     r1 = !state;
00152     
00153     free(message);
00154 }
00155 
00156 void messageArrived_Relay2(MQTT::MessageData& md)
00157 {
00158     char *message = (char *)malloc(md.message.payloadlen);
00159     int state = 0;
00160     MbedJSONValue dhMessage;
00161     memcpy(message, md.message.payload, md.message.payloadlen);
00162      printf("message: %s\n", message);
00163     
00164     parse(dhMessage, message);
00165     state = atoi(dhMessage["state"].get<std::string>().c_str());
00166      printf("state: %d\n", state);
00167     
00168     r2 = !state;
00169     
00170     free(message);
00171 }
00172 
00173 void sw_left_release(void)
00174 {
00175     state_left = !state_left;
00176     pressed_left = 1;
00177 }
00178 
00179 void sw_right_release(void)
00180 {
00181      state_right = !state_right;
00182      pressed_right = 1;   
00183 }
00184 
00185 int main()
00186 {
00187     red = 1;
00188     green = 1;
00189     blue = 1;
00190     r1 = 1;
00191     r2 = 1;
00192     led = 0;
00193     
00194     printf("Hello Freedom :)\n");
00195     MQTTEthernet ipstack = MQTTEthernet();
00196 
00197     MQTT::Client<MQTTEthernet, Countdown> client = MQTT::Client<MQTTEthernet, Countdown>(ipstack);
00198     MQTTPacket_connectData data = MQTTPacket_connectData_initializer;
00199     data.MQTTVersion = 3;
00200 
00201     /* set connect info */
00202     char *hostname  = "mqtt.devicehub.net";
00203     char *username = NULL;
00204     char *password = NULL;
00205     int r = rand() % 100;
00206     char buf_client[10] = {0};
00207     sprintf(buf_client, "K64F-%d", r);
00208     char *clientID = buf_client;
00209     int  port = 1883;
00210 
00211     data.username.cstring = username ;
00212     data.password.cstring = password ;
00213     data.clientID.cstring = clientID ;
00214     
00215     // Set publish info
00216     MQTT::Message message;
00217     message.qos = MQTT::QOS0;
00218     message.retained = true;
00219     message.dup = false;
00220     
00221     int rc = ipstack.connect(hostname, port, NULL);
00222     if (rc != 0){
00223         printf("rc from TCP connect is %d\r\n", rc);
00224         NVIC_SystemReset();
00225     }
00226 
00227     if ((rc = client.connect(data)) != 0){
00228         printf("rc from MQTT connect is %d\r\n", rc);
00229         NVIC_SystemReset();
00230     }
00231     printf("MQTT connected\r\n");
00232     
00233     client.subscribe(subTopic_RLED, MQTT::QOS0, messageArrived_RLED);
00234     client.subscribe(subTopic_GLED, MQTT::QOS0, messageArrived_GLED);
00235     client.subscribe(subTopic_BLED, MQTT::QOS0, messageArrived_BLED);
00236     client.subscribe(subTopic_LED, MQTT::QOS0, messageArrived_LED);
00237     client.subscribe(subTopic_Relay1, MQTT::QOS0, messageArrived_Relay1);
00238     client.subscribe(subTopic_Relay2, MQTT::QOS0, messageArrived_Relay2);
00239     
00240     printf("Subscribed to MQTT topics\r\n");
00241     
00242     acc.enable();
00243     mag.enable();
00244     
00245     sw_left.rise(&sw_left_release);
00246     sw_right.rise(&sw_right_release);
00247     Thread thread(readSensors_thread);
00248     
00249     while(true) {
00250         client.yield(100);
00251         
00252         if(send){
00253             JSON["value"] = acc_data.x;
00254             value = JSON.serialize();
00255             message.payload = (void*)value.c_str();
00256             message.payloadlen = strlen(value.c_str());
00257             client.publish(pubTopic_acc_x, message);
00258             
00259             JSON["value"] = acc_data.y;
00260             value = JSON.serialize();
00261             message.payload = (void*)value.c_str();
00262             message.payloadlen = strlen(value.c_str());
00263             client.publish(pubTopic_acc_y, message);
00264             
00265             JSON["value"] = acc_data.z;
00266             value = JSON.serialize();
00267             message.payload = (void*)value.c_str();
00268             message.payloadlen = strlen(value.c_str());
00269             client.publish(pubTopic_acc_z, message);
00270             
00271             JSON["value"] = mag_data.x;
00272             value = JSON.serialize();
00273             message.payload = (void*)value.c_str();
00274             message.payloadlen = strlen(value.c_str());
00275             client.publish(pubTopic_mag_x, message);
00276             
00277             JSON["value"] = mag_data.y;
00278             value = JSON.serialize();
00279             message.payload = (void*)value.c_str();
00280             message.payloadlen = strlen(value.c_str());
00281             client.publish(pubTopic_mag_y, message);
00282             
00283             JSON["value"] = mag_data.z;
00284             value = JSON.serialize();
00285             message.payload = (void*)value.c_str();
00286             message.payloadlen = strlen(value.c_str());
00287             client.publish(pubTopic_mag_z, message);
00288             
00289             send = 0;  
00290         }
00291         
00292         if(pressed_left){
00293             JSON["value"] = state_left;
00294             value = JSON.serialize();
00295             message.payload = (void*)value.c_str();
00296             message.payloadlen = strlen(value.c_str());
00297             client.publish(pubTopic_sw_left, message);
00298             
00299             pressed_left = 0;
00300         }
00301         
00302         if(pressed_right){
00303             JSON["value"] = state_right;
00304             value = JSON.serialize();
00305             message.payload = (void*)value.c_str();
00306             message.payloadlen = strlen(value.c_str());
00307             client.publish(pubTopic_sw_right, message);
00308             
00309             pressed_right = 0;
00310         }
00311     };
00312 }