+++ enhanced framework hardware interface

source/Concept/Framework/default/Makefile

@@ -34,7 +34,7 @@ HEX_EEPROM_FLAGS += --change-section-lma .eeprom=0
 
 
 ## Objects that must be built in order to link
-OBJECTS = main.o sensor.o tools.o atmega128io.o distance_sensor.o engine.o io_module.o ir_sensor.o kicker.o led.o robot.o 
+OBJECTS = main.o sensor.o tools.o atmega128io.o display.o keyboard.o distance_sensor.o mouse_sensor.o engine.o dribbler.o io_module.o ir_sensor.o kicker.o led.o robot.o position_tracker.o 
 
 ## Objects explicitly added by the user
 LINKONLYOBJECTS = 
@@ -64,15 +64,27 @@ engine.o: ../engine.cpp
 led.o: ../led.cpp
 	$(CC) $(INCLUDES) $(CFLAGS) -c  $<
 
+display.o: ../display.cpp
+	$(CC) $(INCLUDES) $(CFLAGS) -c  $<
+
+keyboard.o: ../keyboard.cpp
+	$(CC) $(INCLUDES) $(CFLAGS) -c  $<
+
 ir_sensor.o: ../ir_sensor.cpp
 	$(CC) $(INCLUDES) $(CFLAGS) -c  $<
 
 distance_sensor.o: ../distance_sensor.cpp
 	$(CC) $(INCLUDES) $(CFLAGS) -c  $<
 
+mouse_sensor.o: ../mouse_sensor.cpp
+	$(CC) $(INCLUDES) $(CFLAGS) -c  $<
+
 kicker.o: ../kicker.cpp
 	$(CC) $(INCLUDES) $(CFLAGS) -c  $<
 
+dribbler.o: ../dribbler.cpp
+	$(CC) $(INCLUDES) $(CFLAGS) -c  $<
+
 atmega128io.o: ../atmega128io.cpp
 	$(CC) $(INCLUDES) $(CFLAGS) -c  $<
 

source/Concept/Framework/defines.h

@@ -105,6 +105,8 @@ enum IOModuleNames
 	IO_SENSOR_DISTANCE_90_DEG,
 	IO_SENSOR_DISTANCE_180_DEG,
 	IO_SENSOR_DISTANCE_270_DEG,
+	IO_SENSOR_MOUSE_LEFT,
+	IO_SENSOR_MOUSE_RIGHT,
 
 	IO_SENSOR_END,
 
@@ -124,8 +126,24 @@ enum IOModuleNames
 
 	IO_DISPLAY_END,
 
+	//Keyboards
+
+	IO_KEYBOARD_START = IO_DISPLAY_END,
+
+	IO_KEYBOARD_MAIN = IO_KEYBOARD_START,
+
+	IO_KEYBOARD_END,
+
+	//Position Tracker
+
+	IO_POSITION_TRACKER_START = IO_KEYBOARD_END,
+
+	IO_POSITION_TRACKER_MAIN,
+
+	IO_POSITION_TRACKER_END,
+
 	//General
-	IO_END = IO_DISPLAY_END,
+	IO_END = IO_POSITION_TRACKER_END,
 };
 
 #endif

source/Concept/Framework/display.h

@@ -10,31 +10,74 @@ public:
 	{
 		this->parent = NULL;
 		this->moduleId = 0;
+		this->cursorVisible = false;
+		this->illuminationEnabled = true;
+		this->commandClear = 0;
+		this->commandReturnCursor = 0;
+		this->commandNewLine = 0;
+		this->commandSetting = 0;
+		this->settingCursorVisible = 0;
+		this->settingIllumination = 0;
+		this->settingCursorPosition = 0;
 	}
 
 	Display(uint32 displayId)
 	{
 		this->parent = NULL;
 		this->moduleId = displayId;
+		this->cursorVisible = false;
+		this->illuminationEnabled = true;
 		
 		switch(displayId)
 		{
 			case IO_DISPLAY_MAIN:
+				this->commandClear = 12;
+				this->commandReturnCursor = 13;
+				this->commandNewLine = 10;
+				this->commandSetting = 27;
+				this->settingCursorVisible = 67;
+				this->settingIllumination = 76;
+				this->settingCursorPosition = 79;
 				msleep(500);
 				uart1_init(103);//9600 BAUD at 16MHz Atmel
 				sleep(2);
 				break;
 			default:
+				this->commandClear = 0;
+				this->commandReturnCursor = 0;
+				this->commandNewLine = 0;
+				this->commandSetting = 0;
+				this->settingCursorVisible = 0;
+				this->settingIllumination = 0;
+				this->settingCursorPosition = 0;
 				break;
 		}
 	}
 
 protected:
-	//Hardware
+	bool cursorVisible;
-	volatile uint8* hardwarePort;
+	bool illuminationEnabled;
-	volatile uint16* pwmSpeed;
+	//Commands
-	uint8 pinForward;
+	uint8 commandClear;
-	uint8 pinReverse;
+	uint8 commandReturnCursor;
+	uint8 commandNewLine;
+	uint8 commandSetting;
+	//Settings
+	uint8 settingCursorVisible;
+	uint8 settingIllumination;
+	uint8 settingCursorPosition;
+
+	void SendCommand(uint8 newCommand)
+	{
+		switch(moduleId)
+		{
+			case IO_DISPLAY_MAIN:
+				uart1_putc(newCommand);
+				break;
+			default:
+				break;
+		}
+	}
 
 public:
 	void Print(char* newString)
@@ -55,6 +98,88 @@ public:
 		ltoa(newInteger, buffer, 10);
 		Print(buffer);
 	}
+
+	void Print(char* newString, uint8 xPos, uint8 yPos)
+	{
+		SetCursorPosition(xPos, yPos);
+		Print(newString);
+	}
+
+	void Print(int32 newInteger, uint8 xPos, uint8 yPos)
+	{
+		SetCursorPosition(xPos, yPos);
+		Print(newInteger);
+	}
+
+	void Clear()
+	{
+		SendCommand(commandClear);
+	}
+
+	void ReturnCursor()
+	{
+		SendCommand(commandReturnCursor);
+	}
+
+	void NewLine()
+	{
+		SendCommand(commandNewLine);
+	}
+
+	bool GetCursorVisible()
+	{
+		return cursorVisible;
+	}
+
+	void SetCursorVisible(bool newStatus)
+	{
+		cursorVisible = newStatus;
+
+		SendCommand(commandSetting);
+		SendCommand(settingCursorVisible);
+
+		if(cursorVisible)
+		{
+			SendCommand(1);
+		}
+		else
+		{
+			SendCommand(0);
+		}
+	}
+
+	bool GetLightingEnabled()
+	{
+		return illuminationEnabled;
+	}
+
+	void SetLightingEnabled(bool newStatus)
+	{
+		illuminationEnabled = newStatus;
+
+		SendCommand(commandSetting);
+		SendCommand(settingIllumination);
+
+		if(illuminationEnabled)
+		{
+			SendCommand(1);
+		}
+		else
+		{
+			SendCommand(0);
+		}
+	}
+
+	void SetCursorPosition(uint8 newX, uint8 newY)
+	{
+		if(!newX || newX > 20) return;
+		if(!newY || newY > 4) return;
+
+		SendCommand(commandSetting);
+		SendCommand(settingCursorPosition);
+		SendCommand(newX);
+		SendCommand(newY);
+	}
 };
 
 #endif

source/Concept/Framework/engine.h

@@ -103,7 +103,7 @@ public:
 	{
 		curSpeed = newSpeed;
 
-		*pwmSpeed = abs(newSpeed / SPEED_PER_PWM);
+		*pwmSpeed = (abs((int16)(newSpeed / SPEED_PER_PWM)));
 
 		UpdateDirection();
 	}

source/Concept/Framework/keyboard.cpp

@@ -0,0 +1 @@
+#include "keyboard.h"

source/Concept/Framework/keyboard.h

@@ -0,0 +1,87 @@
+#ifndef _KEYBOARD_H
+#define _KEYBOARD_H
+
+#include "stdafx.h"
+
+class Keyboard : public IO_Module
+{
+public:
+	Keyboard()
+	{
+		this->parent = NULL;
+		this->moduleId = 0;
+		this->commandSetting = 0;
+		this->settingClearBuffer = 0;
+	}
+
+	Keyboard(uint32 keyboardId)
+	{
+		this->parent = NULL;
+		this->moduleId = keyboardId;
+		
+		switch(keyboardId)
+		{
+			case IO_KEYBOARD_MAIN:
+				this->commandSetting = 27;
+				this->settingClearBuffer = 123;
+				break;
+			default:
+				this->commandSetting = 0;
+				this->settingClearBuffer = 0;
+				break;
+		}
+	}
+
+protected:
+	//Commands
+	uint8 commandSetting;
+	//Settings
+	uint8 settingClearBuffer;
+
+	void SendCommand(uint8 newCommand)
+	{
+		switch(moduleId)
+		{
+			case IO_KEYBOARD_MAIN:
+				uart1_putc(newCommand);
+				break;
+			default:
+				break;
+		}
+	}
+
+public:
+	uint8 GetInput()
+	{
+		uint16 input = uart1_getc();
+
+		if(input == 0x100)//no data
+		{
+			return 0xEE;//empty
+		}
+		else if(input >= '0' && input <= '9')
+		{
+			return (uint8)(input - '0');
+		}
+		else if(input == '*')
+		{
+			return 10;
+		}
+		else if(input == '#')
+		{
+			return 11;
+		}
+		else
+		{
+			return 0xFF;//unknown
+		}
+	}
+
+	void ClearKeyBuffer()
+	{
+		SendCommand(commandSetting);
+		SendCommand(settingClearBuffer);
+	}
+};
+
+#endif

source/Concept/Framework/main.cpp

@@ -59,6 +59,14 @@ int main()
 				newSensor = NULL;
 				break;
 			}
+			case IO_SENSOR_MOUSE_LEFT:
+			case IO_SENSOR_MOUSE_RIGHT:
+			{
+				Mouse_Sensor* newSensor = new Mouse_Sensor(i);
+				localRobot->AddModule(newSensor);
+				newSensor = NULL;
+				break;
+			}
 			//Other cases
 			default:
 			{
@@ -86,9 +94,61 @@ int main()
 		newDisplay = NULL;
 	}
 
+	//Init Keyboards
+	for(uint8 i = IO_KEYBOARD_START; i < IO_KEYBOARD_END; i++)
+	{
+		Keyboard* newKeyboard = new Keyboard(i);
+		localRobot->AddModule(newKeyboard);
+		newKeyboard = NULL;
+	}
+
+	Keyboard* ourKeyboard = localRobot->GetModule<Keyboard>(IO_KEYBOARD_MAIN);
+	IR_Sensor* ourSensor = NULL;
+	uint16 value = 0;
+	Display* ourDisplay = localRobot->GetModule<Display>(IO_DISPLAY_MAIN);
+	uint32 i = 1;
+
 	//Run
 	while(true)
 	{
+		msleep(500);
+		ourDisplay->Clear();
+		ourDisplay->Print(i++);
+		ourDisplay->NewLine();
+		ourSensor = localRobot->GetModule<IR_Sensor>(IO_SENSOR_IR_0_DEG);
+		value = ourSensor->GetIRIntensity();
+		ourDisplay->Print(value, 1, 2);
+		ourDisplay->Print(";");
+		ourSensor = localRobot->GetModule<IR_Sensor>(IO_SENSOR_IR_30_DEG);
+		value = ourSensor->GetIRIntensity();
+		ourDisplay->Print(value);
+		ourDisplay->Print(";");
+		ourSensor = localRobot->GetModule<IR_Sensor>(IO_SENSOR_IR_60_DEG);
+		value = ourSensor->GetIRIntensity();
+		ourDisplay->Print(value);
+		ourDisplay->Print(";");
+		ourSensor = localRobot->GetModule<IR_Sensor>(IO_SENSOR_IR_100_DEG);
+		value = ourSensor->GetIRIntensity();
+		ourDisplay->Print(value);
+		ourDisplay->Print(";");
+		ourSensor = localRobot->GetModule<IR_Sensor>(IO_SENSOR_IR_180_DEG);
+		value = ourSensor->GetIRIntensity();
+		ourDisplay->Print(value, 1, 3);
+		ourDisplay->Print(";");
+		ourSensor = localRobot->GetModule<IR_Sensor>(IO_SENSOR_IR_260_DEG);
+		value = ourSensor->GetIRIntensity();
+		ourDisplay->Print(value);
+		ourDisplay->Print(";");
+		ourSensor = localRobot->GetModule<IR_Sensor>(IO_SENSOR_IR_300_DEG);
+		value = ourSensor->GetIRIntensity();
+		ourDisplay->Print(value);
+		ourDisplay->Print(";");
+		ourSensor = localRobot->GetModule<IR_Sensor>(IO_SENSOR_IR_330_DEG);
+		value = ourSensor->GetIRIntensity();
+		ourDisplay->Print(value);
+		ourDisplay->Print(";");
+		ourDisplay->Print(ourKeyboard->GetInput(), 1, 4);
+
 		localRobot->Update();
 	}
 

source/Concept/Framework/mouse_sensor.cpp

@@ -0,0 +1 @@
+#include "mouse_sensor.h"

source/Concept/Framework/mouse_sensor.h

@@ -0,0 +1,203 @@
+#ifndef _MOUSE_SENSOR_H
+#define _MOUSE_SENSOR_H
+
+#include "stdafx.h"
+#include "sensor.h"
+
+class Mouse_Sensor : public Sensor
+{
+public:
+	Mouse_Sensor()
+	{
+		this->parent = NULL;
+		this->moduleId = 0;
+		this->hardwarePort = NULL;
+		this->hardwareDDR = NULL;
+		this->hardwarePin = NULL;
+		this->pinSDA = 0;
+		this->pinSCK = 0;
+		this->registerConfig = 0;
+		this->registerPixelData = 0;
+		this->registerSqual = 0;
+		this->registerDeltaX = 0;
+		this->registerDeltaY = 0;
+		this->configReset = 0;
+		this->configAwake = 0;
+		this->newImage = false;
+	}
+
+	Mouse_Sensor(uint32 sensorId)
+	{
+		this->parent = NULL;
+		this->moduleId = sensorId;
+		this->newImage = false;
+
+		switch(sensorId)
+		{
+			case IO_SENSOR_MOUSE_LEFT:
+				this->hardwarePort = &PORTC;
+				this->hardwareDDR = &DDRC;
+				this->hardwarePin = &PINC;
+				this->pinSDA = (1 << 4);
+				this->pinSCK = (1 << 6);
+				this->registerConfig = 0x00;
+				this->registerPixelData = 0x08;
+				this->registerSqual = 0x4;
+				this->registerDeltaX = 0x3;
+				this->registerDeltaY = 0x2;
+				this->configReset = 0x80;
+				this->configAwake = 0x01;
+				break;
+			case IO_SENSOR_MOUSE_RIGHT:
+				this->hardwarePort = &PORTC;
+				this->hardwareDDR = &DDRC;
+				this->hardwarePin = &PINC;
+				this->pinSDA = (1 << 5);
+				this->pinSCK = (1 << 7);
+				this->registerConfig = 0x00;
+				this->registerPixelData = 0x08;
+				this->registerSqual = 0x4;
+				this->registerDeltaX = 0x3;
+				this->registerDeltaY = 0x2;
+				this->configReset = 0x80;
+				this->configAwake = 0x01;
+				break;
+			default:
+				this->hardwarePort = NULL;
+				this->hardwareDDR = NULL;
+				this->hardwarePin = NULL;
+				this->pinSDA = 0;
+				this->pinSCK = 0;
+				this->registerConfig = 0;
+				this->registerPixelData = 0;
+				this->registerSqual = 0;
+				this->registerDeltaX = 0;
+				this->registerDeltaY = 0;
+				this->configReset = 0;
+				this->configAwake = 0;
+				break;
+		}
+
+		msleep(100);
+
+		*hardwareDDR  |= pinSCK;
+		*hardwarePort &= ~pinSCK;
+	
+		msleep(10);
+	
+		Write(registerConfig, configReset);
+		Write(registerConfig, configAwake);
+	}
+
+protected:
+	//Hardware
+	volatile uint8* hardwarePort;
+	volatile uint8* hardwareDDR;
+	volatile uint8* hardwarePin;
+	uint8 pinSDA;
+	uint8 pinSCK;
+	bool newImage;
+	//Registers and Settings
+	uint8 registerConfig;
+	uint8 registerPixelData;
+	uint8 registerSqual;
+	uint8 registerDeltaX;
+	uint8 registerDeltaY;
+	uint8 configReset;
+	uint8 configAwake;
+
+public:
+	void WriteByte(uint8 newByte)
+	{
+		*hardwareDDR |= pinSDA;//Set SDA output
+	
+		for(uint8 i = 0; i < 8; i++)
+		{
+			*hardwarePort &= ~pinSCK;//prepare SCK
+		
+			//write data
+			*hardwarePort = (*hardwarePort & (~(*hardwarePin))) | 
+				((newByte >> 7) * pinSDA);
+
+			newByte = newByte << 1;//prepare next byte
+			asm volatile("nop");
+		
+			*hardwarePort |= pinSCK;
+		}
+	}
+
+	void Write(int8 adr, uint8 data)
+	{	
+		WriteByte(adr | 0x80);
+		WriteByte(data);
+		usleep(100);
+	}
+
+	uint8 ReadByte()
+	{
+		uint8 data=0;
+
+		*hardwareDDR  &= ~pinSDA;//Set SDA input
+
+		for(uint8 i = 0; i < 8; i++)
+		{
+			*hardwarePort &= ~pinSCK;//Prepare data
+			data = data << 1;
+
+			asm volatile("nop");
+			*hardwarePort |= pinSCK;//Prepare for reading
+
+			data |= (*hardwarePin & pinSDA) / pinSDA;
+		}
+
+		return data;
+	}
+
+	uint8 Read(uint8 adr)
+	{
+		WriteByte(adr);
+		usleep(100);
+	
+		return ReadByte();
+	}
+
+	void ImagePrepare()
+	{
+		Write(registerConfig, configAwake);
+		Write(registerPixelData, 0x00);
+
+		newImage = true;
+	}
+
+	uint8 ImageRead()
+	{
+		uint8 pixel = Read(registerPixelData);
+		if(newImage)
+		{
+			while (!(pixel & 0x80))//0x80 indicates first pixel
+			{
+				pixel=Read(registerPixelData);
+			}
+			newImage = false;
+		}
+	
+		return pixel;
+	}
+
+	uint8 GetSqual()
+	{
+		return Read(registerSqual);
+	}
+
+	int8 GetXMovement()
+	{
+		return (int8)(Read(registerDeltaX));
+	}
+
+	int8 GetYMovement()
+	{
+		return (int8)(Read(registerDeltaY));
+	}
+};
+
+#endif

source/Concept/Framework/position_tracker.cpp

@@ -0,0 +1,7 @@
+#include "position_tracker.h"
+
+//-----------------------------------------------------------------------------
+void Position_Tracker::Update()
+{
+	//insert code here
+}

source/Concept/Framework/position_tracker.h

@@ -0,0 +1,27 @@
+#ifndef _POSITION_TRACKER_H
+#define _POSITION_TRACKER_H
+
+#include "stdafx.h"
+
+class Position_Tracker : public IO_Module
+{
+public:
+	Position_Tracker()
+	{
+		this->parent = NULL;
+		this->moduleId = 0;
+	}
+
+	Position_Tracker(uint32 trackerId)
+	{
+		this->parent = NULL;
+		this->moduleId = trackerId;
+	}
+
+protected:
+
+public:
+	void Update();
+};
+
+#endif

source/Concept/Framework/robot.cpp

@@ -95,8 +95,8 @@ uint16 Robot::GetADCValue(uint8 channel)
 
 	uint32 result = 0;
 	
-	//Activate ADC and set division factor to 64
+	//Activate ADC and set division factor to 8
-	ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1);
+	ADCSRA = (1 << ADEN) | (1 << ADPS1) | (1 << ADPS0);
 
 	//Set multiplexer channel
 	ADMUX = channel;

source/Concept/Framework/stdafx.h

@@ -9,6 +9,7 @@
 #include "tools.h"
 #include "io_module.h"
 #include "display.h"
+#include "keyboard.h"
 #include "sensor.h"
 #include "engine.h"
 #include "dribbler.h"
@@ -16,4 +17,6 @@
 #include "led.h"
 #include "distance_sensor.h"
 #include "ir_sensor.h"
+#include "mouse_sensor.h"
+#include "position_tracker.h"
 #include "robot.h"