176 lines
5.9 KiB
C
176 lines
5.9 KiB
C
|
|
//////////////////////////////////////////////////////
|
|
// First things first, all the includes we need //
|
|
//////////////////////////////////////////////////////
|
|
|
|
#include <cpu/irq.h> // Interrupt functionality from BertOS
|
|
|
|
#include <drv/ser.h> // Serial driver from BertOS
|
|
#include <drv/timer.h> // Timer driver from BertOS
|
|
|
|
#include <stdio.h> // Standard input/output
|
|
#include <string.h> // String operations
|
|
#define F_CPU 16000000UL
|
|
#include <util/delay.h>
|
|
|
|
#include <net/ax25.h>
|
|
|
|
#include "afsk.h" // Header for AFSK modem
|
|
|
|
|
|
#include "protocol/SimpleSerial.h" // Simple serial control protocol
|
|
#include "protocol/KISS.h" // KISS TNC protocol
|
|
|
|
#if SERIAL_DEBUG
|
|
#include "cfg/debug.h" // Debug configuration from BertOS
|
|
#endif
|
|
|
|
#define SERIAL_PROTOCOL PROTOCOL_SIMPLE_SERIAL
|
|
|
|
//////////////////////////////////////////////////////
|
|
// A few definitions //
|
|
//////////////////////////////////////////////////////
|
|
|
|
static Afsk afsk; // Declare a AFSK modem struct
|
|
static AX25Ctx ax25; // Declare a protocol struct
|
|
static Serial ser; // Declare a serial interface struct
|
|
|
|
#define ADC_CH 0 // Define which channel (pin) we want
|
|
// for the ADC (this is A0 on arduino)
|
|
|
|
|
|
static uint8_t serialBuffer[CONFIG_AX25_FRAME_BUF_LEN+1]; // Buffer for holding incoming serial data
|
|
static int sbyte; // For holding byte read from serial port
|
|
static size_t serialLen = 0; // Counter for counting length of data from serial
|
|
static bool sertx = false; // Flag signifying whether it's time to send data
|
|
// received on the serial port.
|
|
|
|
#define SER_BUFFER_FULL (serialLen < CONFIG_AX25_FRAME_BUF_LEN-1)
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////
|
|
// And here comes the actual program :) //
|
|
//////////////////////////////////////////////////////
|
|
|
|
// This is a callback we register with the protocol,
|
|
// so we can process each packet as they are decoded.
|
|
// Right now it just prints the packet to the serial port.
|
|
static void message_callback(struct AX25Msg *msg)
|
|
{
|
|
if (SERIAL_PROTOCOL == PROTOCOL_SIMPLE_SERIAL) {
|
|
ss_messageCallback(msg, &ser);
|
|
}
|
|
if (SERIAL_PROTOCOL == PROTOCOL_KISS) {
|
|
// Not implemented yet
|
|
}
|
|
}
|
|
|
|
// Simple initialization function.
|
|
static void init(void)
|
|
{
|
|
// Enable interrupts
|
|
IRQ_ENABLE;
|
|
|
|
// Initialize hardware timers
|
|
timer_init();
|
|
|
|
// Initialize serial comms on UART0,
|
|
// which is the hardware serial on arduino
|
|
ser_init(&ser, SER_UART0);
|
|
ser_setbaudrate(&ser, 9600);
|
|
|
|
// For some reason BertOS sets the serial
|
|
// to 7 bit characters by default. We set
|
|
// it to 8 instead.
|
|
UCSR0C = _BV(UCSZ01) | _BV(UCSZ00);
|
|
|
|
// Create a modem context
|
|
afsk_init(&afsk, ADC_CH);
|
|
// ... and a protocol context with the modem
|
|
ax25_init(&ax25, &afsk.fd, message_callback);
|
|
|
|
// Init SimpleSerial
|
|
ss_init(&ax25);
|
|
|
|
// That's all!
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
// Start by running the main initialization
|
|
init();
|
|
// Record the current tick count for time-keeping
|
|
ticks_t start = timer_clock();
|
|
|
|
// Go into ye good ol' infinite loop
|
|
while (1)
|
|
{
|
|
// First we instruct the protocol to check for
|
|
// incoming data
|
|
ax25_poll(&ax25);
|
|
|
|
// Poll for incoming serial data
|
|
if (!sertx && ser_available(&ser)) {
|
|
// We then read a byte from the serial port.
|
|
// Notice that we use "_nowait" since we can't
|
|
// have this blocking execution until a byte
|
|
// comes in.
|
|
sbyte = ser_getchar_nowait(&ser);
|
|
|
|
// If SERIAL_DEBUG is specified we'll handle
|
|
// serial data as direct human input and only
|
|
// transmit when we get a LF character
|
|
#if SERIAL_DEBUG
|
|
// If we have not yet surpassed the maximum frame length
|
|
// and the byte is not a "transmit" (newline) character,
|
|
// we should store it for transmission.
|
|
if ((serialLen < CONFIG_AX25_FRAME_BUF_LEN) && (sbyte != 10)) {
|
|
// Put the read byte into the buffer;
|
|
serialBuffer[serialLen] = sbyte;
|
|
// Increment the read length counter
|
|
serialLen++;
|
|
} else {
|
|
// If one of the above conditions were actually the
|
|
// case, it means we have to transmit, se we set
|
|
// transmission flag to true.
|
|
sertx = true;
|
|
}
|
|
#else
|
|
// Otherwise we assume the modem is running
|
|
// in automated mode, and we push out data
|
|
// as it becomes available. We either transmit
|
|
// immediately when the max frame length has
|
|
// been reached, or when we get no input for
|
|
// a certain amount of time.
|
|
|
|
if (serialLen < CONFIG_AX25_FRAME_BUF_LEN-1) {
|
|
// Put the read byte into the buffer;
|
|
serialBuffer[serialLen] = sbyte;
|
|
// Increment the read length counter
|
|
serialLen++;
|
|
} else {
|
|
// If max frame length has been reached
|
|
// we need to transmit.
|
|
serialBuffer[serialLen] = sbyte;
|
|
serialLen++;
|
|
sertx = true;
|
|
}
|
|
|
|
start = timer_clock();
|
|
#endif
|
|
} else {
|
|
if (!SERIAL_DEBUG && serialLen > 0 && timer_clock() - start > ms_to_ticks(TX_MAXWAIT)) {
|
|
sertx = true;
|
|
}
|
|
}
|
|
|
|
if (sertx) {
|
|
ss_serialCallback(serialBuffer, serialLen, &ser, &ax25);
|
|
sertx = false;
|
|
serialLen = 0;
|
|
}
|
|
|
|
}
|
|
return 0;
|
|
} |