Merge branch 'master' of https://twinetfs.visualstudio.com/Tango/_git/Tango

1 files changed, 228 insertions, 7 deletions

diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
index f9806552d..6324c904e 100644
--- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
+++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
@@ -6,6 +6,7 @@
  */
 #include "include.h"
 #include "Communication/CommunicationTask.h"
+#include <DataDef.h>
 
 #include  <Communication/PMR/IO/FileUploadRequest.pb-c.h>
 #include  <Communication/PMR/IO/FileUploadResponse.pb-c.h>
@@ -23,19 +24,57 @@
 #include  <Communication/PMR/IO/GetStorageInfoResponse.pb-c.h>
 #include  <Communication/PMR/IO/GetFilesRequest.pb-c.h>
 #include  <Communication/PMR/IO/GetFilesResponse.pb-c.h>
+#include  <Communication/PMR/IO/FileAttribute.pb-c.h>
 
+#include "third_party/fatfs/src/ffconf.h"
+#include "third_party/fatfs/src/diskio.h"
+#include "drivers/Flash_Memory/Flash_Memory.h"
+#include "drivers/Flash_Memory/fatfs/ff.h"
 
+#include "third_party/fatfs/src/ffconf.h"
+FIL *FileHandle = 0;  //the system supports a single active file
+char FileHandleChar[5];
+char ErrorMsg[100];
+#define MAX_CHUNK_LENGTH 2000
+int FileLength = 0;
+int FileReceivedLength = 0;
+
+bool isDirectory(FileAttribute FileAtt)
+{
+    if (FileAtt&&FILE_ATTRIBUTE__Directory)
+        return true;
+    return false;
+}
 
 uint32_t    FileUploadRequestFunc(MessageContainer* requestContainer)
 {
     uint32_t status = OK;
 
+    FRESULT Fresult = FR_OK;
+
     MessageContainer responseContainer;
 
     FileUploadRequest* request = file_upload_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
 
     FileUploadResponse response = FILE_UPLOAD_RESPONSE__INIT;
 
+    if (FileHandle == 0)
+    {
+        Fresult = f_open(FileHandle,request->filename,FA_READ | FA_WRITE | FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW);
+        if (Fresult == FR_OK)
+        {
+            FileLength = request->length;
+            response.has_maxchunklength = true;
+            response.maxchunklength = MAX_CHUNK_LENGTH;
+            memcpy (FileHandleChar,FileHandle,sizeof(FileHandle));
+            response.uploadid = FileHandleChar; //supporting only single file at each time.
+        }
+    }
+    else
+    {
+        Fresult = FR_DENIED;
+    }
+
 
     responseContainer = createContainer(MESSAGE_TYPE__FileUploadResponse,  requestContainer->token, false, &response, &file_upload_response__pack, &file_upload_response__get_packed_size);
     if (status!= OK)
@@ -55,6 +94,9 @@ uint32_t    FileUploadRequestFunc(MessageContainer* requestContainer)
 uint32_t    FileChunkUploadRequestFunc(MessageContainer* requestContainer)
 {
     uint32_t status = OK;
+    FRESULT Fresult = FR_OK;
+    uint32_t WrittenBytes = 0;
+
 
     MessageContainer responseContainer;
 
@@ -62,6 +104,48 @@ uint32_t    FileChunkUploadRequestFunc(MessageContainer* requestContainer)
 
     FileChunkUploadResponse response = FILE_CHUNK_UPLOAD_RESPONSE__INIT;
 
+    FIL *ReceivedFileHandle = 0;  //the system supports a single active file
+
+    memcpy (ReceivedFileHandle,request->uploadid,sizeof(ReceivedFileHandle));
+    if (ReceivedFileHandle == FileHandle)
+    {
+        Fresult = f_write(ReceivedFileHandle,request->buffer.data,request->buffer.len,&WrittenBytes );
+//            FIL *fp,            /* Pointer to the file object */
+//            const void *buff,   /* Pointer to the data to be written */
+//            UINT btw,           /* Number of bytes to write */
+//            UINT *bw            /* Pointer to number of bytes written */
+        if(Fresult != FR_OK)
+        {
+            LOG_ERROR (Fresult,"f_write error");
+        }
+        else
+        {
+            int FileLength = 0;
+            FileReceivedLength += WrittenBytes;
+            if (FileReceivedLength == FileLength)
+            {
+                REPORT_MSG (FileReceivedLength,"file upload ended successfully");
+                f_close(ReceivedFileHandle);
+                FileHandle = 0;
+            }
+            else
+            {
+                if (FileReceivedLength > FileLength)
+                {
+                    REPORT_MSG (FileReceivedLength,"file upload too much data!");
+                    f_close(ReceivedFileHandle);
+                    FileHandle = 0;
+                }
+            }
+        }
+    }
+    else
+    {
+        LOG_ERROR (ReceivedFileHandle,"file id error");
+        f_close(FileHandle);
+        FileHandle = 0;
+        status = ERROR_CODE__FILE_NOT_FOUND;
+    }
 
     responseContainer = createContainer(MESSAGE_TYPE__FileChunkUploadResponse,  requestContainer->token, false, &response, &file_chunk_upload_response__pack, &file_chunk_upload_response__get_packed_size);
     if (status!= OK)
@@ -91,7 +175,7 @@ uint32_t    ExecuteProcessRequestFunc(MessageContainer* requestContainer)
     responseContainer = createContainer(MESSAGE_TYPE__ExecuteProcessResponse,  requestContainer->token, false, &response, &execute_process_response__pack, &execute_process_response__get_packed_size);
     if (status!= OK)
     {
-        responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
+        responseContainer.error = ERROR_CODE__FILE_NOT_FOUND;
         responseContainer.errormessage = "JOb Active or incorrect parameters";
     }
     responseContainer.continuous = false;
@@ -116,7 +200,7 @@ uint32_t    KillProcessRequestFunc(MessageContainer* requestContainer)
     responseContainer = createContainer(MESSAGE_TYPE__KillProcessResponse,  requestContainer->token, false, &response, &kill_process_response__pack, &kill_process_response__get_packed_size);
     if (status!= OK)
     {
-        responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
+        responseContainer.error = ERROR_CODE__FILE_NOT_FOUND;
         responseContainer.errormessage = "JOb Active or incorrect parameters";
     }
     responseContainer.continuous = false;
@@ -130,19 +214,48 @@ uint32_t    KillProcessRequestFunc(MessageContainer* requestContainer)
 uint32_t    CreateRequestFunc(MessageContainer* requestContainer)
 {
     uint32_t status = OK;
-
+    FRESULT Fresult = FR_OK;
     MessageContainer responseContainer;
 
     CreateRequest* request = create_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
 
     CreateResponse response = CREATE_RESPONSE__INIT;
 
+    if (isDirectory(request->attribute))
+    {
+        Fresult = f_mkdir(request->path);
+    }
+    else
+    {
+        if (FileHandle == 0)
+        {
+            Fresult = f_open(FileHandle,request->path,FA_CREATE_NEW);
+            if (Fresult == FR_OK)
+            {
+                if (f_close (FileHandle)!= FR_OK)
+                {
+                    Fresult = FR_LOCKED;
+                }
+            }
+        }
+        else
+        {
+            Fresult = FR_DENIED;
+        }
+    }
+    if (Fresult != FR_OK)
+    {
+        status = ERROR_CODE__FILE_NOT_FOUND;
+        usnprintf(ErrorMsg, 100, "File Operation failed error code %d",Fresult);
+
+    }
+    FileHandle = 0;
 
     responseContainer = createContainer(MESSAGE_TYPE__CreateResponse,  requestContainer->token, false, &response, &create_response__pack, &create_response__get_packed_size);
     if (status!= OK)
     {
-        responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
-        responseContainer.errormessage = "JOb Active or incorrect parameters";
+        responseContainer.error = ERROR_CODE__FILE_NOT_FOUND;
+        responseContainer.errormessage = ErrorMsg;
     }
     responseContainer.continuous = false;
     uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
@@ -162,11 +275,52 @@ uint32_t    DeleteRequestFunc(MessageContainer* requestContainer)
 
     DeleteResponse response = DELETE_RESPONSE__INIT;
 
+    DIR dir;
+    FILINFO* fno = 0;
+    int NumOfFiles = 0;
+    FRESULT Fresult = FR_OK;
+
+    Fresult = f_stat(request->path,fno);
+    if (Fresult == FR_OK)
+    {
+        if (isDirectory(fno->fattrib))
+        {
+            //============================
+            Fresult = f_opendir(&dir, request->path);                       /* Open the directory */
+             if (Fresult == FR_OK)
+             {
+                 Fresult = f_readdir(&dir, &fno);                   /* Read a directory item */
+                 if (Fresult == FR_OK)
+                 {
+                     if(fno->fname[0] ==0)
+                     {
+                         //no files
+                         Fresult = f_unlink(request->path);
+                     }
+                     else
+                     {
+                         LOG_ERROR (fno,"Directory not empty");
+                     }
+                 }
+             }
+        }
+        else
+        {
+            Fresult = f_unlink(request->path);
+        }
+    }
+    if (Fresult != FR_OK)
+    {
+        status = ERROR_CODE__FILE_NOT_FOUND;
+        usnprintf(ErrorMsg, 100, "File Operation failed error code %d",Fresult);
+    }
+    FileHandle = 0;
+
 
     responseContainer = createContainer(MESSAGE_TYPE__DeleteResponse,  requestContainer->token, false, &response, &delete_response__pack, &delete_response__get_packed_size);
     if (status!= OK)
     {
-        responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
+        responseContainer.error = ERROR_CODE__FILE_NOT_FOUND;
         responseContainer.errormessage = "JOb Active or incorrect parameters";
     }
     responseContainer.continuous = false;
@@ -186,6 +340,24 @@ uint32_t    GetStorageInfoRequestFunc(MessageContainer* requestContainer)
     GetStorageInfoRequest* request = get_storage_info_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
 
     GetStorageInfoResponse response = GET_STORAGE_INFO_RESPONSE__INIT;
+    FATFS *fs;
+    DWORD fre_clust, fre_sect, tot_sect;
+    FRESULT Fresult = FR_OK;
+
+
+    /* Get volume information and free clusters of drive 1 */
+    Fresult = f_getfree("0:", &fre_clust, &fs);
+     if (Fresult == FR_OK)
+     {
+
+    /* Get total sectors and free sectors */
+         tot_sect = (fs->n_fatent - 2) * fs->csize;
+         fre_sect = fre_clust * fs->csize;
+         response.has_capacity = true;
+         response.capacity = tot_sect/2;
+         response.has_freespace = true;
+         response.freespace = fre_sect/2;
+     }
 
 
     responseContainer = createContainer(MESSAGE_TYPE__GetStorageInfoResponse,  requestContainer->token, false, &response, &get_storage_info_response__pack, &get_storage_info_response__get_packed_size);
@@ -212,11 +384,60 @@ uint32_t    GetFilesRequestFunc(MessageContainer* requestContainer)
 
     GetFilesResponse response = GET_FILES_RESPONSE__INIT;
 
+    #define MAX_NUM_OF_FILES 10
+    DIR dir;
+    FILINFO* fno[MAX_NUM_OF_FILES] = {0,0,0,0,0,0,0,0,0,0};
+    int NumOfFiles = 0;
+    FRESULT Fresult = FR_OK;
 
+    FileInfo **FilesInfo = (FileInfo**)malloc(sizeof(FileInfo *)*(MAX_NUM_OF_FILES));
+    FileInfo Data[MAX_NUM_OF_FILES];
+    Fresult = f_stat(request->path,fno[0]);
+    if (Fresult == FR_OK)
+    {
+        if (isDirectory(fno[0]->fattrib))
+        {
+            NumOfFiles++;
+            //============================
+            Fresult = f_opendir(&dir, request->path);                       /* Open the directory */
+             if (Fresult == FR_OK)
+             {
+                 for (NumOfFiles = 1;NumOfFiles < MAX_NUM_OF_FILES;NumOfFiles++)
+                 {
+                     Fresult = f_readdir(&dir, &fno[NumOfFiles]);                   /* Read a directory item */
+                     if (Fresult == FR_OK)
+                     {
+                         if(fno[NumOfFiles]->fname[0] ==0)
+                         {
+                             break;
+                         }
+                     }
+                 }
+             }
+        }
+        else
+        {
+            Fresult = FR_DENIED;
+        }
+    }
+
+    if (Fresult == FR_OK)
+    {
+        for (NumOfFiles = 0;NumOfFiles < MAX_NUM_OF_FILES;NumOfFiles++)
+        {
+            Data[NumOfFiles].attribute = fno[NumOfFiles]->fattrib;
+            Data[NumOfFiles].name = fno[NumOfFiles]->fname;
+            Data[NumOfFiles].length = fno[NumOfFiles]->fsize;
+            Data[NumOfFiles].lastmodifieddate = fno[NumOfFiles]->fdate;
+            Data[NumOfFiles].lastmodifiedtime = fno[NumOfFiles]->ftime;
+            response.items[NumOfFiles] = &Data[NumOfFiles];
+        }
+    }
     responseContainer = createContainer(MESSAGE_TYPE__GetFilesResponse,  requestContainer->token, false, &response, &get_files_response__pack, &get_files_response__get_packed_size);
+
     if (status!= OK)
     {
-        responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
+        responseContainer.error = ERROR_CODE__FILE_NOT_FOUND;
         responseContainer.errormessage = "JOb Active or incorrect parameters";
     }
     responseContainer.continuous = false;