From 40490d3a6438a54e3330efd32460e161c21773b6 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Thu, 3 Jan 2019 12:27:07 +0200 Subject: heater - turn off when above temperature on initial heating --- Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'Software/Embedded_SW/Embedded/Modules/Control') diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c index 64b6ac4e0..1ab3a21e9 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c @@ -541,6 +541,13 @@ uint32_t MillisecLowLoop(uint32_t tick) FPGA_GetAllDispensersValveBusyOCD(); DrawerFansStatus = Read_Fans_Tacho(); KeepAliveOneSecondCall(); + for (Motor_i = 0;Motor_i < NUM_OF_MOTORS;Motor_i++) + { + if (Motor_i == HARDWARE_MOTOR_TYPE__MOTO_SCREW) + continue; // + if (isMotorConfigured(Motor_i)) + MotorGetStatusFromFPGA(Motor_i); + } } if (OneMinute_Tick) { -- cgit v1.3.1 From d50d729a2b7d45ca4b22df7ff0d8823825c479b6 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Wed, 9 Jan 2019 10:42:14 +0200 Subject: Version 1.3.1.1 changes Communication tx traces (reports, diagnostics, alarms, job reports) File system file download support – not tested! Communication tx with pre-allocated memory (improve and add areas) Winder Screw – send messages in regular mode Preparation for motor actions timeouts Preparations for control debug Heaters: bug fix, enlarge PID start region IDS: • Dispenser time out between motor operation and valve operation (start->open. Close->stop). • Dispenser homing backlash – to pressure above limit (currently 0.1 for machines without mixer) or timeout (10 seconds). State machine – Suspend Large Messages cancelled. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Embedded/Common/SWUpdate/FileSystem.c | 105 +++++++++++++++++ .../Embedded/Common/SWUpdate/FileSystem.h | 2 + .../Embedded/Common/SWUpdate/FirmwareUpgrade.c | 22 ++++ .../Embedded/Common/SWUpdate/FirmwareUpgrade.h | 17 +++ .../Embedded_SW/Embedded/Common/SW_Info/SW_Info.c | 2 +- .../Embedded/Common/report/reportInit.c | 3 +- .../Embedded_SW/Embedded/Communication/Container.c | 50 +++++++- .../Embedded_SW/Embedded/Communication/Container.h | 2 + .../Embedded/Drivers/FPGA/FPGA_SPI_Comm.c | 14 +-- .../Embedded_SW/Embedded/Drivers/Motors/Motor.c | 6 +- .../Embedded_SW/Embedded/Drivers/Motors/Motor.h | 4 +- .../Embedded/Drivers/USB_Communication/USBCDCD.c | 77 ------------ .../Embedded/Modules/AlarmHandling/AlarmHandling.c | 7 +- .../Embedded/Modules/Control/MillisecTask.c | 70 +---------- .../Embedded_SW/Embedded/Modules/Control/control.c | 130 ++++++--------------- .../Embedded_SW/Embedded/Modules/Control/control.h | 2 + .../Embedded/Modules/Diagnostics/Diagnostics.c | 12 +- .../Modules/Diagnostics/DiagnosticsHoming.c | 8 +- .../Embedded/Modules/Heaters/Heaters_print.c | 42 +++++-- Software/Embedded_SW/Embedded/Modules/IDS/IDS.h | 2 + .../Embedded/Modules/IDS/IDS_dispenser.c | 105 +++++++++++++++++ Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h | 4 + .../Embedded_SW/Embedded/Modules/IDS/IDS_maint.c | 43 ++++++- .../Embedded_SW/Embedded/Modules/IDS/IDS_print.c | 30 +++-- .../Embedded/Modules/Thread/Thread_Winder.c | 12 +- .../Embedded/StateMachines/Printing/JobSTM.c | 15 ++- .../Embedded/StateMachines/Printing/PrintingSTM.c | 4 +- 27 files changed, 479 insertions(+), 311 deletions(-) create mode 100644 Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c create mode 100644 Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.h create mode 100644 Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c (limited to 'Software/Embedded_SW/Embedded/Modules/Control') diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c index c1f673745..51c30782c 100644 --- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c +++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c @@ -12,6 +12,10 @@ #include #include #include +#include +#include +#include +#include #include #include #include @@ -499,3 +503,104 @@ uint32_t GetFilesRequestFunc(MessageContainer* requestContainer) } return Fresult; } +uint32_t FileDownloadRequestFunc(MessageContainer* requestContainer) +{ + uint32_t status = OK; + + FRESULT Fresult = FR_OK; + + MessageContainer responseContainer; + + FileDownloadRequest* request = file_download_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data); + + FileDownloadResponse response = FILE_DOWNLOAD_RESPONSE__INIT; + + WrittenBytes=0; + FileHandle = malloc(sizeof(FIL)); + if (FileHandle == 0) + Fresult = FR_DENIED; + else + { + Fresult = f_open(FileHandle,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. + } + + } + + + responseContainer = createContainer(MESSAGE_TYPE__FileDownloadResponse, requestContainer->token, false, &response, &file_download_response__pack, &file_download_response__get_packed_size); + if (Fresult!= FR_OK) + { + responseContainer.error = getErrorCode(Fresult); + responseContainer.errormessage = "File operation error"; + } + responseContainer.continuous = false; + uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); + size_t container_size = message_container__pack(&responseContainer, container_buffer); + my_free(responseContainer.data.data); + file_download_request__free_unpacked(request,NULL); + SendChars(container_buffer, container_size); + + return OK; +} +uint32_t FileChunkDownloadRequestFunc(MessageContainer* requestContainer) +{ + MessageContainer responseContainer; + FileChunkDownloadRequest* request = file_chunk_download_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data); + FileChunkDownloadResponse response = FILE_CHUNK_DOWNLOAD_RESPONSE__INIT; + FRESULT Fresult = FR_OK; + FIL *ReceivedFileHandle; //the system supports a single active file + + ReceivedFileHandle = FileHandle; + char *Buffer = 0; + Buffer = malloc (2000); + if (Buffer != NULL) + { + Fresult = f_read(ReceivedFileHandle,response.buffer.data,2000,&WrittenBytes ); + if(Fresult != FR_OK) + { + LOG_ERROR (Fresult,"f_write error"); + } + else + { + response.buffer.len = WrittenBytes; + FileReceivedLength += WrittenBytes; + if (FileReceivedLength == FileLength) + { + REPORT_MSG (FileReceivedLength,"file download ended successfully"); + f_close(ReceivedFileHandle); + free (FileHandle); + } + else + { + if (FileReceivedLength > FileLength) + { + REPORT_MSG (FileReceivedLength,"file download too much data!"); + f_close(ReceivedFileHandle); + free (FileHandle); + } + } + } + } + + 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.error = getErrorCode(Fresult); + responseContainer.errormessage = "File operation error"; + } + responseContainer.continuous = false; + uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); + size_t container_size = message_container__pack(&responseContainer, container_buffer); + file_chunk_download_request__free_unpacked(request,NULL); + my_free(responseContainer.data.data); + my_free(Buffer); + SendChars(container_buffer, container_size); + + return OK; +} diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.h b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.h index 4a76a0aad..de0da71a5 100644 --- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.h +++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.h @@ -16,6 +16,8 @@ uint32_t CreateRequestFunc(MessageContainer* requestContainer); uint32_t DeleteRequestFunc(MessageContainer* requestContainer); uint32_t GetStorageInfoRequestFunc(MessageContainer* requestContainer); uint32_t GetFilesRequestFunc(MessageContainer* requestContainer); +uint32_t FileDownloadRequestFunc(MessageContainer* requestContainer); +uint32_t FileChunkDownloadRequestFunc(MessageContainer* requestContainer); diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c new file mode 100644 index 000000000..4c18131f4 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c @@ -0,0 +1,22 @@ +/* + * FirmwareUpgrade.c + * + * Created on: Dec 24, 2018 + * Author: shlomo + */ + +#include "include.h" +#include "Communication/CommunicationTask.h" +#include + +#include +#include +#include +#include +#include +#include +#include + + +uint32_t ActivateVersionRequestFunc(MessageContainer* requestContainer); +uint32_t ValidateVersionRequestFunc(MessageContainer* requestContainer); diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.h b/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.h new file mode 100644 index 000000000..9af76f96f --- /dev/null +++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.h @@ -0,0 +1,17 @@ +/* + * FirmwareUpgrade.h + * + * Created on: Dec 24, 2018 + * Author: shlomo + */ + +#ifndef COMMON_SWUPDATE_FIRMWAREUPGRADE_H_ +#define COMMON_SWUPDATE_FIRMWAREUPGRADE_H_ + + +uint32_t ActivateVersionRequestFunc(MessageContainer* requestContainer); +uint32_t ValidateVersionRequestFunc(MessageContainer* requestContainer); + + + +#endif /* COMMON_SWUPDATE_FIRMWAREUPGRADE_H_ */ 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 1bbd5a8ad..dc61e6d2f 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,3,0,8}; +TangoVersion_t _gTangoVersion = {1,3,1,1}; #define BUILD_DATE __DATE__ char Dat[50] = BUILD_DATE; char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d diff --git a/Software/Embedded_SW/Embedded/Common/report/reportInit.c b/Software/Embedded_SW/Embedded/Common/report/reportInit.c index 711e82639..deb0fd5ff 100644 --- a/Software/Embedded_SW/Embedded/Common/report/reportInit.c +++ b/Software/Embedded_SW/Embedded/Common/report/reportInit.c @@ -136,7 +136,8 @@ int ReportResponseFunc(char *message, /* The formatted message if (container_buffer) { size_t container_size = message_container__pack(&responseContainer, container_buffer); - if (SendChars(container_buffer, container_size) == false) //comm tx mailbox full + // if (SendChars(container_buffer, container_size) == false) //comm tx mailbox full + if (SendCharsWithType(container_buffer, container_size,MESSAGE_TYPE__StartDebugLogResponse) == false) //comm tx mailbox full { //CommunicationMailboxFlush(); //protobufToken[0] = 0; diff --git a/Software/Embedded_SW/Embedded/Communication/Container.c b/Software/Embedded_SW/Embedded/Communication/Container.c index 8543f0493..07b030824 100644 --- a/Software/Embedded_SW/Embedded/Communication/Container.c +++ b/Software/Embedded_SW/Embedded/Communication/Container.c @@ -76,7 +76,7 @@ MessageContainer createContainer(MessageType type, char* token, protobuf_c_boole container.data.data = response_buffer; container.data.len = response_size; - // if (SuspendLargeMessages == true) + if (SuspendLargeMessages == true) { // Report("EndJobMessage",__FILE__,__LINE__,(int)type,RpWarning,(int)response_size,0); TxmsgId[Txindex] = type; @@ -89,6 +89,38 @@ MessageContainer createContainer(MessageType type, char* token, protobuf_c_boole //free(response); return container; } +MessageContainer createAllocatedContainer(MessageType type, char* token, protobuf_c_boolean completed, void* response, size_t (*packPtr)(void*, uint8_t*), size_t (*sizePtr)(void*),uint8_t* response_buffer) +{ + MessageContainer container = MESSAGE_CONTAINER__INIT; + container.completed = completed; + container.token = token; + container.has_completed = true; + container.has_data = true; + container.has_type = true; + container.type = type; + + //uint8_t* response_buffer = my_malloc((*sizePtr)(response)); + size_t response_size = 0; + if (response_buffer) + { + response_size = (*packPtr)(response, response_buffer); + } + container.data.data = response_buffer; + container.data.len = response_size; + + /*if (SuspendLargeMessages == true) + { +// Report("EndJobMessage",__FILE__,__LINE__,(int)type,RpWarning,(int)response_size,0); + TxmsgId[Txindex] = type; + TxLength[Txindex] = response_size; + TxAddr[Txindex] = msec_millisecondCounter; + if (Txindex++>=MAX_CONT_LOG) + Txindex = 0; + }*/ + + //free(response); + return container; +} void receive_callback(char* buffer, size_t length) { @@ -375,6 +407,10 @@ void receive_callback(char* buffer, size_t length) } bool SendResult,KeepSendResult = true; +uint16_t SendmsgId[MAX_CONT_LOG+1] = {0}; +uint16_t SendSize[MAX_CONT_LOG+1] = {0}; +uint32_t SendTime[MAX_CONT_LOG+1] = {0}; +uint16_t Sendindex = 0; bool SendChars(char* buffer,size_t length) { SendResult = CommunicationTaskSendMessage(buffer, length); @@ -382,4 +418,16 @@ bool SendChars(char* buffer,size_t length) KeepSendResult = false; return SendResult; } +bool SendCharsWithType(char* buffer,size_t length,MessageType type) +{ + SendmsgId[Sendindex] = type; + SendSize[Sendindex] = length; + SendTime[Sendindex] = msec_millisecondCounter; + if (Sendindex++>=MAX_CONT_LOG) + Sendindex = 0; + SendResult = CommunicationTaskSendMessage(buffer, length); + if (SendResult == false) + KeepSendResult = false; + return SendResult; +} diff --git a/Software/Embedded_SW/Embedded/Communication/Container.h b/Software/Embedded_SW/Embedded/Communication/Container.h index 212814160..169db0b8b 100644 --- a/Software/Embedded_SW/Embedded/Communication/Container.h +++ b/Software/Embedded_SW/Embedded/Communication/Container.h @@ -5,8 +5,10 @@ #include MessageContainer createContainer(MessageType type, char* token, protobuf_c_boolean completed, void* response, size_t (*packPtr)(void*, uint8_t*), size_t (*sizePtr)(void*)); +MessageContainer createAllocatedContainer(MessageType type, char* token, protobuf_c_boolean completed, void* response, size_t (*packPtr)(void*, uint8_t*), size_t (*sizePtr)(void*),uint8_t* response_buffer); void receive_callback(char* buffer, size_t length); bool SendChars(char* buffer,size_t length); +bool SendCharsWithType(char* buffer,size_t length,MessageType type); #endif //CONTAINER_H diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_SPI_Comm.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_SPI_Comm.c index ecc154e29..f2ab34f16 100644 --- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_SPI_Comm.c +++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_SPI_Comm.c @@ -678,11 +678,7 @@ void FPGA_SetMotMaxSpeed(TimerMotors_t _motorId)//Mov if (speed_calc > 0x3FF) //TODO to check if it is needed here speed_calc = 0x3FF; temp |= speed_calc<<8; - -// if (_motorId == HARDWARE_MOTOR_TYPE__MOTO_SCREW) -// MillisecSetScrewSpeed(temp, 4, NULL); -// else - MillisecWriteToMotor(_motorId, temp, 4, NULL); + MillisecWriteToMotor(_motorId, temp, 4, NULL); } @@ -751,11 +747,9 @@ void FPGA_SetMotPosition(TimerMotors_t _motorId)//Mov Fpga_Spi[_motorId].TX_MOSI = temp; //Fpga_Spi[_motorId].AMT_OF_Words = 4; -// if (_motorId == HARDWARE_MOTOR_TYPE__MOTO_SCREW) -// MillisecMoveScrew(temp, 4, NULL); -// else - MillisecWriteToMotor(_motorId, temp, 4, NULL); -// FPGA_SPI_Transnit(_motorId); + MillisecWriteToMotor(_motorId, temp, 4, NULL); + + // FPGA_SPI_Transnit(_motorId); } void FPGA_SetGoMotHome(TimerMotors_t _motorId) diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c index 8a54526a5..1ea1133fb 100644 --- a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c +++ b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c @@ -381,7 +381,7 @@ uint32_t MotorMove(TimerMotors_t _motorId,bool direction, uint32_t Steps) return OK; } -uint32_t MotorMoveWithCallback (TimerMotors_t _motorId,bool direction, uint32_t Steps, callback_fptr callback) //TODO +uint32_t MotorMoveWithCallback (TimerMotors_t _motorId,bool direction, uint32_t Steps, callback_fptr callback,uint32_t timeout) //TODO { assert (callback); //assert (isValid(deviceId)); @@ -485,7 +485,7 @@ uint32_t MotorMoveToLimitSwitchCallBackFunction(uint32_t IfIndex, bool LimitSwit } return OK; } -uint32_t MotorMovetoLimitSwitch (TimerMotors_t _motorId,bool direction, uint32_t Freq, uint32_t LimitSwitchId, callback_fptr callback) //TODO +uint32_t MotorMovetoLimitSwitch (TimerMotors_t _motorId,bool direction, uint32_t Freq, uint32_t LimitSwitchId, callback_fptr callback,uint32_t timeout) //TODO { //assert (callback); assert (LimitSwitchId<=MAX_GPI); @@ -500,7 +500,7 @@ uint32_t MotorMovetoLimitSwitch (TimerMotors_t _motorId,bool direction, uint32_t MotorSetDirection( _motorId, direction); MotorSetSpeed(_motorId, Freq); - MotorMovetoLimitSwitchControlId[_motorId] = AddControlCallback( MotorMoveToLimitSwitchCallBackFunction, eOneMillisecond , FPGA_Read_limit_Switches,(IfTypeMotors*0x100+_motorId), LimitSwitchId, 0 ); + MotorMovetoLimitSwitchControlId[_motorId] = AddControlCallback( MotorMoveToLimitSwitchCallBackFunction, eTenMillisecond , FPGA_Read_limit_Switches,(IfTypeMotors*0x100+_motorId), LimitSwitchId, 0 ); if ( MotorMovetoLimitSwitchControlId[_motorId] == 0xFF) return ERROR; MotorMovetoLimitSwitchCallback[_motorId] = callback; diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h index 392cd9058..e204e91dc 100644 --- a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h +++ b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.h @@ -170,7 +170,7 @@ uint32_t MotorStop(TimerMotors_t _motorId, STOP_TYPE_ENUM StopType); uint32_t MotorMove(TimerMotors_t _motorId,bool direction, uint32_t Steps); -uint32_t MotorMoveWithCallback (TimerMotors_t _motorId,bool direction, uint32_t Steps, callback_fptr callback); +uint32_t MotorMoveWithCallback (TimerMotors_t _motorId,bool direction, uint32_t Steps, callback_fptr callback,uint32_t timeout); bool MotorControlGetnBusyState(uint32_t _motorId, uint32_t parameter); @@ -181,7 +181,7 @@ uint32_t SetMotHome(TimerMotors_t _motorId); uint32_t MotorGetStatus(TimerMotors_t _motorId); uint32_t MotorGetStatusFromFPGA_Callback(TimerMotors_t _motorId,uint32_t Data); -uint32_t MotorMovetoLimitSwitch (TimerMotors_t _motorId,bool direction, uint32_t Freq, uint32_t LimitSwitchId, callback_fptr callback); +uint32_t MotorMovetoLimitSwitch (TimerMotors_t _motorId,bool direction, uint32_t Freq, uint32_t LimitSwitchId, callback_fptr callback,uint32_t timeout); uint32_t MotorAbortMovetoLimitSwitch (TimerMotors_t _motorId); diff --git a/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c b/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c index 08a8b05c2..b18c0f2e5 100644 --- a/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c +++ b/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c @@ -422,66 +422,6 @@ void USBCDCD_hwiHandler(UArg arg0) } //***************************************************************************** // -// This function is called whenever serial data is received from the UART. -// It is passed the accumulated error flags from each character received in -// this interrupt and determines from them whether or not an interrupt -// notification to the host is required. -// -// If a notification is required and the control interrupt endpoint is idle, -// we send the notification immediately. If the endpoint is not idle, we -// accumulate the errors in a global variable which will be checked on -// completion of the previous notification and used to send a second one -// if necessary. -// -//***************************************************************************** -void CheckForSerialStateChange(const tUSBDCDCDevice *psDevice, uint32_t ui32Errors) -{ - uint16_t ui16SerialState; - - // - // Clear our USB serial state. Since we are faking the handshakes, always - // set the TXCARRIER (DSR) and RXCARRIER (DCD) bits. - // - ui16SerialState = USB_CDC_SERIAL_STATE_TXCARRIER | - USB_CDC_SERIAL_STATE_RXCARRIER; - - // - // Are any error bits set? - // - if(ui32Errors) - { - // - // At least one error is being notified so translate from our hardware - // error bits into the correct state markers for the USB notification. - // - if(ui32Errors & UART_DR_OE) - { - ui16SerialState |= USB_CDC_SERIAL_STATE_OVERRUN; - } - - if(ui32Errors & UART_DR_PE) - { - ui16SerialState |= USB_CDC_SERIAL_STATE_PARITY; - } - - if(ui32Errors & UART_DR_FE) - { - ui16SerialState |= USB_CDC_SERIAL_STATE_FRAMING; - } - - if(ui32Errors & UART_DR_BE) - { - ui16SerialState |= USB_CDC_SERIAL_STATE_BREAK; - } - - // - // Call the CDC driver to notify the state change. - // - USBDCDCSerialStateChange((void *)psDevice, ui16SerialState); - } -} -//***************************************************************************** -// // This is the callback from the USB DFU runtime interface driver. // // \param pvCBData is ignored by this function. @@ -850,23 +790,6 @@ uint32_t RxHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue,voi return(0); } - -//Execute this function on UART0 Interrupt; -void InitUSB(void) -{ - CheckForSerialStateChange(&g_sCDCDevice, 0); -} -//***************************************************************************** -// -// Interrupt handler for the UART which we are redirecting via USB. -// -//***************************************************************************** -void USB0Handler(void) -{ - InitUSB(); - -} - void * USBDComposite = NULL; /******************************************************************* * ======== USBCDCD_init ======== diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index 1ead15683..a46318666 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -53,6 +53,8 @@ bool AlarmHandlingActive = false; uint32_t AlarmHandlingControlId = 0xFF; uint32_t AlarmHandlingTick = 0; +uint8_t alarm_response_buffer[500]; + /******************** Functions ********************************************/ void SendEventNotifications(void); @@ -758,7 +760,7 @@ void SendEventNotifications(void) } } } - responseContainer = createContainer(MESSAGE_TYPE__StartEventsNotificationResponse, AlarmHandlingToken, false, &response, &start_events_notification_response__pack, &start_events_notification_response__get_packed_size); + responseContainer = createAllocatedContainer(MESSAGE_TYPE__StartEventsNotificationResponse, AlarmHandlingToken, false, &response, &start_events_notification_response__pack, &start_events_notification_response__get_packed_size,&alarm_response_buffer); responseContainer.continuous = true; uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); @@ -766,7 +768,8 @@ void SendEventNotifications(void) { size_t container_size = message_container__pack(&responseContainer, container_buffer); - if (SendChars(container_buffer, container_size) == false) //comm tx mailbox full +// if (SendChars(container_buffer, container_size) == false) //comm tx mailbox full + if (SendCharsWithType(container_buffer, container_size,MESSAGE_TYPE__StartEventsNotificationResponse) == false) //comm tx mailbox full { //AlarmHandlingToken[0] = 0; my_free(container_buffer); diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c index 1ab3a21e9..aaa4b1228 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c @@ -212,53 +212,6 @@ int32_t MillisecReadFromTempSensor(uint32_t TempSensorId, MSecFptr Callback) //typedef uint32_t (* MSecFptr)(uint32_t deviceID, uint32_t ReadValue); uint32_t MotorActivity = 0; -int32_t MillisecMoveScrew(unsigned long Data, int Length, MSecFptr Callback) -{ - //========================== - /*MSBacklog[MsecLogindex]=Data; - Motor_Id[MsecLogindex]=HARDWARE_MOTOR_TYPE__MOTO_SCREW; - MSTick[MsecLogindex]=msec_millisecondCounter; - MsecLogindex++; - if (MsecLogindex>=LOG_SIZE) - MsecLogindex = 0;*/ - - //========================== - - ScrewMovePending.Callback = Callback; - ScrewMovePending.Data = Data; - ScrewMovePending.Length = Length; - ScrewMovePending.DataRequired = false; - if (ScrewMovePending.Active == false) - { - MotorActivity++; - ScrewMovePending.Active = true; - } - - return OK; -} - -int32_t MillisecSetScrewSpeed(unsigned long Data, int Length, MSecFptr Callback) -{ - //========================== -/* MSBacklog[MsecLogindex]=Data; - Motor_Id[MsecLogindex]=HARDWARE_MOTOR_TYPE__MOTO_SCREW; - MsecLogindex++; - if (MsecLogindex>=LOG_SIZE) - MsecLogindex = 0; - */ //========================== - - ScrewSetMaxSpeedPending.Callback = Callback; - ScrewSetMaxSpeedPending.Data = Data; - ScrewSetMaxSpeedPending.Length = Length; - ScrewSetMaxSpeedPending.DataRequired = false; - if (ScrewSetMaxSpeedPending.Active == false) - { - MotorActivity++; - ScrewSetMaxSpeedPending.Active = true; - } - - return OK; -} int32_t MillisecSetMotorSpeed(TimerMotors_t MotorId, unsigned long Data, int Length, MSecFptr Callback) { if (MotorId >= NUM_OF_MOTORS) return -1; @@ -402,27 +355,6 @@ uint32_t MillisecLoop(uint32_t tick) } MotorActivity--; } - if (Motor_i == HARDWARE_MOTOR_TYPE__MOTO_SCREW) - { - if (ScrewSetMaxSpeedPending.Active == true) - { - MotorSendFPGARequest(HARDWARE_MOTOR_TYPE__MOTO_SCREW,ScrewSetMaxSpeedPending.Data,ScrewSetMaxSpeedPending.Length); - MotorActivity--; - ScrewSetMaxSpeedPending.Active = false; - if (ScrewSetMaxSpeedPending.Callback) - ScrewSetMaxSpeedPending.Callback(Motor_i,0); - continue; - } - else if (ScrewMovePending.Active == true) - { - MotorSendFPGARequest(HARDWARE_MOTOR_TYPE__MOTO_SCREW,ScrewMovePending.Data,ScrewMovePending.Length); - MotorActivity--; - ScrewMovePending.Active = false; - if (ScrewMovePending.Callback) - ScrewMovePending.Callback(Motor_i,0); - continue; - } - } if (SpeedSetPending[Motor_i].Active == true) { MotorSendFPGARequest((HardwareMotorType)Motor_i,SpeedSetPending[Motor_i].Data,SpeedSetPending[Motor_i].Length); @@ -492,7 +424,7 @@ uint32_t MillisecLoop(uint32_t tick) } uint32_t MillisecLowLoop(uint32_t tick) { - uint8_t Disp_i; + uint8_t Motor_i,Disp_i; TEMPERATURE_SENSOR_ID_ENUM Sensor_i; static int temp=0; diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c index 001cafeb3..a35b804e4 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/control.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c @@ -304,12 +304,22 @@ void OneMilliSecondControlInterrupt(UArg arg0) return ; } +uint32_t ControlDevice_i; +uint32_t ControlLowDevice_i; +uint32_t GetControlDevice_i(void) +{ + return ControlDevice_i; +} +uint32_t GetControlLowDevice_i(void) +{ + return ControlLowDevice_i; +} uint32_t ControlLoop(uint32_t tick) { //call all modules control functions //test dancers and speed encoders //check all callback units (state machine waiting for completion of a change) - uint32_t Device_i; + //uint32_t ControlDevice_i; /*bool Ten_msTick, Hundred_msTick, Onesecond_Tick,Tick98,Tick998; Ten_msTick = (tick%eTenMillisecond == 0) ?true:false; Hundred_msTick = (tick%eHundredMillisecond == 0) ?true:false; @@ -320,24 +330,24 @@ uint32_t ControlLoop(uint32_t tick) Tick998 = (tick%eOneSecond == 996) ?true:false; */ //ROM_IntMasterDisable(); - for (Device_i = 0; Device_i < MAX_TANGO_CONTROL_DEVICES;Device_i++) + for (ControlDevice_i = 0; ControlDevice_i < MAX_TANGO_CONTROL_DEVICES;ControlDevice_i++) { - if (ControlArray[Device_i].ControlActive) + if (ControlArray[ControlDevice_i].ControlActive) { - ControlBacklog[backlogindex]=Device_i; + ControlBacklog[backlogindex]=ControlDevice_i; if ( ++backlogindex >= 999) backlogindex = 0; - switch (ControlArray[Device_i].ControlTiming) + switch (ControlArray[ControlDevice_i].ControlTiming) { case eOneMillisecond: - if(ControlArray[Device_i].ControlDataReadPtr) - ControlDatalog[Device_i] = ControlArray[Device_i].ControlDataReadPtr( ControlArray[Device_i].Parameter1); + if(ControlArray[ControlDevice_i].ControlDataReadPtr) + ControlDatalog[ControlDevice_i] = ControlArray[ControlDevice_i].ControlDataReadPtr( ControlArray[ControlDevice_i].Parameter1); else - LOG_ERROR (Device_i, "Invalid callback ptr"); - if(ControlArray[Device_i].ControlCallbackPtr) - ControlArray[Device_i].ControlCallbackPtr(ControlArray[Device_i].IfIndex, ControlDatalog[Device_i]); + LOG_ERROR (ControlDevice_i, "Invalid callback ptr"); + if(ControlArray[ControlDevice_i].ControlCallbackPtr) + ControlArray[ControlDevice_i].ControlCallbackPtr(ControlArray[ControlDevice_i].IfIndex, ControlDatalog[ControlDevice_i]); else - LOG_ERROR (Device_i, "Invalid callback ptr"); + LOG_ERROR (ControlDevice_i, "Invalid callback ptr"); break; default: break; @@ -353,7 +363,7 @@ uint32_t ControlLowLoop(uint32_t tick) //call all modules control functions //test dancers and speed encoders //check all callback units (state machine waiting for completion of a change) - uint32_t Device_i; + //uint32_t Device_i; bool Ten_msTick, Hundred_msTick, Onesecond_Tick,Tick98,Tick998; Ten_msTick = (tick%eTenMillisecond == 0) ?true:false; Hundred_msTick = (tick%eHundredMillisecond == 0) ?true:false; @@ -362,101 +372,27 @@ uint32_t ControlLowLoop(uint32_t tick) Tick998 = (tick%eOneSecond == 996) ?true:false; //ROM_IntMasterDisable(); - for (Device_i = 0; Device_i < MAX_TANGO_CONTROL_DEVICES;Device_i++) + for (ControlLowDevice_i = 0; ControlLowDevice_i < MAX_TANGO_CONTROL_DEVICES;ControlLowDevice_i++) { - if (ControlArray[Device_i].ControlActive) + if (ControlArray[ControlLowDevice_i].ControlActive) { - if (tick == ControlArray[Device_i].StartTick) + if (tick == ControlArray[ControlLowDevice_i].StartTick) continue; - if (((tick - ControlArray[Device_i].StartTick)%ControlArray[Device_i].ControlTiming)==0) // run the control on exact intervals + if (((tick - ControlArray[ControlLowDevice_i].StartTick)%ControlArray[ControlLowDevice_i].ControlTiming)==0) // run the control on exact intervals { - ControlBacklog[backlogindex]=Device_i; + ControlBacklog[backlogindex]=ControlLowDevice_i; if ( ++backlogindex >= 999) backlogindex = 0; - if(ControlArray[Device_i].ControlDataReadPtr) - ControlDatalog[Device_i] = ControlArray[Device_i].ControlDataReadPtr( ControlArray[Device_i].Parameter1); + if(ControlArray[ControlLowDevice_i].ControlDataReadPtr) + ControlDatalog[ControlLowDevice_i] = ControlArray[ControlLowDevice_i].ControlDataReadPtr( ControlArray[ControlLowDevice_i].Parameter1); else - LOG_ERROR (Device_i, "Invalid callback ptr"); - if(ControlArray[Device_i].ControlCallbackPtr) - ControlArray[Device_i].ControlCallbackPtr(ControlArray[Device_i].IfIndex, ControlDatalog[Device_i]); + LOG_ERROR (ControlLowDevice_i, "Invalid callback ptr"); + if(ControlArray[ControlLowDevice_i].ControlCallbackPtr) + ControlArray[ControlLowDevice_i].ControlCallbackPtr(ControlArray[ControlLowDevice_i].IfIndex, ControlDatalog[ControlLowDevice_i]); else - LOG_ERROR (Device_i, "Invalid callback ptr"); + LOG_ERROR (ControlLowDevice_i, "Invalid callback ptr"); } - /* - ControlBacklog[backlogindex]=Device_i; - if ( ++backlogindex >= 999) - backlogindex = 0; - switch (ControlArray[Device_i].ControlTiming) - { - case eOneMillisecond: - break; - case eTenMillisecond: - if (Ten_msTick) - { - if(ControlArray[Device_i].ControlDataReadPtr) - ControlDatalog[Device_i] = ControlArray[Device_i].ControlDataReadPtr( ControlArray[Device_i].Parameter1); - else - LOG_ERROR (Device_i, "Invalid callback ptr"); - if(ControlArray[Device_i].ControlCallbackPtr) - ControlArray[Device_i].ControlCallbackPtr(ControlArray[Device_i].IfIndex, ControlDatalog[Device_i]); - else - LOG_ERROR (Device_i, "Invalid callback ptr"); - } - break; - case eHundredMillisecond: - if (Tick98) - { - //there is a need to trigger the data collection from FPGA, from I2C or from ADC 1.5 milliseconds to collect the data - if(ControlArray[Device_i].ControlDataReadPtr) - ControlDatalog[Device_i] = ControlArray[Device_i].ControlDataReadPtr( ControlArray[Device_i].Parameter1); - else - LOG_ERROR (Device_i, "Invalid callback ptr"); - } - if (Hundred_msTick) - { - //there is a need to trigger the data collection from FPGA, from I2C or from ADC 1.5 milliseconds to collect the data - if(ControlArray[Device_i].ControlCallbackPtr) - ControlArray[Device_i].ControlCallbackPtr(ControlArray[Device_i].IfIndex, ControlDatalog[Device_i]); - else - LOG_ERROR (Device_i, "Invalid callback ptr"); - } - break; - case eOneSecond: - if (Tick998) - { - if(ControlArray[Device_i].ControlDataReadPtr) - ControlDatalog[Device_i] = ControlArray[Device_i].ControlDataReadPtr( ControlArray[Device_i].Parameter1); - else - LOG_ERROR (Device_i, "Invalid callback ptr"); - } - if (Onesecond_Tick) - { - if(ControlArray[Device_i].ControlCallbackPtr) - ControlArray[Device_i].ControlCallbackPtr(ControlArray[Device_i].IfIndex, ControlDatalog[Device_i]); - else - LOG_ERROR (Device_i, "Invalid callback ptr"); - } - break; - case eNoControl: - memset (&ControlArray[Device_i],0,sizeof(ControlDeviceStruc) ); - break; - default: - //LOG_ERROR(tick, "Default Timing checked"); - if (tick%ControlArray[Device_i].ControlTiming == 0) - { - Report("Default Timing checked",__FILE__,__LINE__,tick,RpWarning,ControlArray[Device_i].ControlTiming,0); - if(ControlArray[Device_i].ControlDataReadPtr) - ControlDatalog[Device_i] = ControlArray[Device_i].ControlDataReadPtr( ControlArray[Device_i].Parameter1); - else - LOG_ERROR (Device_i, "Invalid callback ptr"); - if(ControlArray[Device_i].ControlCallbackPtr) - ControlArray[Device_i].ControlCallbackPtr(ControlArray[Device_i].IfIndex, ControlDatalog[Device_i]); - else - LOG_ERROR (Device_i, "Invalid callback ptr"); - } - break; - } //switch*/ } //if control active } //for //ROM_IntMasterEnable(); diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.h b/Software/Embedded_SW/Embedded/Modules/Control/control.h index b3e574d2a..d50868064 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/control.h +++ b/Software/Embedded_SW/Embedded/Modules/Control/control.h @@ -40,6 +40,8 @@ void ControlStart(void); uint32_t AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 ); int RemoveControlCallback(uint32_t deviceId, ControlCBFunction Callback ); uint32_t TemplateDataReadCBFunction (uint32_t deviceId, uint32_t Parameter1); +uint32_t GetControlDevice_i(void); +uint32_t GetControlLowDevice_i(void); extern Task_Handle Control_Task_Handle; extern uint32_t millisecondCounter; diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c index 2a0d88c7f..9bc1da9a8 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c @@ -394,7 +394,8 @@ void DiagnosticsReset(void) } int j=0; MessageContainer diagnosticsresponseContainer; -uint8_t* diagnosticscontainer_buffer; +uint8_t diagnostics_response_buffer[3500]; +uint8_t* diagnosticscontainer_buffer=0; int LargeMessagesD = 0; void SendDiagnostics(void) @@ -586,7 +587,9 @@ void SendDiagnostics(void) response.n_heatersstates = HEATER_TYPE__MixerHeater+1; response.heatersstates = heatersstates; - diagnosticsresponseContainer = createContainer(MESSAGE_TYPE__StartDiagnosticsResponse, DiagnosticsToken, false, &response, &start_diagnostics_response__pack, &start_diagnostics_response__get_packed_size); + +// diagnosticsresponseContainer = createContainer(MESSAGE_TYPE__StartDiagnosticsResponse, DiagnosticsToken, false, &response, &start_diagnostics_response__pack, &start_diagnostics_response__get_packed_size); + diagnosticsresponseContainer = createAllocatedContainer(MESSAGE_TYPE__StartDiagnosticsResponse, DiagnosticsToken, false, &response, &start_diagnostics_response__pack, &start_diagnostics_response__get_packed_size,&diagnostics_response_buffer); diagnosticsresponseContainer.continuous = true; if (diagnosticsresponseContainer.data.data) @@ -597,7 +600,8 @@ void SendDiagnostics(void) if (diagnosticscontainer_buffer) { size_t container_size = message_container__pack(&diagnosticsresponseContainer, diagnosticscontainer_buffer); - if (SendChars(diagnosticscontainer_buffer, container_size) == false) //comm tx mailbox full + // if (SendChars(diagnosticscontainer_buffer, container_size)== false) //comm tx mailbox full + if (SendCharsWithType(diagnosticscontainer_buffer, container_size,MESSAGE_TYPE__StartDiagnosticsResponse) == false) //comm tx mailbox full { DiagnosticsStop(); my_free(diagnosticscontainer_buffer); @@ -622,7 +626,7 @@ void SendDiagnostics(void) { LOG_ERROR(Task_self(),"previous packet not sent"); } - my_free(diagnosticsresponseContainer.data.data); + //my_free(diagnosticsresponseContainer.data.data); } else { diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c index 58d05f383..1d5ba163a 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c @@ -98,9 +98,9 @@ typedef enum { MotorHomingDirectionEnum Motor_Id_to_LS_Direction[NUM_OF_MOTORS] = { MotorHomingDirectionNoHoming, //MOTO_DH_CLEANHEAD = 0, MotorHomingDirectionNoHoming, //MOTO_DH_CLEANMECH = 1, - MotorHomingDirectionNoHoming, //MOTO_DH_LID = 2, + MotorHomingDirectionDown, //MOTO_DH_LID = 2, MotorHomingDirectionNoHoming, //MOTO_DRYER_DRIVING = 3, - MotorHomingDirectionNoHoming, //MOTO_DRYER_LID = 4, + MotorHomingDirectionDown, //MOTO_DRYER_LID = 4, MotorHomingDirectionNoHoming, //MOTO_DRYER_LOADARM = 5, MotorHomingDirectionDown, //MOTO_DISPENSER_1 = 6, MotorHomingDirectionDown, //MOTO_DISPENSER_2 = 7, @@ -163,7 +163,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer) { if ( Motor_Id_to_LS_IdUp[MotorId] != MAX_GPI) { - MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed, Motor_Id_to_LS_IdDown[MotorId], MotorHomingRequestCallback); + MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed, Motor_Id_to_LS_IdDown[MotorId], MotorHomingRequestCallback,10000); ustrncpy (HomingToken[MotorId], requestContainer->token,36); return OK; } @@ -172,7 +172,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer) { if ( Motor_Id_to_LS_IdDown[MotorId] != MAX_GPI) { - MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed, Motor_Id_to_LS_IdUp[MotorId], MotorHomingRequestCallback); + MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed, Motor_Id_to_LS_IdUp[MotorId], MotorHomingRequestCallback,10000); ustrncpy (HomingToken[MotorId], requestContainer->token,36); 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 472d53b81..dbd2342c9 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -56,6 +56,7 @@ typedef struct PID_Config_Params m_params; }HeaterControlConfig_t; HeaterControlConfig_t HeaterPIDConfig[MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0,0,0}; +//PID_Config_Params temp_params; /******************** GLOBAL PARAMETERS ********************************************/ HeaterCommand HeaterCmd[MAX_HEATERS_NUM]; @@ -367,6 +368,19 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue) HeaterPIDConfig[HeaterId].m_preError = 0; HeaterPIDConfig[HeaterId].m_SetParam = SetTemperatue*100;//need to update SetParams on presegment stage + /*if (HeaterId == HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3) + { + temp_params.MAX = HeaterControl[HeaterId].outputproportionalpowerlimit*100; + temp_params.MIN = 0.0; + temp_params.Kd = HeaterControl[HeaterId].kd; + temp_params.Kp = HeaterControl[HeaterId].kp/HeaterControl[HeaterId].outputonoffhysteresisvalue; + temp_params.Ki = HeaterControl[HeaterId].ki/HeaterControl[HeaterId].setpointramprateorsoftstartramp; + temp_params.IntegralErrorMultiplier = 0; + temp_params.ProportionalErrorMultiplier = 0; + temp_params.dt = HeaterControl[HeaterId].dt; + temp_params.epsilon = HeaterControl[HeaterId].epsilon; //0.1 degree + + }*/ if (HeaterPIDConfig[HeaterId].m_params.IntegralErrorMultiplier) { Frequency = eOneSecond*HeaterPIDConfig[HeaterId].m_params.dt; @@ -374,8 +388,8 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue) if (HeaterId >= MAX_AC_HEATERS) //DC Heaters { if (ControlIdtoHeaterId [HeaterId] == 0xFF) - ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, Frequency/*eOneSecond/*eHundredMillisecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0); - HeaterPIDConfig[HeaterId].m_params.dt *=10; + ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, Frequency/*eOneSecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0); + //HeaterPIDConfig[HeaterId].m_params.dt *=10; //DCInitialHeating[HeaterId] = true; HeaterReady[HeaterId] = false; HeaterPreviousRead[HeaterId] = TemperatureSensorRead(HeaterId2PT100Id[HeaterId]); @@ -384,7 +398,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue) { if (ControlIdtoHeaterId [HeaterId] == 0xFF) { - ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond/*eHundredMillisecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0); + ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0); HeaterPIDConfig[HeaterId].m_params.dt *=10; HeaterPreviousRead[HeaterId] = TemperatureSensorRead(DryerInternalPT100Id); HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]); @@ -682,7 +696,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) return OK; } - if ((readValue > (HeaterCmd[index].targettemperatue * 998/1000))&&(readValue < (HeaterCmd[index].targettemperatue * 1002/1000)))//read value within 0.5 percent from target + if ((readValue > (HeaterCmd[index].targettemperatue * 997/1000))&&(readValue < (HeaterCmd[index].targettemperatue * 1004/1000)))//read value within 0.5 percent from target { //DCInitialHeating[index] = false; HeatersControlStart(); @@ -717,14 +731,20 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) } else { - //temp_preError = HeaterPIDConfig[index].m_preError; temp_integral = HeaterPIDConfig[index].m_integral; - //temp_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, - // &HeaterPIDConfig[index].m_params, &temp_preError, &temp_integral); - HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, + /*if (index == HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3) + { + //temp_preError = HeaterPIDConfig[index].m_preError; temp_integral = HeaterPIDConfig[index].m_integral; + temp_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, + &temp_params, &temp_preError, &temp_integral); + }*/ + HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); - //len = usnprintf(heatstr, 100, "ACD Id, Temp , Integral, Output,AdvIntegral, AdvOutput{ %d, %d ,%d, %d,%d, %d} ",index,(int)HeaterPIDConfig[index].m_mesuredParam , - // (int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError,(int)temp_integral,(int)temp_calculatedError); - //Report(heatstr,__FILE__,__LINE__,index,RpWarning,index, readValue); + /*if (index == HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3) + { + len = usnprintf(heatstr, 100, "ACD Id, Temp , Integral, Output,AdvIntegral, AdvOutput{ %d, %d ,%d, %d,%d, %d} ",index,(int)HeaterPIDConfig[index].m_mesuredParam , + (int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError,(int)temp_integral,(int)temp_calculatedError); + Report(heatstr,__FILE__,__LINE__,index,RpWarning,index, readValue); + }*/ } // error[index][Counter[index]] = HeaterPIDConfig[index].m_preError; // integral[index][Counter[index]] = HeaterPIDConfig[index].m_integral; diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h index c3499454d..7f7934439 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h @@ -13,6 +13,8 @@ extern HardwareDispenser DispensersCfg[ MAX_SYSTEM_DISPENSERS]; extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS]; +uint32_t IDS_Dispenser_EmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue); + #endif //MODULES_IDS_IDS_H_ diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c new file mode 100644 index 000000000..e6ec4d971 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c @@ -0,0 +1,105 @@ +/************************************************************************************************************************ + **************************************************************************************************************************/ + +#include +#include "include.h" + +#include "ids.h" +#include "ids_ex.h" + +#include "control/control.h" + +#include "drivers/Motors/Motor.h" +#include "drivers/valves/valve.h" + +//extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS]; +#define CloseValve MidTank_Dispenser +#define OpenValve Dispenser_Mixer + +uint32_t CloseValveTimeout = 250; +uint32_t OpenValveTimeout = 250; + +callback_fptr DispenserCallback[MAX_SYSTEM_DISPENSERS] = {0, 0, 0, 0, 0, 0, 0, 0,}; +uint32_t DispenserControlId[MAX_SYSTEM_DISPENSERS] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; + +void IDS_Dispenser_SetTimeOutValues(uint32_t CloseTimeout, uint32_t OpenTimeout) +{ + CloseValveTimeout = CloseTimeout; + OpenValveTimeout = OpenTimeout; +} +uint32_t IDS_Dispenser_EmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue) +{ + return OK; +} + + uint32_t IDS_Dispenser_StopMotorCallback(uint32_t DispenserId, uint32_t ReadValue) + { + if (RemoveControlCallback(DispenserControlId[DispenserId], IDS_Dispenser_StopMotorCallback )==OK) + { + Report("Remove control callback",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); + DispenserControlId[DispenserId] = 0xFF; + } + else + Report("Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); + + TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[DispenserId]; + MotorStop(HW_Motor_Id,Hard_Hiz); + + if (DispenserCallback[DispenserId]) + { + DispenserCallback[DispenserId](DispenserId,ReadValue); + DispenserCallback[DispenserId] = 0; + } + return OK; +} + + uint32_t IDS_Dispenser_Close_Valve_And_Stop_Motor(int DispenserId, callback_fptr callback) +{ + DispenserCallback[DispenserId] = callback; + + Control3WayValvesWithCallback ((Valves_t)DispenserId, CloseValve, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer + + DispenserControlId[DispenserId] = AddControlCallback( IDS_Dispenser_StopMotorCallback, CloseValveTimeout, IDS_Dispenser_EmptyCBFunction,DispenserId, DispenserId, 0 ); + if (DispenserControlId[DispenserId] == 0xFF) + Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); + else + Report("Add control callback",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); + + return OK; +} + +uint32_t IDS_Dispenser_OpenValveCallback(uint32_t DispenserId, uint32_t ReadValue) +{ + + if (RemoveControlCallback(DispenserControlId[DispenserId], IDS_Dispenser_OpenValveCallback )==OK) + { + Report("Remove control callback",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); + DispenserControlId[DispenserId] = 0xFF; + } + else + Report("Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); + + Control3WayValvesWithCallback (DispenserId, OpenValve, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer + + if (DispenserCallback[DispenserId]) + { + DispenserCallback[DispenserId](DispenserId,ReadValue); + DispenserCallback[DispenserId] = 0; + } + return OK; +} +uint32_t IDS_Dispenser_Start_Motor_and_Open_Valve(int DispenserId, int MotorSpeed, callback_fptr callback) +{ + DispenserCallback[DispenserId] = callback; + + TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[DispenserId]; + MotorSetSpeed(HW_Motor_Id, MotorSpeed); + + DispenserControlId[DispenserId] = AddControlCallback( IDS_Dispenser_OpenValveCallback, OpenValveTimeout, IDS_Dispenser_EmptyCBFunction,DispenserId, DispenserId, 0 ); + if (DispenserControlId[DispenserId] == 0xFF) + Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); + else + Report("Add control callback",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); + + return OK; +} diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h index 1e15cc1c2..c976e0c50 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h @@ -47,6 +47,10 @@ uint32_t IDS_StopDispenser (uint8_t deviceID); uint32_t IDS_CheckDispenserLimitSwitch (LimitSwitchAlarms LS_Id); +void IDS_Dispenser_SetTimeOutValues(uint32_t CloseTimeout, uint32_t OpenTimeout); +uint32_t IDS_Dispenser_Close_Valve_And_Stop_Motor(int DispenserId, callback_fptr callback); +uint32_t IDS_Dispenser_Start_Motor_and_Open_Valve(int DispenserId, int MotorSpeed, callback_fptr callback); + float CalculateDispenserPressure (int DispenserId); float GetDispenserPressure(int DispenserId); diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c index bf03b42de..e1c5c3c1a 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c @@ -58,20 +58,55 @@ FPGA_GPI_ENUM Dispenser_Id_to_Alarm_LS_Id[MAX_SYSTEM_DISPENSERS*2] = { }; callback_fptr HomingRequestCallback[MAX_SYSTEM_DISPENSERS]={0,0,0,0,0,0,0,0}; bool HomingActive[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false}; +uint32_t DispenserHomingControlId[MAX_SYSTEM_DISPENSERS] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; +uint32_t DispenserHomingTime[MAX_SYSTEM_DISPENSERS] = {0,0,0,0,0,0,0,0}; +#define INITIAL_DISPENSER_PRESSURE 0.10 +#define INITIAL_DISPENSER_TIMEOUT_LIMIT 10000 +#define INITIAL_DISPENSER_TIMEOUT 100 +uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t deviceID, uint32_t ReadValue) +{ + uint8_t DispenserId = deviceID-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1; + if ((GetDispenserPressure(DispenserId)>=0.0)||(DispenserHomingTime[DispenserId]>INITIAL_DISPENSER_TIMEOUT_LIMIT)) + { + MotorStop(deviceID,Hard_Hiz); + MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep); + HomingActive[DispenserId]= false; + Report("End backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0); + if (RemoveControlCallback(DispenserHomingControlId[DispenserId], IDS_HomeDispenserBackMoveCallback )==OK) + { + //Report("Remove control callback",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)Valve3WayControlId[DispenserId],0); + DispenserHomingControlId[DispenserId] = 0xFF; + } + else + Report("Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserHomingControlId[DispenserId],0); + DispenserHomingTime[DispenserId]=0; + } + else + { + DispenserHomingTime[DispenserId]+=INITIAL_DISPENSER_TIMEOUT; + } +} uint32_t IDS_HomeDispenserCallback(uint32_t deviceID, uint32_t ReadValue) { uint8_t DispenserId = deviceID-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1; //close dry air valve in the dispenser Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF); - MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep); + //MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep); if (HomingRequestCallback[DispenserId]) { HomingRequestCallback[DispenserId](DispenserId,0); HomingRequestCallback[DispenserId] = NULL; } - HomingActive[DispenserId]= false; +// HomingActive[DispenserId]= false; + Report("Start backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0); + DispenserHomingControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserBackMoveCallback, INITIAL_DISPENSER_TIMEOUT, GetDispenserPressure,deviceID, deviceID, 0 ); + + MotorSetDirection(deviceID,MotorsCfg[deviceID].directionthreadwize); + + MotorSetSpeed(deviceID, 1000); + return OK; @@ -99,7 +134,7 @@ uint32_t IDS_HomeDispenser (uint32_t deviceID, uint32_t speed , callback_fptr ca Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_ON); - MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed, Dispenser_Id_to_LS_Id[deviceID], IDS_HomeDispenserCallback); + MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed, Dispenser_Id_to_LS_Id[deviceID], IDS_HomeDispenserCallback,0); return OK; } return ERROR; @@ -171,7 +206,7 @@ uint32_t IDS_EmptyDispenser (uint32_t deviceID, uint32_t speed , callback_fptr c //Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_ON); - MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed, Dispenser_Id_to_LS_Empty_Id[deviceID], IDS_HomeDispenserCallback); + MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed, Dispenser_Id_to_LS_Empty_Id[deviceID], IDS_HomeDispenserCallback,0); return OK; } return ERROR; diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c index 346ee0246..79fa9ced3 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c @@ -187,8 +187,8 @@ bool IDS_isDispenserUsedNextSegment(void *JobDetails,int DispenserId, int Segmen //******************************************************************************************************************** uint32_t IDS_Valve_PresegmentValveReady(uint32_t deviceID, uint32_t ReadValue) { - TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[deviceID]; - MotorStop(HW_Motor_Id,Hard_Hiz); + //TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[deviceID]; + //MotorStop(HW_Motor_Id,Hard_Hiz); //REPORT_MSG(deviceID,"Dispenser PreSegment called"); IDS_Valve_PresegmentReady( deviceID, ReadValue); return OK; @@ -268,14 +268,16 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) if (JobTicket->segments[SegmentId]->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond==0) { //MotorStop(HW_Motor_Id,Hard_Hiz); - Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, IDS_Valve_PresegmentValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer + //Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, IDS_Valve_PresegmentValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer + IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,IDS_Valve_PresegmentValveReady); REPORT_MSG(DispenserId,"Dispenser Not Used Next Segment"); } else { if ((JobTicket->intersegmentlength)&&(SegmentId>0)) //there is an intersegment, stop all the dispensers. otherwise stop only dispensers that are not in use in the next segment. { - Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, IDS_Valve_PresegmentValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer + //Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, IDS_Valve_PresegmentValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer + IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,IDS_Valve_PresegmentValveReady); REPORT_MSG(DispenserId,"Dispenser Used Next Segment with intersegment"); } else @@ -359,8 +361,9 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) if ((int)segmentfirst_speed > 0) { DispenserSegmentReady[DispenserId] = false; - MotorSetSpeed(HW_Motor_Id, segmentfirst_speed); - Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer + //MotorSetSpeed(HW_Motor_Id, segmentfirst_speed); + //Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer + IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,segmentfirst_speed,NULL); usnprintf(Message, 80, "Dispenser %d nl/sec %d nl/pulse %d speed %d",Dispenser_i,(int)JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanolitterpersecond, (int)JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse,(int)segmentfirst_speed); //REPORT_MSG(segmentfirst_speed,Message); @@ -377,8 +380,8 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) //******************************************************************************************************************** uint32_t IDS_Valve_DistanceToSpoolValveReady(uint32_t deviceID, uint32_t ReadValue) { - TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[deviceID]; - MotorStop(HW_Motor_Id,Hard_Hiz); + //TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[deviceID]; + //MotorStop(HW_Motor_Id,Hard_Hiz); //REPORT_MSG(deviceID,"Dispenser DTS called"); IDS_Valve_DistanceToSpoolReady( deviceID, ReadValue); return OK; @@ -414,7 +417,8 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) continue; DispenserDistanceToSpoolReady[Dispenser_i] = false; //MotorStop(HW_Motor_Id,Hard_Hiz); - Control3WayValvesWithCallback ((Valves_t)Dispenser_i, MidTank_Dispenser, IDS_Valve_DistanceToSpoolValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer + //Control3WayValvesWithCallback ((Valves_t)Dispenser_i, MidTank_Dispenser, IDS_Valve_DistanceToSpoolValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer + IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,IDS_Valve_DistanceToSpoolValveReady); } return OK; @@ -422,9 +426,9 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) //******************************************************************************************************************** uint32_t IDS_Valve_EndValveReady(uint32_t deviceID, uint32_t ReadValue) { - TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[deviceID]; + //TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[deviceID]; //REPORT_MSG(deviceID,"Dispenser End called"); - MotorStop(HW_Motor_Id,Hard_Hiz); + //MotorStop(HW_Motor_Id,Hard_Hiz); return OK; } //******************************************************************************************************************** @@ -437,7 +441,9 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) for ( Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++) { //MotorStop(DispenserIdToMotorId[Dispenser_i],Hard_Hiz); - Control3WayValvesWithCallback (Dispenser_i, MidTank_Dispenser, IDS_Valve_EndValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer + //Control3WayValvesWithCallback (Dispenser_i, MidTank_Dispenser, IDS_Valve_EndValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer + IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,IDS_Valve_EndValveReady); + } return OK; diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c index 3b9311b77..73eb6ea30 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c @@ -106,7 +106,7 @@ uint32_t Winder_Prepare(void) //REPORT_MSG(ScrewSpeed, "Winder_Prepare"); Winder_ScrewHoming = true; //REPORT_MSG(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, "Winder_Prepare move to limit"); - status = MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, ScrewSpeed, GPI_LS_SCREW_RIGHT, Winder_PrepareStage2); + status = MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, ScrewSpeed, GPI_LS_SCREW_RIGHT, Winder_PrepareStage2,2000); } return status; } @@ -125,7 +125,7 @@ uint32_t Winder_PrepareStage2(uint32_t deviceID, uint32_t ReadValue) //REPORT_MSG(numOfSteps, "Winder_PrepareStage2"); REPORT_MSG(millisecondCounter/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].maxfrequency*/, "Winder_PrepareStage2"); - status |= MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_SCREW, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize),numOfSteps, Winder_ScrewAtOffsetCallback); + status |= MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_SCREW, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize),numOfSteps, Winder_ScrewAtOffsetCallback,1000); //set motor location 0 here return status; @@ -225,7 +225,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) }*/ Averagewinderspeed = TotalWinderSpeed/MAX_WINDER_SPEED_CALCULATION; //REPORT_MSG(winderspeed, "WinderSpeedUpdated"); - Report("WinderSpeedUpdated",__FILE__,__LINE__,TotalWinderSpeed,RpWarning,Averagewinderspeed,0); + //Report("WinderSpeedUpdated",__FILE__,__LINE__,TotalWinderSpeed,RpWarning,Averagewinderspeed,0); WinderReferenceSpeed = Averagewinderspeed; } @@ -243,11 +243,11 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) ScrewRunningTime = temp;//(SYS_CLK_FREQ*Steps)/ScrewSpeed; //ROM_IntMasterEnable(); //usnprintf(TempScrewStr, 100, "Winder: Horizon,Rotation, PPR, RPP{ %d, %d ,%d, %d} ",(int)screw_horizontal_speed,(int)RotationsPerSecond,(int)InternalWinderCfg.NumberOfRotationPerPassage,(int)MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].pulseperround); - usnprintf(ScrewStr, 100, "Winder: Steps,Speed, Time, WinderSpeed{ %d, %d ,%d, %d} ",(int)ScrewNumberOfSteps,(int)ScrewSpeed,(int)temp,(int)WinderReferenceSpeed); + //usnprintf(ScrewStr, 100, "Winder: Steps,Speed, Time, WinderSpeed{ %d, %d ,%d, %d} ",(int)ScrewNumberOfSteps,(int)ScrewSpeed,(int)temp,(int)WinderReferenceSpeed); // Report(logmsg[index],__FILE__,__LINE__,index,RpWarning,index, Counter[index]); // #warning PID is now only proportional (above) //Report(TempScrewStr,__FILE__,__LINE__,0,RpWarning,0, 0); - Report(ScrewStr,__FILE__,__LINE__,ScrewCurrentDirection,RpWarning,CalculationDirectionChangeCounter, 0); + //Report(ScrewStr,__FILE__,__LINE__,ScrewCurrentDirection,RpWarning,CalculationDirectionChangeCounter, 0); //REPORT_MSG(temp , "new winder speed"); //Report("new winder speed",__FILE__,__LINE__,temp,RpWarning,ScrewSpeed,0); } @@ -341,7 +341,7 @@ uint32_t Winder_End(void) CurrentControlledSpeed[SCREW_MOTOR] = 0; ScrewsStopControlTimer(); //move the cart to the edge so the spool can be easily replaced - MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, 1000, GPI_LS_SCREW_RIGHT, NULL); + MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, 1000, GPI_LS_SCREW_RIGHT, NULL,0); return OK; } diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c index e044808ca..b442f7557 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c +++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c @@ -686,6 +686,8 @@ void JobRequestFunc(MessageContainer* requestContainer) //******************************************************************************************************************** char logmsg[254]; char infomsg[254]; +uint8_t JobStatusBuffer[400]; + void SendJobProgress(double ProcessedLength, int SegmentId, bool done, char *Message) { MessageContainer responseContainer; @@ -727,12 +729,14 @@ void SendJobProgress(double ProcessedLength, int SegmentId, bool done, char *Mes if (JobResumed == true) { resumeresponse.status = &jobStatus; - responseContainer = createContainer(MESSAGE_TYPE__ResumeCurrentJobResponse, JobToken, done, &resumeresponse, &resume_current_job_response__pack, &resume_current_job_response__get_packed_size); + //responseContainer = createContainer(MESSAGE_TYPE__ResumeCurrentJobResponse, JobToken, done, &resumeresponse, &resume_current_job_response__pack, &resume_current_job_response__get_packed_size); + responseContainer = createAllocatedContainer(MESSAGE_TYPE__ResumeCurrentJobResponse, JobToken, done, &resumeresponse, &resume_current_job_response__pack, &resume_current_job_response__get_packed_size,&JobStatusBuffer); } else { response.status = &jobStatus; - responseContainer = createContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &response, &job_response__pack, &job_response__get_packed_size); + //responseContainer = createContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &response, &job_response__pack, &job_response__get_packed_size); + responseContainer = createAllocatedContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &response, &job_response__pack, &job_response__get_packed_size,&JobStatusBuffer); } container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); @@ -753,14 +757,15 @@ void SendJobProgress(double ProcessedLength, int SegmentId, bool done, char *Mes if (container_buffer) { size_t container_size = message_container__pack(&responseContainer, container_buffer); - if (SendChars(container_buffer, container_size) == false) //comm tx mailbox full + // if (SendChars(container_buffer, container_size) == false) //comm tx mailbox full + if (SendCharsWithType(container_buffer, container_size,MESSAGE_TYPE__JobResponse) == false) //comm tx mailbox full { //AlarmHandlingToken[0] = 0; my_free(container_buffer); } } - if (responseContainer.data.data) - my_free(responseContainer.data.data); +// if (responseContainer.data.data) +// my_free(responseContainer.data.data); } void JobStopReporting(void) { diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c index 85421fae5..9e44a8dfd 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c +++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c @@ -332,7 +332,7 @@ uint32_t DistanceToSpoolReady(int ModuleId, ModuleStateEnum result) } else { - SuspendLargeMessages = true; + //SuspendLargeMessages = true; //DiagnosticsStop(); PrtMessage->messageId = FinishResultsFail; SendJobProgress(0.0, 0, false, "DistanceToSpool Fail"); @@ -374,7 +374,7 @@ static uint32_t DistanceToSpoolState(void *JobDetails) uint32_t EndState(void *JobDetails, char *Message) { //ROM_IntMasterDisable(); - SuspendLargeMessages = true; + //SuspendLargeMessages = true; LOG_ERROR(2,"SuspendLargeMessages EndState"); //DiagnosticsStop(); if (Configured[Module_Winder]) -- cgit v1.3.1