Index: firmware/App/Services/NVMessagingDD.c =================================================================== diff -u -r2f1c3a32a7e6f196fb0ca6f28fdb91b5ff237c07 -r3b7c92408ac36d501987a526bca1dab2bc9782eb --- firmware/App/Services/NVMessagingDD.c (.../NVMessagingDD.c) (revision 2f1c3a32a7e6f196fb0ca6f28fdb91b5ff237c07) +++ firmware/App/Services/NVMessagingDD.c (.../NVMessagingDD.c) (revision 3b7c92408ac36d501987a526bca1dab2bc9782eb) @@ -75,7 +75,9 @@ static U32 calRecordReceiveStartTime; ///< Time stamp the calibration record was received. static U32 institRecordReceiveStartTime; ///< Time stamp the institutional record was received. static U32 recordReceiveStartTime; ///< Time stamp the calibration/service was received. -static DD_INSTIT_REC_TYPE sendInstitRec; ///< Current Institutional Record to be sent +static DD_INSTIT_REC_TYPE sendInstitRec; ///< Current Institutional Record to be sent +static DD_CAL_REC_TYPE sendCalRec; ///< Current Calibration Record to be sent +static U32 sendSensorIdx; ///< Index of sensor calibration data to be sent static BOOL isPublishRecordRequested[ NUM_OF_NVM_RECORD_TYPES ]; ///< Record state machine publish request flag. // ********** private function prototypes ********** @@ -128,6 +130,7 @@ previousRecordMessageNum = 0; recordReceiveStartTime = 0; sendInstitRec = DD_INSTIT_MIN_DIALYSATE_FLOW_MLPM; + sendCalRec = DD_CAL_RECORD_PRESSURE_SENSOR; } /*********************************************************************//** @@ -429,123 +432,255 @@ static SEND_RECORD_STATE_T handleSendDDCalibrationRecord( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; - BOOL calStatus = FALSE; - int i; + BOOL sendStatus = FALSE; + U08 maxSensorIdx = 0; + DD_NVM_SEND_RECORD_PAYLOAD_T payload; + MSG_ID_T msgID; - DD_PRES_SENSORS_CAL_RECORD_T* pressure; - calStatus = getNVMRecord( GET_CAL_PRESSURE_SENOSRS, - (U08*)&pressure, - sizeof( DD_PRES_SENSORS_CAL_RECORD_T ), - NUM_OF_PRESSURE_SENSORS, - ALARM_ID_DD_NVM_INVALID_CAL_PRESSURE_SENSOR ); - for ( i = 0; i < NUM_OF_PRESSURE_SENSORS; i++ ) + switch( sendCalRec ) { - calStatus = sendDDRecord( MSG_ID_DD_NVM_CAL_PRESSURE_SENSOR_RESPONSE, i, - sizeof(DD_PRES_SENSORS_CAL_RECORD_T), - (U08*)&pressure->pressureSensors[ i ] ); - } + case DD_CAL_RECORD_PRESSURE_SENSOR: + { + msgID = MSG_ID_DD_NVM_CAL_PRESSURE_SENSOR_RESPONSE; + maxSensorIdx = NUM_OF_PRESSURE_SENSORS; + DD_PRES_SENSORS_CAL_RECORD_T pressure; - DD_TEMP_SENSORS_CAL_RECORD_T* temperature; - calStatus = getNVMRecord( GET_CAL_TEMP_SENSORS, - (U08*)&temperature, - sizeof( DD_TEMP_SENSORS_CAL_RECORD_T ), - NUM_OF_TEMPERATURE_SENSORS, - ALARM_ID_DD_NVM_INVALID_CAL_TEMP_SENSOR ); - for ( i = 0; i < NUM_OF_TEMPERATURE_SENSORS; i++ ) - { - calStatus = sendDDRecord( MSG_ID_DD_NVM_CAL_TEMP_SENSOR_RESPONSE, i, - sizeof(DD_PRES_SENSORS_CAL_RECORD_T), - (U08*)&temperature->tempSensors[ i ] ); - } + if ( TRUE == getNVMRecord( GET_CAL_PRESSURE_SENOSRS, + (U08*)&pressure, + sizeof( DD_PRES_SENSORS_CAL_RECORD_T ), + NUM_OF_PRESSURE_SENSORS, + ALARM_ID_DD_NVM_INVALID_CAL_PRESSURE_SENSOR ) ) + { + memcpy( &payload.data, + &pressure.pressureSensors[ sendSensorIdx ], + sizeof( DD_PRES_SENSORS_CAL_RECORD_T ) ); + } + } + break; - DD_CONC_PUMPS_CAL_RECORD_T* concPump; - calStatus = getNVMRecord( GET_CAL_CONCENTRATE_PUMPS_RECORD, - (U08*)&concPump, - sizeof( DD_CONC_PUMPS_CAL_RECORD_T ), - NUM_OF_CONCENTRATE_PUMPS, - ALARM_ID_DD_NVM_INVALID_CAL_CONC_PUMP ); - for ( i = 0; i < NUM_OF_CONCENTRATE_PUMPS; i++ ) - { - calStatus = sendDDRecord( MSG_ID_DD_NVM_CAL_CONC_PUMP_RESPONSE, i, - sizeof(DD_CONC_PUMPS_CAL_RECORD_T), - (U08*)&concPump->concentratePumps[ i ] ); - } + case DD_CAL_RECORD_TEMPERATURE_SENSOR: + { + msgID = MSG_ID_DD_NVM_CAL_TEMP_SENSOR_RESPONSE; + maxSensorIdx = NUM_OF_TEMPERATURE_SENSORS; + DD_TEMP_SENSORS_CAL_RECORD_T temperature; - DD_D12_DIALYSATE_PUMP_RECORD_T* d12Pump; - calStatus = getNVMRecord( GET_CAL_D12_PUMP_RECORD, - (U08*)&d12Pump, - sizeof( DD_D12_DIALYSATE_PUMP_RECORD_T ), - 0, - ALARM_ID_DD_NVM_INVALID_CAL_D12_PUMP ); - calStatus = sendDDRecord( MSG_ID_DD_NVM_CAL_D12_PUMP_RESPONSE, 0, - sizeof(DD_D12_DIALYSATE_PUMP_RECORD_T), - (U08*)&d12Pump ); + if ( TRUE == getNVMRecord( GET_CAL_TEMP_SENSORS, + (U08*)&temperature, + sizeof( DD_TEMP_SENSORS_CAL_RECORD_T ), + NUM_OF_TEMPERATURE_SENSORS, + ALARM_ID_DD_NVM_INVALID_CAL_TEMP_SENSOR ) ) + { - DD_D48_DIALYSATE_PUMP_RECORD_T* d48Pump; - calStatus = getNVMRecord( GET_CAL_D48_PUMP_RECORD, - (U08*)&d48Pump, - sizeof( DD_D48_DIALYSATE_PUMP_RECORD_T ), - 0, - ALARM_ID_DD_NVM_INVALID_CAL_D48_PUMP ); - calStatus = sendDDRecord( MSG_ID_DD_NVM_CAL_D48_PUMP_RESPONSE, 0, - sizeof(DD_D48_DIALYSATE_PUMP_RECORD_T), - (U08*)&d48Pump ); + memcpy( &payload.data, + &temperature.tempSensors[ sendSensorIdx ], + sizeof( DD_TEMP_SENSORS_CAL_RECORD_T ) ); + } + } + break; - DD_ACID_CONCENTRATES_RECORD_T* acidConc; - calStatus = getNVMRecord( GET_CAL_ACID_CONCENTREATES, - (U08*)&acidConc, - sizeof( DD_ACID_CONCENTRATES_RECORD_T ), - NUM_OF_CAL_DATA_ACID_CONCENTRATES, - ALARM_ID_DD_NVM_INVALID_CAL_ACID_CONCENTRATE ); - for ( i = 0; i < NUM_OF_CAL_DATA_ACID_CONCENTRATES; i++ ) - { - calStatus = sendDDRecord( MSG_ID_DD_NVM_CAL_ACID_CONCENTRATE_RESPONSE, i, - sizeof(DD_ACID_CONCENTRATES_RECORD_T), - (U08*)&acidConc->acidConcentrate[ i ] ); - } + case DD_CAL_RECORD_CONCENTRATE_PUMP: + { + msgID = MSG_ID_DD_NVM_CAL_CONC_PUMP_RESPONSE; + maxSensorIdx = NUM_OF_CONCENTRATE_PUMPS; + DD_CONC_PUMPS_CAL_RECORD_T concPump; - DD_BICARB_CONCENTRATES_RECORD_T* bicarbConc; - calStatus |= getNVMRecord( GET_CAL_BICARB_CONCENTRATES, - (U08*)&bicarbConc, - sizeof( DD_BICARB_CONCENTRATES_RECORD_T ), - NUM_OF_CAL_DATA_BICARB_CONCENTRATES, - ALARM_ID_DD_NVM_INVALID_CAL_BICARB_CONCENTRATE ); - for ( i = 0; i < NUM_OF_CAL_DATA_BICARB_CONCENTRATES; i++ ) - { - calStatus = sendDDRecord( MSG_ID_DD_NVM_CAL_BICARB_CONCENTRATE_RESPONSE, i, - sizeof(DD_BICARB_CONCENTRATES_RECORD_T), - (U08*)&bicarbConc->bicarbConcentrate[ i ] ); + if ( TRUE == getNVMRecord( GET_CAL_CONCENTRATE_PUMPS_RECORD, + (U08*)&concPump, + sizeof( DD_CONC_PUMPS_CAL_RECORD_T ), + NUM_OF_CONCENTRATE_PUMPS, + ALARM_ID_DD_NVM_INVALID_CAL_CONC_PUMP ) ) + { + memcpy( &payload.data, + &concPump.concentratePumps[ sendSensorIdx ], + sizeof( DD_CONC_PUMPS_CAL_RECORD_T ) ); + + } + } + break; + + case DD_CAL_RECORD_D12_PUMP: + { + msgID = MSG_ID_DD_NVM_CAL_D12_PUMP_RESPONSE; + sendSensorIdx = 0; + maxSensorIdx = 0; + DD_D12_DIALYSATE_PUMP_RECORD_T d12Pump; + + if ( TRUE == getNVMRecord( GET_CAL_D12_PUMP_RECORD, + (U08*)&d12Pump, + sizeof( DD_D12_DIALYSATE_PUMP_RECORD_T ), + sendSensorIdx, + ALARM_ID_DD_NVM_INVALID_CAL_D12_PUMP ) ) + { + memcpy( &payload.data, + &d12Pump, + sizeof( DD_D12_DIALYSATE_PUMP_RECORD_T ) ); + } + } + break; + + case DD_CAL_RECORD_D48_PUMP: + { + msgID = MSG_ID_DD_NVM_CAL_D48_PUMP_RESPONSE; + sendSensorIdx = 0; + maxSensorIdx = 0; + DD_D48_DIALYSATE_PUMP_RECORD_T d48Pump; + + if ( TRUE == getNVMRecord( GET_CAL_D48_PUMP_RECORD, + (U08*)&d48Pump, + sizeof( DD_D48_DIALYSATE_PUMP_RECORD_T ), + sendSensorIdx, + ALARM_ID_DD_NVM_INVALID_CAL_D48_PUMP ) ) + { + memcpy( &payload.data, + &d48Pump, + sizeof( DD_D48_DIALYSATE_PUMP_RECORD_T ) ); + } + } + break; + + case DD_CAL_RECORD_ACID_CONCENTRATE: + { + msgID = MSG_ID_DD_NVM_CAL_ACID_CONCENTRATE_RESPONSE; + maxSensorIdx = NUM_OF_ACID_TYPE; + DD_ACID_CONCENTRATES_RECORD_T acidConc; + + if ( TRUE == getNVMRecord( GET_CAL_ACID_CONCENTREATES, + (U08*)&acidConc, + sizeof( DD_ACID_CONCENTRATES_RECORD_T ), + NUM_OF_ACID_TYPE, + ALARM_ID_DD_NVM_INVALID_CAL_ACID_CONCENTRATE ) ) + { + memcpy( &payload.data, + &acidConc.acidConcentrate[ sendSensorIdx ], + sizeof( DD_ACID_CONCENTRATES_RECORD_T ) ); + } + } + break; + + case DD_CAL_RECORD_BICARB_CONCENTRATE: + { + msgID = MSG_ID_DD_NVM_CAL_BICARB_CONCENTRATE_RESPONSE; + maxSensorIdx = NUM_OF_BICARB_TYPE; + DD_BICARB_CONCENTRATES_RECORD_T bicarbConc; + + if ( TRUE == getNVMRecord( GET_CAL_BICARB_CONCENTRATES, + (U08*)&bicarbConc, + sizeof( DD_BICARB_CONCENTRATES_RECORD_T ), + NUM_OF_BICARB_TYPE, + ALARM_ID_DD_NVM_INVALID_CAL_BICARB_CONCENTRATE ) ) + { + memcpy( &payload.data, + &bicarbConc.bicarbConcentrate[ sendSensorIdx ], + sizeof( DD_BICARB_CONCENTRATES_RECORD_T ) ); + } + } + break; + + case DD_CAL_RECORD_ACCELEROMETER_SENSOR: + { + msgID = MSG_ID_DD_NVM_CAL_ACCEL_SENSOR_RESPONSE; + sendSensorIdx = 0; + maxSensorIdx = 0; + DD_ACCEL_SENSOR_CAL_RECORD_T accelerometer; + if ( TRUE == getNVMRecord( GET_CAL_ACCEL_SENSORS, + (U08*)&accelerometer, + sizeof( DD_ACCEL_SENSOR_CAL_RECORD_T ), + sendSensorIdx, + ALARM_ID_DD_NVM_INVALID_CAL_ACCEL_SENSOR ) ) + { + memcpy( &payload.data, + &accelerometer, + sizeof( DD_ACCEL_SENSOR_CAL_RECORD_T ) ); + } + } + break; + + case DD_CAL_RECORD_BLLOD_LEAK_SENSOR: + { + msgID = MSG_ID_DD_NVM_CAL_BLOOD_LEAK_SENSOR_RESPONSE; + sendSensorIdx = 0; + maxSensorIdx = 0; + DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T bloodLeak; + if ( TRUE == getNVMRecord( GET_CAL_BLOOD_LEAK_SENSOR, + (U08*)&bloodLeak, + sizeof( DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T ), + sendSensorIdx, + ALARM_ID_DD_NVM_INVALID_CAL_BLOOD_LEAK_SENSOR ) ) + { + memcpy( &payload.data, + &bloodLeak, + sizeof( DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T ) ); + } + } + break; + + default: + break; } - DD_ACCEL_SENSOR_CAL_RECORD_T* accelerometer; - calStatus = getNVMRecord( GET_CAL_ACCEL_SENSORS, - (U08*)&accelerometer, - sizeof( DD_ACCEL_SENSOR_CAL_RECORD_T ), - 0, - ALARM_ID_DD_NVM_INVALID_CAL_ACCEL_SENSOR ); - calStatus = sendDDRecord( MSG_ID_DD_NVM_CAL_ACCEL_SENSOR_RESPONSE, 0, - sizeof(DD_ACCEL_SENSOR_CAL_RECORD_T), - (U08*)&accelerometer ); + payload.idx = (U08)sendSensorIdx; - DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T* bloodLeak; - calStatus = getNVMRecord( GET_CAL_BLOOD_LEAK_SENSOR, - (U08*)&bloodLeak, - sizeof( DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T ), - 0, - ALARM_ID_DD_NVM_INVALID_CAL_BLOOD_LEAK_SENSOR ); - calStatus = sendDDRecord( MSG_ID_DD_NVM_CAL_BLOOD_LEAK_SENSOR_RESPONSE, 0, - sizeof(DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T), - (U08*)&bloodLeak ); + // Send the record + sendStatus = sendMessage( msgID, + COMM_BUFFER_OUT_CAN_DD_BROADCAST, + (U08*)&payload, + sizeof( DD_NVM_SEND_RECORD_PAYLOAD_T ) ); + // Check if record was sent successfully + if ( TRUE == sendStatus) + { + // Check if we sent the last record of calibration component + if ( sendSensorIdx >= maxSensorIdx ) + { + // Reset Sensor Index for the next calibration data + sendSensorIdx = 0; + + // Reset the retry count for the next calibration data + sendRetryCount = 0; + + // Move on to publish the next calibration record + sendCalRec = (DD_CAL_REC_TYPE)( (U32)sendCalRec + 1 ); + } + else + { + sendSensorIdx++; + } + } + else + { + sendRetryCount ++; + } + + // If all the allowed retries has been utilized or + // If all the calibration records have been published + if ( ( sendRetryCount > MAX_NUM_OF_SEND_RETRIES ) || + ( sendCalRec >= NUM_OF_CAL_RECORD_TYPE ) ) + { + // Reset Sensor Index for the next request + sendSensorIdx = 0; + + // Reset Index tracker for next request. + sendCalRec = DD_CAL_RECORD_PRESSURE_SENSOR; + + // Clear the publishing flags + recordToPublish = NUM_OF_NVM_RECORD_TYPES; + + // Move to Send Idle State + state = NVM_SEND_RECORD_STATE_IDLE; + + // Reset the retry count + sendRetryCount = 0; + } + return state; } static SEND_RECORD_STATE_T handleSendDDInstitutionalRecord( void ) { - BOOL sendStatus = FALSE; SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; - U32 valueU32 = 0; - F32 valueF32 = 0.0; + BOOL sendStatus = FALSE; + U32 valueU32 = 0; + F32 valueF32 = 0.0; DD_NVM_SEND_RECORD_PAYLOAD_T payload; CRITICAL_DATA_TYPES_T dataType; @@ -687,7 +822,7 @@ DD_NVM_SEND_RECORD_PAYLOAD_T payload; payload.idx = idx; - memcpy( payload.data, recordAddress, length ); + memcpy( &payload.data, recordAddress, length ); result = sendMessage( msgId, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&payload, sizeof( DD_NVM_SEND_RECORD_PAYLOAD_T ) ); @@ -697,27 +832,29 @@ static BOOL receiveCalRecord( MESSAGE_T *message, DD_CAL_REC_TYPE calRecordType, U16 recordSize ) { BOOL status = FALSE; - U08 idx = 0; - MSG_ID_T msgID = (MSG_ID_T)message->hdr.msgID; +// U08 idx = 0; +// MSG_ID_T msgID = (MSG_ID_T)message->hdr.msgID; U08* payloadPtr = message->payload; U08 expectedPayloadLen = ( sizeof(U08) + recordSize ); - U08 tempBuffer[ recordSize ]; +// U08 tempBuffer[ recordSize ]; + DD_NVM_SEND_RECORD_PAYLOAD_T recvdPayload; + if ( message->hdr.payloadLen == expectedPayloadLen ) { - memcpy(&idx, payloadPtr, sizeof(U32)); + memcpy( &recvdPayload.idx, payloadPtr, sizeof(U32)); payloadPtr += sizeof(U08); - memcpy( tempBuffer, payloadPtr, recordSize ); + memcpy( &recvdPayload.data, payloadPtr, recordSize ); // CRC assumed at end of record - U16 *recordCRC = (U16 *)( tempBuffer + ( recordSize - sizeof(U16) ) ); - U16 calcCRC = crc16( tempBuffer, recordSize - sizeof(U16) ); + U16 *recordCRC = (U16 *)( recvdPayload.data + ( recordSize - sizeof(U16) ) ); + U16 calcCRC = crc16( recvdPayload.data, recordSize - sizeof(U16) ); if (calcCRC == *recordCRC) { nvmExecreceiveRecordState = NVM_RECEIVE_RECORD_STATE_RECEIVE; - status = setNVMCalRecord( calRecordType, &tempBuffer, idx ); + status = setNVMCalRecord( calRecordType, (U08*)&recvdPayload.data, recvdPayload.idx ); // It is possible that we receive multiple packets of cal record // So we write it to flash when we finish receiving all packets or @@ -936,7 +1073,7 @@ memcpy( &idx, payloadPtr, sizeof(U32) ); payloadPtr += sizeof(U08); - result = setNVMInstitRecord( (DD_CAL_REC_TYPE)idx, payloadPtr ); + result = setNVMInstitRecord( (DD_INSTIT_REC_TYPE)idx, payloadPtr ); // It is possible that we receive multiple packets of instit record // So we write it to flash when we finish receiving all packets or