merge - fix

1 files changed, 303 insertions, 154 deletions

diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
index 018e83ce0..efc156da3 100644
--- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
+++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
@@ -31,14 +31,11 @@
 #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 "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 
-#include "third_party/fatfs/src/ffconf.h"
-
+#include "Modules/Control/Control.h"
 #include "StateMachines/Printing/PrintingSTM.h"
 
 
@@ -53,7 +50,7 @@ FIL *UploadFileHandle = 0;  //the system supports a single active file
 FIL *DownloadFileHandle = 0;  //the system supports a single active file
 char FileHandleChar[5];
 char ErrorMsg[100];
-#define MAX_CHUNK_LENGTH 3500
+#define MAX_CHUNK_LENGTH 4096
 int32_t FileLength = 0;
 int32_t FileReceivedLength = 0;
 int32_t FileSentLength = 0;
@@ -63,6 +60,7 @@ uint32_t ReadBytes = 0;
 Task_Handle CommRxTaskHandle;
 
 extern Semaphore_Handle FFS_Sem;
+extern Semaphore_Handle FileUpload_sem_param;
 
 ErrorCode getErrorCode(FRESULT Fresult)
 {
@@ -74,14 +72,19 @@ bool isDirectory(FileAttribute FileAtt)
         return true;
     return false;
 }
-bool FileDone = false;
+bool FileDone = true;
+bool FileUploadGetState(void)
+{
+    return FileDone;
+}
+int CommRxpri;
 
 uint32_t    FileUploadRequestFunc(MessageContainer* requestContainer)
 {
     //uint32_t status = OK;
 
     FRESULT Fresult = FR_OK;
-
+    bool sem_ok = false;
     MessageContainer responseContainer;
 
     FileUploadRequest* request = file_upload_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
@@ -90,7 +93,10 @@ uint32_t    FileUploadRequestFunc(MessageContainer* requestContainer)
 
     WrittenBytes=0;
     if (JobIsActive())
+    {
         Fresult = FR_DENIED;
+        Report("file uplad rejected - job is running", __FILE__, __LINE__, 4, RpWarning,   (int)0, 0);
+    }
     else
     {
         UploadFileHandle = my_malloc(sizeof(FIL));
@@ -98,38 +104,58 @@ uint32_t    FileUploadRequestFunc(MessageContainer* requestContainer)
             Fresult = FR_DENIED;
         else
         {
-            Semaphore_pend(FFS_Sem, BIOS_WAIT_FOREVER);
-            Fresult = f_open(UploadFileHandle,request->path,FA_READ | FA_WRITE | FA_OPEN_ALWAYS | FA_CREATE_ALWAYS);
-            if (Fresult == FR_OK)
+            if (1)//(Semaphore_pend(FileUpload_sem_param, BIOS_NO_WAIT))
             {
-                FileLength = request->length;
-                FileReceivedLength = 0;
-                REPORT_MSG (FileLength,"file upload request");
-                response.has_maxchunklength = true;
-                response.maxchunklength = MAX_CHUNK_LENGTH;
-                strcpy(FileHandleChar, "1234");
-                response.uploadid = FileHandleChar; //supporting only single file at each time.
-                FileDone = false;
+                sem_ok = true;
             }
             else
             {
-                my_free (UploadFileHandle);
-                UploadFileHandle = 0;
-                Semaphore_post(FFS_Sem);
+                Semaphore_post(FileUpload_sem_param);
+                Report("semaphore was not free", __FILE__, __LINE__, request->length, RpWarning,   (int)MAX_CHUNK_LENGTH, 0);
+                sem_ok = true;
             }
+            if (sem_ok == true)
+            {
+                CommRxTaskHandle = Task_self();
+                CommRxpri = Task_getPri(CommRxTaskHandle);
+                Task_setPri(CommRxTaskHandle, 11);
+                Report("Task_setPri", __FILE__, __LINE__, 11, RpWarning,   (int)CommRxTaskHandle, 0);
+                //Report("FileUploadRequestFunc 2", __FILE__, __LINE__, msec_millisecondCounter, RpWarning,   (int)0, 0);
+                Fresult = f_open(UploadFileHandle,request->path,FA_READ | FA_WRITE | FA_OPEN_ALWAYS | FA_CREATE_ALWAYS);
+                if (Fresult == FR_OK)
+                {
+                    usnprintf(ErrorMsg, 100, "file upload request %s %d",request->path,request->length);
 
+                    Report(ErrorMsg, __FILE__, __LINE__, request->length, RpWarning,   (int)MAX_CHUNK_LENGTH, 0);
+                    FileLength = request->length;
+                    FileReceivedLength = 0;
+                    response.has_maxchunklength = true;
+                    response.maxchunklength = MAX_CHUNK_LENGTH;
+                    strcpy(FileHandleChar, "1234");
+                    response.uploadid = FileHandleChar; //supporting only single file at each time.
+                    FileDone = false;
+                }
+                else
+                {
+                    my_free (UploadFileHandle);
+                    UploadFileHandle = 0;
+                    Semaphore_post(FileUpload_sem_param);
+                }
+            }
+            else
+            {
+                Fresult = FR_DENIED;
+                Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning,   (int)0, 0);
+            }
         }
     }
-    CommRxTaskHandle = Task_self();
-    Task_setPri(CommRxTaskHandle, 4);
-   // Report("Task_setPri", __FILE__, __LINE__, 4, RpWarning,   (int)CommRxTaskHandle, 0);
 
-
-    responseContainer = createContainer(MESSAGE_TYPE__FileUploadResponse,  requestContainer->token, false, &response, &file_upload_response__pack, &file_upload_response__get_packed_size);
+    responseContainer = createContainer(MESSAGE_TYPE__FileUploadResponse,  requestContainer->token, true, &response, &file_upload_response__pack, &file_upload_response__get_packed_size);
     if (Fresult!= FR_OK)
     {
+        responseContainer.has_error = true;
         responseContainer.error = getErrorCode(Fresult);
-        responseContainer.errormessage = "File operation error";
+        responseContainer.errormessage = "File operation upload request error";
     }
     responseContainer.continuous = false;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
@@ -141,6 +167,25 @@ uint32_t    FileUploadRequestFunc(MessageContainer* requestContainer)
     return OK;
 }
 FRESULT lFresult = FR_OK;
+uint32_t Chunk_ControlId = 0xFF;
+uint32_t FileChunkUploadCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
+{
+    Report("chunk timeout error",__FILE__,IfIndex,FileReceivedLength,RpWarning,BusyFlag,0);
+    f_close(UploadFileHandle);
+    my_free (UploadFileHandle);
+    UploadFileHandle = 0;
+    FileReceivedLength = 0;
+    FileDone = true;
+    Task_setPri(CommRxTaskHandle, CommRxpri);
+    Semaphore_post(FileUpload_sem_param);
+    Report("Task_setPri", __FILE__, __LINE__, CommRxpri, RpWarning,   (int)CommRxTaskHandle, 0);
+    if (SafeRemoveControlCallback(Chunk_ControlId, FileChunkUploadCallBackFunction )==OK)
+        Chunk_ControlId = 0xFF;
+
+    return OK;
+
+}
+
 uint32_t    FileChunkUploadRequestFunc(MessageContainer* requestContainer)
 {
     //uint32_t status = OK;
@@ -155,15 +200,27 @@ uint32_t    FileChunkUploadRequestFunc(MessageContainer* requestContainer)
 
     FIL *ReceivedFileHandle;  //the system supports a single active file
 
+    uint32_t save_milisec = 0;
   //  if (request->uploadid == 1)
     ReceivedFileHandle = UploadFileHandle;
 //    memcpy (&ReceivedFileHandle,request->uploadid,sizeof(ReceivedFileHandle));
     //if (ReceivedFileHandle == FileHandle)
     //{
-    Control_WD(ENABLE,55);  //activate heaters/dispenser watchdog, 0.5 seconds
-    GeneralHwReady = false;
-    KeepAliveOneSecondCounter = 0;
-    Fresult = f_write(ReceivedFileHandle,request->buffer.data,request->buffer.len,&WrittenBytes );
+    //Control_WD(ENABLE,55);  //activate heaters/dispenser watchdog, 0.5 seconds
+    //GeneralHwReady = false;
+    if (ReceivedFileHandle==NULL)
+    {
+        Fresult = FR_DENIED;
+        Report("file chunk upload rejected - file not created", __FILE__, __LINE__, 4, RpWarning,   (int)0, 0);
+        FileDone = true;
+    }
+    else
+    {
+        KeepAliveOneSecondCounter = 0;
+        save_milisec = msec_millisecondCounter;
+        Chunk_ControlId = AddControlCallback("chunk", FileChunkUploadCallBackFunction, eOneSecond, TemplateDataReadCBFunction,0,request->buffer.len, WrittenBytes );
+
+        Fresult = f_write(ReceivedFileHandle,request->buffer.data,request->buffer.len,&WrittenBytes );
         lFresult = Fresult;
         if(Fresult != FR_OK)
         {
@@ -173,6 +230,10 @@ uint32_t    FileChunkUploadRequestFunc(MessageContainer* requestContainer)
         else
         {
             FileReceivedLength += WrittenBytes;
+            ReportWithPackageFilter(CommFilter,"Chunk received", __FILE__,FileLength,FileReceivedLength, RpMessage,msec_millisecondCounter-save_milisec, 0);
+            RemoveControlCallback(Chunk_ControlId, FileChunkUploadCallBackFunction );
+            Chunk_ControlId = 0xFF;
+
             //REPORT_MSG (FileReceivedLength,"file upload chunk");
             if (FileReceivedLength == FileLength)
             {
@@ -196,20 +257,14 @@ uint32_t    FileChunkUploadRequestFunc(MessageContainer* requestContainer)
                 }
             }
         }
-    /*}
-    else
-    {
-        LOG_ERROR (ReceivedFileHandle,"file id error");
-        f_close(FileHandle);
-        free (FileHandle);
-        status = ERROR_CODE__FILE_NOT_FOUND;
-    }*/
+    }
 
     responseContainer = createContainer(MESSAGE_TYPE__FileChunkUploadResponse,  requestContainer->token, FileDone, &response, &file_chunk_upload_response__pack, &file_chunk_upload_response__get_packed_size);
     if (Fresult!= OK)
     {
+        responseContainer.has_error = true;
         responseContainer.error = getErrorCode(Fresult);
-        responseContainer.errormessage = "File operation error";
+        responseContainer.errormessage = "File operation chunk upload error";
     }
     responseContainer.continuous = false;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
@@ -220,13 +275,26 @@ uint32_t    FileChunkUploadRequestFunc(MessageContainer* requestContainer)
     SendCharsWithType(container_buffer, container_size,MESSAGE_TYPE__FileChunkUploadResponse);
     if (FileDone == true)
     {
-        Task_setPri(CommRxTaskHandle, 9);
-        GeneralHwReady = true;
-        Semaphore_post(FFS_Sem);
-        //Report("Task_setPri", __FILE__, __LINE__, 9, RpWarning,   (int)CommRxTaskHandle, 0);
+        Task_setPri(CommRxTaskHandle, CommRxpri);
+        Semaphore_post(FileUpload_sem_param);
+        Report("Task_setPri", __FILE__, __LINE__, CommRxpri, RpWarning,   (int)CommRxTaskHandle, 0);
     }
     return OK;
 }
+void FileChunkUploadError(void)
+{
+    if (FileDone == false)
+    {
+        REPORT_MSG (FileReceivedLength,"file upload too much data!");
+        f_close(UploadFileHandle);
+        //my_free (UploadFileHandle); CAN NOT CALL FREE() FROM INTERRUPT
+        UploadFileHandle = 0;
+        FileReceivedLength = 0;
+        FileDone = true;
+        Task_setPri(CommRxTaskHandle, CommRxpri);
+        Semaphore_post(FileUpload_sem_param);
+    }
+}
 uint32_t    FileDownloadRequestFunc(MessageContainer* requestContainer)
 {
     //uint32_t status = OK;
@@ -256,16 +324,27 @@ uint32_t    FileDownloadRequestFunc(MessageContainer* requestContainer)
             Fresult = FR_DENIED;
         else
         {
-            Semaphore_pend(FFS_Sem, BIOS_WAIT_FOREVER);
-            Fresult = f_open(DownloadFileHandle,request->filename,FA_READ  );
-            if (Fresult == FR_OK)
+            if (1)//(Semaphore_pend(FFS_Sem, BIOS_NO_WAIT))
+            {
+                Fresult = f_open(DownloadFileHandle,request->filename,FA_READ  );
+                if (Fresult == FR_OK)
+                {
+                    response.has_maxchunklength = true;
+                    response.maxchunklength = MAX_CHUNK_LENGTH;
+                    strcpy(FileHandleChar, "1234");
+                    response.downloadid = FileHandleChar; //supporting only single file at each time.
+                    Report("data request", __FILE__, 1234, MAX_CHUNK_LENGTH, RpWarning,   (int)fno->fsize, 0);
+                }
+                else
+                {
+                    Semaphore_post(FFS_Sem);
+                }
+            }
+            else
             {
-                response.has_maxchunklength = true;
-                response.maxchunklength = MAX_CHUNK_LENGTH;
-                strcpy(FileHandleChar, "1234");
-                response.downloadid = FileHandleChar; //supporting only single file at each time.
+                Fresult = FR_DENIED;
+                Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning,   (int)0, 0);
             }
-
         }
     }
 
@@ -273,8 +352,9 @@ uint32_t    FileDownloadRequestFunc(MessageContainer* requestContainer)
     responseContainer = createContainer(MESSAGE_TYPE__FileDownloadResponse,  requestContainer->token, false, &response, &file_download_response__pack, &file_download_response__get_packed_size);
     if (Fresult!= FR_OK)
     {
+        responseContainer.has_error = true;
         responseContainer.error = getErrorCode(Fresult);
-        responseContainer.errormessage = "File operation error";
+        responseContainer.errormessage = "File operation download request error";
     }
     responseContainer.continuous = false;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
@@ -299,10 +379,11 @@ uint32_t    FileChunkDownloadRequestFunc(MessageContainer* requestContainer)
     Buffer = my_malloc (MAX_CHUNK_LENGTH);
     if (Buffer != NULL)
     {
-        Fresult = f_read(SentFileHandle,Buffer,2000,&ReadBytes );
+        Fresult = f_read(SentFileHandle,Buffer,MAX_CHUNK_LENGTH,&ReadBytes );
         if(Fresult != FR_OK)
         {
-            LOG_ERROR (Fresult,"f_write error");
+            LOG_ERROR (Fresult,"f_read error");
+            Semaphore_post(FFS_Sem);
         }
         else
         {
@@ -310,6 +391,7 @@ uint32_t    FileChunkDownloadRequestFunc(MessageContainer* requestContainer)
             response.buffer.len = ReadBytes;
             response.buffer.data = Buffer;
             FileSentLength += ReadBytes;
+            Report("sending data to MS", __FILE__, ReadBytes, FileSentLength, RpWarning,   (int)FileLength, 0);
             if (FileSentLength == FileLength)
             {
                 REPORT_MSG (FileSentLength,"file download ended successfully");
@@ -335,8 +417,9 @@ uint32_t    FileChunkDownloadRequestFunc(MessageContainer* requestContainer)
     responseContainer = createContainer(MESSAGE_TYPE__FileChunkDownloadResponse,  requestContainer->token, false, &response, &file_chunk_download_response__pack, &file_chunk_download_response__get_packed_size);
     if (Fresult!= OK)
     {
+        responseContainer.has_error = true;
         responseContainer.error = getErrorCode(Fresult);
-        responseContainer.errormessage = "File operation error";
+        responseContainer.errormessage = "File operation chunk download error";
     }
     responseContainer.continuous = false;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
@@ -362,8 +445,9 @@ 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.has_error = true;
         responseContainer.error = ERROR_CODE__GENERAL_ERROR;//getErrorCode(Fresult);
-        responseContainer.errormessage = "File operation error";
+        responseContainer.errormessage = "File operation execute error";
     }
     responseContainer.continuous = false;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
@@ -388,8 +472,9 @@ 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.has_error = true;
         responseContainer.error = ERROR_CODE__GENERAL_ERROR;//getErrorCode(Fresult);
-        responseContainer.errormessage = "File operation error";
+        responseContainer.errormessage = "File operation kill error";
     }
     responseContainer.continuous = false;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
@@ -413,6 +498,8 @@ uint32_t    CreateRequestFunc(MessageContainer* requestContainer)
     if (isDirectory(request->attribute))
     {
         Fresult = f_mkdir(request->path);
+        if (Fresult == FR_EXIST)
+            Fresult = FR_OK; //ingnore f_exist in directory create
     }
     else
     {
@@ -421,22 +508,30 @@ uint32_t    CreateRequestFunc(MessageContainer* requestContainer)
             Fresult = FR_DENIED;
         else
         {
-            Semaphore_pend(FFS_Sem, BIOS_WAIT_FOREVER);
-            Fresult = f_open(UploadFileHandle,request->path,FA_CREATE_NEW);
-            if (Fresult == FR_OK)
+            if (1)//(Semaphore_pend(FFS_Sem, BIOS_NO_WAIT))
             {
-                if (f_close (UploadFileHandle)!= FR_OK)
+                Fresult = f_open(UploadFileHandle,request->path,FA_READ | FA_WRITE | FA_OPEN_ALWAYS | FA_CREATE_ALWAYS);
+                if (Fresult == FR_OK)
                 {
-                    Fresult = FR_LOCKED;
+                    if (f_close (UploadFileHandle)!= FR_OK)
+                    {
+                        Fresult = FR_LOCKED;
+                    }
                 }
+                Semaphore_post(FFS_Sem);
+            }
+            else
+            {
+                Fresult = FR_DENIED;
+                Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning,   (int)0, 0);
             }
-            Semaphore_post(FFS_Sem);
         }
     }
     if (Fresult != FR_OK)
     {
         //status = ERROR_CODE__FILE_NOT_FOUND;
-        usnprintf(ErrorMsg, 100, "File Operation failed error code %d",Fresult);
+        //usnprintf(ErrorMsg, 100, "File Operation failed error code %d",Fresult);
+        Report("File Operation failed error code", __FILE__, __LINE__, Fresult, RpWarning,   (int)0, 0);
 
     }
     free (UploadFileHandle);
@@ -444,8 +539,9 @@ uint32_t    CreateRequestFunc(MessageContainer* requestContainer)
     responseContainer = createContainer(MESSAGE_TYPE__CreateResponse,  requestContainer->token, false, &response, &create_response__pack, &create_response__get_packed_size);
     if (Fresult!= OK)
     {
+        responseContainer.has_error = true;
         responseContainer.error = getErrorCode(Fresult);
-        responseContainer.errormessage = "File operation error";
+        responseContainer.errormessage = "File operation create error";
     }
     responseContainer.continuous = false;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
@@ -470,17 +566,17 @@ uint32_t    DeleteRequestFunc(MessageContainer* requestContainer)
     //int NumOfFiles = 0;
     FRESULT Fresult = FR_OK;
 
-    Semaphore_pend(FFS_Sem, BIOS_WAIT_FOREVER);
     Fresult = f_unlink(request->path);
     Semaphore_post(FFS_Sem);
 
     REPORT_MSG(Fresult, "File Delete");
     responseContainer = createContainer(MESSAGE_TYPE__DeleteResponse,  requestContainer->token, false, &response, &delete_response__pack, &delete_response__get_packed_size);
-    if (Fresult!= OK)
+    if ((Fresult!= FR_OK)&&(Fresult!= FR_NO_FILE))
     {
-        usnprintf(ErrorMsg, 100, "File Operation failed error code %d",Fresult);
+        //usnprintf(ErrorMsg, 100, "File Operation failed error code %d",Fresult);
+        responseContainer.has_error = true;
         responseContainer.error = getErrorCode(Fresult);
-        responseContainer.errormessage = ErrorMsg;
+        responseContainer.errormessage = "File operation delete error";
     }
     responseContainer.continuous = false;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
@@ -525,8 +621,9 @@ uint32_t    GetStorageInfoRequestFunc(MessageContainer* requestContainer)
     responseContainer = createContainer(MESSAGE_TYPE__GetStorageInfoResponse,  requestContainer->token, false, &response, &get_storage_info_response__pack, &get_storage_info_response__get_packed_size);
     if (Fresult!= OK)
     {
+        responseContainer.has_error = true;
         responseContainer.error = getErrorCode(Fresult);
-        responseContainer.errormessage = "File operation error";
+        responseContainer.errormessage = "File operation get storage info error";
     }
     responseContainer.continuous = false;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
@@ -537,6 +634,8 @@ uint32_t    GetStorageInfoRequestFunc(MessageContainer* requestContainer)
 
     return OK;
 }
+//char Datestr[100];
+
 uint32_t    GetFilesRequestFunc(MessageContainer* requestContainer)
 {
     //uint32_t status = OK;
@@ -546,77 +645,98 @@ uint32_t    GetFilesRequestFunc(MessageContainer* requestContainer)
     GetFilesRequest* request = get_files_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
 
     GetFilesResponse response = GET_FILES_RESPONSE__INIT;
-
-    #define MAX_NUM_OF_FILES 20
+    //struct tm RTC_time;
+    #define MAX_NUM_OF_FILES 40
     DIR dir;
     FILINFO* fno[MAX_NUM_OF_FILES];
     char FullPath[MAX_NUM_OF_FILES][60];
-    int i,NumOfFiles = 0;
+    int i,NumOfFiles = 0, ListedFiles = 0;
     FRESULT Fresult = FR_OK;
+    FileInfo **FilesInfo = (FileInfo**)my_malloc(sizeof(FileInfo *)*(MAX_NUM_OF_FILES));
+    FileInfo Data[MAX_NUM_OF_FILES];
 
-    Semaphore_pend(FFS_Sem, BIOS_WAIT_FOREVER);
-    Fresult |= f_opendir(&dir, g_cCwdBuf);
-    if(Fresult != FR_OK)
+    if (1)//(Semaphore_pend(FFS_Sem, BIOS_NO_WAIT))
     {
-        Semaphore_post(FFS_Sem);
-        return(Fresult);
-    }
+        Fresult |= f_opendir(&dir, g_cCwdBuf);
+        if(Fresult != FR_OK)
+        {
+            Semaphore_post(FFS_Sem);
+            return(Fresult);
+        }
 
-    memset (fno,0,sizeof(fno));
-    FileInfo **FilesInfo = (FileInfo**)my_malloc(sizeof(FileInfo *)*(MAX_NUM_OF_FILES));
-    FileInfo Data[MAX_NUM_OF_FILES];
-    memset(fno,0,sizeof(fno));
-    fno[0] = my_malloc(sizeof(FILINFO));
-	memset (fno[0],0,sizeof(FILINFO));
+        memset (fno,0,sizeof(fno));
+        memset(fno,0,sizeof(fno));
+        fno[0] = my_malloc(sizeof(FILINFO));
+        memset (fno[0],0,sizeof(FILINFO));
 
-    //============================
-    Fresult = f_opendir(&dir, request->path);                       /* Open the directory */
-     if (Fresult == FR_OK)
-     {
-         for (NumOfFiles = 1;NumOfFiles < MAX_NUM_OF_FILES;NumOfFiles++)
+        //============================
+        Fresult = f_opendir(&dir, request->path);                       /* Open the directory */
+         if (Fresult == FR_OK)
          {
-             fno[NumOfFiles] = my_malloc(sizeof(FILINFO));
-             memset (fno[NumOfFiles],0,sizeof(FILINFO));
-             Fresult = f_readdir(&dir, fno[NumOfFiles]);                   /* Read a directory item */
-             if (Fresult == FR_OK)
+             for (NumOfFiles = 1;NumOfFiles < MAX_NUM_OF_FILES;NumOfFiles++)
              {
-                 if(fno[NumOfFiles]->fname[0] ==0)
+                 fno[NumOfFiles] = my_malloc(sizeof(FILINFO));
+                 memset (fno[NumOfFiles],0,sizeof(FILINFO));
+                 Fresult = f_readdir(&dir, fno[NumOfFiles]);                   /* Read a directory item */
+                 if (Fresult == FR_OK)
                  {
-                     break;
+                     if(fno[NumOfFiles]->fname[0] ==0)
+                     {
+                         break;
+                     }
                  }
              }
          }
-     }
-     Semaphore_post(FFS_Sem);
+         Semaphore_post(FFS_Sem);
+    }
+    else
+    {
+        Fresult = FR_DENIED;
+        Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning,   (int)0, 0);
+    }
 
     if ((Fresult == FR_OK)&&(NumOfFiles))
     {
         for (i = 0;i < NumOfFiles;i++)
         {
-           file_info__init(&Data[i]);
-           FilesInfo[i] = &Data[i];
-           Data[i].has_attribute = true;
-           Data[i].attribute = fno[i]->fattrib;
-           Data[i].name = fno[i]->fname;
-           Data[i].has_length = true;
-           Data[i].length = fno[i]->fsize;
-           Data[i].has_lastmodifieddate = true;
-           Data[i].lastmodifieddate = fno[i]->fdate;
-           Data[i].has_lastmodifiedtime = true;
-           Data[i].lastmodifiedtime = fno[i]->ftime;
-            //Report(Data[i].name, __FILE__, __LINE__, Data[i].lastmodifieddate, RpWarning,   (int)Data[i].lastmodifiedtime, 0);
-
-           if (i==0)
-               usnprintf(&FullPath[i], 50,  "%s", request->path);
+            if (i==0)
+                usnprintf(&FullPath[ListedFiles], 50,  "%s", request->path);
+            else
+               if (strlen(request->path)==1) //info under the root
+                   usnprintf(&FullPath[ListedFiles], 50,  "%s%s", request->path, fno[i]->fname);
+               else
+                usnprintf(&FullPath[ListedFiles], 50,  "%s%s%s", request->path,"/", fno[i]->fname);
+           if (fno[i]->fattrib != 0xFF) //garbage
+           {
+               file_info__init(&Data[ListedFiles]);
+               FilesInfo[ListedFiles] = &Data[ListedFiles];
+               Data[ListedFiles].has_attribute = true;
+               Data[ListedFiles].attribute = fno[i]->fattrib;
+               Data[ListedFiles].name = fno[i]->fname;
+               Data[ListedFiles].has_length = true;
+               Data[ListedFiles].length = fno[i]->fsize;
+               Data[ListedFiles].has_lastmodifieddate = true;
+               Data[ListedFiles].lastmodifieddate = fno[i]->fdate;
+               Data[ListedFiles].has_lastmodifiedtime = true;
+               Data[ListedFiles].lastmodifiedtime = fno[i]->ftime;
+               Data[ListedFiles].fullpath = &FullPath[i][0];
+               ListedFiles++;
+           }
            else
-              if (strlen(request->path)==1) //info under the root
-                  usnprintf(&FullPath[i], 50,  "%s%s", request->path, fno[i]->fname);
-              else
-               usnprintf(&FullPath[i], 50,  "%s%s%s", request->path,"/", fno[i]->fname);
-           Data[i].fullpath = &FullPath[i];
+           {
+              // f_unlink(Data[ListedFiles].fullpath);
+		        Report("file system error - format FFS", __FILE__, __LINE__, 255, RpWarning,   (int)0, 0);
+           }
+           /*RTC_time.tm_year=(fno[i]->fdate>>9)+1980;//populate the time struct (FAT start==1980, RTC.year==0)
+           RTC_time.tm_mon=(fno[i]->fdate>>5)&0x000F;
+           RTC_time.tm_mday=fno[i]->fdate&0x001F;
+           RTC_time.tm_hour=(fno[i]->ftime>>11)&0x001F;
+           RTC_time.tm_min=(fno[i]->ftime>>5)&0x003F;
+           RTC_time.tm_sec=(fno[i]->ftime<<1)&0x003E;*/
+
 
         }
-        response.n_items = NumOfFiles;
+        response.n_items = ListedFiles;
         response.items = FilesInfo;
     }
     else
@@ -628,8 +748,9 @@ uint32_t    GetFilesRequestFunc(MessageContainer* requestContainer)
 
     if (Fresult!= OK)
     {
+        responseContainer.has_error = true;
         responseContainer.error = getErrorCode(Fresult);
-        responseContainer.errormessage = "File operation error";
+        responseContainer.errormessage = "File operation get files error";
     }
     responseContainer.continuous = false;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
@@ -638,8 +759,10 @@ uint32_t    GetFilesRequestFunc(MessageContainer* requestContainer)
         size_t container_size = message_container__pack(&responseContainer, container_buffer);
         SendChars(container_buffer, container_size);
     }
-    my_free(responseContainer.data.data);
-    my_free(FilesInfo);
+    if (responseContainer.data.data)
+        my_free(responseContainer.data.data);
+    if (FilesInfo)
+        my_free(FilesInfo);
     get_files_request__free_unpacked(request,NULL);
     for (i = 0;i < NumOfFiles;i++)
     {
@@ -661,27 +784,35 @@ FRESULT FileWrite(void * buffer, uint16_t size,char *path, uint32_t timeout)
             Fresult = FR_DENIED;
         else
         {
-           if (Semaphore_pend(FFS_Sem, timeout) == false)
-           {
-               LOG_ERROR (false,"file system busy error");
-               return FR_TIMEOUT;
-           }
-
-            Fresult = f_open(FileHandle,path,FA_WRITE |  FA_OPEN_ALWAYS);
-            if (Fresult == FR_OK)
+            if (1)//(Semaphore_pend(FFS_Sem, BIOS_NO_WAIT))
             {
-                Fresult = f_write(FileHandle,buffer,size,&Bytes );
-                if(Fresult != FR_OK)
+                Fresult = f_open(FileHandle,path,FA_WRITE |  FA_OPEN_ALWAYS|FA_CREATE_ALWAYS);
+                if (Fresult == FR_OK)
+                {
+                    Fresult = f_write(FileHandle,buffer,size,&Bytes );
+                    if(Fresult != FR_OK)
+                    {
+                        LOG_ERROR (Fresult,"fwrite error");
+                    }
+                    else
+                    {
+                        //LOG_ERROR (Bytes,"f_write ok no of bytes");
+                         Report("f_write ok no of bytes", __FILE__, __LINE__, Bytes, RpWarning,   (int)size, 0);
+                    }
+                    f_close(FileHandle);
+                }
+                else
                 {
-                    LOG_ERROR (Fresult,"fread error");
+                    LOG_ERROR (Fresult,"fopen error");
                 }
-                f_close(FileHandle);
+                Semaphore_post(FFS_Sem);
             }
             else
             {
-                LOG_ERROR (Fresult,"fopen error");
+                Fresult = FR_DENIED;
+                Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning,   (int)0, 0);
             }
-            Semaphore_post(FFS_Sem);
+
             my_free(FileHandle);
         }
     }
@@ -711,40 +842,50 @@ FRESULT FileRead(char *path, uint32_t *Size, void **Buffer)
                 Fresult = FR_DENIED;
             else
             {
-                Semaphore_pend(FFS_Sem, BIOS_WAIT_FOREVER);
-                Fresult = f_open(FileHandle,path,FA_READ);
-                if (Fresult == FR_OK)
+                if (1)//(Semaphore_pend(FFS_Sem, BIOS_NO_WAIT))
                 {
-                    Fresult = f_read(FileHandle,buffer,fno->fsize,&Bytes );
-                    if(Fresult == FR_OK)
+                    Fresult = f_open(FileHandle,path,FA_READ);
+                    if (Fresult == FR_OK)
                     {
-                        *Buffer = buffer;
-                        *Size = (uint32_t)fno->fsize;
+                        Fresult = f_read(FileHandle,buffer,fno->fsize,&Bytes );
+                        if(Fresult == FR_OK)
+                        {
+                            *Buffer = buffer;
+                            *Size = (uint32_t)fno->fsize;
+                            Report("f_read ok no of bytes", __FILE__, __LINE__, Bytes, RpWarning,   (int)fno->fsize, 0);
+                        }
+                        else
+                        {
+                            LOG_ERROR (Fresult,"fread error");
+                            my_free (buffer);
+                        }
+                        f_close(FileHandle);
                     }
                     else
                     {
-                        LOG_ERROR (Fresult,"fread error");
+                        LOG_ERROR (Fresult,"fopen error");
                         my_free (buffer);
                     }
-                    f_close(FileHandle);
                     Semaphore_post(FFS_Sem);
                 }
                 else
                 {
-                    LOG_ERROR (Fresult,"fopen error");
-                    my_free (buffer);
+                    Fresult = FR_DENIED;
+                    Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning,   (int)0, 0);
                 }
                 my_free(FileHandle);
             }
         }
         else
         {
-            LOG_ERROR (Fresult,"malloc error");
+            Report("malloc error", __FILE__, __LINE__, Fresult, RpWarning,   (int)fno->fsize, 0);
+            Fresult = FR_DENIED;
         }
     }
     else
     {
-        LOG_ERROR (Fresult,"f_stat error");
+        Report("f_stat error", __FILE__, __LINE__, Fresult, RpWarning,   (int)0, 0);
+        Fresult = FR_DENIED;
     }
     my_free(fno);
     return Fresult;
@@ -766,12 +907,20 @@ FRESULT FileOpen(char *path, uint32_t *Size, FIL *FileHandle)
         if (FileHandle == 0)
             Fresult = FR_DENIED;
         else
-            Semaphore_pend(FFS_Sem, BIOS_WAIT_FOREVER);
-            Fresult = f_open(FileHandle,path,FA_READ);
+            if (1)//(Semaphore_pend(FFS_Sem, BIOS_NO_WAIT))
+            {
+                Fresult = f_open(FileHandle,path,FA_READ);
+                Semaphore_post(FFS_Sem); //will be closed with the f_close, in the job
+            }
+            else
+            {
+                Fresult = FR_DENIED;
+                Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning,   (int)0, 0);
+            }
     }
     else
     {
-        LOG_ERROR (Fresult,"f_stat error");
+        Report("f_stat error", __FILE__, __LINE__,Fresult, RpWarning,   (int)0, 0);
     }
     my_free(fno);
     return Fresult;