aboutsummaryrefslogtreecommitdiff
path: root/libraries/Robot_Control/utility
diff options
context:
space:
mode:
Diffstat (limited to 'libraries/Robot_Control/utility')
-rw-r--r--libraries/Robot_Control/utility/RobotTextManager.cpp192
-rw-r--r--libraries/Robot_Control/utility/RobotTextManager.h77
-rw-r--r--libraries/Robot_Control/utility/VirtualKeyboard.cpp127
-rw-r--r--libraries/Robot_Control/utility/VirtualKeyboard.h28
-rw-r--r--libraries/Robot_Control/utility/scripts_Hello_User.h51
-rw-r--r--libraries/Robot_Control/utility/twi.c527
-rw-r--r--libraries/Robot_Control/utility/twi.h53
7 files changed, 1055 insertions, 0 deletions
diff --git a/libraries/Robot_Control/utility/RobotTextManager.cpp b/libraries/Robot_Control/utility/RobotTextManager.cpp
new file mode 100644
index 0000000..b516409
--- /dev/null
+++ b/libraries/Robot_Control/utility/RobotTextManager.cpp
@@ -0,0 +1,192 @@
+#include <avr/pgmspace.h>
+#include <ArduinoRobot.h>
+#include "VirtualKeyboard.h"
+#include "RobotTextManager.h"
+#include "scripts_Hello_User.h"
+
+const int TextManager::lineHeight=10;
+const int TextManager::charWidth=6;
+
+
+void TextManager::setMargin(int margin_left,int margin_top){
+ this->margin_left=margin_left;
+ this->margin_top=margin_top;
+}
+int TextManager::getLin(int lineNum){
+ return lineNum*lineHeight+margin_top;
+}
+
+int TextManager::getCol(int colNum){
+ return colNum*charWidth+margin_left;
+}
+
+void TextManager::writeText(int lineNum, int colNum, char* txt, bool onOff){
+ if(!onOff)
+ Robot.setTextColor(WHITE);
+
+ Robot.setCursor(getCol(colNum),getLin(lineNum));
+ Robot.print(txt);
+
+ Robot.setTextColor(BLACK);
+}
+
+void TextManager::drawInput(bool onOff){
+ if(!onOff)
+ Robot.setTextColor(WHITE);
+
+ Robot.setCursor(getCol(inputCol),getLin(inputLin)+1);
+ Robot.print('_');
+
+ Robot.setTextColor(BLACK);
+
+}
+
+void TextManager::mvInput(int dire){
+ drawInput(0);
+ if(dire<0){
+ if(inputPos>0){
+ inputPos--;
+ inputCol--;
+ }
+ }else{
+ if(inputPos<16){
+ inputPos++;
+ inputCol++;
+ }
+ }
+ drawInput(1);
+}
+
+char TextManager::selectLetter(){
+ static int oldVal;
+ char val=map(Robot.knobRead(),0,1023,32,125);
+ if(val==oldVal){
+ return 0; //No changes
+ }else{
+ oldVal=val;
+ return val; //Current letter
+ }
+}
+
+void TextManager::refreshCurrentLetter(char letter){
+ if(letter){
+ writeText(inputLin,inputCol,inputPool+inputPos,false);//erase
+ inputPool[inputPos]=letter;
+ writeText(inputLin,inputCol,inputPool+inputPos,true);//write
+ }
+}
+
+
+void TextManager::getInput(int lin, int col){
+ writeText(lin,col,">"); //Input indicator
+
+ writeText(lin, col+1, inputPool);
+
+ inputLin=lin; //Ini input cursor
+ inputCol=col+1;
+ inputPos=0;
+ drawInput(true);
+
+ Vkey.display(100);//Vkey is a object of VirtualKeyboard class
+
+ while(true){
+ switch(Robot.keyboardRead()){
+ case BUTTON_LEFT:
+ //Robot.beep(BEEP_SIMPLE);
+ mvInput(-1);
+ break;
+ case BUTTON_RIGHT:
+ //Robot.beep(BEEP_SIMPLE);
+ mvInput(1);
+ break;
+ case BUTTON_MIDDLE:
+ //Robot.beep(BEEP_DOUBLE);
+ char selection=Vkey.getSelection();
+ if(selection!='\0'){
+ refreshCurrentLetter(selection);
+ mvInput(1);
+ }else{
+ drawInput(false);
+ return;
+ }
+ }
+ Vkey.run();
+ delay(10);
+ }
+}
+void TextManager::setInputPool(int code){
+ switch(code){
+ case USERNAME:
+ Robot.userNameRead(inputPool);
+ break;
+ case ROBOTNAME:
+ Robot.robotNameRead(inputPool);
+ break;
+ case CITYNAME:
+ Robot.cityNameRead(inputPool);
+ break;
+ case COUNTRYNAME:
+ Robot.countryNameRead(inputPool);
+ break;
+ }
+ for(int i=0;i<18;i++){
+ if(inputPool[i]=='\0'){
+ for(int j=i;j<18;j++){
+ inputPool[j]='\0';
+ }
+ break;
+ }
+ }
+}
+void TextManager::pushInput(int code){
+ switch(code){
+ case USERNAME:
+ Robot.userNameWrite(inputPool);
+ break;
+ case ROBOTNAME:
+ Robot.robotNameWrite(inputPool);
+ break;
+ case CITYNAME:
+ Robot.cityNameWrite(inputPool);
+ break;
+ case COUNTRYNAME:
+ Robot.countryNameWrite(inputPool);
+ break;
+ }
+ for(int i=0;i<18;i++){
+ inputPool[i]='\0';
+ }
+}
+void TextManager::input(int lin,int col, int code){
+ setInputPool(code);
+ getInput(lin,col);
+ pushInput(code);
+}
+
+void TextManager::showPicture(char * filename, int posX, int posY){
+ Robot.pause();
+ Robot._drawBMP(filename,posX,posY);
+ Robot.play();
+}
+
+void TextManager::getPGMtext(int seq){
+ //It takes a string from program space, and fill it
+ //in the buffer
+ //if(in hello user example){
+ if(true){
+ strcpy_P(PGMbuffer,(char*)pgm_read_word(&(::scripts_Hello_User[seq])));
+ }
+}
+
+void TextManager::writeScript(int seq, int line, int col){
+ //print a string from program space to a specific line,
+ //column on the LCD
+
+ //first fill the buffer with text from program space
+ getPGMtext(seq);
+ //then print it to the screen
+ textManager.writeText(line,col,PGMbuffer);
+}
+
+
+TextManager textManager=TextManager();
diff --git a/libraries/Robot_Control/utility/RobotTextManager.h b/libraries/Robot_Control/utility/RobotTextManager.h
new file mode 100644
index 0000000..6c0b7bd
--- /dev/null
+++ b/libraries/Robot_Control/utility/RobotTextManager.h
@@ -0,0 +1,77 @@
+#ifndef ROBOTTEXTMANAGER_H
+#define ROBOTTEXTMANAGER_H
+
+#define USERNAME 0
+#define ROBOTNAME 1
+#define CITYNAME 2
+#define COUNTRYNAME 3
+#define EMPTY 4
+
+class TextManager{
+ //The TextManager class is a collection of features specific for Hello
+ //User example.
+ //
+ //- It includes solution for setting text position based on
+ // line/column. The original Robot.text(), or the more low level
+ // print() function can only set text position on pixels from left,
+ // top.
+ //
+ //- The process of accepting input with the virtual keyboard, saving
+ // into or reading from EEPROM is delt with here.
+ //
+ //- A workflow for stop the music while displaying image. Trouble
+ // will happen otherwise.
+
+ public:
+ //add some margin to the text, left side only atm.
+ void setMargin(int margin_left,int margin_top);
+
+ //print text based on line, column.
+ void writeText(int lineNum, int colNum, char* txt, bool onOff=true);
+
+ //print a script from the scripts library
+ void writeScript(int seq, int line, int col);
+
+ //The whole process of getting input
+ void input(int lin,int col, int code);
+ //Print a cursor and virtual keyboard on screen, and save the user's input
+ void getInput(int lin, int col);
+ //Get user name, robot name, city name or country name from EEPROM
+ //and store in the input pool.
+ void setInputPool(int code);
+ //save user input to EEPROM
+ void pushInput(int code);
+
+ //Replaces Robot.drawPicture(), as this one solves collision between
+ //image and music
+ void showPicture(char * filename, int posX, int posY);
+
+ private:
+ int margin_left,margin_top;
+ int getLin(int lineNum); //Convert line to pixels from top
+ int getCol(int colNum); //Convert line to pixels from left
+
+ static const int lineHeight;//8+2=10
+ static const int charWidth;//5+1=6
+
+ int inputPos;
+ int inputLin;
+ int inputCol;
+
+ void drawInput(bool onOff);
+ void mvInput(int dire);
+
+ char selectLetter();
+ void refreshCurrentLetter(char letter);
+
+ void getPGMtext(int seq);
+
+ char PGMbuffer[85]; //the buffer for storing strings
+ char inputPool[18];
+};
+
+//a trick for removing the need of creating an object of TextManager.
+//So you can call me.somefunction() directly in the sketch.
+extern TextManager textManager;
+
+#endif
diff --git a/libraries/Robot_Control/utility/VirtualKeyboard.cpp b/libraries/Robot_Control/utility/VirtualKeyboard.cpp
new file mode 100644
index 0000000..ad73c75
--- /dev/null
+++ b/libraries/Robot_Control/utility/VirtualKeyboard.cpp
@@ -0,0 +1,127 @@
+#include "VirtualKeyboard.h"
+
+int VirtualKeyboard::getColLin(int val){
+ uint8_t col,lin;
+ lin=val/10;
+ col=val%10; // saving 36 bytes :(
+ /*if(0<=val && 9>=val){
+ col=val;
+ lin=0;
+ }else if(10<=val && 19>=val){
+ col=val-10;
+ lin=1;
+ }else if(20<=val && 29>=val){
+ col=val-20;
+ lin=2;
+ }else if(30<=val && 39>=val){
+ col=val-30;
+ lin=3;
+ }*/
+ return (col<<8)+lin; //Put col and lin in one int
+}
+void VirtualKeyboard::run(){
+/** visually select a letter on the keyboard
+* The selection boarder is 1px higher than the character,
+* 1px on the bottom, 2px to the left and 2px to the right.
+*
+*/
+ if(!onOff)return;
+ //Serial.println(onOff);
+ static int oldColLin=0;
+ uint8_t val=map(Robot.knobRead(),0,1023,0,38);
+ if(val==38)val=37; //The last value is jumpy when using batteries
+ int colLin=getColLin(val);
+
+ if(oldColLin!=colLin){
+ uint8_t x=(oldColLin>>8 & 0xFF)*11+10;//col*11+1+9
+ uint8_t y=(oldColLin & 0xFF)*11+1+top;//lin*11+1+top
+ uint8_t w=9;
+ if(oldColLin==1795) //last item "Enter", col=7 lin=3
+ w=33; //(5+1)*6-1+2+2 charWidth=5, charMargin=1, count("Enter")=6, lastItem_MarginRight=0, marginLeft==marginRight=2
+ Robot.drawRect(x,y,w,9,hideColor);
+
+
+ x=(colLin>>8 & 0xFF)*11+10;
+ y=(colLin & 0xFF)*11+1+top;
+ w=9;
+ if(colLin==1795) //last item "Enter", col=7 lin=3
+ w=33; //(5+1)*6-1+2+2 charWidth=5, charMargin=1, count("Enter")=6, lastItem_MarginRight=0, marginLeft==marginRight=2
+ Robot.drawRect(x,y,w,9,showColor);
+ oldColLin=colLin;
+ }
+}
+
+char VirtualKeyboard::getSelection(){
+ if(!onOff)return -1;
+
+ uint8_t val=map(Robot.knobRead(),0,1023,0,38);
+ if(0<=val && 9>=val)
+ val='0'+val;
+ else if(10<=val && 35>=val)
+ val='A'+val-10;
+ else if(val==36)
+ val=' ';
+ else if(val>=37)
+ val='\0';
+
+ return val;
+}
+void VirtualKeyboard::hide(){
+ onOff=false;
+ Robot.fillRect(0,top,128,44,hideColor);//11*4
+}
+
+void VirtualKeyboard::display(uint8_t top, uint16_t showColor, uint16_t hideColor){
+/** Display the keyboard at y position of top
+* formular:
+* When text size is 1, one character is 5*7
+* margin-left==margin-right==3,
+* margin-top==margin-bottom==2,
+* keyWidth=5+3+3==11,
+* keyHeight=7+2+2==11,
+* keyboard-margin-left=keyboard-margin-right==9
+* so character-x=11*col+9+3=11*col+12
+* character-y=11*lin+2+top
+*
+**/
+ this->top=top;
+ this->onOff=true;
+
+ this->showColor=showColor;
+ this->hideColor=hideColor;
+
+ for(uint8_t i=0;i<36;i++){
+ Robot.setCursor(i%10*11+12,2+top+i/10*11);
+ if(i<10)
+ Robot.print(char('0'+i));
+ else
+ Robot.print(char(55+i));//'A'-10=55
+ }//for saving 58 bytes :(
+
+ /*for(int i=0;i<10;i++){
+ Robot.setCursor(i*11+12,2+top);//11*0+2+top
+ Robot.print(char('0'+i));//line_1: 0-9
+ }
+ for(int i=0;i<10;i++){
+ Robot.setCursor(i*11+12,13+top);//11*1+2+top
+ Robot.print(char('A'+i));//line_2: A-J
+ }
+ for(int i=0;i<10;i++){
+ Robot.setCursor(i*11+12,24+top);//11*2+2+top
+ Robot.print(char('K'+i));//line_3: K-T
+ }
+ for(int i=0;i<6;i++){
+ Robot.setCursor(i*11+12,35+top);//11*3+2+top
+ Robot.print(char('U'+i));//line_4: U-Z
+ }*/
+ //space and enter at the end of the last line.
+ Robot.setCursor(78,35+top);//6*11+12=78
+ Robot.print('_');//_
+
+ Robot.setCursor(89,35+top);//7*11+12=89
+ Robot.print("Enter");//enter
+}
+
+
+
+VirtualKeyboard Vkey=VirtualKeyboard(); \ No newline at end of file
diff --git a/libraries/Robot_Control/utility/VirtualKeyboard.h b/libraries/Robot_Control/utility/VirtualKeyboard.h
new file mode 100644
index 0000000..273edb7
--- /dev/null
+++ b/libraries/Robot_Control/utility/VirtualKeyboard.h
@@ -0,0 +1,28 @@
+#ifndef VIRTUAL_KEYBOARD_H
+#define VIRTUAL_KEYBOARD_H
+
+#include <Arduino.h>
+#include <ArduinoRobot.h>
+
+class VirtualKeyboard{
+ public:
+ //void begin();
+ void display(uint8_t top, uint16_t showColor=BLACK, uint16_t hideColor=WHITE);
+ void hide();
+
+ char getSelection();
+ void run();
+
+ private:
+ uint8_t top;
+ bool onOff;
+
+ uint16_t showColor;
+ uint16_t hideColor;
+
+ int getColLin(int val);
+
+};
+
+extern VirtualKeyboard Vkey;
+#endif \ No newline at end of file
diff --git a/libraries/Robot_Control/utility/scripts_Hello_User.h b/libraries/Robot_Control/utility/scripts_Hello_User.h
new file mode 100644
index 0000000..29f085f
--- /dev/null
+++ b/libraries/Robot_Control/utility/scripts_Hello_User.h
@@ -0,0 +1,51 @@
+#include <avr/pgmspace.h>
+
+//an advanced trick for storing strings inside the program space
+//as the ram of Arduino is very tiny, keeping too many string in it
+//can kill the program
+
+prog_char hello_user_script1[] PROGMEM="What's your name?";
+prog_char hello_user_script2[] PROGMEM="Give me a name!";
+prog_char hello_user_script3[] PROGMEM="And the country?";
+prog_char hello_user_script4[] PROGMEM="The city you're in?";
+prog_char hello_user_script5[] PROGMEM=" Plug me to\n\n your computer\n\n and start coding!";
+
+prog_char hello_user_script6[] PROGMEM=" Hello User!\n\n It's me, your robot\n\n I'm alive! <3";
+prog_char hello_user_script7[] PROGMEM=" First I need some\n\n input from you!";
+prog_char hello_user_script8[] PROGMEM=" Use the knob\n\n to select letters";
+prog_char hello_user_script9[] PROGMEM=" Use L/R button\n\n to move the cursor,\n\n middle to confirm";
+prog_char hello_user_script10[] PROGMEM=" Press middle key\n to continue...";
+prog_char hello_user_script11[] PROGMEM=" Choose \"enter\" to\n\n finish the input";
+
+PROGMEM const char *scripts_Hello_User[]={
+ hello_user_script1,
+ hello_user_script2,
+ hello_user_script3,
+ hello_user_script4,
+ hello_user_script5,
+ hello_user_script6,
+ hello_user_script7,
+ hello_user_script8,
+ hello_user_script9,
+ hello_user_script10,
+ hello_user_script11,
+};
+
+/*
+void getPGMtext(int seq){
+ //It takes a string from program space, and fill it
+ //in the buffer
+ strcpy_P(buffer,(char*)pgm_read_word(&(scripts[seq])));
+}
+
+void writeScript(int seq, int line, int col){
+ //print a string from program space to a specific line,
+ //column on the LCD
+
+ //first fill the buffer with text from program space
+ getPGMtext(seq);
+ //then print it to the screen
+ textManager.writeText(line,col,buffer);
+}
+
+*/ \ No newline at end of file
diff --git a/libraries/Robot_Control/utility/twi.c b/libraries/Robot_Control/utility/twi.c
new file mode 100644
index 0000000..6b2db3c
--- /dev/null
+++ b/libraries/Robot_Control/utility/twi.c
@@ -0,0 +1,527 @@
+/*
+ twi.c - TWI/I2C library for Wiring & Arduino
+ Copyright (c) 2006 Nicholas Zambetti. All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+ Modified 2012 by Todd Krein (todd@krein.org) to implement repeated starts
+*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <compat/twi.h>
+#include "Arduino.h" // for digitalWrite
+
+#ifndef cbi
+#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
+#endif
+
+#ifndef sbi
+#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
+#endif
+
+#include "pins_arduino.h"
+#include "twi.h"
+
+static volatile uint8_t twi_state;
+static volatile uint8_t twi_slarw;
+static volatile uint8_t twi_sendStop; // should the transaction end with a stop
+static volatile uint8_t twi_inRepStart; // in the middle of a repeated start
+
+static void (*twi_onSlaveTransmit)(void);
+static void (*twi_onSlaveReceive)(uint8_t*, int);
+
+static uint8_t twi_masterBuffer[TWI_BUFFER_LENGTH];
+static volatile uint8_t twi_masterBufferIndex;
+static volatile uint8_t twi_masterBufferLength;
+
+static uint8_t twi_txBuffer[TWI_BUFFER_LENGTH];
+static volatile uint8_t twi_txBufferIndex;
+static volatile uint8_t twi_txBufferLength;
+
+static uint8_t twi_rxBuffer[TWI_BUFFER_LENGTH];
+static volatile uint8_t twi_rxBufferIndex;
+
+static volatile uint8_t twi_error;
+
+/*
+ * Function twi_init
+ * Desc readys twi pins and sets twi bitrate
+ * Input none
+ * Output none
+ */
+void twi_init(void)
+{
+ // initialize state
+ twi_state = TWI_READY;
+ twi_sendStop = true; // default value
+ twi_inRepStart = false;
+
+ // activate internal pullups for twi.
+ digitalWrite(SDA, 1);
+ digitalWrite(SCL, 1);
+
+ // initialize twi prescaler and bit rate
+ cbi(TWSR, TWPS0);
+ cbi(TWSR, TWPS1);
+ TWBR = ((F_CPU / TWI_FREQ) - 16) / 2;
+
+ /* twi bit rate formula from atmega128 manual pg 204
+ SCL Frequency = CPU Clock Frequency / (16 + (2 * TWBR))
+ note: TWBR should be 10 or higher for master mode
+ It is 72 for a 16mhz Wiring board with 100kHz TWI */
+
+ // enable twi module, acks, and twi interrupt
+ TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA);
+}
+
+/*
+ * Function twi_slaveInit
+ * Desc sets slave address and enables interrupt
+ * Input none
+ * Output none
+ */
+void twi_setAddress(uint8_t address)
+{
+ // set twi slave address (skip over TWGCE bit)
+ TWAR = address << 1;
+}
+
+/*
+ * Function twi_readFrom
+ * Desc attempts to become twi bus master and read a
+ * series of bytes from a device on the bus
+ * Input address: 7bit i2c device address
+ * data: pointer to byte array
+ * length: number of bytes to read into array
+ * sendStop: Boolean indicating whether to send a stop at the end
+ * Output number of bytes read
+ */
+uint8_t twi_readFrom(uint8_t address, uint8_t* data, uint8_t length, uint8_t sendStop)
+{
+ uint8_t i;
+
+ // ensure data will fit into buffer
+ if(TWI_BUFFER_LENGTH < length){
+ return 0;
+ }
+
+ // wait until twi is ready, become master receiver
+ while(TWI_READY != twi_state){
+ continue;
+ }
+ twi_state = TWI_MRX;
+ twi_sendStop = sendStop;
+ // reset error state (0xFF.. no error occured)
+ twi_error = 0xFF;
+
+ // initialize buffer iteration vars
+ twi_masterBufferIndex = 0;
+ twi_masterBufferLength = length-1; // This is not intuitive, read on...
+ // On receive, the previously configured ACK/NACK setting is transmitted in
+ // response to the received byte before the interrupt is signalled.
+ // Therefor we must actually set NACK when the _next_ to last byte is
+ // received, causing that NACK to be sent in response to receiving the last
+ // expected byte of data.
+
+ // build sla+w, slave device address + w bit
+ twi_slarw = TW_READ;
+ twi_slarw |= address << 1;
+
+ if (true == twi_inRepStart) {
+ // if we're in the repeated start state, then we've already sent the start,
+ // (@@@ we hope), and the TWI statemachine is just waiting for the address byte.
+ // We need to remove ourselves from the repeated start state before we enable interrupts,
+ // since the ISR is ASYNC, and we could get confused if we hit the ISR before cleaning
+ // up. Also, don't enable the START interrupt. There may be one pending from the
+ // repeated start that we sent outselves, and that would really confuse things.
+ twi_inRepStart = false; // remember, we're dealing with an ASYNC ISR
+ TWDR = twi_slarw;
+ TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN) | _BV(TWIE); // enable INTs, but not START
+ }
+ else
+ // send start condition
+ TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT) | _BV(TWSTA);
+
+ // wait for read operation to complete
+ while(TWI_MRX == twi_state){
+ continue;
+ }
+
+ if (twi_masterBufferIndex < length)
+ length = twi_masterBufferIndex;
+
+ // copy twi buffer to data
+ for(i = 0; i < length; ++i){
+ data[i] = twi_masterBuffer[i];
+ }
+
+ return length;
+}
+
+/*
+ * Function twi_writeTo
+ * Desc attempts to become twi bus master and write a
+ * series of bytes to a device on the bus
+ * Input address: 7bit i2c device address
+ * data: pointer to byte array
+ * length: number of bytes in array
+ * wait: boolean indicating to wait for write or not
+ * sendStop: boolean indicating whether or not to send a stop at the end
+ * Output 0 .. success
+ * 1 .. length to long for buffer
+ * 2 .. address send, NACK received
+ * 3 .. data send, NACK received
+ * 4 .. other twi error (lost bus arbitration, bus error, ..)
+ */
+uint8_t twi_writeTo(uint8_t address, uint8_t* data, uint8_t length, uint8_t wait, uint8_t sendStop)
+{
+ uint8_t i;
+
+ // ensure data will fit into buffer
+ if(TWI_BUFFER_LENGTH < length){
+ return 1;
+ }
+
+ // wait until twi is ready, become master transmitter
+ while(TWI_READY != twi_state){
+ continue;
+ }
+ twi_state = TWI_MTX;
+ twi_sendStop = sendStop;
+ // reset error state (0xFF.. no error occured)
+ twi_error = 0xFF;
+
+ // initialize buffer iteration vars
+ twi_masterBufferIndex = 0;
+ twi_masterBufferLength = length;
+
+ // copy data to twi buffer
+ for(i = 0; i < length; ++i){
+ twi_masterBuffer[i] = data[i];
+ }
+
+ // build sla+w, slave device address + w bit
+ twi_slarw = TW_WRITE;
+ twi_slarw |= address << 1;
+
+ // if we're in a repeated start, then we've already sent the START
+ // in the ISR. Don't do it again.
+ //
+ if (true == twi_inRepStart) {
+ // if we're in the repeated start state, then we've already sent the start,
+ // (@@@ we hope), and the TWI statemachine is just waiting for the address byte.
+ // We need to remove ourselves from the repeated start state before we enable interrupts,
+ // since the ISR is ASYNC, and we could get confused if we hit the ISR before cleaning
+ // up. Also, don't enable the START interrupt. There may be one pending from the
+ // repeated start that we sent outselves, and that would really confuse things.
+ twi_inRepStart = false; // remember, we're dealing with an ASYNC ISR
+ TWDR = twi_slarw;
+ TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN) | _BV(TWIE); // enable INTs, but not START
+ }
+ else
+ // send start condition
+ TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN) | _BV(TWIE) | _BV(TWSTA); // enable INTs
+
+ // wait for write operation to complete
+ while(wait && (TWI_MTX == twi_state)){
+ continue;
+ }
+
+ if (twi_error == 0xFF)
+ return 0; // success
+ else if (twi_error == TW_MT_SLA_NACK)
+ return 2; // error: address send, nack received
+ else if (twi_error == TW_MT_DATA_NACK)
+ return 3; // error: data send, nack received
+ else
+ return 4; // other twi error
+}
+
+/*
+ * Function twi_transmit
+ * Desc fills slave tx buffer with data
+ * must be called in slave tx event callback
+ * Input data: pointer to byte array
+ * length: number of bytes in array
+ * Output 1 length too long for buffer
+ * 2 not slave transmitter
+ * 0 ok
+ */
+uint8_t twi_transmit(const uint8_t* data, uint8_t length)
+{
+ uint8_t i;
+
+ // ensure data will fit into buffer
+ if(TWI_BUFFER_LENGTH < length){
+ return 1;
+ }
+
+ // ensure we are currently a slave transmitter
+ if(TWI_STX != twi_state){
+ return 2;
+ }
+
+ // set length and copy data into tx buffer
+ twi_txBufferLength = length;
+ for(i = 0; i < length; ++i){
+ twi_txBuffer[i] = data[i];
+ }
+
+ return 0;
+}
+
+/*
+ * Function twi_attachSlaveRxEvent
+ * Desc sets function called before a slave read operation
+ * Input function: callback function to use
+ * Output none
+ */
+void twi_attachSlaveRxEvent( void (*function)(uint8_t*, int) )
+{
+ twi_onSlaveReceive = function;
+}
+
+/*
+ * Function twi_attachSlaveTxEvent
+ * Desc sets function called before a slave write operation
+ * Input function: callback function to use
+ * Output none
+ */
+void twi_attachSlaveTxEvent( void (*function)(void) )
+{
+ twi_onSlaveTransmit = function;
+}
+
+/*
+ * Function twi_reply
+ * Desc sends byte or readys receive line
+ * Input ack: byte indicating to ack or to nack
+ * Output none
+ */
+void twi_reply(uint8_t ack)
+{
+ // transmit master read ready signal, with or without ack
+ if(ack){
+ TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT) | _BV(TWEA);
+ }else{
+ TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT);
+ }
+}
+
+/*
+ * Function twi_stop
+ * Desc relinquishes bus master status
+ * Input none
+ * Output none
+ */
+void twi_stop(void)
+{
+ // send stop condition
+ TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT) | _BV(TWSTO);
+
+ // wait for stop condition to be exectued on bus
+ // TWINT is not set after a stop condition!
+ while(TWCR & _BV(TWSTO)){
+ continue;
+ }
+
+ // update twi state
+ twi_state = TWI_READY;
+}
+
+/*
+ * Function twi_releaseBus
+ * Desc releases bus control
+ * Input none
+ * Output none
+ */
+void twi_releaseBus(void)
+{
+ // release bus
+ TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT);
+
+ // update twi state
+ twi_state = TWI_READY;
+}
+
+SIGNAL(TWI_vect)
+{
+ switch(TW_STATUS){
+ // All Master
+ case TW_START: // sent start condition
+ case TW_REP_START: // sent repeated start condition
+ // copy device address and r/w bit to output register and ack
+ TWDR = twi_slarw;
+ twi_reply(1);
+ break;
+
+ // Master Transmitter
+ case TW_MT_SLA_ACK: // slave receiver acked address
+ case TW_MT_DATA_ACK: // slave receiver acked data
+ // if there is data to send, send it, otherwise stop
+ if(twi_masterBufferIndex < twi_masterBufferLength){
+ // copy data to output register and ack
+ TWDR = twi_masterBuffer[twi_masterBufferIndex++];
+ twi_reply(1);
+ }else{
+ if (twi_sendStop)
+ twi_stop();
+ else {
+ twi_inRepStart = true; // we're gonna send the START
+ // don't enable the interrupt. We'll generate the start, but we
+ // avoid handling the interrupt until we're in the next transaction,
+ // at the point where we would normally issue the start.
+ TWCR = _BV(TWINT) | _BV(TWSTA)| _BV(TWEN) ;
+ twi_state = TWI_READY;
+ }
+ }
+ break;
+ case TW_MT_SLA_NACK: // address sent, nack received
+ twi_error = TW_MT_SLA_NACK;
+ twi_stop();
+ break;
+ case TW_MT_DATA_NACK: // data sent, nack received
+ twi_error = TW_MT_DATA_NACK;
+ twi_stop();
+ break;
+ case TW_MT_ARB_LOST: // lost bus arbitration
+ twi_error = TW_MT_ARB_LOST;
+ twi_releaseBus();
+ break;
+
+ // Master Receiver
+ case TW_MR_DATA_ACK: // data received, ack sent
+ // put byte into buffer
+ twi_masterBuffer[twi_masterBufferIndex++] = TWDR;
+ case TW_MR_SLA_ACK: // address sent, ack received
+ // ack if more bytes are expected, otherwise nack
+ if(twi_masterBufferIndex < twi_masterBufferLength){
+ twi_reply(1);
+ }else{
+ twi_reply(0);
+ }
+ break;
+ case TW_MR_DATA_NACK: // data received, nack sent
+ // put final byte into buffer
+ twi_masterBuffer[twi_masterBufferIndex++] = TWDR;
+ if (twi_sendStop)
+ twi_stop();
+ else {
+ twi_inRepStart = true; // we're gonna send the START
+ // don't enable the interrupt. We'll generate the start, but we
+ // avoid handling the interrupt until we're in the next transaction,
+ // at the point where we would normally issue the start.
+ TWCR = _BV(TWINT) | _BV(TWSTA)| _BV(TWEN) ;
+ twi_state = TWI_READY;
+ }
+ break;
+ case TW_MR_SLA_NACK: // address sent, nack received
+ twi_stop();
+ break;
+ // TW_MR_ARB_LOST handled by TW_MT_ARB_LOST case
+
+ // Slave Receiver
+ case TW_SR_SLA_ACK: // addressed, returned ack
+ case TW_SR_GCALL_ACK: // addressed generally, returned ack
+ case TW_SR_ARB_LOST_SLA_ACK: // lost arbitration, returned ack
+ case TW_SR_ARB_LOST_GCALL_ACK: // lost arbitration, returned ack
+ // enter slave receiver mode
+ twi_state = TWI_SRX;
+ // indicate that rx buffer can be overwritten and ack
+ twi_rxBufferIndex = 0;
+ twi_reply(1);
+ break;
+ case TW_SR_DATA_ACK: // data received, returned ack
+ case TW_SR_GCALL_DATA_ACK: // data received generally, returned ack
+ // if there is still room in the rx buffer
+ if(twi_rxBufferIndex < TWI_BUFFER_LENGTH){
+ // put byte in buffer and ack
+ twi_rxBuffer[twi_rxBufferIndex++] = TWDR;
+ twi_reply(1);
+ }else{
+ // otherwise nack
+ twi_reply(0);
+ }
+ break;
+ case TW_SR_STOP: // stop or repeated start condition received
+ // put a null char after data if there's room
+ if(twi_rxBufferIndex < TWI_BUFFER_LENGTH){
+ twi_rxBuffer[twi_rxBufferIndex] = '\0';
+ }
+ // sends ack and stops interface for clock stretching
+ twi_stop();
+ // callback to user defined callback
+ twi_onSlaveReceive(twi_rxBuffer, twi_rxBufferIndex);
+ // since we submit rx buffer to "wire" library, we can reset it
+ twi_rxBufferIndex = 0;
+ // ack future responses and leave slave receiver state
+ twi_releaseBus();
+ break;
+ case TW_SR_DATA_NACK: // data received, returned nack
+ case TW_SR_GCALL_DATA_NACK: // data received generally, returned nack
+ // nack back at master
+ twi_reply(0);
+ break;
+
+ // Slave Transmitter
+ case TW_ST_SLA_ACK: // addressed, returned ack
+ case TW_ST_ARB_LOST_SLA_ACK: // arbitration lost, returned ack
+ // enter slave transmitter mode
+ twi_state = TWI_STX;
+ // ready the tx buffer index for iteration
+ twi_txBufferIndex = 0;
+ // set tx buffer length to be zero, to verify if user changes it
+ twi_txBufferLength = 0;
+ // request for txBuffer to be filled and length to be set
+ // note: user must call twi_transmit(bytes, length) to do this
+ twi_onSlaveTransmit();
+ // if they didn't change buffer & length, initialize it
+ if(0 == twi_txBufferLength){
+ twi_txBufferLength = 1;
+ twi_txBuffer[0] = 0x00;
+ }
+ // transmit first byte from buffer, fall
+ case TW_ST_DATA_ACK: // byte sent, ack returned
+ // copy data to output register
+ TWDR = twi_txBuffer[twi_txBufferIndex++];
+ // if there is more to send, ack, otherwise nack
+ if(twi_txBufferIndex < twi_txBufferLength){
+ twi_reply(1);
+ }else{
+ twi_reply(0);
+ }
+ break;
+ case TW_ST_DATA_NACK: // received nack, we are done
+ case TW_ST_LAST_DATA: // received ack, but we are done already!
+ // ack future responses
+ twi_reply(1);
+ // leave slave receiver state
+ twi_state = TWI_READY;
+ break;
+
+ // All
+ case TW_NO_INFO: // no state information
+ break;
+ case TW_BUS_ERROR: // bus error, illegal stop/start
+ twi_error = TW_BUS_ERROR;
+ twi_stop();
+ break;
+ }
+}
+
diff --git a/libraries/Robot_Control/utility/twi.h b/libraries/Robot_Control/utility/twi.h
new file mode 100644
index 0000000..6526593
--- /dev/null
+++ b/libraries/Robot_Control/utility/twi.h
@@ -0,0 +1,53 @@
+/*
+ twi.h - TWI/I2C library for Wiring & Arduino
+ Copyright (c) 2006 Nicholas Zambetti. All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#ifndef twi_h
+#define twi_h
+
+ #include <inttypes.h>
+
+ //#define ATMEGA8
+
+ #ifndef TWI_FREQ
+ #define TWI_FREQ 100000L
+ #endif
+
+ #ifndef TWI_BUFFER_LENGTH
+ #define TWI_BUFFER_LENGTH 32
+ #endif
+
+ #define TWI_READY 0
+ #define TWI_MRX 1
+ #define TWI_MTX 2
+ #define TWI_SRX 3
+ #define TWI_STX 4
+
+ void twi_init(void);
+ void twi_setAddress(uint8_t);
+ uint8_t twi_readFrom(uint8_t, uint8_t*, uint8_t, uint8_t);
+ uint8_t twi_writeTo(uint8_t, uint8_t*, uint8_t, uint8_t, uint8_t);
+ uint8_t twi_transmit(const uint8_t*, uint8_t);
+ void twi_attachSlaveRxEvent( void (*)(uint8_t*, int) );
+ void twi_attachSlaveTxEvent( void (*)(void) );
+ void twi_reply(uint8_t);
+ void twi_stop(void);
+ void twi_releaseBus(void);
+
+#endif
+
generated by cgit v1.2.3-18-g5258 (git 2.32.0) at 2024-11-22 14:16:56 +0000