// Copies the serial_slave_buffer to the master and sends the
// serial_master_buffer to the slave.
//
// Returns:
// 0 => no error
// 1 => slave did not respond
int serial_update_buffers(void) {
// this code is very time dependent, so we need to disable interrupts
cli();
// signal to the slave that we want to start a transaction
serial_output();
serial_low();
_delay_us(1);
// wait for the slaves response
serial_input();
serial_high();
_delay_us(SERIAL_DELAY);
// check if the slave is present
if (serial_read_pin()) {
// slave failed to pull the line low, assume not present
sei();
return 1;
}
// if the slave is present syncronize with it
sync_recv();
uint8_t checksum_computed = 0;
// receive data from the slave
for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
serial_slave_buffer[i] = serial_read_byte();
sync_recv();
checksum_computed += serial_slave_buffer[i];
}
uint8_t checksum_received = serial_read_byte();
sync_recv();
if (checksum_computed != checksum_received) {
sei();
return 1;
}
uint8_t checksum = 0;
// send data to the slave
for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
serial_write_byte(serial_master_buffer[i]);
sync_recv();
checksum += serial_master_buffer[i];
}
serial_write_byte(checksum);
sync_recv();
// always, release the line when not in use
serial_output();
serial_high();
sei();
return 0;
}
uint8_t configure_serial_drv(void)
{
#if UART_FLOWCONTROL_4WIRE_MODE == true
usart_configure_flowcontrol();
#warning "This mode works only if Flow Control Permanently Enabled in the BTLC1000"
#else
struct usart_config config_usart;
usart_get_config_defaults(&config_usart);
config_usart.baudrate = CONF_BLE_BAUDRATE;
config_usart.generator_source = CONF_BLE_UART_CLOCK;
config_usart.mux_setting = CONF_BLE_MUX_SETTING;
config_usart.pinmux_pad0 = CONF_BLE_PINMUX_PAD0;
config_usart.pinmux_pad1 = CONF_BLE_PINMUX_PAD1;
config_usart.pinmux_pad2 = CONF_BLE_PINMUX_PAD2;
config_usart.pinmux_pad3 = CONF_BLE_PINMUX_PAD3;
while (usart_init(&usart_instance, CONF_BLE_USART_MODULE, &config_usart) != STATUS_OK);
usart_enable(&usart_instance);
/* register and enable usart callbacks */
usart_register_callback(&usart_instance,
serial_drv_read_cb, USART_CALLBACK_BUFFER_RECEIVED);
usart_register_callback(&usart_instance,
serial_drv_write_cb, USART_CALLBACK_BUFFER_TRANSMITTED);
usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_TRANSMITTED);
serial_read_byte(&rx_data);
#endif
return STATUS_OK;
}
/* === IMPLEMENTATION ====================================================== */
static inline void usart_configure_flowcontrol(void)
{
struct usart_config config_usart;
#if UART_FLOWCONTROL_6WIRE_MODE == true
usart_disable(&usart_instance);
usart_reset(&usart_instance);
#endif
usart_get_config_defaults(&config_usart);
config_usart.baudrate = CONF_FLCR_BLE_BAUDRATE;
config_usart.generator_source = CONF_FLCR_BLE_UART_CLOCK;
config_usart.mux_setting = CONF_FLCR_BLE_MUX_SETTING;
config_usart.pinmux_pad0 = CONF_FLCR_BLE_PINMUX_PAD0;
config_usart.pinmux_pad1 = CONF_FLCR_BLE_PINMUX_PAD1;
config_usart.pinmux_pad2 = CONF_FLCR_BLE_PINMUX_PAD2;
config_usart.pinmux_pad3 = CONF_FLCR_BLE_PINMUX_PAD3;
while (usart_init(&usart_instance, CONF_FLCR_BLE_USART_MODULE, &config_usart) != STATUS_OK);
usart_enable(&usart_instance);
/* register and enable usart callbacks */
usart_register_callback(&usart_instance,
serial_drv_read_cb, USART_CALLBACK_BUFFER_RECEIVED);
usart_register_callback(&usart_instance,
serial_drv_write_cb, USART_CALLBACK_BUFFER_TRANSMITTED);
usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_TRANSMITTED);
serial_read_byte(&rx_data);
}
int readpacket(uint8_t *packet_buf, size_t size)
{
uint8_t *line_buf_ptr = packet_buf;
uint8_t byte = END + 1;
uint8_t esc = 0;
uint8_t translate = 1;
while ((line_buf_ptr - packet_buf) < size - 1) {
byte = serial_read_byte();
if (translate && byte == END) {
break;
}
if (line_buf_ptr == packet_buf && byte != 0) {
translate = 0;
}
if (line_buf_ptr > packet_buf && !translate && byte == '\n') {
*line_buf_ptr++ = '\0';
return line_buf_ptr - packet_buf;
}
if (translate) {
if (esc) {
esc = 0;
switch(byte) {
case (END_ESC): {
*line_buf_ptr++ = END;
continue;
}
case (ESC_ESC): {
*line_buf_ptr++ = ESC;
continue;
}
default:
continue;
}
}
if (byte == ESC) {
esc = 1;
continue;
}
}
*line_buf_ptr++ = byte;
}
return (line_buf_ptr - packet_buf);
}
void platfrom_start_rx(void)
{
serial_read_byte(&rx_data);
}
void ta(int pi)
{
int h, b, e;
char *TEXT;
char text[2048];
printf("Serial link tests.\n");
/* this test needs RXD and TXD to be connected */
h = serial_open(pi, "/dev/ttyAMA0", 57600, 0);
CHECK(10, 1, h, 0, 0, "serial open");
time_sleep(0.1); /* allow time for transmission */
b = serial_read(pi, h, text, sizeof(text)); /* flush buffer */
b = serial_data_available(pi, h);
CHECK(10, 2, b, 0, 0, "serial data available");
TEXT = "\
To be, or not to be, that is the question-\
Whether 'tis Nobler in the mind to suffer\
The Slings and Arrows of outrageous Fortune,\
Or to take Arms against a Sea of troubles,\
";
e = serial_write(pi, h, TEXT, strlen(TEXT));
CHECK(10, 3, e, 0, 0, "serial write");
e = serial_write_byte(pi, h, 0xAA);
e = serial_write_byte(pi, h, 0x55);
e = serial_write_byte(pi, h, 0x00);
e = serial_write_byte(pi, h, 0xFF);
CHECK(10, 4, e, 0, 0, "serial write byte");
time_sleep(0.1); /* allow time for transmission */
b = serial_data_available(pi, h);
CHECK(10, 5, b, strlen(TEXT)+4, 0, "serial data available");
b = serial_read(pi, h, text, strlen(TEXT));
CHECK(10, 6, b, strlen(TEXT), 0, "serial read");
if (b >= 0) text[b] = 0;
CHECK(10, 7, strcmp(TEXT, text), 0, 0, "serial read");
b = serial_read_byte(pi, h);
CHECK(10, 8, b, 0xAA, 0, "serial read byte");
b = serial_read_byte(pi, h);
CHECK(10, 9, b, 0x55, 0, "serial read byte");
b = serial_read_byte(pi, h);
CHECK(10, 10, b, 0x00, 0, "serial read byte");
b = serial_read_byte(pi, h);
CHECK(10, 11, b, 0xFF, 0, "serial read byte");
b = serial_data_available(pi, h);
CHECK(10, 12, b, 0, 0, "serial data availabe");
e = serial_close(pi, h);
CHECK(10, 13, e, 0, 0, "serial close");
}
