MicroAPRS/Modem/main.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

#include "afsk.h"           // Header for AFSK modem
#include "protocol/mp1.h"   // Header for MP.1 protocol

#if SERIAL_DEBUG
    #include "cfg/debug.h"  // Debug configuration from BertOS
#endif


//////////////////////////////////////////////////////
// A few definitions                                //
//////////////////////////////////////////////////////

static Afsk afsk;           // Declare a AFSK modem struct
static MP1 mp1;             // 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[MP1_MAX_DATA_SIZE];	// This is a buffer for 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 < MP1_MAX_DATA_SIZE-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 mp1Callback(struct MP1Packet *packet) {
    if (SERIAL_DEBUG) {
        kfile_printf(&ser.fd, "%.*s\n", packet->dataLength, packet->data);
    } else {
        for (unsigned long i = 0; i < packet->dataLength; i++) {
            kfile_putc(packet->data[i], &ser.fd);
        }
    }
}

// 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
    mp1Init(&mp1, &afsk.fd, mp1Callback);

    // 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();
    #if MP1_USE_TX_QUEUE
        ticks_t frameQueued = 0;
    #endif
    
    // Go into ye good ol' infinite loop
    while (1)
    {    
        // First we instruct the protocol to check for
        // incoming data
        mp1Poll(&mp1);

        
        // If there was actually some data waiting for us
        // there, let's se what it tastes like :)
        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 < MP1_MAX_DATA_SIZE) && (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 < MP1_MAX_DATA_SIZE-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;
            }
        }

        // Check whether we should send data in our serial buffer
        if (sertx) {
            #if MP1_USE_TX_QUEUE
                mp1QueueFrame(&mp1, serialBuffer, serialLen);
                frameQueued = timer_clock();
                sertx = false;
                serialLen = 0;
            #else
                // Wait until incoming packets are done
                if (!mp1CarrierSense(&mp1)) {
                    // And then send the data
                    mp1Send(&mp1, serialBuffer, serialLen);
                    
                    // Reset the transmission flag and length counter
                    sertx = false;
                    serialLen = 0;
                }
            #endif
        }

        #if MP1_USE_TX_QUEUE
            // We first wait a little to see if more
            // frames are coming in.
            if (timer_clock() - frameQueued > ms_to_ticks(MP1_QUEUE_TX_WAIT)) {
                if (!ser_available(&ser) && !mp1CarrierSense(&mp1)) {
                    // And if not, we send process the frame
                    // queue if possible.
                    mp1ProcessQueue(&mp1);
                }
            }
        #endif
    }
    return 0;
}