pci fix

.gitignore

@@ -103,3 +103,4 @@ local.properties
 .cache-main
 .scala_dependencies
 .worksheet
+/Release/

.gitmodules

@@ -1,3 +1,3 @@
-[submodule "arduino_core"]
+[submodule "arduino"]
 	path = arduino_core
-	url = https://egit.irs.uni-stuttgart.de/mohr/arduino_core.git
+	url = https://egit.irs.uni-stuttgart.de/eive/arduino_core.git

ArduinoConfig.h

@@ -0,0 +1,37 @@
+#ifndef ARDUINOCONFIG_H_
+#define ARDUINOCONFIG_H_
+
+static const uint8_t COMMAND_TRANSFER_SPI = 1;
+
+// Can be set to one for additional programming information from the primary
+// serial port which is usually also used to flash the Arduino
+// Can be disabled if this output interferes with the usual
+// serial communication logic
+#define PROGRAMMING_OUTPUT          1
+
+#define BAUD_RATE               115200
+#define SERIAL_RX_BUFFER_SIZE   256
+#define RING_BUFFER_SIZE        100
+#define MAX_PACKET_LENGTH       100
+#define RING_BUFFER_CHECK_INTVL 1000
+
+// Define which port to use for the SPI Chip Select by using the register
+// definitions. The data direction register is assigned as well.
+// The ports can be looked up on the official Arduino pinout schematics.
+#ifdef ARDUINO_AVR_MEGA2560
+// Defines for the Arduino Mega
+#define CS_PORT PORTK
+#define CS_DDR DDRK
+#elif defined(ARDUINO_AVR_UNO)
+#define CS_PORT PORTD
+#define CS_DDR DDRD
+#elif defined(__SAM3X8E__)
+// Define for the Arduino Due
+#define CS_PORT PORTC
+#define CS_DDR DDRC
+#else
+#define CS_PORT PORTC
+#define CS_DDR DDRC
+#endif
+
+#endif /* ARDUINOCONFIG_H_ */

IOBoard.cpp

@@ -0,0 +1,172 @@
+#include "IOBoard.h"
+#include <SPI.h>
+#include "ArduinoConfig.h"
+#include "helper/SimpleRingBuffer.h"
+#include "helper/DleEncoder.h"
+#include "helper/crc_ccitt.h"
+
+SimpleRingBuffer ringBuffer(RING_BUFFER_SIZE, true);
+
+uint8_t rawData[2 * RING_BUFFER_SIZE];
+size_t rawDataSize = 0;
+
+#define PACKET_COMMAND_LENGTH       1
+#define PACKET_ADDRESS_LENGTH       1
+#define PACKET_SIZE_FIELD_LENGTH    2
+
+#define PACKET_HEADER_LENGTH        4
+
+namespace IOBoard {
+
+void handleNewData() {
+    ringBuffer.readData(rawData, sizeof(rawData), true, &rawDataSize);
+
+    if (rawDataSize == 0) {
+        return;
+    }
+
+    //look for STX
+    size_t firstSTXinRawData = 0;
+    while ((firstSTXinRawData < rawDataSize)
+            && (rawData[firstSTXinRawData] != DleEncoder::STX)) {
+        Serial.println(rawData[firstSTXinRawData]);
+        firstSTXinRawData++;
+    }
+
+    if (rawData[firstSTXinRawData] != DleEncoder::STX) {
+        //there is no STX in our data, throw it away...
+        Serial.println("NO STX");
+        ringBuffer.deleteData(rawDataSize);
+        return;
+    }
+
+    uint8_t packet[MAX_PACKET_LENGTH];
+    size_t packetLen;
+
+    size_t readSize;
+
+    ReturnValue_t result = DleEncoder::decode(rawData + firstSTXinRawData,
+            rawDataSize - firstSTXinRawData, &readSize, packet, sizeof(packet),
+            &packetLen);
+
+    size_t toDelete = firstSTXinRawData;
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        handlePacket(packet, packetLen);
+
+        // after handling the packet, we can delete it from the raw stream,
+        // it has been copied to packet
+        toDelete += readSize;
+    }
+
+    //remove Data which was processed
+    ringBuffer.deleteData(toDelete);
+
+}
+
+void handlePacket(uint8_t *packet, size_t packetLen) {
+    /* Paket layout is:
+      ------------------------------
+     |byte     |  field             |
+     |         |                    |
+     |------------------------------|
+     |1        | 8 bit command      |
+     |------------------------------|
+     |1        | 8 bit address      |
+     |------------------------------|
+     |2        | 16bit length       |
+     |------------------------------|
+     |length   | <length> byte data |
+     |------------------------------|
+     |2        | 16 bit crc         |
+     |------------------------------|
+      ------------------------------
+    */
+
+    uint16_t crc = Calculate_CRC(packet, packetLen);
+
+    if (crc != 0) {
+        Serial.println("-AI- Invalid packet checksum detected!");
+        return;
+    }
+
+    uint16_t payloadLen = (packet[2] << 8) | packet[3];
+
+    if (payloadLen != packetLen - 6) {
+        Serial.println("-AI- Invalid packet length detected!");
+        return;
+    }
+
+    uint8_t command = packet[0];
+    uint8_t address = packet[1];
+
+    switch (command) {
+    case COMMAND_TRANSFER_SPI:
+        transferSPI(address, packet + PACKET_HEADER_LENGTH, payloadLen);
+        //echo the data back, no need to change the header fields, they are the same
+        //checksum will be written by sendReply()
+        //check reply:
+        Serial.println("Data response check: ");
+        for(size_t i =0; i< packetLen; i++){
+            Serial.print("packet nr ");Serial.print(i);Serial.print(" ");
+            Serial.println(packet[i]);
+        }
+        sendReply(packet, packetLen);
+        break;
+    default:
+        Serial.println("invalid command");
+        break;
+    }
+
+}
+
+void transferSPI(uint8_t address, uint8_t *data, size_t datalen) {
+    SPI.beginTransaction(SPISettings(14000000, MSBFIRST, SPI_MODE3));
+    // The specified address is the bit where the last bit is port 0
+    // and the first bit is port 7. It is inverted because the SPI protocol
+    // requires the slave select to be driven low.
+    CS_PORT = ~address;
+    SPI.transfer(data, datalen);
+    delay(100);
+    // Pull the slave select high again.
+    CS_PORT = 0xff;
+    SPI.endTransaction();
+}
+
+/**
+ * Encode and send the data, last two bytes of data are assumed to be for the checksum
+ * and will be overwritten with it
+ */
+void sendReply(uint8_t *data, size_t len) {
+    uint16_t crc = Calculate_CRC(data, len - 2);
+    data[len - 2] = crc >> 8;
+    data[len - 1] = crc;
+    //we're being conservative here
+    //TODO move this to global so other protocols can use it too
+    uint8_t buffer[2 * len + 2];
+    buffer[0] = DleEncoder::STX;
+    size_t writtenLen;
+    ReturnValue_t result = DleEncoder::encode(data, len, buffer, sizeof(buffer),
+            &writtenLen, true);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return;
+    }
+    Serial.write(buffer, writtenLen);
+}
+
+
+//TODO check if this is thread safe by arduino
+// I think it is, see HardwareSerial::available()
+void serialEvent() {
+    //Serial.println(ringBuffer.availableWriteSpace());
+    //uint8_t i = 0;
+
+    while (Serial.available()>0) {
+        uint8_t byte = Serial.read();
+        ringBuffer.writeData(&byte, 1);
+    }
+    //Serial.println(ringBuffer.availableWriteSpace());
+}
+}
+
+
+

IOBoard.h

@@ -0,0 +1,17 @@
+#ifndef IOBOARD_H_
+#define IOBOARD_H_
+
+#include <Arduino.h>
+
+namespace IOBoard {
+
+void handleNewData();
+void handlePacket(uint8_t *packet, size_t packetLen);
+void transferSPI(uint8_t address, uint8_t *data, size_t datalen);
+void sendReply(uint8_t *data, size_t len);
+
+}
+
+
+
+#endif /* IOBOARD_H_ */

Makefile

@@ -0,0 +1,19 @@
+TARGET = ArduinoIO
+
+# The C source files
+SRC = 
+
+# The C++ source files
+PSRC += main.cpp
+PSRC += IOBoard.cpp
+PSRC += $(wildcard helper/*.cpp) 
+PSRC += arduino_core/ArduinoCore-avr/libraries/SPI/src/SPI.cpp
+
+# extra Arduino libraries
+ARDLIBS = 				
+
+EXTRAINCDIRS += arduino_core/ArduinoCore-avr/libraries/SPI/src
+EXTRAINCDIRS += arduino_core/src
+
+# this line includes the Makefile.base
+include arduino_core/arduino-base.mk

README.md

@@ -0,0 +1,64 @@
+Arduino IO Interface Board for EIVE
+======
+
+## General Information
+
+This is the software for an Arduino board to set it up as an interface board.
+The interface board will be used to relay commands from a host computer serial
+interface to connected I2C or SPI sensors. This allows device handler testing 
+on a host machine. There are 2 options to build and flash an Arduino with this repository:
+1. The software is compiled and programmed on the Arduino with make and avrdude, provided the AVR GCC toolchain is installed
+2. Eclipse with the Sloeber plugin is used. The plugin and Eclipse take care of the build management, and an Arduino IDE like interface is provided in Eclipse
+
+It is recommended to use Sloeber for enhanced convenience, as it takes care of the building process. Furthermore, the interface is similar to the Arduino IDE, which lowers the entry barrier for new developers. It is also integrated into Eclipse, which has a powerful indexer and several other tools to ease development.
+
+## Instructions to build with make
+
+### Prerequisites
+
+1. When compiling on a Windows system, make sure the [Windows Development Tools](https://xpack.github.io/windows-build-tools/install/) are installed and added to the system path.This is required for make to work.
+
+2. Install the [AVR toolchain](https://www.microchip.com/mplab/avr-support/avr-and-arm-toolchains-c-compilers) for your OS
+
+3. If building the binary with make, initiate the contained arduino\_core submodule and the required core contained within that submodule by running
+```sh
+git submodule update --init --recursively
+```
+
+### Build Instructions
+Make sure to add `WINDOWS=1` when building on Windows! 
+
+1. Run following command to build the software. 
+
+```sh
+make all -j
+```
+
+2. Run following command to clean up the directories
+
+```sh
+make clean -j
+```
+
+## Instructions build with Sloeber
+
+### Prerequisite
+
+1. Install [Eclipse for C/C++ developers](https://www.eclipse.org/downloads/packages/installer)
+
+2. Install the Eclipse Sloeber plugin by going to Help → Eclipse Marketplace and searching for Sloeber V4 and installing it 
+
+3. Set up the plugin for the  used board and install all required libraries.
+
+4. Create a new Arduino sketch
+
+5. The Sloeber plugin build mangement system will parse the arduino folder and all contained subfolders for source files. If you want to exclude source files from the build (for example, to exclude the arduino\_core, Sloeber will take care to include the core files via its integrated board manager!), right click on that folder in the tree view on the left, go to Resource Configureation and configure Exclude from Build. 
+
+6. It is recommended to get familiary with the interface provided by the plugin. A majority of functions is provided by top bar elements as shown in the following picture.
+
+<img src="helper/eclipse_top_bar.png" width="80%">
+### Build and flash instructions
+
+1. An Arduino like bar can be seen at the top, which can be used to compile the software and flash it to the board. The check symbol is used to compile while the right arrow symbol is used to flash the software. There are also symbols to open the serial monitor or the serial plot.
+
+2. The serial monitor can be opened in the Serial monitor view tab at the bottom or with the icons at the top bar. Take care to pick the correct USB port and baud rate.

main.cpp

@@ -1,172 +1,52 @@
 #include <Arduino.h>
 
-#include "helper/SimpleRingBuffer.h"
-#include "helper/DleEncoder.h"
-#include "helper/crc_ccitt.h"
+#include "IOBoard.h"
+#include "ArduinoConfig.h"
 
+// TODO: Copy this header into arduino_core, so it can be used without
+// Eclipse Sloeber as well.
+#include <arduino-timer.h>
 #include <avr/io.h>
 
 //SPI is formally a library, so it is not part of the objects compiled
 //from the core and we need to include it explicitly
-#include "arduino_core/ArduinoCore-avr/libraries/SPI/src/SPI.h"
+#include <SPI.h>
 
-//Define which port to use for the SPI Chip Select
-#define CS_PORT PORTC
-#define CS_DDR DDRC
-
-#define RING_BUFFER_SIZE 100
-#define MAX_PACKET_LENGTH 100
-#define SERIAL_RX_BUFFER_SIZE 256
-
-static const uint8_t COMMAND_TRANSFER_SPI = 1;
-
-SimpleRingBuffer ringBuffer(RING_BUFFER_SIZE, true);
-
-uint8_t rawData[2 * RING_BUFFER_SIZE];
-size_t rawDataSize = 0;
-
-/**
- * Encode and send the data, last two bytes of data are assumed to be for the checksum
- * and will be overwritten with it
- */
-void sendData(uint8_t *data, size_t len) {
-	uint16_t crc = Calculate_CRC(data, len - 2);
-	data[len - 2] = crc >> 8;
-	data[len - 1] = crc;
-	//we're being conservative here
-	//TODO move this to global so other protocols can use it too
-	uint8_t buffer[2 * len + 2];
-	buffer[0] = DleEncoder::STX;
-	size_t writtenLen;
-	ReturnValue_t result = DleEncoder::encode(data, len, buffer, sizeof(buffer),
-			&writtenLen, true);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	Serial.write(buffer, writtenLen);
-}
-
-void transferSPI(uint8_t address, uint8_t *data, size_t datalen) {
-	SPI.beginTransaction(SPISettings(14000000, MSBFIRST, SPI_MODE3));
-	CS_PORT = ~address;
-	SPI.transfer(data, datalen);
-	delay(100);
-	CS_PORT = 0xff;
-	SPI.endTransaction();
-
-}
-
-void handlePacket(uint8_t *packet, size_t packetLen) {
-	//Paket layout is:
-	// 8 bit command | 8 bit address | 16bit length | <length> byte data | 16 bit crc
-
-
-
-
-	uint16_t crc = Calculate_CRC(packet, packetLen);
-
-
-	if (crc != 0) {
-		Serial.println("invalid Checksum");
-		return;
-	}
-
-	uint16_t payloadLen = (packet[2] << 8) | packet[3];
-
-	if (payloadLen != packetLen - 6) {
-		Serial.println("invalid len");
-		return;
-	}
-
-	uint8_t command = packet[0];
-	uint8_t address = packet[1];
-
-
-
-	switch (command) {
-	case COMMAND_TRANSFER_SPI:
-		transferSPI(address, packet + 4, payloadLen);
-		//echo the data back, no need to change the header fields, they are the same
-		//checksum will be written by sendData()
-		//check reply:
-		Serial.println("Data response check: ");
-		for(size_t i =0; i< packetLen; i++){
-			Serial.print("packet nr ");Serial.print(i);Serial.print(" ");Serial.println(packet[i]);
-		}
-		sendData(packet, packetLen);
-		break;
-	default:
-		Serial.println("invalid command");
-		break;
-	}
-
-}
-
-void handleNewData() {
-	ringBuffer.readData(rawData, sizeof(rawData), true, &rawDataSize);
-
-	if (rawDataSize == 0) {
-		return;
-	}
-
-	//look for STX
-	size_t firstSTXinRawData = 0;
-	while ((firstSTXinRawData < rawDataSize)
-			&& (rawData[firstSTXinRawData] != DleEncoder::STX)) {
-		Serial.println(rawData[firstSTXinRawData]);
-		firstSTXinRawData++;
-	}
-
-	if (rawData[firstSTXinRawData] != DleEncoder::STX) {
-		//there is no STX in our data, throw it away...
-		Serial.println("NO STX");
-		ringBuffer.deleteData(rawDataSize);
-		return;
-	}
-
-	uint8_t packet[MAX_PACKET_LENGTH];
-	size_t packetLen;
-
-	size_t readSize;
-
-	ReturnValue_t result = DleEncoder::decode(rawData + firstSTXinRawData,
-			rawDataSize - firstSTXinRawData, &readSize, packet, sizeof(packet),
-			&packetLen);
-
-	size_t toDelete = firstSTXinRawData;
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		handlePacket(packet, packetLen);
-
-		//after handling the packet, we can delete it from the raw stream, it has been copied to packet
-		toDelete += readSize;
-	}
-
-	//remove Data which was processed
-	ringBuffer.deleteData(toDelete);
-
-}
-
-//TODO check if this is thread safe by arduino
-void serialEvent() {
-	//Serial.println(ringBuffer.availableWriteSpace());
-	uint8_t i = 0;
-
-	while (Serial.available()>0) {
-		uint8_t byte = Serial.read();
-		ringBuffer.writeData(&byte, 1);
-	}
-	//Serial.println(ringBuffer.availableWriteSpace());
-}
+// Crete default timer which is able to manage 10 concurrent tasks
+// and uses milliseconds as a timebase.
+auto timer = timer_create_default();
+bool periodicHandler1(void* args);
 
 void setup() {
-	CS_DDR = 0xff;
-	CS_PORT = 0xff;
-	Serial.begin(9600);
-	SPI.begin();
+    // Set data direction of selected port to output.
+    CS_DDR = 0xff;
+    // Drive all the slave selects high as required for the SPI protocol
+    // if no transfer is going on.
+    CS_PORT = 0xff;
+    Serial.begin(BAUD_RATE);
+#if PROGRAMMING_OUTPUT == 1
+    Serial.println("-AI- Setting up Arduino IO interface board.");
+    Serial.print("-AI- Configured baud rate for serial communication: ");
+    Serial.println(BAUD_RATE, DEC);
+    Serial.print("-AI- Size of serial receiver buffer: ");
+    Serial.print(SERIAL_RX_BUFFER_SIZE, DEC);
+    Serial.println(" bytes");
+#endif
+    SPI.begin();
+    // Call periodic handler with certain interval
+    timer.every(RING_BUFFER_CHECK_INTVL, periodicHandler1);
+}
+
+bool periodicHandler1(void* args) {
+    if(args) {};
+    Serial.println("Handling new data!");
+    IOBoard::handleNewData();
+    // repeat action
+    return true;
 }
 
 void loop() {
-;
-	handleNewData();
-	delay(1000);
+    timer.tick();
 }
+
+

makefile

@@ -1,5 +0,0 @@
-TARGET = ArduinoIO
-SRC =   									# the C source files
-PSRC = main.cpp $(wildcard helper/*.cpp) arduino_core/ArduinoCore-avr/libraries/SPI/src/SPI.cpp							# the C++ source files
-ARDLIBS = 						# extra Arduino libraries
-include arduino_core/arduino-base.mk 		# this line includes the Makefile.base