Diff: ICE-Application/src/CloudDataHandler/CloudFileReceiver.cpp

Revision:

0:61364762ee0e

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ICE-Application/src/CloudDataHandler/CloudFileReceiver.cpp	Tue Jan 24 19:05:33 2017 +0000
@@ -0,0 +1,356 @@
+#include "CloudFileReceiver.h"
+#include "CloudDataHandler.h"
+#include "mbed.h"
+#include "global.h"
+#include "cJSON.h"
+#include <algorithm>
+#include <string>
+#include "stdio.h"
+
+char CloudFileReceiverWriteBuf[MAX_FILE_SIZE];
+char CloudFileReceiverReadBuf[MAX_FILE_SIZE];
+
+bool StoreReceivedFile( std::string &payload_string )
+{
+    FILENAME_STRING filename;
+
+    memset( filename, '\0', sizeof(FILENAME_STRING) );
+
+    cJSON * root = cJSON_Parse(payload_string.c_str());
+    int mType = cJSON_GetObjectItem(root,"mtype")->valueint;
+//    printf("%s:%d: mtype=%d\r\n", __func__,__LINE__,mType);
+    switch( mType ) {
+        case SETPOINT_CONTROL_MTYPE:
+        case MANUAL_CONTROL_MTYPE:
+        case TIMER_CONTROL_MTYPE: {
+
+            std::string control_json;
+            ConfigMessage_t *mail  = ConfigHandlerMailBox.alloc();
+            memset(mail, 0, sizeof(ConfigMessage_t));
+            mail->action  = ACTION_CREATE;
+
+            switch( mType ) {
+                case SETPOINT_CONTROL_MTYPE: {
+                    cJSON * spcontrol = cJSON_GetObjectItem(root,"spcontrol");
+                    snprintf( filename, sizeof(FILENAME_STRING), "control_sp_%s.json", cJSON_GetObjectItem(spcontrol,"id")->valuestring );
+                    control_json = cJSON_PrintUnformatted(spcontrol);
+                    mail->control = CONTROL_SETPOINT;
+                    break;
+                }
+                case MANUAL_CONTROL_MTYPE: {
+                    cJSON * mncontrol = cJSON_GetObjectItem(root,"mncontrol");
+                    snprintf( filename, sizeof(FILENAME_STRING), "control_mn_%s.json", cJSON_GetObjectItem(mncontrol,"id")->valuestring );
+                    control_json = cJSON_PrintUnformatted(mncontrol);
+                    mail->control = CONTROL_MANUAL;
+                    break;
+                }
+                case TIMER_CONTROL_MTYPE: {
+                    cJSON * tmcontrol = cJSON_GetObjectItem(root,"tmcontrol");
+                    snprintf( filename, sizeof(FILENAME_STRING), "control_tm_%s.json", cJSON_GetObjectItem(tmcontrol,"id")->valuestring );
+                    std::string control_str = cJSON_PrintUnformatted(tmcontrol);
+                    mail->control = CONTROL_TIMER;
+                    break;
+                }
+                default: {
+                    printf("%s:%d: Unknown message type: %d\r\n",__func__,__LINE__,mType);
+                    cJSON_Delete(root);
+                    return false;
+                }
+            }
+
+            bool status = GLOBAL_mdot->saveUserFile(filename, (void *)control_json.c_str(), MAX_FILE_SIZE);
+            if( status != true ) {
+                printf("(%d)save file failed, status=%d\r\n", __LINE__, status);
+                break;
+            }
+
+            strncpy(mail->controlFile, filename, sizeof(mail->controlFile)-1);
+            ConfigHandlerMailBox.put(mail);
+
+            printf("%s:%d: Control JSON: %s\r\n", __func__,__LINE__, control_json.c_str() );
+            printf("%s:%d: Sending a create request for control %s type = %u\r\n", __func__,__LINE__, mail->controlFile, mail->control);
+            break;
+        }
+        case INPUT_CONFIG_MTYPE:
+        case VINPUT_CONFIG_MTYPE: {
+
+            cJSON * input = cJSON_GetObjectItem(root,"input");
+            if( mType == INPUT_CONFIG_MTYPE ) {
+                snprintf( filename, sizeof(FILENAME_STRING), "input_%s%s", cJSON_GetObjectItem(input,"id")->valuestring, ".json" );
+            } else {
+                snprintf( filename, sizeof(FILENAME_STRING), "vinput_%s%s", cJSON_GetObjectItem(input,"id")->valuestring, ".json" );
+            }
+            std::string input_str = cJSON_PrintUnformatted(input);
+
+
+            bool status = GLOBAL_mdot->saveUserFile(filename, (void *)input_str.c_str(), MAX_FILE_SIZE);
+            if( status != true ) {
+                printf("(%d)save file failed, status=%d", __LINE__, status);
+                break;
+            }
+
+            ModbusMasterReq_t *mail = ModbusMasterMailBox.alloc();
+            mail->action = ACTION_READ_FILE;
+            strncpy( mail->msg, filename, (sizeof(mail->msg)-1));
+            ModbusMasterMailBox.put(mail);
+
+            printf("%s:%d: INPUT JSON: %s\r\n", __func__,__LINE__, input_str.c_str() );
+            printf("%s:%d: Sending New INPUT to ModbusMasterMailBox, filename=%s\r\n", __func__,__LINE__, filename);
+            break;
+        }
+        case OUTPUT_CONFIG_MTYPE:
+        case VOUTPUT_CONFIG_MTYPE: {
+
+            cJSON * output = cJSON_GetObjectItem(root,"output");
+            if( mType == OUTPUT_CONFIG_MTYPE ) {
+                snprintf( filename, sizeof(FILENAME_STRING), "output_%s%s", cJSON_GetObjectItem(output,"id")->valuestring, ".json" );
+            } else {
+                snprintf( filename, sizeof(FILENAME_STRING), "voutput_%s%s", cJSON_GetObjectItem(output,"id")->valuestring, ".json" );
+            }
+            std::string output_str = cJSON_PrintUnformatted(output);
+
+            bool status = GLOBAL_mdot->saveUserFile(filename, (void *)output_str.c_str(), MAX_FILE_SIZE);
+            if( status != true ) {
+                printf("(%d)save file failed, status=%d\r\n", __LINE__, status);
+                break;
+            }
+
+            // send a message to the modbus master
+            ModbusMasterReq_t *mail = ModbusMasterMailBox.alloc();
+            mail->action = ACTION_READ_FILE;
+            strncpy( mail->msg, filename, (sizeof(mail->msg)-1));
+            ModbusMasterMailBox.put(mail);
+
+            // send a message to the output master
+            OutputControlMsg_t *output_mail = OutputMasterMailBox.alloc();
+            output_mail->action = ACTION_NEW;
+            strncpy(output_mail->controlFile, filename, sizeof(output_mail->controlFile)-1);
+            OutputMasterMailBox.put(output_mail);
+
+            printf("%s:%d: OUTPUT JSON: %s\r\n", __func__,__LINE__, output_str.c_str() );
+            printf("%s:%d: Sending New OUTPUT to ModbusMaster and OutputMaster, filename=%s\r\n", __func__,__LINE__, filename);
+
+            break;
+        }
+        case HOLDING_CONFIG_MTYPE: {
+
+            cJSON * holding = cJSON_GetObjectItem(root,"holding");
+            snprintf( filename, sizeof(FILENAME_STRING), "hold_%s%s", cJSON_GetObjectItem(holding,"id")->valuestring, ".json" );
+            std::string holding_str = cJSON_PrintUnformatted(holding);
+
+            bool status = GLOBAL_mdot->saveUserFile(filename, (void *)holding_str.c_str(), MAX_FILE_SIZE);
+            if( status != true ) {
+                printf("(%d)save file failed, status=%d", __LINE__, status);
+                break;
+            }
+
+            ModbusMasterReq_t *mail = ModbusMasterMailBox.alloc();
+            mail->action = ACTION_READ_FILE;
+            strncpy( mail->msg, filename, (sizeof(mail->msg)-1));
+            ModbusMasterMailBox.put(mail);
+
+            printf("%s:%d: HOLDING JSON: %s\r\n", __func__,__LINE__, holding_str.c_str() );
+            printf("%s:%d: Sending New HOLDING REGISTER to ModbusMasterMailBox, filename=%s\r\n", __func__,__LINE__, filename);
+            break;
+        }
+        case DESTROY_SETPOINT_MTYPE: {
+
+            cJSON * spcontrol = cJSON_GetObjectItem(root,"spcontrol");
+            snprintf( filename, sizeof(FILENAME_STRING), "control_sp_%s.json", cJSON_GetObjectItem(spcontrol,"id")->valuestring );
+
+            // send a message to the configuration handler to create the control
+            ConfigMessage_t *msg  = ConfigHandlerMailBox.alloc();
+            memset(msg, 0, sizeof(ConfigMessage_t));
+            msg->action  = ACTION_DESTROY;
+            msg->control = CONTROL_SETPOINT;
+            strncpy(msg->controlFile, filename, sizeof(msg->controlFile)-1);
+
+            printf("%s:%d: Sending a destroy request for setpoint control %s type = %u\r\n", __func__,__LINE__, msg->controlFile, msg->control);
+
+            ConfigHandlerMailBox.put(msg);
+            break;
+        }
+        case DESTROY_MANUAL_MTYPE: {
+
+            cJSON * mncontrol = cJSON_GetObjectItem(root,"mncontrol");
+            snprintf( filename, sizeof(FILENAME_STRING), "control_mn_%s.json", cJSON_GetObjectItem(mncontrol,"id")->valuestring );
+
+            // send a message to the configuration handler to create the control
+            ConfigMessage_t *msg  = ConfigHandlerMailBox.alloc();
+            memset(msg, 0, sizeof(ConfigMessage_t));
+            msg->action  = ACTION_DESTROY;
+            msg->control = CONTROL_MANUAL;
+            strncpy(msg->controlFile, filename, sizeof(msg->controlFile)-1);
+
+            printf("%s:%d: Sending a destroy request for manual control %s type = %u\r\n", __func__,__LINE__, msg->controlFile, msg->control);
+
+            ConfigHandlerMailBox.put(msg);
+            break;
+        }
+        case DESTROY_TIMER_MTYPE: {
+
+            cJSON * tmcontrol = cJSON_GetObjectItem(root,"tmcontrol");
+            snprintf( filename, sizeof(FILENAME_STRING), "control_tm_%s.json", cJSON_GetObjectItem(tmcontrol,"id")->valuestring );
+
+            ConfigMessage_t *msg  = ConfigHandlerMailBox.alloc();
+            memset(msg, 0, sizeof(ConfigMessage_t));
+            msg->action  = ACTION_DESTROY;
+            msg->control = CONTROL_TIMER;
+            strncpy(msg->controlFile, filename, sizeof(msg->controlFile)-1);
+
+            printf("%s:%d: Sending a destroy request for timer control %s type = %u\r\n", __func__,__LINE__, msg->controlFile, msg->control);
+
+            ConfigHandlerMailBox.put(msg);
+            break;
+        }
+        case VIRTUAL_COMMAND_MTYPE: {
+
+            cJSON * command = cJSON_GetObjectItem(root,"command");
+            snprintf( filename, sizeof(FILENAME_STRING), "cmd_%s.json", cJSON_GetObjectItem(command,"id")->valuestring );
+            std::string command_json = cJSON_PrintUnformatted(command);
+
+            bool status = GLOBAL_mdot->saveUserFile(filename, (void *)command_json.c_str(), MAX_FILE_SIZE);
+            if( status != true ) {
+                printf("(%d)save file failed, status=%d\r\n", __LINE__, status);
+                break;
+            }
+
+            ModbusMasterReq_t *mail = ModbusMasterMailBox.alloc();
+            mail->action = ACTION_READ_FILE;
+            strncpy( mail->msg, filename, (sizeof(mail->msg)-1));
+            ModbusMasterMailBox.put(mail);
+
+            printf("%s:%d: COMMAND: %s\r\n", __func__,__LINE__, command_json.c_str() );
+            printf("%s:%d: Sending a create command requst to ModbusMaster %s type = %u\r\n", __func__,__LINE__, mail->msg, mail->control);
+
+            break;
+        }
+        case BT_MODBUS_HOLD_COMMAND_MTYPE: {
+
+            cJSON * mbcommand = cJSON_GetObjectItem(root,"mbcommand");
+            std::string mbcommand_json = cJSON_PrintUnformatted(mbcommand);
+            ModbusMasterReq_t *mail = ModbusMasterMailBox.alloc();
+            mail->action = ACTION_EXEC_CMD;
+            mail->replyThread = CLOUD_DATA_HANDLER;
+            strncpy( mail->msg, mbcommand_json.c_str(), (sizeof(mail->msg)-1));
+            ModbusMasterMailBox.put(mail);
+
+            printf("%s:%d: MODBUS Command: %s\r\n", __func__,__LINE__, mbcommand_json.c_str());
+
+            break;
+        }
+        default:
+//            printf("%s:%d: DEFAULT\r\n", __func__,__LINE__);
+            break;
+    }
+    cJSON_Delete(root);
+    return true;
+}
+
+bool CloudDataHandler_RcvFile = false;
+bool CloudFileReceiver( std::string *recv_string )
+{
+    bool status;
+    CloudDataHandler_RcvFile = false;
+    int sequence;
+    std::string seq_str = recv_string->c_str();
+    std::string remove_seq = "{\"seq\":";
+    std::string::size_type i = seq_str.find(remove_seq);
+    if (i != std::string::npos) {
+        seq_str.erase(i, remove_seq.length());
+        std::string remove_comma = ",";
+        i = seq_str.find(remove_comma);
+        if (i != std::string::npos) {
+            seq_str.erase(i, (seq_str.length()-i));
+            sequence = atoi(seq_str.c_str());
+        }
+    }
+    std::string payload_string = recv_string->c_str();
+    std::string extract_pay = "\"pay\":";
+    i = payload_string.find(extract_pay);
+    if (i != std::string::npos) {
+        i = i + extract_pay.length();
+        payload_string.erase(0, i);
+        payload_string.erase((payload_string.length()-1), 1);
+        if( sequence != -1 ) {
+            payload_string = payload_string.substr(1, payload_string.size() - 2);
+        }
+    }
+
+    printf("sequence=%d, payload_string:%s", sequence, payload_string.c_str() );
+
+    CloudDataHandler_RcvFile = false;
+    if( sequence == -1 ) {
+
+        // sequence of -1 means string sent in 1 chunk.
+//        printf("%s:%d: payload=%s\r\n",__func__,__LINE__, payload_string.c_str() );
+        status = StoreReceivedFile( payload_string );
+
+    } else if( sequence == 0 ) {
+
+        memset(CloudFileReceiverWriteBuf,0,sizeof(CloudFileReceiverWriteBuf));
+        snprintf(CloudFileReceiverWriteBuf, sizeof(CloudFileReceiverWriteBuf), "%s", payload_string.c_str() );
+
+        printf("(%d)Writing String Length=%d, %s", __LINE__, MAX_FILE_SIZE, CloudFileReceiverWriteBuf );
+
+        status = GLOBAL_mdot->saveUserFile("scratch.json", (void *)CloudFileReceiverWriteBuf, MAX_FILE_SIZE);
+        if( status != true ) {
+            printf("(%d)save file failed, status=%d", __LINE__, status);
+        } else {
+            CloudDataHandler_RcvFile = true;
+            printf("(%d)UPDATED scratch.json FILE, status:%d, strlen=%d", __LINE__, status, strlen(CloudFileReceiverWriteBuf));
+        }
+
+    } else if( sequence == -2 ) {
+
+        printf("(%d)READING BACK scratch.json FILE FOR LAST PACKET", __LINE__);
+
+        // read the file back
+        status = GLOBAL_mdot->readUserFile("scratch.json", (void *)CloudFileReceiverReadBuf, MAX_FILE_SIZE);
+        if( status != true ) {
+            printf("(%d)read file failed, status=%d", __LINE__, status);
+            return false;
+        }
+
+        snprintf(CloudFileReceiverWriteBuf, sizeof(CloudFileReceiverWriteBuf), "%s%s", CloudFileReceiverReadBuf, payload_string.c_str() );
+        printf("(%d)Final String Length=%d, %s", __LINE__, strlen(CloudFileReceiverWriteBuf), CloudFileReceiverWriteBuf );
+
+        std::string final_json = CloudFileReceiverWriteBuf;
+        printf("%s:%d: finished parse: %s\r\n", __func__,__LINE__,final_json.c_str() );
+
+        status = StoreReceivedFile( final_json );
+        if( status != true ) {
+            printf("(%d)save file failed, status=%d", __LINE__, status);
+        }
+
+        status = GLOBAL_mdot->deleteUserFile("scratch.json");
+        if( status != true ) {
+            printf("(%d)delete file failed, status=%d", __LINE__, status);
+        }
+
+        printf("(%d)DELETED scratch.json FILE, status:%d", __LINE__, status );
+
+    } else {
+
+        printf("(%d)READING BACK scratch.json FILE", __LINE__);
+
+        // read the file back
+        status = GLOBAL_mdot->readUserFile("scratch.json", (void *)CloudFileReceiverReadBuf, MAX_FILE_SIZE);
+        if( status != true ) {
+            printf("(%d)read file failed, status=%d", __LINE__, status);
+            return false;
+        }
+
+        snprintf(CloudFileReceiverWriteBuf, sizeof(CloudFileReceiverWriteBuf), "%s%s", CloudFileReceiverReadBuf, payload_string.c_str() );
+        printf("(%d)Writing String Length=%d, %s", __LINE__, strlen(CloudFileReceiverWriteBuf), CloudFileReceiverWriteBuf );
+
+        status = GLOBAL_mdot->saveUserFile("scratch.json", (void *)CloudFileReceiverWriteBuf, MAX_FILE_SIZE);
+        if( status != true ) {
+            printf("(%d)save file failed, status=%d", __LINE__, status);
+        } else {
+            CloudDataHandler_RcvFile = true;
+            printf("(%d)UPDATED scratch.json FILE, status:%d, strlen=%d", __LINE__, status, strlen(CloudFileReceiverWriteBuf));
+        }
+    }
+    return true;
+}
\ No newline at end of file