flm01/mote/v2/avr/basiciotest.c

174 lines
4.3 KiB
C

//
// basiciotest.c : test code for the io and buffer ops of the UART and SPI ports
//
// Copyright (c) 2010 flukso.net
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
// $Id$
#include <avr/io.h> // include I/O definitions (port names, pin names, etc)
#include <avr/interrupt.h> // include interrupt support
#include "uart.h" // include uart function library
#include "spi.h"
#include "ctrl.h"
#define NO_OP_1 1
#define NO_OP_2 2
#define TRANSMIT 4
#define HIGH_HEX 8
#define TO_FROM_UART 16
#define NEW_CTRL_MSG 32
#define SPI_END_OF_TX 0x00
#define SPI_END_OF_MESSAGE ':'
#define SPI_FORWARD_TO_UART_PORT 'u'
#define SPI_FORWARD_TO_CTRL_PORT 'l'
volatile uint8_t high_hex;
volatile uint8_t spi_status;
uint8_t htoi(uint16_t hex) {
uint8_t low_hex = (uint8_t) hex;
uint8_t high_hex = (uint8_t) (hex >> 8);
uint8_t byte;
byte = (high_hex > 0x40) ? (high_hex & 0x0F) + 9 : high_hex & 0x0F;
byte = byte << 4;
byte |= (low_hex > 0x40) ? (low_hex & 0x0F) + 9 : low_hex & 0x0F;
return byte;
}
uint16_t itoh(uint8_t byte) {
uint8_t low_nibble = (byte & 0x0F);
uint8_t high_nibble = (byte & 0xF0) >> 4;
uint16_t hex;
hex = (high_nibble > 0x09) ? high_nibble - 9 + 0x60 : high_nibble + 0x30;
hex = hex << 8;
hex |= (low_nibble > 0x09) ? low_nibble - 9 + 0x60 : low_nibble + 0x30;
return hex;
}
SIGNAL(SPI_STC_vect) {
uint8_t spi_rx, spi_tx, uart_tx;
if (spi_status & (NO_OP_1 | NO_OP_2)) {
spi_status--;
return;
}
// are we in transmit mode?
if (spi_status & TRANSMIT) {
if (spi_status & TO_FROM_UART) {
}
else {
if (ctrlGetFromTxBuffer(&spi_tx)) {
received_from_spi(spi_tx);
}
else {
received_from_spi(SPI_END_OF_TX);
spi_status &= ~TRANSMIT;
spi_status |= NO_OP_2;
uartAddToTxBuffer('r'); //debugging
}
}
return;
}
// switch (spi_rx = received_from_spi(ctrlGetFromTxBuffer())) {
switch (spi_rx = received_from_spi(0x00)) {
case SPI_END_OF_TX:
spi_status |= TRANSMIT;
spi_status &= ~(HIGH_HEX | TO_FROM_UART);
uartAddToTxBuffer('t'); //debugging
break;
case SPI_END_OF_MESSAGE:
if (spi_status & TO_FROM_UART) {
spi_status &= ~TO_FROM_UART;
}
else {
ctrlAddToRxBuffer(spi_rx);
spi_status |= NEW_CTRL_MSG;
}
break;
case SPI_FORWARD_TO_UART_PORT:
spi_status |= TO_FROM_UART;
break;
default:
//check whether the incoming hex-encoded stream needs to be forwarded to the UART port
if (spi_status & TO_FROM_UART) {
if (spi_status & HIGH_HEX) {
uart_tx = htoi(((uint16_t)high_hex << 8) + spi_rx);
uartAddToTxBuffer(uart_tx);
}
else {
high_hex = spi_rx;
}
// toggle to the HEX bit in spi_status
spi_status ^= HIGH_HEX;
}
else {
// forward to CTRL_RX buffer
ctrlAddToRxBuffer(spi_rx);
}
}
}
int main(void) {
// initialize the CTRL buffers
ctrlInit();
// initialize the UART buffers with a default UART baud rate of 4800
uartInit();
// initialize the SPI in slave mode
setup_spi(SPI_MODE_0, SPI_MSB, SPI_INTERRUPT, SPI_SLAVE);
uint8_t data;
uint16_t send;
for(;;) {
if (uartReceiveByte(&data)) {
// check the HEX bit in spi_status
if (spi_status & HIGH_HEX) {
// loopback on the UART itf
send = itoh(htoi(((uint16_t)high_hex << 8) + data));
uartAddToTxBuffer((uint8_t)(send >> 8));
uartAddToTxBuffer((uint8_t)(send));
}
else {
high_hex = data;
}
// toggle to the HEX bit in spi_status
spi_status ^= HIGH_HEX;
}
if (spi_status & NEW_CTRL_MSG) {
ctrlLoop();
spi_status &= ~NEW_CTRL_MSG;
}
}
return 0;
}