mirror of
https://github.com/esp8266/Arduino.git
synced 2025-08-01 03:47:23 +03:00
Added Arduino Robot libraries
This commit is contained in:
Cristian Maglie
192
libraries/Robot_Control/utility/RobotTextManager.cpp
Normal file
192
libraries/Robot_Control/utility/RobotTextManager.cpp
Normal file
@ -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();
|
||||
77
libraries/Robot_Control/utility/RobotTextManager.h
Normal file
77
libraries/Robot_Control/utility/RobotTextManager.h
Normal file
@ -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
|
||||
127
libraries/Robot_Control/utility/VirtualKeyboard.cpp
Normal file
127
libraries/Robot_Control/utility/VirtualKeyboard.cpp
Normal file
@ -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();
|
||||
28
libraries/Robot_Control/utility/VirtualKeyboard.h
Normal file
28
libraries/Robot_Control/utility/VirtualKeyboard.h
Normal file
@ -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
|
||||
51
libraries/Robot_Control/utility/scripts_Hello_User.h
Normal file
51
libraries/Robot_Control/utility/scripts_Hello_User.h
Normal file
@ -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);
|
||||
}
|
||||
|
||||
*/
|
||||
527
libraries/Robot_Control/utility/twi.c
Normal file
527
libraries/Robot_Control/utility/twi.c
Normal file
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
53
libraries/Robot_Control/utility/twi.h
Normal file
53
libraries/Robot_Control/utility/twi.h
Normal file
@ -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
|
||||
|
||||
Reference in New Issue
Block a user