diff options
Diffstat (limited to 'Software/Embedded_SW/Embedded')
16 files changed, 268 insertions, 88 deletions
diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c index 3b5ba176d..6715e8e42 100644 --- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c +++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c @@ -89,7 +89,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)); @@ -132,9 +135,10 @@ uint32_t FileUploadRequestFunc(MessageContainer* requestContainer) } } - 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"; } @@ -170,9 +174,17 @@ uint32_t FileChunkUploadRequestFunc(MessageContainer* requestContainer) //{ //Control_WD(ENABLE,55); //activate heaters/dispenser watchdog, 0.5 seconds //GeneralHwReady = false; - KeepAliveOneSecondCounter = 0; - save_milisec = msec_millisecondCounter; - Fresult = f_write(ReceivedFileHandle,request->buffer.data,request->buffer.len,&WrittenBytes ); + if (ReceivedFileHandle==NULL) + { + Fresult = FR_DENIED; + Report("file chunk uplad rejected - file not created", __FILE__, __LINE__, 4, RpWarning, (int)0, 0); + FileDone = true; + } + else + { + KeepAliveOneSecondCounter = 0; + save_milisec = msec_millisecondCounter; + Fresult = f_write(ReceivedFileHandle,request->buffer.data,request->buffer.len,&WrittenBytes ); lFresult = Fresult; if(Fresult != FR_OK) { @@ -207,18 +219,12 @@ 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"; } @@ -296,6 +302,11 @@ uint32_t FileDownloadRequestFunc(MessageContainer* requestContainer) Semaphore_post(FFS_Sem); } } + else + { + Fresult = FR_DENIED; + Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning, (int)0, 0); + } } } @@ -303,6 +314,7 @@ 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"; } @@ -367,6 +379,7 @@ 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"; } @@ -394,6 +407,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.has_error = true; responseContainer.error = ERROR_CODE__GENERAL_ERROR;//getErrorCode(Fresult); responseContainer.errormessage = "File operation error"; } @@ -420,6 +434,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.has_error = true; responseContainer.error = ERROR_CODE__GENERAL_ERROR;//getErrorCode(Fresult); responseContainer.errormessage = "File operation error"; } @@ -453,16 +468,23 @@ 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 (Semaphore_pend(FFS_Sem, BIOS_NO_WAIT)) { - if (f_close (UploadFileHandle)!= FR_OK) + Fresult = f_open(UploadFileHandle,request->path,FA_CREATE_NEW); + 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) @@ -476,6 +498,7 @@ 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"; } @@ -502,15 +525,23 @@ 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); + if (Semaphore_pend(FFS_Sem, BIOS_NO_WAIT)) + { + Fresult = f_unlink(request->path); + Semaphore_post(FFS_Sem); + } + else + { + Fresult = FR_DENIED; + Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning, (int)0, 0); + } 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) { usnprintf(ErrorMsg, 100, "File Operation failed error code %d",Fresult); + responseContainer.has_error = true; responseContainer.error = getErrorCode(Fresult); responseContainer.errormessage = ErrorMsg; } @@ -557,6 +588,7 @@ 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"; } @@ -587,6 +619,8 @@ uint32_t GetFilesRequestFunc(MessageContainer* requestContainer) char FullPath[MAX_NUM_OF_FILES][60]; int i,NumOfFiles = 0; FRESULT Fresult = FR_OK; + FileInfo **FilesInfo = (FileInfo**)my_malloc(sizeof(FileInfo *)*(MAX_NUM_OF_FILES)); + FileInfo Data[MAX_NUM_OF_FILES]; /* time_t t; struct tm *ltm; @@ -597,40 +631,45 @@ uint32_t GetFilesRequestFunc(MessageContainer* requestContainer) Report(curTime, __FILE__, ltm->tm_hour,ltm->tm_min , RpWarning, ltm->tm_sec, 0); */ - Semaphore_pend(FFS_Sem, BIOS_WAIT_FOREVER); - Fresult |= f_opendir(&dir, g_cCwdBuf); - if(Fresult != FR_OK) + if (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)) { @@ -678,6 +717,7 @@ uint32_t GetFilesRequestFunc(MessageContainer* requestContainer) if (Fresult!= OK) { + responseContainer.has_error = true; responseContainer.error = getErrorCode(Fresult); responseContainer.errormessage = "File operation error"; } @@ -688,8 +728,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++) { @@ -711,29 +753,32 @@ 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|FA_CREATE_ALWAYS); - if (Fresult == FR_OK) + if (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"); + } + //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,"fwrite error"); + LOG_ERROR (Fresult,"fopen error"); } - //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); + 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); } } @@ -763,29 +808,36 @@ 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 (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; - Report("f_read ok no of bytes", __FILE__, __LINE__, Bytes, RpWarning, (int)fno->fsize, 0); + 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); } @@ -819,8 +871,16 @@ 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 (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 { diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c index 4bbe44aea..c3c273f56 100644 --- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c +++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c @@ -196,6 +196,7 @@ uint32_t ActivateVersionRequestFunc(MessageContainer* requestContainer) responseContainer.continuous = true; if (Fresult!= OK) { + responseContainer.has_error = true; responseContainer.error = FileError_to_ErrorCode[Fresult]; responseContainer.errormessage = "Activate Version Request error"; responseContainer.continuous = false; @@ -223,6 +224,7 @@ uint32_t ValidateVersionRequestFunc(MessageContainer* requestContainer) responseContainer = createContainer(MESSAGE_TYPE__ValidateVersionResponse, requestContainer->token, false, &response, &validate_version_response__pack, &validate_version_response__get_packed_size); if (status!= OK) { + responseContainer.has_error = true; responseContainer.error = ERROR_CODE__INVALID_UPLOAD_ID; responseContainer.errormessage = "Validate Version Request error"; } diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c index 28ab799a1..6c2e35f76 100644 --- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c +++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c @@ -20,7 +20,7 @@ typedef struct } TangoVersion_t; -TangoVersion_t _gTangoVersion = {1,4,6,15}; +TangoVersion_t _gTangoVersion = {1,4,6,16}; #define BUILD_DATE __DATE__ char Dat[50] = BUILD_DATE; char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d diff --git a/Software/Embedded_SW/Embedded/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h index 0ada1e7ec..06cec2e1e 100644 --- a/Software/Embedded_SW/Embedded/DataDef.h +++ b/Software/Embedded_SW/Embedded/DataDef.h @@ -438,6 +438,8 @@ typedef union uint8_t Buf[16]; }DISP_EEPROM; */ + +/* //////////////////////////////////////////// typedef struct { @@ -482,6 +484,44 @@ typedef struct uint32_t Spare[5]; }DISP_EEPROM_BYTES; + +*/ + +typedef struct +{ + uint32_t Header; + uint32_t Table_Length; + uint32_t Table_version; + uint8_t Dispenser_Part_Number[20];//String + uint8_t PCB_SN[20];//String + uint8_t PCB_Part_Number[20];//String + uint8_t Dispenser_SN[20];//String + int32_t Minimal_Pressure; + int32_t Maximal_Pressure; + int32_t Minimal_MV; + int32_t Maximal_MV; + uint32_t Total_Cycles; + uint32_t Bubble_Size; + uint32_t AVG_Nl_Step_Value_1_4; + uint32_t AVG_Nl_Step_Value_2_4; + uint32_t AVG_Nl_Step_Value_3_4; + uint32_t AVG_Nl_Step_Value_4_4; + uint32_t SW_Reserve; + int32_t Spare1_pressure; + int32_t Spare2_pressure; + uint32_t Motor_PPC; + uint32_t color; + uint32_t Pressure_Slope; + uint8_t Production_Test_Date[8];//string + uint32_t ATS_Location; + uint32_t Spare1; + uint32_t Spare2; + uint8_t Unit_Empty; + uint8_t Dry_Run_Status; + uint8_t Flow_Status; + uint8_t CheckSum; +}DISP_EEPROM_BYTES; + typedef union { DISP_EEPROM_BYTES bytes; diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.c index 3abe727dc..1c9935a52 100644 --- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.c +++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.c @@ -97,7 +97,7 @@ uint32_t test_disp_eeprom(uint8_t Dispenser_ID , uint8_t EEprom_Add)//0..7 { uint32_t status= OK; uint32_t i; - +/* Dispenser_struct[Dispenser_ID].Write_Disp_EEPROM.bytes.Dispebser_Data.SN = 0x12345678; Dispenser_struct[Dispenser_ID].Write_Disp_EEPROM.bytes.Nl_Pulse_Value = 0xAB; Dispenser_struct[Dispenser_ID].Write_Disp_EEPROM.bytes.Flow_Pass_Fail = 0xCD; @@ -108,17 +108,18 @@ uint32_t test_disp_eeprom(uint8_t Dispenser_ID , uint8_t EEprom_Add)//0..7 status |= I2C_EEprom_Write_Ch(Dispenser_ID, EEprom_Add); SysCtlDelay(5000000);//Must delay for at least 5 milli. !!! (See data sheet ) + */ status |= I2C_EEprom_Set_for_Read_Ch(Dispenser_ID, EEprom_Add); status |= I2C_EEprom_Read_Ch(Dispenser_ID, EEprom_Add); - if(status == 0) +/* if(status == 0) { for(i=0;i<Max_buf_size;i++) { if(Dispenser_struct[Dispenser_ID].Read_Disp_EEPROM.Buf[i]!=Dispenser_struct[Dispenser_ID].Write_Disp_EEPROM.Buf[i]) status |= ERROR; } - } + }*/ return status; } diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h index 76eee82af..2db341914 100644 --- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h +++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h @@ -14,7 +14,7 @@ uint32_t I2C_EEprom_Write_Ch(uint8_t Dispenser_ID); uint32_t I2C_EEprom_Set_for_Read_Ch(uint8_t Dispenser_ID);; uint32_t I2C_EEprom_Read_Ch(uint8_t Dispenser_ID); -uint32_t test_disp_eeprom(uint8_t Dispenser_ID); +uint32_t test_disp_eeprom(uint8_t Dispenser_ID , uint8_t EEprom_Add); uint8_t Check_Dispenser_Type(); diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_FIFO.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_FIFO.h new file mode 100644 index 000000000..2e2ccc37a --- /dev/null +++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_FIFO.h @@ -0,0 +1,17 @@ +/* + * I2C_FIFO.h + * + * Created on: Mar 3, 2020 + * Author: avi + */ + +#ifndef DRIVERS_I2C_COMMUNICATION_I2C_FIFO_H_ +#define DRIVERS_I2C_COMMUNICATION_I2C_FIFO_H_ + +void i2c_setup(uint32_t base, bool highspeed); +uint32_t I2C_ReadFifo(uint32_t base, uint8_t addr, void *data, size_t len); +uint32_t I2C_WriteFifo(uint32_t base, uint8_t addr, void *data, size_t len); + + + +#endif /* DRIVERS_I2C_COMMUNICATION_I2C_FIFO_H_ */ diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c index 0b2b56c5b..685542722 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c @@ -39,11 +39,21 @@ char HomingToken[NUM_OF_MOTORS][36+1]={0}; /******************************************************************************** * Motor Homing ********************************************************************************/ +int32_t keepkvalright,keepkvalleft; + uint32_t MotorHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue) { MessageContainer responseContainer; MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT; + if(deviceID == HARDWARE_MOTOR_TYPE__MOTO_RLOADING) + { + MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, keepkvalright); + } + if(deviceID == HARDWARE_MOTOR_TYPE__MOTO_LLOADING) + { + MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, keepkvalleft); + } responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse, HomingToken[deviceID], true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size); responseContainer.has_continuous = true; responseContainer.continuous = true; @@ -107,6 +117,16 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer) } if ( Motor_Id_to_LS_IdDown[MotorId] != MAX_GPI) { + if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_RLOADING) + { + keepkvalright = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun; + MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 70); + } + if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_LLOADING) + { + keepkvalleft = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].kvalrun; + MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 70); + } MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed, Motor_Id_to_LS_IdUp[MotorId], MotorHomingRequestCallback,30000); return OK; } @@ -153,6 +173,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer) } } } + responseContainer.has_error = true; responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID; responseContainer.errormessage = "Job Active or incorrect motor ID"; responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse, requestContainer->token, true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size); diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c index e2eb264a7..a1a0c96c1 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c @@ -90,6 +90,7 @@ uint32_t MotorJoggingRequestFunc(MessageContainer* requestContainer) responseContainer = createContainer(MESSAGE_TYPE__MotorJoggingResponse, requestContainer->token, false, &response, &motor_jogging_response__pack, &motor_jogging_response__get_packed_size); if (status!= OK) { + responseContainer.has_error = true; responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID; responseContainer.errormessage = "JOb Active or incorrect parameters"; } @@ -191,6 +192,7 @@ uint32_t DispenserJoggingRequestFunc(MessageContainer* requestContainer) responseContainer = createContainer(MESSAGE_TYPE__DispenserJoggingResponse, requestContainer->token, false, &response, &dispenser_jogging_response__pack, &dispenser_jogging_response__get_packed_size); if (status!= OK) { + responseContainer.has_error = true; responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID; responseContainer.errormessage = "JOb Active or incorrect parameters"; } diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c index 6297299de..618d4569c 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c +++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c @@ -649,6 +649,7 @@ uint32_t HWConfigurationFunc(MessageContainer* requestContainer) responseContainer = createContainer(MESSAGE_TYPE__UploadHardwareConfigurationResponse, requestContainer->token, true, &response, &upload_hardware_configuration_response__pack, &upload_hardware_configuration_response__get_packed_size); if (status!= OK) { + responseContainer.has_error = true; responseContainer.error = ERROR_CODE__INVALID_PARAMETER; responseContainer.errormessage = "JOb Active or incorrect parameters"; } diff --git a/Software/Embedded_SW/Embedded/Modules/General/Safety.c b/Software/Embedded_SW/Embedded/Modules/General/Safety.c index 139763c75..9680e11d0 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/Safety.c +++ b/Software/Embedded_SW/Embedded/Modules/General/Safety.c @@ -47,6 +47,11 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag) bool mAirFlowAlarmState = false; bool mAirFilterAlarmState = false; bool mWasteOverflowAlarmState = false; +#ifdef CONTROL_DEBUG + uint32_t tempp,tempq,delta; + uint32_t sys_ticks_start = msec_millisecondCounter,sys_ticks_end,max = 0,dev = 0; + tempp = HibernateRTCSSGet(); +#endif for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++) { if (isMotorConfigured(Disp_i + HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1)==true) @@ -194,6 +199,19 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag) AlarmHandlingSetAlarm(EVENT_TYPE__WASTE_CONTAINER_OVERFLOW, false); WasteOverflowAlarmState = mWasteOverflowAlarmState; } +#ifdef CONTROL_DEBUG + tempq = HibernateRTCSSGet(); + if (tempq < tempp) + { + delta = (32768 - tempp) + tempq + 1; + } + else + delta = tempq - tempp; + if (delta>1000) + { + ReportWithPackageFilter(GeneralFilter,"------ Safety Delta ------------", __FILE__,delta,tempq, RpMessage,tempp, 0); + } +#endif return OK; } diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c index 9b628a160..ca4255a95 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -908,6 +908,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue) } else { + ReportWithPackageFilter(HeatersFilter,"restoring read Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,HeaterSpikeRead[index], index); HeaterPreviousRead[index] = HeaterSpikeRead[index]; HeaterSpikeRead[index] = 0; } @@ -1088,7 +1089,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) ReportWithPackageFilter(HeatersFilter,"AC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index); if (readValue > HeaterCmd[index].targettemperatue) { - if (HeaterSpikeRead[index] == 0) + /*if (HeaterSpikeRead[index] == 0) { HeaterSpikeRead[index] = readValue; } @@ -1096,7 +1097,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) { HeaterPreviousRead[index] = HeaterSpikeRead[index]; HeaterSpikeRead[index] = 0; - } + }*/ DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater); DeActivateHeater(HEATER_TYPE__DryerMainHeater); HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0); @@ -1302,6 +1303,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) } else { + ReportWithPackageFilter(HeatersFilter,"restoring read Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,HeaterSpikeRead[index], index); HeaterPreviousRead[index] = HeaterSpikeRead[index]; HeaterSpikeRead[index] = 0; } diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c index 57b596931..76a92bd89 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c @@ -44,6 +44,10 @@ #include <Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.h> +#include "Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h" + + + extern float NumberOfRotationPerPassage; // how many rotations per spool passage //#include "graphics_adapter.h" @@ -563,6 +567,13 @@ void Stub_ProgressRequest(MessageContainer* requestContainer) response.has_progress = true; } else + if((request->amount == 0x0D) && (request->delay == 0xEE)) //Dispenser EEprom + { + test_disp_eeprom(0x01,0xA0); + response.progress = OK; + response.has_progress = true; + } + else if((request->amount == 0xCF) && (request->delay == 0xCF)) //Create File System on the Drive { #ifdef WATCHDOG diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c index 91f655171..26d7ea854 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c @@ -458,8 +458,8 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue) //extern int MotorSamplePointer[MAX_THREAD_MOTORS_NUM]; //read value is the dancer angle - int i,index=MAX_THREAD_MOTORS_NUM,len; - //int len; + int i,index=MAX_THREAD_MOTORS_NUM; + int len; int DancerId; int32_t TranslatedReadValue, avreageSampleValue = 0;//,avreageMotorSampleValue = 0; //double tempcalcspeed = 0; diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c index 92d3e05a7..e3461515c 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c +++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c @@ -536,6 +536,7 @@ void ThreadJoggingRequestFunc(MessageContainer* requestContainer) responseContainer = createContainer(MESSAGE_TYPE__ThreadJoggingResponse, requestContainer->token, true, &response, &thread_jogging_response__pack, &thread_jogging_response__get_packed_size); if (status!= OK) { + responseContainer.has_error = true; responseContainer.error = ERROR_CODE__INVALID_PARAMETER; responseContainer.errormessage = "JOb Active or incorrect parameters"; } @@ -663,6 +664,7 @@ void Stub_JobRequest(MessageContainer* requestContainer) responseContainer = createContainer(MESSAGE_TYPE__StubJobResponse, JobToken, false, &response, &stub_job_response__pack, &stub_job_response__get_packed_size); if (status!= OK) { + responseContainer.has_error = true; responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID; responseContainer.errormessage = "JOb Active or incorrect parameters"; } @@ -1058,6 +1060,7 @@ uint32_t CurrentJobRequestFunc(MessageContainer* requestContainer) responseContainer = createContainer(MESSAGE_TYPE__CurrentJobResponse, requestContainer->token, false, &response, ¤t_job_response__pack, ¤t_job_response__get_packed_size); if (status!= OK) { + responseContainer.has_error = true; responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID; responseContainer.errormessage = "JOb Active or incorrect parameters"; } @@ -1115,6 +1118,7 @@ uint32_t ResumeCurrentJobRequestFunc(MessageContainer* requestContainer) responseContainer = createContainer(MESSAGE_TYPE__ResumeCurrentJobResponse, JobToken, false, &response, &resume_current_job_response__pack, &resume_current_job_response__get_packed_size); if (status!= OK) { + responseContainer.has_error = true; responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID; responseContainer.errormessage = "JOb Active or incorrect parameters"; } diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c index 962bc37ee..a8490556b 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c +++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c @@ -141,7 +141,8 @@ extern Semaphore_Handle FFS_Sem; FRESULT CloseJobFile() { Fresult = f_close(JobRequestFileHandle); - Semaphore_post(FFS_Sem); + //Semaphore_post(FFS_Sem); +#warning trying not to hold the semaphore and enable the PPC/MS to work on several files simultaneously readbBytes = 0; ImmediateRead = 0; |