Can now compile for Arduino with ATmega328 for debugging, added serial library for this purpose.

include/cppm.h

@@ -7,10 +7,21 @@
 
 #include <stdint.h>
 
+#ifdef DEBUG
+
+// Arduino D10
+#define CPPM_PORT PORTB
+#define CPPM_DDR DDRB
+#define CPPM_PIN PB2
+
+#else
+
 #define CPPM_PORT PORTB
 #define CPPM_DDR DDRB
 #define CPPM_PIN PB5
 
+#endif
+
 extern volatile uint16_t cppmData[8];
 
 void cppmInit(void);

include/serial.h

@@ -0,0 +1,125 @@
+/*
+ * serial.h
+ *
+ * Copyright (c) 2012, 2013, Thomas Buck <xythobuz@me.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef _serial_h
+#define _serial_h
+
+/** \addtogroup uart UART Library
+ *  UART Library enabling you to control all available
+ *  UART Modules. With XON/XOFF Flow Control and buffered
+ *  Receiving and Transmitting.
+ *  @{
+ */
+
+/** \file serial.h
+ *  UART Library Header File
+ */
+
+/** Calculate Baudrate Register Value */
+#define BAUD(baudRate,xtalCpu) ((xtalCpu)/((baudRate)*16l)-1)
+
+/** Get number of available UART modules.
+ *  \returns number of modules
+ */
+uint8_t serialAvailable(void);
+
+/** Initialize the UART Hardware.
+ *  \param uart UART Module to initialize
+ *  \param baud Baudrate. Use the BAUD() macro!
+ */
+void serialInit(uint8_t uart, uint16_t baud);
+
+/** Stop the UART Hardware.
+ *  \param uart UART Module to stop
+ */
+void serialClose(uint8_t uart);
+
+/** Manually change the flow control.
+ *  Flow Control has to be compiled into the library!
+ *  \param uart UART Module to operate on
+ *  \param on 1 of on, 0 if off
+ */
+void setFlow(uint8_t uart, uint8_t on);
+
+/** Check if a byte was received.
+ *  \param uart UART Module to check
+ *  \returns 1 if a byte was received, 0 if not
+ */
+uint8_t serialHasChar(uint8_t uart);
+
+/** Read a single byte.
+ *  \param uart UART Module to read from
+ *  \returns Received byte or 0
+ */
+uint8_t serialGet(uint8_t uart);
+
+/** Wait until a character is received.
+ *  \param uart UART Module to read from
+ *  \returns Received byte
+ */
+uint8_t serialGetBlocking(uint8_t uart);
+
+/** Check if the receive buffer is full.
+ *  \param uart UART Module to check
+ *  \returns 1 if buffer is full, 0 if not
+ */
+uint8_t serialRxBufferFull(uint8_t uart);
+
+/** Check if the receive buffer is empty.
+ *  \param uart UART Module to check
+ *  \returns 1 if buffer is empty, 0 if not.
+ */
+uint8_t serialRxBufferEmpty(uint8_t uart);
+
+/** Send a byte.
+ *  \param uart UART Module to write to
+ *  \param data Byte to send
+ */
+void serialWrite(uint8_t uart, uint8_t data);
+
+/** Send a string.
+ *  \param uart UART Module to write to
+ *  \param data Null-Terminated String
+ */
+void serialWriteString(uint8_t uart, const char *data);
+
+/** Check if the transmit buffer is full.
+ *  \param uart UART Module to check
+ *  \returns 1 if buffer is full, 0 if not
+ */
+uint8_t serialTxBufferFull(uint8_t uart);
+
+/** Check if the transmit buffer is empty.
+ *  \param uart UART Module to check
+ *  \returns 1 if buffer is empty, 0 if not.
+ */
+uint8_t serialTxBufferEmpty(uint8_t uart);
+
+#endif // _serial_h
+/** @} */

include/serial_device.h

@@ -0,0 +1,240 @@
+/*
+ * serial_device.h
+ *
+ * Copyright (c) 2012, 2013, Thomas Buck <xythobuz@me.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef _serial_device_h
+#define _serial_device_h
+
+/** \addtogroup uart UART Library
+ *  UART Library enabling you to control all available
+ *  UART Modules. With XON/XOFF Flow Control and buffered
+ *  Receiving and Transmitting.
+ *  @{
+ */
+
+/** \file serial_device.h
+ *  UART Library device-specific configuration.
+ *  Contains Register and Bit Positions for different AVR devices.
+ */
+
+#if  defined(__AVR_ATmega8__) || defined(__AVR_ATmega16__) || defined(__AVR_ATmega32__) \
+    || defined(__AVR_ATmega8515__) || defined(__AVR_ATmega8535__) \
+|| defined(__AVR_ATmega323__)
+
+#define UART_COUNT 1
+#define UART_REGISTERS 6
+#define UART_BITS 7
+volatile uint8_t *serialRegisters[UART_COUNT][UART_REGISTERS] = {{
+    &UDR,
+    &UCSRB,
+    &UCSRC,
+    &UCSRA,
+    &UBRRH,
+    &UBRRL
+}};
+#define SERIALBAUDBIT 8
+uint8_t serialBits[UART_COUNT][UART_BITS] = {{
+    UCSZ0,
+    UCSZ1,
+    RXCIE,
+    RXEN,
+    TXEN,
+    UDRIE,
+    UDRE
+}};
+#define SERIALRECIEVEINTERRUPT USART_RXC_vect
+#define SERIALTRANSMITINTERRUPT USART_UDRE_vect
+ 
+#elif defined(__AVR_ATmega168__) || defined(__AVR_ATmega328__) \
+    || defined(__AVR_ATmega48__) || defined(__AVR_ATmega88__) \
+    || defined(__AVR_ATmega168P__) || defined(__AVR_ATmega328P__) \
+    || defined(__AVR_ATmega48P__) || defined(__AVR_ATmega88P__) 
+
+#define UART_COUNT 1
+#define UART_REGISTERS 5
+#define UART_BITS 7
+volatile uint8_t *serialRegisters[UART_COUNT][UART_REGISTERS] = {{
+    &UDR0,
+    &UCSR0B,
+    &UCSR0C,
+    &UCSR0A
+}};
+#define SERIALBAUDBIT 16
+volatile uint16_t *serialBaudRegisters[UART_COUNT] = {
+    &UBRR0
+};
+uint8_t serialBits[UART_COUNT][UART_BITS] = {{
+    UCSZ00,
+    UCSZ01,
+    RXCIE0,
+    RXEN0,
+    TXEN0,
+    UDRIE0,
+    UDRE0
+}};
+#define SERIALRECIEVEINTERRUPT USART_RX_vect
+#define SERIALTRANSMITINTERRUPT USART_UDRE_vect
+
+#elif defined(__AVR_ATmega2561__) || defined(__AVR_ATmega1281__) || defined(__AVR_ATmega1284P__)
+
+#define UART_COUNT 2
+#define UART_REGISTERS 4
+#define UART_BITS 7
+volatile uint8_t *serialRegisters[UART_COUNT][UART_REGISTERS] = {
+    {
+        &UDR0,
+        &UCSR0B,
+        &UCSR0C,
+        &UCSR0A
+    },
+    {
+        &UDR1,
+        &UCSR1B,
+        &UCSR1C,
+        &UCSR1A
+    }
+};
+#define SERIALBAUDBIT 16
+volatile uint16_t *serialBaudRegisters[UART_COUNT] = {
+    &UBRR0, &UBRR1
+};
+uint8_t serialBits[UART_COUNT][UART_BITS] = {
+    {
+        UCSZ00,
+        UCSZ01,
+        RXCIE0,
+        RXEN0,
+        TXEN0,
+        UDRIE0,
+        UDRE0
+    },
+    {
+        UCSZ10,
+        UCSZ11,
+        RXCIE1,
+        RXEN1,
+        TXEN1,
+        UDRIE1,
+        UDRE1
+    }
+};
+#define SERIALRECIEVEINTERRUPT   USART0_RX_vect
+#define SERIALTRANSMITINTERRUPT  USART0_UDRE_vect
+#define SERIALRECIEVEINTERRUPT1  USART1_RX_vect
+#define SERIALTRANSMITINTERRUPT1 USART1_UDRE_vect
+
+
+#elif defined(__AVR_ATmega2560__) || defined(__AVR_ATmega1280__) \
+    || defined(__AVR_ATmega640__)
+
+#define UART_COUNT 4
+#define UART_REGISTERS 4
+#define UART_BITS 7
+volatile uint8_t *serialRegisters[UART_COUNT][UART_REGISTERS] = {
+    {
+        &UDR0,
+        &UCSR0B,
+        &UCSR0C,
+        &UCSR0A
+    },
+    {
+        &UDR1,
+        &UCSR1B,
+        &UCSR1C,
+        &UCSR1A
+    },
+    {
+        &UDR2,
+        &UCSR2B,
+        &UCSR2C,
+        &UCSR2A
+    },
+    {
+        &UDR3,
+        &UCSR3B,
+        &UCSR3C,
+        &UCSR3A
+    }
+};
+#define SERIALBAUDBIT 16
+volatile uint16_t *serialBaudRegisters[UART_COUNT] = {
+    &UBRR0, &UBRR1, &UBRR2, &UBRR3
+};
+uint8_t serialBits[UART_COUNT][UART_BITS] = {
+    {
+        UCSZ00,
+        UCSZ01,
+        RXCIE0,
+        RXEN0,
+        TXEN0,
+        UDRIE0,
+        UDRE0
+    },
+    {
+        UCSZ10,
+        UCSZ11,
+        RXCIE1,
+        RXEN1,
+        TXEN1,
+        UDRIE1,
+        UDRE1
+    },
+    {
+        UCSZ20,
+        UCSZ21,
+        RXCIE2,
+        RXEN2,
+        TXEN2,
+        UDRIE2,
+        UDRE2
+    },
+    {
+        UCSZ30,
+        UCSZ31,
+        RXCIE3,
+        RXEN3,
+        TXEN3,
+        UDRIE3,
+        UDRE3
+    }
+};
+#define SERIALRECIEVEINTERRUPT   USART0_RX_vect
+#define SERIALTRANSMITINTERRUPT  USART0_UDRE_vect
+#define SERIALRECIEVEINTERRUPT1  USART1_RX_vect
+#define SERIALTRANSMITINTERRUPT1 USART1_UDRE_vect
+#define SERIALRECIEVEINTERRUPT2  USART2_RX_vect
+#define SERIALTRANSMITINTERRUPT2 USART2_UDRE_vect
+#define SERIALRECIEVEINTERRUPT3  USART3_RX_vect
+#define SERIALTRANSMITINTERRUPT3 USART3_UDRE_vect
+
+#else
+#error "AvrSerialLibrary not compatible with your MCU!"
+#endif
+
+#endif // _serial_device_h
+/** @} */

include/spi.h

@@ -8,6 +8,30 @@
 #include <stdint.h>
 #include <avr/io.h>
 
+#ifdef DEBUG
+
+// Arduino D2
+#define SCK_on PORTD |= PD2
+#define SCK_off PORTD &= ~(PD2)
+
+// Arduino D4
+#define MO_on PORTD |= PD4
+#define MO_off PORTD &= ~(PD4)
+
+// Arduino D7
+#define CS_on PORTD |= PD7
+#define CS_off PORTD &= ~(PD7)
+
+// Arduino D8
+#define MI_1 (PINB & PB0) == PB0
+#define MI_0 (PINB & PB0) != PB0
+
+// Arduino D12
+#define GDO_1 (PINB & PB4) == PB4
+#define GDO_0 (PINB & PB4) != PB4
+
+#else
+
 #define SCK_on PORTB |= PB4
 #define SCK_off PORTB &= ~(PB4)
 
@@ -23,6 +47,8 @@
 #define GDO_1 (PINB & PB0) == PB0
 #define GDO_0 (PINB & PB0) != PB0
 
+#endif
+
 #define NOP() __asm__ __volatile__("nop")
 
 void spiInit(void);

makefile

@@ -19,6 +19,10 @@ SRC += src/cc2500.c
 SRC += src/rx.c
 SRC += src/cppm.c
 
+ifeq ($(DEBUG),1)
+	SRC += src/serial.c
+endif
+
 OBJ = $(addprefix $(BUILDDIR)/, $(SRC:.c=.o))
 
 CARGS = -mmcu=$(MCU)
@@ -35,6 +39,10 @@ CARGS += -std=$(CSTANDARD)
 CARGS += -DF_CPU=$(F_CPU)
 CARGS += -ffunction-sections
 
+ifeq ($(DEBUG),1)
+	CARGS += -DDEBUG
+endif
+
 LINKER = -Wl,--relax
 
 PROGRAMMER = avrisp2
@@ -44,6 +52,9 @@ TARGET = rx
 
 all: $(BUILDDIR)/$(TARGET).hex
 
+debug:
+	$(MAKE) BUILDDIR=build/debug TARGET=debug MCU=atmega328 DEBUG=1 all
+
 $(BUILDDIR)/%.o: %.c
 	@$(MKDIR) $(BUILDDIR)/$(dir $<)
 	$(GCC) -c $< -o $@ $(CARGS)
@@ -57,7 +68,10 @@ $(BUILDDIR)/$(TARGET).hex: $(BUILDDIR)/$(TARGET).elf
 	$(OBJDUMP) -h -S $< > $(@:.hex=.lss)
 
 program: $(BUILDDIR)/$(TARGET).hex
-	$(AVRDUDE) -p $(MCU) -c $(PROGRAMMER) -P $(ISPPORT) -e -U $(TARGET).hex
+	$(AVRDUDE) -p $(MCU) -c $(PROGRAMMER) -P $(ISPPORT) -e -U $(BUILDDIR)/$(TARGET).hex
+
+debugProgram:
+	$(MAKE) BUILDDIR=build/debug TARGET=debug MCU=atmega328 DEBUG=1 PROGRAMMER=stk500v1 ISPPORT=/dev/tty.usbserial-A100OZQ1 program
 
 clean:
 	$(RM) $(BUILDDIR)

src/cppm.c

@@ -60,7 +60,12 @@ void cppmInit(void) {
     CPPM_PORT &= ~(1 << CPPM_PIN);
 
     TCCR0B |= (1 << CS01); // Prescaler: 8
+
+#ifdef DEBUG
+    TIMSK0 |= (1 << TOIE0) | (1 << OCIE0A); // Enable Overflow and Compare Match Interrupt
+#else
     TIMSK |= (1 << TOIE0) | (1 << OCIE0A); // Enable Overflow and Compare Match Interrupt
+#endif
     OCR0A = 0;
 
     state = 0;
@@ -111,7 +116,11 @@ static void nextState(void) {
     }
 }
 
+#ifdef DEBUG
+ISR(TIMER0_OVF_vect) {
+#else
 ISR(TIM0_OVF_vect) {
+#endif
     if (triggerState == OVERFLOW) {
         if (triggerTimeRemaining == 0) {
             triggerState = NONE;
@@ -122,7 +131,11 @@ ISR(TIM0_OVF_vect) {
     }
 }
 
+#ifdef DEBUG
+ISR(TIMER0_COMPA_vect) {
+#else
 ISR(TIM0_COMPA_vect) {
+#endif
     if (triggerState == COMPARE_MATCH) {
         triggerState = NONE;
         nextState();

src/main.c

@@ -10,6 +10,10 @@
 #include "cppm.h"
 #include "rx.h"
 
+#ifdef DEBUG
+#include "serial.h"
+#endif
+
 void watchdogBoot(void) __attribute__((naked)) __attribute__((section(".init3")));
 void watchdogBoot(void) {
     MCUSR = 0;
@@ -20,12 +24,24 @@ void main(void) {
     cppmInit();
     timerInit();
 
+#ifdef DEBUG
+    serialInit(0, BAUD(19200, F_CPU));
+#endif
+
     sei(); // Enable interrupts (required for timer)
     wdt_enable(WDTO_250MS); // Trigger Watchdog after 250ms
 
+#ifdef DEBUG
+    serialWriteString(0, "RX reset.\n");
+#endif
+
     spiInit();
     rxInit();
 
+#ifdef DEBUG
+    serialWriteString(0, "RX ready!\n");
+#endif
+
     for(;;) {
         wdt_reset();
         rxReceivePacket();

src/rx.c

@@ -14,6 +14,10 @@
 #include "timer.h"
 #include "rx.h"
 
+#ifdef DEBUG
+#include "serial.h"
+#endif
+
 #define CHANNELS 8
 #define PPM_MIN 1000
 #define PPM_MAX 2000
@@ -57,9 +61,17 @@ static void readBindingData(void);
 static void writeBindingData(void);
 
 void rxInit(void) {
+#ifdef DEBUG
+    serialWriteString(0, "RX: binding\n");
+#endif
+
     initialize(1); // binding
     binding();
 
+#ifdef DEBUG
+    serialWriteString(0, "RX: receiving\n");
+#endif
+
     initialize(0); // data
     cc2500WriteReg(CC2500_0A_CHANNR, hopData[channr]);//0A-hop
     cc2500WriteReg(CC2500_23_FSCAL3, 0x89); //23-89
@@ -119,9 +131,16 @@ static void binding(void) {
     readBindingData();
     if ((txid[0] != 0xff) || (txid[1] != 0xff)) {
         // valid binding data found
+#ifdef DEBUG
+        serialWriteString(0, "RX: found data in EEPROM!\n");
+#endif
         return;
     }
 
+#ifdef DEBUG
+    serialWriteString(0, "RX: no stored data, tuning...\n");
+#endif
+
     // No valid txid, forcing bind
     tuning();
 
@@ -129,6 +148,10 @@ static void binding(void) {
     cc2500WriteReg(CC2500_0C_FSCTRL0, frequencyOffsetHack);
     eeprom_write_byte(EEPROM_BASE_ADDRESS + 101, frequencyOffsetHack);
 
+#ifdef DEBUG
+    serialWriteString(0, "RX: tuned, binding...\n");
+#endif
+
     performBind();
 }
 
@@ -188,6 +211,10 @@ static void performBind(void) {
         wdt_reset();
     }
 
+#ifdef DEBUG
+    serialWriteString(0, "RX: got hop data, reading list...\n");
+#endif
+
     listLength = 0;
     uint8_t eol = 0;
     for (uint8_t bindIdx = 0x05; bindIdx <= 120; bindIdx += 5) {
@@ -223,6 +250,10 @@ static void performBind(void) {
         }
     }
 
+#ifdef DEBUG
+    serialWriteString(0, "RX: binding finished!\n");
+#endif
+
     writeBindingData();
     cc2500Strobe(CC2500_SIDLE); // Back to idle
 }
@@ -277,7 +308,13 @@ void rxReceivePacket() {
             if (missingPackets > MAX_MISSING_PACKET) {
                 nextChannel(SEEK_CHANNEL_SKIP);
                 counter++;
-                //if (counter > (MAX_MISSING_PACKET << 1)) LED_ON;
+
+#ifdef DEBUG
+                if (counter > (MAX_MISSING_PACKET << 1)) {
+                    serialWriteString(0, "RX: missing packet notification!\n");
+                }
+#endif
+
                 if (counter == (MAX_MISSING_PACKET << 2)) counter = 0;
                 break;
             } else
@@ -343,6 +380,10 @@ void rxReceivePacket() {
         ppmBuffer[RSSI_OVER_PPM] = map(rssi, RSSI_MIN, RSSI_MAX, PPM_MIN, PPM_MAX);
 #endif
 
+#ifdef DEBUG
+        serialWriteString(0, "RX: packet received, sending CPPM!\n");
+#endif
+
         cppmCopy(ppmBuffer);
     }
 

src/serial.c

@@ -0,0 +1,410 @@
+/*
+ * serial.c
+ *
+ * Copyright (c) 2012, 2013, Thomas Buck <xythobuz@me.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <stdint.h>
+
+#include "serial.h"
+#include "serial_device.h"
+
+/** \addtogroup uart UART Library
+ *  UART Library enabling you to control all available
+ *  UART Modules. With XON/XOFF Flow Control and buffered
+ *  Receiving and Transmitting.
+ *  @{
+ */
+
+/** \file serial.c
+ *  UART Library Implementation
+ */
+
+/** If you define this, a '\\r' (CR) will be put in front of a '\\n' (LF) when sending a byte.
+ *  Binary Communication will then be impossible!
+ */
+// #define SERIALINJECTCR
+
+#ifndef RX_BUFFER_SIZE
+#define RX_BUFFER_SIZE 32 /**< RX Buffer Size in Bytes (Power of 2) */
+#endif
+
+#ifndef TX_BUFFER_SIZE
+#define TX_BUFFER_SIZE 32 /**< TX Buffer Size in Bytes (Power of 2) */
+#endif
+
+/** Defining this enables incoming XON XOFF (sends XOFF if rx buff is full) */
+#define FLOWCONTROL
+
+#define FLOWMARK 5 /**< Space remaining to trigger xoff/xon */
+#define XON 0x11 /**< XON Value */
+#define XOFF 0x13 /**< XOFF Value */
+
+#if (RX_BUFFER_SIZE < 2) || (TX_BUFFER_SIZE < 2)
+#error SERIAL BUFFER TOO SMALL!
+#endif
+
+#ifdef FLOWCONTROL
+#if (RX_BUFFER_SIZE < 8) || (TX_BUFFER_SIZE < 8)
+#error SERIAL BUFFER TOO SMALL!
+#endif
+#endif
+
+#if ((RX_BUFFER_SIZE + TX_BUFFER_SIZE) * UART_COUNT) >= (RAMEND - 0x60)
+#error SERIAL BUFFER TOO LARGE!
+#endif
+
+// serialRegisters
+#define SERIALDATA  0
+#define SERIALB     1
+#define SERIALC     2
+#define SERIALA     3
+#define SERIALUBRRH 4
+#define SERIALUBRRL 5
+
+// serialBits
+#define SERIALUCSZ0 0
+#define SERIALUCSZ1 1
+#define SERIALRXCIE 2
+#define SERIALRXEN  3
+#define SERIALTXEN  4
+#define SERIALUDRIE 5
+#define SERIALUDRE  6
+
+uint8_t volatile rxBuffer[UART_COUNT][RX_BUFFER_SIZE];
+uint8_t volatile txBuffer[UART_COUNT][TX_BUFFER_SIZE];
+uint16_t volatile rxRead[UART_COUNT];
+uint16_t volatile rxWrite[UART_COUNT];
+uint16_t volatile txRead[UART_COUNT];
+uint16_t volatile txWrite[UART_COUNT];
+uint8_t volatile shouldStartTransmission[UART_COUNT];
+
+#ifdef FLOWCONTROL
+uint8_t volatile sendThisNext[UART_COUNT];
+uint8_t volatile flow[UART_COUNT];
+uint8_t volatile rxBufferElements[UART_COUNT];
+#endif
+
+uint8_t serialAvailable(void) {
+    return UART_COUNT;
+}
+
+void serialInit(uint8_t uart, uint16_t baud) {
+    if (uart >= UART_COUNT)
+        return;
+
+    // Initialize state variables
+    rxRead[uart] = 0;
+    rxWrite[uart] = 0;
+    txRead[uart] = 0;
+    txWrite[uart] = 0;
+    shouldStartTransmission[uart] = 1;
+#ifdef FLOWCONTROL
+    sendThisNext[uart] = 0;
+    flow[uart] = 1;
+    rxBufferElements[uart] = 0;
+#endif
+
+    // Default Configuration: 8N1
+    *serialRegisters[uart][SERIALC] = (1 << serialBits[uart][SERIALUCSZ0]) | (1 << serialBits[uart][SERIALUCSZ1]);
+
+    // Set baudrate
+#if SERIALBAUDBIT == 8
+    *serialRegisters[uart][SERIALUBRRH] = (baud >> 8);
+    *serialRegisters[uart][SERIALUBRRL] = baud;
+#else
+    *serialBaudRegisters[uart] = baud;
+#endif
+
+    *serialRegisters[uart][SERIALB] = (1 << serialBits[uart][SERIALRXCIE]); // Enable Interrupts
+    *serialRegisters[uart][SERIALB] |= (1 << serialBits[uart][SERIALRXEN]) | (1 << serialBits[uart][SERIALTXEN]); // Enable Receiver/Transmitter
+}
+
+void serialClose(uint8_t uart) {
+    if (uart >= UART_COUNT)
+        return;
+
+    uint8_t sreg = SREG;
+    sei();
+    while (!serialTxBufferEmpty(uart));
+    while (*serialRegisters[uart][SERIALB] & (1 << serialBits[uart][SERIALUDRIE])); // Wait while Transmit Interrupt is on
+    cli();
+    *serialRegisters[uart][SERIALB] = 0;
+    *serialRegisters[uart][SERIALC] = 0;
+    SREG = sreg;
+}
+
+#ifdef FLOWCONTROL
+void setFlow(uint8_t uart, uint8_t on) {
+    if (uart >= UART_COUNT)
+        return;
+
+    if (flow[uart] != on) {
+        if (on == 1) {
+            // Send XON
+            while (sendThisNext[uart] != 0);
+            sendThisNext[uart] = XON;
+            flow[uart] = 1;
+            if (shouldStartTransmission[uart]) {
+                shouldStartTransmission[uart] = 0;
+                *serialRegisters[uart][SERIALB] |= (1 << serialBits[uart][SERIALUDRIE]);
+                *serialRegisters[uart][SERIALA] |= (1 << serialBits[uart][SERIALUDRE]); // Trigger Interrupt
+            }
+        } else {
+            // Send XOFF
+            sendThisNext[uart] = XOFF;
+            flow[uart] = 0;
+            if (shouldStartTransmission[uart]) {
+                shouldStartTransmission[uart] = 0;
+                *serialRegisters[uart][SERIALB] |= (1 << serialBits[uart][SERIALUDRIE]);
+                *serialRegisters[uart][SERIALA] |= (1 << serialBits[uart][SERIALUDRE]); // Trigger Interrupt
+            }
+        }
+        // Wait till it's transmitted
+        while (*serialRegisters[uart][SERIALB] & (1 << serialBits[uart][SERIALUDRIE]));
+    }
+}
+#endif
+
+// ---------------------
+// |     Reception     |
+// ---------------------
+
+uint8_t serialHasChar(uint8_t uart) {
+    if (uart >= UART_COUNT)
+        return 0;
+
+    if (rxRead[uart] != rxWrite[uart]) { // True if char available
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+uint8_t serialGetBlocking(uint8_t uart) {
+    if (uart >= UART_COUNT)
+        return 0;
+
+    while(!serialHasChar(uart));
+    return serialGet(uart);
+}
+
+uint8_t serialGet(uint8_t uart) {
+    if (uart >= UART_COUNT)
+        return 0;
+
+    uint8_t c;
+
+#ifdef FLOWCONTROL
+    rxBufferElements[uart]--;
+    if ((flow[uart] == 0) && (rxBufferElements[uart] <= FLOWMARK)) {
+        while (sendThisNext[uart] != 0);
+        sendThisNext[uart] = XON;
+        flow[uart] = 1;
+        if (shouldStartTransmission[uart]) {
+            shouldStartTransmission[uart] = 0;
+            *serialRegisters[uart][SERIALB] |= (1 << serialBits[uart][SERIALUDRIE]); // Enable Interrupt
+            *serialRegisters[uart][SERIALA] |= (1 << serialBits[uart][SERIALUDRE]); // Trigger Interrupt
+        }
+    }
+#endif
+
+    if (rxRead[uart] != rxWrite[uart]) {
+        c = rxBuffer[uart][rxRead[uart]];
+        rxBuffer[uart][rxRead[uart]] = 0;
+        if (rxRead[uart] < (RX_BUFFER_SIZE - 1)) {
+            rxRead[uart]++;
+        } else {
+            rxRead[uart] = 0;
+        }
+        return c;
+    } else {
+        return 0;
+    }
+}
+
+uint8_t serialRxBufferFull(uint8_t uart) {
+    if (uart >= UART_COUNT)
+        return 0;
+
+    return (((rxWrite[uart] + 1) == rxRead[uart]) || ((rxRead[uart] == 0) && ((rxWrite[uart] + 1) == RX_BUFFER_SIZE)));
+}
+
+uint8_t serialRxBufferEmpty(uint8_t uart) {
+    if (uart >= UART_COUNT)
+        return 0;
+
+    if (rxRead[uart] != rxWrite[uart]) {
+        return 0;
+    } else {
+        return 1;
+    }
+}
+
+// ----------------------
+// |    Transmission    |
+// ----------------------
+
+void serialWrite(uint8_t uart, uint8_t data) {
+    if (uart >= UART_COUNT)
+        return;
+
+#ifdef SERIALINJECTCR
+    if (data == '\n') {
+        serialWrite(uart, '\r');
+    }
+#endif
+    while (serialTxBufferFull(uart));
+
+    txBuffer[uart][txWrite[uart]] = data;
+    if (txWrite[uart] < (TX_BUFFER_SIZE - 1)) {
+        txWrite[uart]++;
+    } else {
+        txWrite[uart] = 0;
+    }
+    if (shouldStartTransmission[uart]) {
+        shouldStartTransmission[uart] = 0;
+        *serialRegisters[uart][SERIALB] |= (1 << serialBits[uart][SERIALUDRIE]); // Enable Interrupt
+        *serialRegisters[uart][SERIALA] |= (1 << serialBits[uart][SERIALUDRE]); // Trigger Interrupt
+    }
+}
+
+void serialWriteString(uint8_t uart, const char *data) {
+    if (uart >= UART_COUNT)
+        return;
+
+    if (data == 0) {
+        serialWriteString(uart, "NULL");
+    } else {
+        while (*data != '\0') {
+            serialWrite(uart, *data++);
+        }
+    }
+}
+
+uint8_t serialTxBufferFull(uint8_t uart) {
+    if (uart >= UART_COUNT)
+        return 0;
+
+    return (((txWrite[uart] + 1) == txRead[uart]) || ((txRead[uart] == 0) && ((txWrite[uart] + 1) == TX_BUFFER_SIZE)));
+}
+
+uint8_t serialTxBufferEmpty(uint8_t uart) {
+    if (uart >= UART_COUNT)
+        return 0;
+
+    if (txRead[uart] != txWrite[uart]) {
+        return 0;
+    } else {
+        return 1;
+    }
+}
+
+void serialReceiveInterrupt(uint8_t uart) {
+    rxBuffer[uart][rxWrite[uart]] = *serialRegisters[uart][SERIALDATA];
+    if (rxWrite[uart] < (RX_BUFFER_SIZE - 1)) {
+        rxWrite[uart]++;
+    } else {
+        rxWrite[uart] = 0;
+    }
+
+#ifdef FLOWCONTROL
+    rxBufferElements[uart]++;
+    if ((flow[uart] == 1) && (rxBufferElements[uart] >= (RX_BUFFER_SIZE - FLOWMARK))) {
+        sendThisNext[uart] = XOFF;
+        flow[uart] = 0;
+        if (shouldStartTransmission[uart]) {
+            shouldStartTransmission[uart] = 0;
+            *serialRegisters[uart][SERIALB] |= (1 << serialBits[uart][SERIALUDRIE]); // Enable Interrupt
+            *serialRegisters[uart][SERIALA] |= (1 << serialBits[uart][SERIALUDRE]); // Trigger Interrupt
+        }
+    }
+#endif
+}
+
+void serialTransmitInterrupt(uint8_t uart) {
+#ifdef FLOWCONTROL
+    if (sendThisNext[uart]) {
+        *serialRegisters[uart][SERIALDATA] = sendThisNext[uart];
+        sendThisNext[uart] = 0;
+    } else {
+#endif
+        if (txRead[uart] != txWrite[uart]) {
+            *serialRegisters[uart][SERIALDATA] = txBuffer[uart][txRead[uart]];
+            if (txRead[uart] < (TX_BUFFER_SIZE -1)) {
+                txRead[uart]++;
+            } else {
+                txRead[uart] = 0;
+            }
+        } else {
+            shouldStartTransmission[uart] = 1;
+            *serialRegisters[uart][SERIALB] &= ~(1 << serialBits[uart][SERIALUDRIE]); // Disable Interrupt
+        }
+#ifdef FLOWCONTROL
+    }
+#endif
+}
+
+ISR(SERIALRECIEVEINTERRUPT) { // Receive complete
+    serialReceiveInterrupt(0);
+}
+
+ISR(SERIALTRANSMITINTERRUPT) { // Data register empty
+    serialTransmitInterrupt(0);
+}
+
+#if UART_COUNT > 1
+ISR(SERIALRECIEVEINTERRUPT1) { // Receive complete
+    serialReceiveInterrupt(1);
+}
+
+ISR(SERIALTRANSMITINTERRUPT1) { // Data register empty
+    serialTransmitInterrupt(1);
+}
+#endif
+
+#if UART_COUNT > 2
+ISR(SERIALRECIEVEINTERRUPT2) { // Receive complete
+    serialReceiveInterrupt(2);
+}
+
+ISR(SERIALTRANSMITINTERRUPT2) { // Data register empty
+    serialTransmitInterrupt(2);
+}
+#endif
+
+#if UART_COUNT > 3
+ISR(SERIALRECIEVEINTERRUPT3) { // Receive complete
+    serialReceiveInterrupt(3);
+}
+
+ISR(SERIALTRANSMITINTERRUPT3) { // Data register empty
+    serialTransmitInterrupt(3);
+}
+#endif
+/** @} */

src/spi.c

@@ -5,11 +5,19 @@
 #include "spi.h"
 
 void spiInit(void) {
+#ifdef DEBUG
+    DDRB |= (1 << PB0);  // SI output
+    DDRD &= ~(1 << PD4); // SO input
+    DDRD |= (1 << PD2);  // SCLK output
+    DDRD |= (1 << PD7);  // CS output
+    DDRB &= ~(1 << PB4); // GDO0 input
+#else
     DDRB |= (1 << PB2);  // SI output
     DDRB &= ~(1 << PB3); // SO input
     DDRB |= (1 << PB4);  // SCLK output
     DDRB |= (1 << PB1);  // CS output
     DDRB &= ~(1 << PB0); // GDO0 input
+#endif
 
     SCK_off;
     MO_off;

src/timer.c

@@ -10,14 +10,25 @@
 volatile time_t systemTime = 0;
 
 void timerInit(void) {
+#ifdef DEBUG
+    TCCR2A |= (1 << WGM21); // CTC Mode
+    TCCR2B |= (1 << CS22); // Prescaler: 64
+    OCR2A = 250; // Count to 250
+    TIMSK2 |= (1 << OCIE2A); // Enable compare match interrupt
+#else
     // Using 8bit Timer1
     TCCR1 |= (1 << CTC1); // CTC Mode
     TCCR1 |= (1 << CS12) | (1 << CS11) | (1 << CS10); // Prescaler: 64
     OCR1A = 250; // Count to 250
     TIMSK |= (1 << OCIE1A); // Enable compare match interrupt
+#endif
 }
 
+#ifdef DEBUG
+ISR(TIMER2_COMPA_vect) {
+#else
 ISR(TIMER1_COMPA_vect) {
+#endif
     systemTime++; // one millisecond has passed
 }