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);
}
}
