void deviceI2cSlaveDebugHandleRawData(char header, InputStream* inputStream, OutputStream* outputStream) { // I2C Management if (header == COMMAND_I2C_DEBUG_SLAVE_DEBUG) { ackCommand(outputStream, I2C_SLAVE_DEBUG_DEVICE_HEADER, COMMAND_I2C_DEBUG_SLAVE_DEBUG); printI2cDebugBuffers(); } else if (header == COMMANG_I2C_DEBUG_SLAVE_ADDRESS) { ackCommand(outputStream, I2C_SLAVE_DEBUG_DEVICE_HEADER, COMMANG_I2C_DEBUG_SLAVE_ADDRESS); unsigned char address = slaveDebugDeviceI2cBusConnection->i2cAddress; appendHex2(outputStream, address); } else if (header == COMMAND_I2C_DEBUG_SLAVE_ENABLE_DISABLE) { ackCommand(outputStream, I2C_SLAVE_DEBUG_DEVICE_HEADER, COMMAND_I2C_DEBUG_SLAVE_ENABLE_DISABLE); unsigned char enable = readHex2(inputStream); setDebugI2cEnabled(enable != 0); } else if (header == COMMAND_I2C_DEBUG_SLAVE_SEND_CHAR_I2C_TO_MASTER) { ackCommand(outputStream, I2C_SLAVE_DEBUG_DEVICE_HEADER, COMMAND_I2C_DEBUG_SLAVE_SEND_CHAR_I2C_TO_MASTER); int c = readHex2(inputStream); portableSlaveWriteI2C(slaveDebugDeviceI2cBusConnection, c); } else if (header == COMMAND_I2C_DEBUG_SLAVE_READ_CHAR_I2C_FROM_MASTER) { ackCommand(outputStream, I2C_SLAVE_DEBUG_DEVICE_HEADER, COMMAND_I2C_DEBUG_SLAVE_READ_CHAR_I2C_FROM_MASTER); char c = portableSlaveReadI2C(slaveDebugDeviceI2cBusConnection); appendHex2(outputStream, c); } }
void deviceRobotInfraredDetectorHandleRawData(char header, InputStream* inputStream, OutputStream* outputStream) { // Command to ask if (header == COMMAND_INFRARED_DETECTOR_DETECTION) { appendAck(outputStream); append(outputStream, COMMAND_INFRARED_DETECTOR_DETECTION); int type = readHex2(inputStream); BOOL hasDetected; if (type == DETECTOR_FORWARD_INDEX) { hasDetected = getRobotInfraredObstacleForward(); } else { hasDetected = getRobotInfraredObstacleBackward(); } // Send argument if (hasDetected) { appendHex2(outputStream, 1); } else { appendHex2(outputStream, 0); } } }
void devicePwmMotorHandleRawData(char commandHeader, InputStream* inputStream, OutputStream* outputStream) { if (commandHeader == COMMAND_MOVE_MOTOR) { signed int left = readSignedHex2(inputStream); signed int right = readSignedHex2(inputStream); ackCommand(outputStream, MOTOR_DEVICE_HEADER, COMMAND_MOVE_MOTOR); setMotorSpeeds(left * 2, right * 2); } else if (commandHeader == COMMAND_READ_MOTOR_VALUE) { ackCommand(outputStream, MOTOR_DEVICE_HEADER, COMMAND_READ_MOTOR_VALUE); signed int left = getLeftSpeed(); signed int right = getRightSpeed(); appendHex2(outputStream, left / 2); appendHex2(outputStream, right / 2); } else if (commandHeader == COMMAND_STOP_MOTOR) { ackCommand(outputStream, MOTOR_DEVICE_HEADER, COMMAND_STOP_MOTOR); stopMotors(); } else if (commandHeader == COMMAND_TEST_MOTOR) { ackCommand(outputStream, MOTOR_DEVICE_HEADER, COMMAND_TEST_MOTOR); appendString(getAlwaysOutputStreamLogger(), "Left Forward\n"); // Left forward setMotorSpeeds(50, 0); delaymSec(2000); appendString(getAlwaysOutputStreamLogger(), "Right Forward\n"); // Right forward setMotorSpeeds(0, 50); delaymSec(2000); appendString(getAlwaysOutputStreamLogger(), "Left Backward\n"); // Left backward setMotorSpeeds(-50, 0); delaymSec(2000); appendString(getAlwaysOutputStreamLogger(), "Right Forward\n"); // Right backward setMotorSpeeds(0, -50); delaymSec(2000); appendString(getAlwaysOutputStreamLogger(), "Both Forward\n"); // Both forward setMotorSpeeds(50, 50); delaymSec(2000); appendString(getAlwaysOutputStreamLogger(), "Both Backward\n"); // Both backward setMotorSpeeds(-50, -50); delaymSec(2000); stopMotors(); } }
void notifyInfraredDetectorDetection(int type) { Buffer* buffer = getMechanicalBoard2I2CSlaveOutputBuffer(); OutputStream* outputStream = getOutputStream(buffer); append(outputStream, NOTIFY_INFRARED_DETECTOR_DETECTION); appendHex2(outputStream, type); // Debug OutputStream* debugOutputStream = getDebugOutputStreamLogger(); append(debugOutputStream, NOTIFY_INFRARED_DETECTOR_DETECTION); appendHex2(debugOutputStream, type); }
int32_t VL53L0X_read_multi(uint8_t deviceAddress, uint8_t index, uint8_t *pdata, int32_t count) { I2cBusConnection* i2cBusConnection = getI2cBusConnectionBySlaveAddress(deviceAddress); I2cBus* i2cBus = i2cBusConnection->i2cBus; portableMasterWaitSendI2C(i2cBusConnection); portableMasterStartI2C(i2cBusConnection); WaitI2C(i2cBus); portableMasterWriteI2C(i2cBusConnection, deviceAddress); WaitI2C(i2cBus); // Write the "index" from which we want to read portableMasterWriteI2C(i2cBusConnection, index); WaitI2C(i2cBus); portableMasterStartI2C(i2cBusConnection); WaitI2C(i2cBus); // Enter in "read" mode portableMasterWriteI2C(i2cBusConnection, deviceAddress | 1); WaitI2C(i2cBus); #ifdef VL53L0X_DEBUG OutputStream* debugOutputStream = getDebugOutputStreamLogger(); appendString(debugOutputStream, "\tReading "); appendDec(debugOutputStream, count); appendString(debugOutputStream, " from addr 0x"); appendHex2(debugOutputStream, deviceAddress); appendString(debugOutputStream, ": "); #endif while (count--) { pdata[0] = portableMasterReadI2C(i2cBusConnection); // Ack if (count > 0) { portableMasterAckI2C(i2cBusConnection); } else { portableMasterNackI2C(i2cBusConnection); } WaitI2C(i2cBus); #ifdef VL53L0X_DEBUG appendString(debugOutputStream, "0x "); appendHex2(debugOutputStream, pdata[0]); appendString(debugOutputStream, ", "); #endif pdata++; } #ifdef VL53L0X_DEBUG println(debugOutputStream); #endif return VL53L0X_ERROR_NONE; }
BOOL motionSetParameters(int motionType, int a, int speed) { OutputStream* outputStream = getDriverRequestOutputStream(); append(outputStream, COMMAND_SET_MOTION_PARAMETERS); appendHex2(outputStream, motionType); appendHex2(outputStream, a); appendHex2(outputStream, speed); BOOL result = transmitFromDriverRequestBuffer(); return result; }
BOOL motionDriverGotoPositionPulse(float left, float right, float a, float s) { OutputStream* outputStream = getDriverRequestOutputStream(); append(outputStream, COMMAND_MOTION_GOTO_IN_PULSE); appendHex4(outputStream, left); appendHex4(outputStream, right); appendHex2(outputStream, a); appendHex2(outputStream, s); BOOL result = transmitFromDriverRequestBuffer(); return result; }
bool clientLaunch2018(int launcherIndex, bool prepare) { OutputStream* outputStream = getDriverRequestOutputStream(); append(outputStream, LAUNCHER_2018_DEVICE_HEADER); if (prepare) { append(outputStream, LAUNCHER_PREPARE_BALL_COMMAND); appendHex2(outputStream, launcherIndex); } else { append(outputStream, LAUNCHER_SEND_BALL_COMMAND); appendHex2(outputStream, launcherIndex); } bool result = transmitFromDriverRequestBuffer(); return result; }
void deviceTestHandleRawData(char header, InputStream* inputStream, OutputStream* outputStream) { if (header == COMMAND_TEST) { int arg1 = readHex2(inputStream); int arg2 = readHex2(inputStream); int result = arg1 + arg2; // data appendAck(outputStream); append(outputStream, COMMAND_TEST); appendHex2(outputStream, result); } /* TODO else if (header == COMMAND_NOTIFY_TEST) { int argument = readHex2(inputStream); argument *= 2; Buffer* buffer = getI2CSlaveOutputBuffer(); OutputStream* i2cOutputStream = getOutputStream(buffer); // Add the value to I2C append(i2cOutputStream, COMMAND_NOTIFY_TEST); appendHex2(i2cOutputStream, argument); // Response to the call appendAck(outputStream); append(outputStream, COMMAND_NOTIFY_TEST); appendHex2(outputStream, argument); } */ }
void i2cSlaveInitialize(I2cBusConnection* i2cBusConnection) { // Avoid more than one initialization if (i2cBusConnection->opened) { writeError(I2C_SLAVE_ALREADY_INITIALIZED); return; } i2cBusConnection->opened = true; appendString(getDebugOutputStreamLogger(), "I2C Slave Write Address="); appendHex2(getDebugOutputStreamLogger(), i2cBusConnection->i2cAddress); appendCRLF(getDebugOutputStreamLogger()); if (i2cBusConnection == NULL) { // Enable the I2C module with clock stretching enabled OpenI2C1(I2C_ON | I2C_7BIT_ADD | I2C_STR_EN, BRG_VAL); // 7-bit I2C slave address must be initialised here. // we shift because i2c address is shift to the right // to manage read and write address I2C1ADD = i2cBusConnection->i2cAddress >> 1; I2C1MSK = 0; // Interruption on I2C Slave // -> Priority of I2C Slave interruption mI2C1SetIntPriority(I2C_INT_PRI_3 | I2C_INT_SLAVE); // -> Enable Interruption Flag => See the same code in interruption mI2C1SClearIntFlag(); // Enable I2C (MACRO) EnableIntSI2C1; }
BOOL sentStrategyRobotPosition(unsigned char status, unsigned int x, unsigned int y, int angleInDeciDegree) { OutputStream* debugOutputStream = getOutputStreamLogger(INFO); appendString(debugOutputStream, "sentStrategyRobotPosition:"); OutputStream* outputStream = getDriverRequestOutputStream(); append(outputStream, COMMAND_STRATEGY_SET_ROBOT_POSITION); appendHex2(outputStream, status); appendSeparator(outputStream); appendHex4(outputStream, x); appendSeparator(outputStream); appendHex4(outputStream, y); appendSeparator(outputStream); appendHex4(outputStream, angleInDeciDegree); appendStringAndDec(debugOutputStream, "status=", status); appendStringAndDec(debugOutputStream, ", x=", x); appendStringAndDec(debugOutputStream, ", y=", y); appendStringAndDec(debugOutputStream, ", angle=", angleInDeciDegree); println(debugOutputStream); BOOL result = transmitFromDriverRequestBuffer(); return result; }
void deviceColorSensorHandleRawData(unsigned char commandHeader, InputStream* inputStream, OutputStream* outputStream, OutputStream* notificationOutputStream) { if (commandHeader == COMMAND_COLOR_SENSOR_READ) { ackCommand(outputStream, COLOR_SENSOR_DEVICE_HEADER, COMMAND_COLOR_SENSOR_READ); Color* color = colorSensor->colorSensorReadValue(colorSensor); appendHex4(outputStream, color->R); appendSeparator(outputStream); appendHex4(outputStream, color->G); appendSeparator(outputStream); appendHex4(outputStream, color->B); } else if (commandHeader == COMMAND_COLOR_SENSOR_READ_TYPE) { ackCommand(outputStream, COLOR_SENSOR_DEVICE_HEADER, COMMAND_COLOR_SENSOR_READ_TYPE); enum ColorType colorType = colorSensor->colorSensorFindColorType(colorSensor); appendHex2(outputStream, colorType); } else if (commandHeader == COMMAND_COLOR_SENSOR_DEBUG) { ackCommand(outputStream, COLOR_SENSOR_DEVICE_HEADER, COMMAND_COLOR_SENSOR_DEBUG); OutputStream* debugOutputStream = getInfoOutputStreamLogger(); printColorSensorTable(debugOutputStream, colorSensor); } /** Only for PC */ else if (commandHeader == COMMAND_COLOR_SENSOR_WRITE) { ackCommand(outputStream, COLOR_SENSOR_DEVICE_HEADER, COMMAND_COLOR_SENSOR_WRITE); colorSensor->color->R = readHex4(inputStream); checkIsSeparator(inputStream); colorSensor->color->G = readHex4(inputStream); checkIsSeparator(inputStream); colorSensor->color->B = readHex4(inputStream); } }
void i2cSlaveInitialize(I2cBusConnection* i2cBusConnection) { // Avoid more than one initialization if (i2cBusConnection->opened) { writeError(I2C_SLAVE_ALREADY_INITIALIZED); return; } i2cBusConnection->object = &i2cSlaveBusConnectionPc; appendString(getDebugOutputStreamLogger(), "I2C Slave Write Address="); appendHex2(getDebugOutputStreamLogger(), i2cBusConnection->i2cAddress); appendCRLF(getDebugOutputStreamLogger()); i2cSlaveBusConnectionPc.masterToSlaveHandle = initClientPipe(L"\\\\.\\pipe\\mainBoardPipe"); i2cSlaveBusConnectionPc.slaveToMasterHandle = initServerPipe(L"\\\\.\\pipe\\motorBoardPipe"); i2cBusConnection->opened = true; // Thread : master => slave i2cSlaveBusConnectionPc.masterToSlaveThreadHandle = createStandardThread( masterToSlaveCallback, // thread proc (LPVOID)i2cBusConnection, // thread parameter &(i2cSlaveBusConnectionPc.masterToSlaveThreadId)); // returns thread ID // Thread : slave => master i2cSlaveBusConnectionPc.slaveToMasterThreadHandle = createStandardThread( slaveToMasterCallback, // thread proc (LPVOID)i2cBusConnection, // thread parameter &(i2cSlaveBusConnectionPc.slaveToMasterThreadId)); // returns thread ID }
void disableNotificationRobotInfraredDetector(enum InfraredDetectorGroupType type) { OutputStream* outputStream = getDriverRequestOutputStream(); append(outputStream, ROBOT_INFRARED_DETECTOR_DEVICE_HEADER); append(outputStream, DETECTOR_DISABLE_NOTIFICATION_COMMAND); appendHex2(outputStream, type); transmitFromDriverRequestBuffer(); }
int32_t VL53L0X_write_multi(uint8_t deviceAddress, uint8_t index, uint8_t *pdata, int32_t count) { I2cBusConnection* i2cBusConnection = getI2cBusConnectionBySlaveAddress(deviceAddress); I2cBus* i2cBus = i2cBusConnection->i2cBus; portableMasterWaitSendI2C(i2cBusConnection); // Wait till Start sequence is completed WaitI2C(i2cBus); portableMasterStartI2C(i2cBusConnection); WaitI2C(i2cBus); // I2C PICs adress use 8 bits and not 7 bits portableMasterWriteI2C(i2cBusConnection, deviceAddress); WaitI2C(i2cBus); portableMasterWriteI2C(i2cBusConnection, index); WaitI2C(i2cBus); #ifdef VL53L0X_DEBUG OutputStream* debugOutputStream = getDebugOutputStreamLogger(); appendString(debugOutputStream, "\tWriting "); appendDec(debugOutputStream, count); appendString(debugOutputStream, " to addr 0x"); appendHex2(debugOutputStream, deviceAddress); appendString(debugOutputStream, ": "); #endif while(count--) { portableMasterWriteI2C(i2cBusConnection, pdata[0]); WaitI2C(i2cBus); #ifdef VL53L0X_DEBUG appendString(debugOutputStream, "0x "); appendHex2(debugOutputStream, pdata[0]); appendString(debugOutputStream, ", "); #endif pdata++; } #ifdef VL53L0X_DEBUG println(debugOutputStream); #endif portableMasterStopI2C(i2cBusConnection); WaitI2C(i2cBus); return VL53L0X_ERROR_NONE; }
void appendFixedCharArray(OutputStream* outputStream, const FixedCharArray* s) { unsigned int i; char* sPointer = (char*)s; for (i = 0; i < FIXED_CHAR_ARRAY_LENGTH; i++) { char c = *sPointer; appendHex2(outputStream, c); sPointer++; } }
bool clientLightOn2018(int launcherIndex) { OutputStream* outputStream = getDriverRequestOutputStream(); append(outputStream, LAUNCHER_2018_DEVICE_HEADER); append(outputStream, LAUNCHER_LIGHT_ON_SERVO_MOVE_COMMAND); appendHex2(outputStream, launcherIndex); bool result = transmitFromDriverRequestBuffer(); return result; }
void deviceTemperatureSensorHandleRawData(unsigned char header, InputStream* inputStream, OutputStream* outputStream, OutputStream* notificationOutputStream){ if (header == COMMAND_READ_TEMPERATURE_SENSOR) { ackCommand(outputStream, TEMPERATURE_SENSOR_DEVICE_HEADER, COMMAND_READ_TEMPERATURE_SENSOR); unsigned char value = (unsigned char) temperature->readSensorValue(temperature); appendHex2(outputStream, value); } else if (header == COMMAND_SET_TEMPERATURE_SENSOR_ALERT) { unsigned char temperatureSensorAlert = readHex2(inputStream); ackCommand(outputStream, TEMPERATURE_SENSOR_DEVICE_HEADER, COMMAND_SET_TEMPERATURE_SENSOR_ALERT); temperature->writeAlertLimit(temperature, temperatureSensorAlert); } }
BOOL motionDriverBSplineAbsolute(float x, float y, float angle, float dist0, float dist1, int accelerationFactor, int speedFactor) { OutputStream* outputStream = getDriverRequestOutputStream(); append(outputStream, COMMAND_MOTION_SPLINE_ABSOLUTE); appendHex4(outputStream, x); appendSeparator(outputStream); appendHex4(outputStream, y); appendSeparator(outputStream); appendHex4(outputStream, angle); appendSeparator(outputStream); appendHex2(outputStream, dist0); appendSeparator(outputStream); appendHex2(outputStream, dist1); appendSeparator(outputStream); appendHex(outputStream, accelerationFactor); appendHex(outputStream, speedFactor); BOOL result = transmitFromDriverRequestBuffer(); return result; }
void printAllPinValues(OutputStream* outputStream) { int i = 0; for (i = PIN_MIN_INDEX; i <= PIN_MAX_INDEX; i++) { BOOL value = getPinValue(i); appendString(outputStream, "Pin "); appendHex2(outputStream, i); append(outputStream, '='); appendBOOL(outputStream, value); println(outputStream); } }
bool clientDistributor2018LoadAndSendUnicolorBallList(int direction) { OutputStream* outputStream = getDriverRequestOutputStream(); append(outputStream, LAUNCHER_2018_DEVICE_HEADER); append(outputStream, LAUNCHER_LOAD_AND_SEND_UNICOLOR_BALL_LIST); appendHex2(outputStream, direction); bool result = transmitFromDriverRequestBuffer(); return result; }
void printDriverDataDispatcher(OutputStream* outputStream, DriverDataDispatcher* dispatcher) { appendString(outputStream, "dispatcher="); appendString(outputStream, dispatcher->name); appendString(outputStream, ", transmitMode="); TransmitMode transmitMode = dispatcher->transmitMode; appendDec(outputStream, transmitMode); append(outputStream, '('); appendString(outputStream, getTransmitModeAsString(transmitMode)); append(outputStream, ')'); appendString(outputStream, ", address=0x"); appendHex2(outputStream, dispatcher->address); appendCRLF(outputStream); }
bool robotInfraredDetectorHasObstacle(enum InfraredDetectorGroupType type) { OutputStream* outputStream = getDriverRequestOutputStream(); InputStream* inputStream = getDriverResponseInputStream(); append(outputStream, ROBOT_INFRARED_DETECTOR_DEVICE_HEADER); append(outputStream, COMMAND_INFRARED_DETECTOR_DETECTION); appendHex2(outputStream, type); bool result = transmitFromDriverRequestBuffer(); if (result) { int result = readHex2(inputStream); return result == 0x01; } return false; }
void deviceStartMatchDetectorHandleRawData(unsigned char commandHeader, InputStream* inputStream, OutputStream* outputStream, OutputStream* notificationOutputStream) { if (commandHeader == COMMAND_MATCH_IS_STARTED) { StartMatch* startMatch = getStartMatchDetectorStartMatchObject(); int value = isMatchStarted(startMatch); ackCommand(outputStream, START_MATCH_DEVICE_HEADER, COMMAND_MATCH_IS_STARTED); appendHex2(outputStream, value); } else if (commandHeader == COMMAND_START_MATCH_DEBUG) { StartMatch* startMatch = getStartMatchDetectorStartMatchObject(); ackCommand(outputStream, START_MATCH_DEVICE_HEADER, COMMAND_START_MATCH_DEBUG); OutputStream* debugOutputStream = getDebugOutputStreamLogger(); printStartMatchTable(debugOutputStream, startMatch); } }
bool clientDistributor2018CleanNext(int direction) { OutputStream* outputStream = getDriverRequestOutputStream(); InputStream* inputStream = getDriverResponseInputStream(); append(outputStream, LAUNCHER_2018_DEVICE_HEADER); append(outputStream, DISTRIBUTOR_LOAD_NEXT_BALL_COMMAND); appendHex2(outputStream, direction); bool result = transmitFromDriverRequestBuffer(); // Read the distance of detection, but we don't care about readHex2(inputStream); return result; }
char readFilteredChar(InputStream* inputStream) { char b0 = inputStream->readChar(inputStream); char result; if (filterBinaryToValueChar(b0, &result)) { return result; } else { writeError(IO_READER_READ_FILTERED_CHAR); OutputStream* debugOutputStream = getErrorOutputStreamLogger(); appendString(debugOutputStream, "Char:"); append(debugOutputStream, b0); appendString(debugOutputStream, "Hex:"); appendHex2(debugOutputStream, b0); return FILTERED_RESULT; } }
void devicePinHandleRawData(char header, InputStream* inputStream, OutputStream* outputStream) { if (header == COMMAND_SET_PIN_VALUE) { int pinIndex = readHex2(inputStream); int pinValue = readHex2(inputStream); appendAck(outputStream); setPinValue(pinIndex, pinValue); append(outputStream, COMMAND_SET_PIN_VALUE); } else if (header == COMMAND_GET_PIN_VALUE) { int pinIndex = readHex2(inputStream); appendAck(outputStream); int pinValue = getPinValue(pinIndex); // Response append(outputStream, COMMAND_GET_PIN_VALUE); appendHex2(outputStream, pinValue); } }
void printClock(OutputStream* outputStream, Clock* clock) { ClockData* clockData = &(clock->clockData); appendHex2(outputStream, clockData->hour); append(outputStream, ':'); appendHex2(outputStream, clockData->minute); append(outputStream, ':'); appendHex2(outputStream, clockData->second); append(outputStream, ' '); appendHex2(outputStream, clockData->day); append(outputStream, '/'); appendHex2(outputStream, clockData->month); append(outputStream, '/'); appendHex2(outputStream, clockData->year); }
void i2cSlaveInitialize(I2cBusConnection* i2cBusConnection) { // Avoid more than one initialization if (i2cBusConnection->opened) { writeError(I2C_SLAVE_ALREADY_INITIALIZED); return; } i2cBusConnection->opened = true; I2CCONbits.STREN = 1; // I2CCONbits.GCEN = 1; I2CCONbits.DISSLW = 1; I2CCONbits.SCLREL = 1; // 7-bit I2C slave address must be initialised here. // we shift because i2c address is shift to the right // to manage read and write address I2CADD = i2cBusConnection->i2cAddress >> 1; // Interruption on I2C Slave // -> Priority of I2C Slave interruption IPC3bits.SI2CIP = 1; // -> Enable I2C Slave interruption IEC0bits.SI2CIE = 1; // -> Enable Interruption Flag => See the same code in interruption IFS0bits.SI2CIF = 0; // Enable I2C I2CCONbits.I2CEN = 1; appendString(getDebugOutputStreamLogger(), "I2C Slave CONF="); appendBinary16(getDebugOutputStreamLogger(), I2CCON, 4); appendCRLF(getDebugOutputStreamLogger()); appendString(getDebugOutputStreamLogger(), "I2C Slave Write Address="); appendHex2(getDebugOutputStreamLogger(), i2cBusConnection->i2cAddress); appendCRLF(getDebugOutputStreamLogger()); }
void deviceEndMatchDetectorHandleRawData(char commandHeader, InputStream* inputStream, OutputStream* outputStream) { if (commandHeader == COMMAND_GET_TIME_LEFT) { ackCommand(outputStream, END_MATCH_DETECTOR_DEVICE_HEADER, COMMAND_GET_TIME_LEFT); appendHex2(outputStream, MATCH_DURATION - currentTimeInSecond); } }