void receiver_therad(void *arg)
{
chRegSetThreadName("USB receiver");
struct io_dev_s *dev = (struct io_dev_s *)arg;
static char response_buffer[100];
service_call_handler.service_table = service_calls;
service_call_handler.response_buffer = response_buffer;
service_call_handler.response_buffer_sz = sizeof(response_buffer);
service_call_handler.send_cb = io_dev_send;
service_call_handler.send_cb_arg = dev;
serial_datagram_rcv_handler_t rcv;
static char datagram_buf[64];
serial_datagram_rcv_handler_init(
&rcv,
datagram_buf,
sizeof(datagram_buf),
(serial_datagram_cb_t)msg_dispatcher,
messages);
while (1) {
static uint8_t buf[32];
int len = chnReadTimeout(dev->channel, buf, sizeof(buf), MS2ST(1));
if (len == 0) {
continue;
}
serial_datagram_receive(&rcv, buf, len);
}
}
void PExReceive(void) {
if (!AckPending) {
unsigned char received;
while (chnReadTimeout(&BDU1, &received, 1, TIME_IMMEDIATE)) {
PExReceiveByte(received);
}
}
}
int sr5ReadDataTimeout(ts_channel_s *tsChannel, uint8_t * buffer, int size, int timeout) {
#if TS_UART_DMA_MODE || defined(__DOXYGEN__)
UNUSED(tsChannel);
return (int)iqReadTimeout(&tsUartDma.fifoRxQueue, (uint8_t * )buffer, (size_t)size, timeout);
#else /* TS_UART_DMA_MODE */
if (tsChannel->channel == NULL)
return 0;
return chnReadTimeout(tsChannel->channel, (uint8_t * )buffer, size, timeout);
#endif /* TS_UART_DMA_MODE */
}
void virtser_task(void) {
uint8_t numBytesReceived = 0;
uint8_t buffer[16];
do {
numBytesReceived = chnReadTimeout(&drivers.serial_driver.driver, buffer, sizeof(buffer), TIME_IMMEDIATE);
for (int i=0;i<numBytesReceived;i++) {
virtser_recv(buffer[i]);
}
} while (numBytesReceived > 0);
}
void raw_hid_task(void) {
uint8_t buffer[RAW_EPSIZE];
size_t size = 0;
do {
size_t size = chnReadTimeout(&drivers.raw_driver.driver, buffer, sizeof(buffer), TIME_IMMEDIATE);
if (size > 0) {
raw_hid_receive(buffer, size);
}
} while(size > 0);
}
void console_task(void) {
uint8_t buffer[CONSOLE_EPSIZE];
size_t size = 0;
do {
size_t size = chnReadTimeout(&drivers.console_driver.driver, buffer, sizeof(buffer), TIME_IMMEDIATE);
if (size > 0) {
console_receive(buffer, size);
}
} while(size > 0);
}
static msg_t ThreadUSBDMidi(void *arg) {
(void)arg;
#if CH_USE_REGISTRY
chRegSetThreadName("usbdmidi");
#endif
uint8_t r[4];
while (1) {
chnReadTimeout(&MDU1, &r[0], 4, TIME_INFINITE);
MidiInMsgHandler(MIDI_DEVICE_USB_DEVICE, ((r[0] & 0xF0) >> 4) + 1, r[1],
r[2], r[3]);
}
}
void bbio_spi_sniff(t_hydra_console *con)
{
uint8_t cs_state, data, rx_data[2];
mode_config_proto_t* proto = &con->mode->proto;
bsp_status_t status;
proto->dev_mode = DEV_SPI_SLAVE;
status = bsp_spi_init(proto->dev_num, proto);
status = bsp_spi_init(proto->dev_num+1, proto);
if(status == BSP_OK) {
cprint(con, "\x01", 1);
} else {
cprint(con, "\x00", 1);
proto->dev_mode = DEV_SPI_MASTER;
status = bsp_spi_init(proto->dev_num, proto);
status = bsp_spi_deinit(proto->dev_num+1);
return;
}
cs_state = 1;
while(!USER_BUTTON || chnReadTimeout(con->sdu, &data, 1,1)) {
if (cs_state == 0 && bsp_spi_get_cs(proto->dev_num)) {
cprint(con, "]", 1);
cs_state = 1;
} else if (cs_state == 1 && !(bsp_spi_get_cs(proto->dev_num))) {
cprint(con, "[", 1);
cs_state = 0;
}
if(bsp_spi_rxne(proto->dev_num)){
bsp_spi_read_u8(proto->dev_num, &rx_data[0], 1);
if(bsp_spi_rxne(proto->dev_num+1)){
bsp_spi_read_u8(proto->dev_num+1, &rx_data[1], 1);
} else {
rx_data[1] = 0;
}
cprintf(con, "\\%c%c", rx_data[0], rx_data[1]);
}
}
proto->dev_mode = DEV_SPI_MASTER;
status = bsp_spi_init(proto->dev_num, proto);
status = bsp_spi_deinit(proto->dev_num+1);
}
msg_t bridge_thread (void *arg)
{
t_hydra_console *con;
con = arg;
chRegSetThreadName("UART bridge");
chThdSleepMilliseconds(10);
uint8_t rx_data;
uint8_t tx_data;
mode_config_proto_t* proto = &con->mode->proto;
while (!USER_BUTTON) {
if(bsp_uart_rxne(proto->dev_num)) {
bsp_uart_read_u8(proto->dev_num, &rx_data ,1);
chSequentialStreamWrite(con->sdu, &rx_data, 1);
}
if(chnReadTimeout(con->sdu, &tx_data, 1, 1)) {
bsp_uart_write_u8(proto->dev_num, &tx_data, 1);
//chSequentialStreamWrite(con->sdu, &tx_data, 1);
}
}
return (msg_t)1;
}
static void bridge(t_hydra_console *con)
{
uint8_t tx_data[UART_BRIDGE_BUFF_SIZE];
uint8_t bytes_read;
//uint8_t bytes_read;
mode_config_proto_t* proto = &con->mode->proto;
cprintf(con, "Interrupt by pressing user button.\r\n");
cprint(con, "\r\n", 2);
thread_t *bthread = chThdCreateFromHeap(NULL, CONSOLE_WA_SIZE, "bridge_thread",
LOWPRIO, bridge_thread, con);
while(!USER_BUTTON) {
bytes_read = chnReadTimeout(con->sdu, tx_data,
UART_BRIDGE_BUFF_SIZE, US2ST(100));
if(bytes_read > 0) {
bsp_uart_write_u8(proto->dev_num, tx_data, bytes_read);
}
}
chThdTerminate(bthread);
chThdWait(bthread);
}
bool recv_midi_packet(MIDI_EventPacket_t* const event) {
size_t size = chnReadTimeout(&drivers.midi_driver.driver, (uint8_t*)event, sizeof(MIDI_EventPacket_t), TIME_IMMEDIATE);
return size == sizeof(MIDI_EventPacket_t);
}
static msg_t receiverThread(void *arg) {
int i;
UNUSED (arg);
chRegSetThreadName("receiver");
while (TRUE) {
chMtxLock(&nrfMutex);
size_t s = chnReadTimeout(&nrf24l01.channels[0], serialInBuf, 32, MS2ST(10));
chMtxUnlock(&nrfMutex);
if (s) {
if(!wait_for_ack){
// serialOutBuf[0]= serialInBuf[0];
serialInBuf[8]= 1;
for(i=0; i<5; i++){
target_addr[i] = serialInBuf[2+i];
}
nrf24l01SetTXAddress(&nrf24l01, target_addr);
chMtxLock(&nrfMutex);
chnWriteTimeout(&nrf24l01.channels[0], serialInBuf, 32, MS2ST(100));
chMtxUnlock(&nrfMutex);
if(wait_for_ack){
break;
}
for(i=0;i<5; i++){
rec_list[iter][i] = serialInBuf[2+i];
}
rec_list[iter][5] = serialInBuf[10];
for(i=0; i<(serialInBuf[10]);i++){
rec_list[iter][6+i] = serialInBuf[12+i];
}
iter = (iter+1)%10;
for (i=0;i<(int)s;i++) {
chprintf((BaseSequentialStream*)&SD1, "%c ", serialInBuf[i]);
}
chprintf((BaseSequentialStream*)&SD1, "\n\r", s);
}
if(wait_for_ack){
if((serialInBuf[0] = msg_seq) && (serialInBuf[8]==1)){
wait_for_ack = 0;
chprintf((BaseSequentialStream*)&SD1, "Acknowledged.\n\r");
}
//else keep trying to send.
}
}
chSchDoYieldS();
}
return 0;
}
/**
* @return true if legacy command was processed, false otherwise
*/
bool handlePlainCommand(ts_channel_s *tsChannel, uint8_t command) {
if (command == TS_HELLO_COMMAND || command == TS_HELLO_COMMAND_DEPRECATED) {
scheduleMsg(&tsLogger, "Got naked Query command");
handleQueryCommand(tsChannel, TS_PLAIN);
return true;
} else if (command == 't' || command == 'T') {
handleTestCommand(tsChannel);
return true;
} else if (command == TS_PAGE_COMMAND) {
int recieved = chnReadTimeout(tsChannel->channel, (uint8_t * )&pageIn, sizeof(pageIn), TS_READ_TIMEOUT);
if (recieved != sizeof(pageIn)) {
tunerStudioError("ERROR: not enough for PAGE");
return true;
}
handlePageSelectCommand(tsChannel, TS_PLAIN, pageIn);
return true;
} else if (command == TS_BURN_COMMAND) {
scheduleMsg(&tsLogger, "Got naked BURN");
uint16_t page;
int recieved = chnReadTimeout(tsChannel->channel, (uint8_t * )&page, sizeof(page), TS_READ_TIMEOUT);
if (recieved != sizeof(page)) {
tunerStudioError("ERROR: Not enough for plain burn");
return true;
}
handleBurnCommand(tsChannel, TS_PLAIN, page);
return true;
} else if (command == TS_CHUNK_WRITE_COMMAND) {
scheduleMsg(&tsLogger, "Got naked CHUNK_WRITE");
int recieved = chnReadTimeout(tsChannel->channel, (uint8_t * )&writeChunkRequest, sizeof(writeChunkRequest),
TS_READ_TIMEOUT);
if (recieved != sizeof(writeChunkRequest)) {
scheduleMsg(&tsLogger, "ERROR: Not enough for plain chunk write header: %d", recieved);
tsState.errorCounter++;
return true;
}
recieved = chnReadTimeout(tsChannel->channel, (uint8_t * )&tsChannel->crcReadBuffer, writeChunkRequest.count,
TS_READ_TIMEOUT);
if (recieved != writeChunkRequest.count) {
scheduleMsg(&tsLogger, "ERROR: Not enough for plain chunk write content: %d while expecting %d", recieved,
writeChunkRequest.count);
tsState.errorCounter++;
return true;
}
currentPageId = writeChunkRequest.page;
handleWriteChunkCommand(tsChannel, TS_PLAIN, writeChunkRequest.offset, writeChunkRequest.count,
(uint8_t *) &tsChannel->crcReadBuffer);
return true;
} else if (command == TS_READ_COMMAND) {
//scheduleMsg(logger, "Got naked READ PAGE???");
int recieved = chnReadTimeout(tsChannel->channel, (uint8_t * )&readRequest, sizeof(readRequest),
TS_READ_TIMEOUT);
if (recieved != sizeof(readRequest)) {
tunerStudioError("Not enough for plain read header");
return true;
}
handlePageReadCommand(tsChannel, TS_PLAIN, readRequest.page, readRequest.offset, readRequest.count);
return true;
} else if (command == TS_OUTPUT_COMMAND) {
//scheduleMsg(logger, "Got naked Channels???");
handleOutputChannelsCommand(tsChannel, TS_PLAIN);
return true;
} else if (command == TS_LEGACY_HELLO_COMMAND) {
tunerStudioDebug("ignoring LEGACY_HELLO_COMMAND");
return true;
} else if (command == TS_COMMAND_F) {
tunerStudioDebug("not ignoring F");
tunerStudioWriteData(tsChannel, (const uint8_t *) PROTOCOL, strlen(PROTOCOL));
return true;
} else {
return false;
}
}
void runBinaryProtocolLoop(ts_channel_s *tsChannel, bool_t isConsoleRedirect) {
int wasReady = false;
while (true) {
int isReady = ts_serial_ready(isConsoleRedirect);
if (!isReady) {
chThdSleepMilliseconds(10);
wasReady = false;
continue;
}
if (!wasReady) {
wasReady = true;
// scheduleSimpleMsg(&logger, "ts channel is now ready ", hTimeNow());
}
tsState.tsCounter++;
int recieved = chnReadTimeout(tsChannel->channel, &firstByte, 1, TS_READ_TIMEOUT);
if (recieved != 1) {
// tunerStudioError("ERROR: no command");
continue;
}
// scheduleMsg(logger, "Got first=%x=[%c]", firstByte, firstByte);
if (handlePlainCommand(tsChannel, firstByte))
continue;
recieved = chnReadTimeout(tsChannel->channel, &secondByte, 1, TS_READ_TIMEOUT);
if (recieved != 1) {
tunerStudioError("ERROR: no second");
continue;
}
// scheduleMsg(logger, "Got secondByte=%x=[%c]", secondByte, secondByte);
uint32_t incomingPacketSize = firstByte * 256 + secondByte;
if (incomingPacketSize == BINARY_SWITCH_TAG) {
// we are here if we get a binary switch request while already in binary mode. We will just ignore it.
tunerStudioWriteData(tsChannel, (const uint8_t *) &BINARY_RESPONSE, 2);
continue;
}
if (incomingPacketSize == 0 || incomingPacketSize > (sizeof(tsChannel->crcReadBuffer) - CRC_WRAPPING_SIZE)) {
scheduleMsg(&tsLogger, "TunerStudio: invalid size: %d", incomingPacketSize);
tunerStudioError("ERROR: CRC header size");
sendErrorCode(tsChannel);
continue;
}
recieved = chnReadTimeout(tsChannel->channel, (uint8_t* )tsChannel->crcReadBuffer, 1, TS_READ_TIMEOUT);
if (recieved != 1) {
tunerStudioError("ERROR: did not receive command");
continue;
}
char command = tsChannel->crcReadBuffer[0];
if (!isKnownCommand(command)) {
scheduleMsg(&tsLogger, "unexpected command %x", command);
sendErrorCode(tsChannel);
continue;
}
// scheduleMsg(logger, "TunerStudio: reading %d+4 bytes(s)", incomingPacketSize);
recieved = chnReadTimeout(tsChannel->channel, (uint8_t * ) (tsChannel->crcReadBuffer + 1),
incomingPacketSize + CRC_VALUE_SIZE - 1, TS_READ_TIMEOUT);
int expectedSize = incomingPacketSize + CRC_VALUE_SIZE - 1;
if (recieved != expectedSize) {
scheduleMsg(&tsLogger, "got ONLY %d for packet size %d/%d for command %c", recieved, incomingPacketSize,
expectedSize, command);
tunerStudioError("ERROR: not enough");
continue;
}
uint32_t expectedCrc = *(uint32_t*) (tsChannel->crcReadBuffer + incomingPacketSize);
expectedCrc = SWAP_UINT32(expectedCrc);
uint32_t actualCrc = crc32(tsChannel->crcReadBuffer, incomingPacketSize);
if (actualCrc != expectedCrc) {
scheduleMsg(&tsLogger, "TunerStudio: CRC %x %x %x %x", tsChannel->crcReadBuffer[incomingPacketSize + 0],
tsChannel->crcReadBuffer[incomingPacketSize + 1], tsChannel->crcReadBuffer[incomingPacketSize + 2],
tsChannel->crcReadBuffer[incomingPacketSize + 3]);
scheduleMsg(&tsLogger, "TunerStudio: command %c actual CRC %x/expected %x", tsChannel->crcReadBuffer[0],
actualCrc, expectedCrc);
tunerStudioError("ERROR: CRC issue");
continue;
}
// scheduleMsg(logger, "TunerStudio: P00-07 %x %x %x %x %x %x %x %x", crcIoBuffer[0], crcIoBuffer[1],
// crcIoBuffer[2], crcIoBuffer[3], crcIoBuffer[4], crcIoBuffer[5], crcIoBuffer[6], crcIoBuffer[7]);
int success = tunerStudioHandleCrcCommand(tsChannel, tsChannel->crcReadBuffer, incomingPacketSize);
if (!success)
print("got unexpected TunerStudio command %x:%c\r\n", command, command);
}
}
CCM_FUNC static THD_FUNCTION(ThreadSDU, arg)
{
(void)arg;
uint8_t in_buffer[SERIAL_BUFFERS_SIZE];
uint8_t out_buffer[SERIAL_BUFFERS_SIZE];
//uint8_t buffer_check[SERIAL_BUFFERS_SIZE/2];
size_t in, out;
thread_t* th_shell = NULL;
chRegSetThreadName("SDU");
while(USBD1.state != USB_READY) chThdSleepMilliseconds(10);
while(SDU1.state != SDU_READY) chThdSleepMilliseconds(10);
while(SD3.state != SD_READY) chThdSleepMilliseconds(10);
// Enable K-line transceiver
palSetPad(PORT_KLINE_CS, PAD_KLINE_CS);
shellInit();
while (TRUE) {
if (settings.serialMode == SERIAL_MODE_SHELL) {
if (th_shell == NULL || chThdTerminatedX(th_shell)) {
th_shell = shellCreateStatic(&shell_cfg1, waThreadShell, sizeof(waThreadShell), NORMALPRIO +1);
}
chThdSleepMilliseconds(10);
continue;
}
if (settings.serialMode != SERIAL_MODE_KLINE) {
chThdSleepMilliseconds(10);
continue;
}
/* In case we stop it to change baudrate */
while (SD3.state != SD_READY) chThdSleepMilliseconds(10);
if (doKLineInit && 0)
{
sdStop(&SD3);
klineInit(false);
//fiveBaudInit(&SD3);
//sdReadTimeout(&SD3, buffer_check, 1, MS2ST(5)); // noise
doKLineInit = false;
sdStart(&SD3, &uart1Cfg);
}
in = chnReadTimeout(&SDU1, in_buffer, sizeof(in_buffer), TIME_IMMEDIATE);
out = sdReadTimeout(&SD3, out_buffer, sizeof(out_buffer), TIME_IMMEDIATE);
while (in == 0 && out == 0) {
chThdSleepMilliseconds(1);
in = chnReadTimeout(&SDU1, in_buffer, sizeof(in_buffer), TIME_IMMEDIATE);
out = sdReadTimeout(&SD3, out_buffer, sizeof(out_buffer), TIME_IMMEDIATE);
}
if (in > 0)
{
sdWriteTimeout(&SD3, in_buffer, in, MS2ST(10));
}
if (out > 0)
{
chnWriteTimeout(&SDU1, out_buffer, out, MS2ST(10));
}
}
return;
}
static msg_t tsThreadEntryPoint(void *arg) {
(void) arg;
chRegSetThreadName("tunerstudio thread");
int wasReady = false;
while (true) {
int isReady = ts_serail_ready();
if (!isReady) {
chThdSleepMilliseconds(10);
wasReady = false;
continue;
}
if (!wasReady) {
wasReady = TRUE;
// scheduleSimpleMsg(&logger, "ts channel is now ready ", hTimeNow());
}
tsCounter++;
int recieved = chSequentialStreamRead(getTsSerialDevice(), &firstByte, 1);
if (recieved != 1) {
tunerStudioError("ERROR: no command");
continue;
}
// scheduleMsg(&logger, "Got first=%x=[%c]", firstByte, firstByte);
if (handlePlainCommand(firstByte))
continue;
recieved = chSequentialStreamRead(getTsSerialDevice(), &secondByte, 1);
if (recieved != 1) {
tunerStudioError("ERROR: no second");
continue;
}
// scheduleMsg(&logger, "Got secondByte=%x=[%c]", secondByte, secondByte);
uint32_t incomingPacketSize = firstByte * 256 + secondByte;
if (incomingPacketSize == 0 || incomingPacketSize > (sizeof(crcIoBuffer) - CRC_WRAPPING_SIZE)) {
scheduleMsg(&logger, "TunerStudio: invalid size: %d", incomingPacketSize);
tunerStudioError("ERROR: size");
sendErrorCode();
continue;
}
recieved = chnReadTimeout(getTsSerialDevice(), crcIoBuffer, 1, MS2ST(TS_READ_TIMEOUT));
if (recieved != 1) {
tunerStudioError("ERROR: did not receive command");
continue;
}
char command = crcIoBuffer[0];
if (!isKnownCommand(command)) {
scheduleMsg(&logger, "unexpected command %x", command);
sendErrorCode();
continue;
}
// scheduleMsg(&logger, "TunerStudio: reading %d+4 bytes(s)", incomingPacketSize);
recieved = chnReadTimeout(getTsSerialDevice(), (uint8_t * ) (crcIoBuffer + 1), incomingPacketSize + CRC_VALUE_SIZE - 1,
MS2ST(TS_READ_TIMEOUT));
int expectedSize = incomingPacketSize + CRC_VALUE_SIZE - 1;
if (recieved != expectedSize) {
scheduleMsg(&logger, "got ONLY %d for packet size %d/%d for command %c", recieved, incomingPacketSize,
expectedSize, command);
tunerStudioError("ERROR: not enough");
continue;
}
uint32_t expectedCrc = *(uint32_t*) (crcIoBuffer + incomingPacketSize);
expectedCrc = SWAP_UINT32(expectedCrc);
uint32_t actualCrc = crc32(crcIoBuffer, incomingPacketSize);
if (actualCrc != expectedCrc) {
scheduleMsg(&logger, "TunerStudio: CRC %x %x %x %x", crcIoBuffer[incomingPacketSize + 0],
crcIoBuffer[incomingPacketSize + 1], crcIoBuffer[incomingPacketSize + 2],
crcIoBuffer[incomingPacketSize + 3]);
scheduleMsg(&logger, "TunerStudio: command %c actual CRC %x/expected %x", crcIoBuffer[0], actualCrc,
expectedCrc);
tunerStudioError("ERROR: CRC issue");
continue;
}
// scheduleMsg(&logger, "TunerStudio: P00-07 %x %x %x %x %x %x %x %x", crcIoBuffer[0], crcIoBuffer[1],
// crcIoBuffer[2], crcIoBuffer[3], crcIoBuffer[4], crcIoBuffer[5], crcIoBuffer[6], crcIoBuffer[7]);
int success = tunerStudioHandleCrcCommand(crcIoBuffer, incomingPacketSize);
if (!success)
print("got unexpected TunerStudio command %x:%c\r\n", command, command);
}
#if defined __GNUC__
return 0;
#endif
}
