123 lines
3.4 KiB
C
123 lines
3.4 KiB
C
// Generic interrupt based serial uart helper code
|
|
//
|
|
// Copyright (C) 2016-2018 Kevin O'Connor <kevin@koconnor.net>
|
|
//
|
|
// This file may be distributed under the terms of the GNU GPLv3 license.
|
|
|
|
#include <string.h> // memmove
|
|
#include "autoconf.h" // CONFIG_SERIAL_BAUD
|
|
#include "board/io.h" // readb
|
|
#include "board/irq.h" // irq_save
|
|
#include "board/misc.h" // console_sendf
|
|
#include "board/pgm.h" // READP
|
|
#include "command.h" // DECL_CONSTANT
|
|
#include "sched.h" // sched_wake_tasks
|
|
#include "serial_irq.h" // serial_enable_tx_irq
|
|
|
|
#define RX_BUFFER_SIZE 192
|
|
|
|
static uint8_t receive_buf[RX_BUFFER_SIZE], receive_pos;
|
|
static uint8_t transmit_buf[96], transmit_pos, transmit_max;
|
|
|
|
DECL_CONSTANT(SERIAL_BAUD, CONFIG_SERIAL_BAUD);
|
|
DECL_CONSTANT(RECEIVE_WINDOW, RX_BUFFER_SIZE);
|
|
|
|
// Rx interrupt - store read data
|
|
void
|
|
serial_rx_byte(uint_fast8_t data)
|
|
{
|
|
if (data == MESSAGE_SYNC)
|
|
sched_wake_tasks();
|
|
if (receive_pos >= sizeof(receive_buf))
|
|
// Serial overflow - ignore it as crc error will force retransmit
|
|
return;
|
|
receive_buf[receive_pos++] = data;
|
|
}
|
|
|
|
// Tx interrupt - get next byte to transmit
|
|
int
|
|
serial_get_tx_byte(uint8_t *pdata)
|
|
{
|
|
if (transmit_pos >= transmit_max)
|
|
return -1;
|
|
*pdata = transmit_buf[transmit_pos++];
|
|
return 0;
|
|
}
|
|
|
|
// Remove from the receive buffer the given number of bytes
|
|
static void
|
|
console_pop_input(uint_fast8_t len)
|
|
{
|
|
uint_fast8_t copied = 0;
|
|
for (;;) {
|
|
uint_fast8_t rpos = readb(&receive_pos);
|
|
uint_fast8_t needcopy = rpos - len;
|
|
if (needcopy) {
|
|
memmove(&receive_buf[copied], &receive_buf[copied + len]
|
|
, needcopy - copied);
|
|
copied = needcopy;
|
|
sched_wake_tasks();
|
|
}
|
|
irqstatus_t flag = irq_save();
|
|
if (rpos != readb(&receive_pos)) {
|
|
// Raced with irq handler - retry
|
|
irq_restore(flag);
|
|
continue;
|
|
}
|
|
receive_pos = needcopy;
|
|
irq_restore(flag);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Process any incoming commands
|
|
void
|
|
console_task(void)
|
|
{
|
|
uint_fast8_t rpos = readb(&receive_pos), pop_count;
|
|
int_fast8_t ret = command_find_block(receive_buf, rpos, &pop_count);
|
|
if (ret > 0)
|
|
command_dispatch(receive_buf, pop_count);
|
|
if (ret) {
|
|
console_pop_input(pop_count);
|
|
if (ret > 0)
|
|
command_send_ack();
|
|
}
|
|
}
|
|
DECL_TASK(console_task);
|
|
|
|
// Encode and transmit a "response" message
|
|
void
|
|
console_sendf(const struct command_encoder *ce, va_list args)
|
|
{
|
|
// Verify space for message
|
|
uint_fast8_t tpos = readb(&transmit_pos), tmax = readb(&transmit_max);
|
|
if (tpos >= tmax) {
|
|
tpos = tmax = 0;
|
|
writeb(&transmit_max, 0);
|
|
writeb(&transmit_pos, 0);
|
|
}
|
|
uint_fast8_t max_size = READP(ce->max_size);
|
|
if (tmax + max_size > sizeof(transmit_buf)) {
|
|
if (tmax + max_size - tpos > sizeof(transmit_buf))
|
|
// Not enough space for message
|
|
return;
|
|
// Disable TX irq and move buffer
|
|
writeb(&transmit_max, 0);
|
|
tpos = readb(&transmit_pos);
|
|
tmax -= tpos;
|
|
memmove(&transmit_buf[0], &transmit_buf[tpos], tmax);
|
|
writeb(&transmit_pos, 0);
|
|
writeb(&transmit_max, tmax);
|
|
serial_enable_tx_irq();
|
|
}
|
|
|
|
// Generate message
|
|
uint8_t *buf = &transmit_buf[tmax];
|
|
uint_fast8_t msglen = command_encode_and_frame(buf, ce, args);
|
|
|
|
// Start message transmit
|
|
writeb(&transmit_max, tmax + msglen);
|
|
serial_enable_tx_irq();
|
|
}
|