Added to Git, the right way this time.

Signed-off-by: Bill Porter <madsci1016@gmail.com>

Author: madsci1016

EasyTransfer/EasyTransfer.cpp

@@ -0,0 +1,84 @@
+#include "EasyTransfer.h"
+
+
+
+
+//Captures address and size of struct
+void EasyTransfer::begin(uint8_t * ptr, uint8_t length, HardwareSerial *theSerial){
+address = ptr;
+size = length;
+_serial = theSerial;
+}
+
+//Sends out struct in binary, with header, length info and checksum
+void EasyTransfer::sendData(){
+  uint8_t CS = size;
+  _serial->print(0x06, BYTE);
+  _serial->print(0x85, BYTE);
+  _serial->print(size, BYTE);
+  for(int i = 0; i<size; i++){
+    CS^=*(address+i);
+    _serial->print(*(address+i), BYTE);
+  }
+  _serial->print(CS);
+
+}
+
+boolean EasyTransfer::receiveData(){
+  
+  //start off by looking for the header bytes. If they were already found in a previous call, skip it.
+  if(rx_len == 0){
+  //this size check may be redundant due to the size check below, but for now I'll leave it the way it is.
+    if(_serial->available() >= 3){
+	//this will block until a 0x06 is found or buffer size becomes less then 3.
+      while(_serial->read() != 0x06) {
+		//This will trash any preamble junk in the serial buffer
+		//but we need to make sure there is enough in the buffer to process while we trash the rest
+		//if the buffer becomes too empty, we will escape and try again on the next call
+		if(_serial->available() < 3)
+			return false;
+		}
+      if (_serial->read() == 0x85){
+        rx_len = _serial->read();
+		//make sure the binary structs on both Arduinos are the same size.
+        if(rx_len != size){
+          rx_len = 0;
+          return false;
+        }
+      }
+    }
+  }
+  
+  //we get here if we already found the header bytes, the struct size matched what we know, and now we are byte aligned.
+  if(rx_len != 0){
+    while(_serial->available() && rx_array_inx <= rx_len){
+      rx_array[rx_array_inx++] = _serial->read();
+    }
+    
+    if(rx_len == (rx_array_inx-1)){
+      //seem to have got whole message
+      //last uint8_t is CS
+      calc_CS = rx_len;
+      for (int i = 0; i<rx_len; i++){
+        calc_CS^=rx_array[i];
+      } 
+      
+      if(calc_CS == rx_array[rx_array_inx-1]){//CS good
+        memcpy(address,&rx_array,size);
+		rx_len = 0;
+		rx_array_inx = 0;
+		return true;
+		}
+		
+	  else{
+	  //failed checksum, need to clear this out anyway
+		rx_len = 0;
+		rx_array_inx = 0;
+		return false;
+	  }
+        
+    }
+  }
+  
+  return false;
+}

EasyTransfer/EasyTransfer.h

@@ -0,0 +1,59 @@
+/******************************************************************
+*  EasyTransfer Arduino Library 
+*		details and example sketch: 
+*			http://www.billporter.info/easytransfer-arduino-library/
+*
+*		Brought to you by:
+*              Bill Porter
+*              www.billporter.info
+*
+*		See Readme for other info and version history
+*	
+*  
+*This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or(at your option) any later version.
+This program 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 General Public License for more details.
+<http://www.gnu.org/licenses/>
+*
+*This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported License. 
+*To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/ or
+*send a letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
+******************************************************************/
+#ifndef EasyTransfer_h
+#define EasyTransfer_h
+
+
+//make it a little prettier on the front end. 
+#define details(name) (byte*)&name,sizeof(name)
+
+//Not neccessary, but just in case. 
+#include "WProgram.h"
+#include "HardwareSerial.h"
+//#include <NewSoftSerial.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <avr/io.h>
+
+class EasyTransfer {
+public:
+void begin(uint8_t *, uint8_t, HardwareSerial *theSerial);
+//void begin(uint8_t *, uint8_t, NewSoftSerial *theSerial);
+void sendData();
+boolean receiveData();
+private:
+HardwareSerial *_serial;
+//NewSoftSerial *_serial;
+uint8_t * address;  //address of struct
+uint8_t size;       //size of struct
+uint8_t rx_len;		//RX packet length according to the packet
+uint8_t rx_array[255]; //RX packet parsing buffer
+uint8_t rx_array_inx;  //index for RX parsing buffer
+uint8_t calc_CS;	   //calculated Chacksum
+};
+
+
+
+#endif

EasyTransfer/Examples/EasyTransfer_2Way_wPot_Example/EasyTransfer_2Way_wPot_Example.pde

@@ -0,0 +1,85 @@
+/*This is an example of the EasyTransfer Library 2way communications. 
+
+The sketch is for the Arduino with a potentiometer attached to analog pin 0.
+
+This other Arduino has the servo attached to pin 9.
+Both have a putton attached to pin 12 and output a status using the LED on pin 13.
+
+The idea is each arduino will read the status of the button attached to it, and send it
+to the other Arduino, which will toggle it's LED based on the others button. The button 
+should connect pin 12 to ground when pushed.
+
+And the Arduino with the potentiometer will send it's value to the one with the servo.
+The servo will move to the position based on the potentiometer.
+*/
+
+
+
+#include <EasyTransfer.h>
+
+//create two objects
+EasyTransfer ETin, ETout; 
+
+
+struct RECEIVE_DATA_STRUCTURE{
+  //put your variable definitions here for the data you want to receive
+  //THIS MUST BE EXACTLY THE SAME ON THE OTHER ARDUINO
+  int buttonstate;
+};
+
+struct SEND_DATA_STRUCTURE{
+  //put your variable definitions here for the data you want to receive
+  //THIS MUST BE EXACTLY THE SAME ON THE OTHER ARDUINO
+  int buttonstate;
+  int servoval;
+};
+
+//give a name to the group of data
+RECEIVE_DATA_STRUCTURE rxdata;
+SEND_DATA_STRUCTURE txdata;
+
+
+void setup(){
+  Serial.begin(9600);
+  //start the library, pass in the data details and the name of the serial port. Can be Serial, Serial1, Serial2, etc.
+  ETin.begin(details(rxdata), &Serial);
+  ETout.begin(details(txdata), &Serial);
+  
+  pinMode(13, OUTPUT);  
+  pinMode(12, INPUT);
+  //enable pull-up
+  digitalWrite(12, HIGH);
+  
+}
+
+void loop(){
+  
+  //first, lets read our potentiometer and button and store it in our data structure
+  txdata.servoval = analogRead(0);
+  
+  if(!digitalRead(12))
+    txdata.buttonstate = HIGH;
+  else
+    txdata.buttonstate = LOW;
+  
+  //then we will go ahead and send that data out
+  ETout.sendData();
+  
+ //there's a loop here so that we run the recieve function more often then the 
+ //transmit function. This is important due to the slight differences in 
+ //the clock speed of different Arduinos. If we didn't do this, messages 
+ //would build up in the buffer and appear to cause a delay.
+  for(int i=0; i<5; i++){
+    //remember, you could use an if() here to check for new data, this time it's not needed.
+    ETin.receiveData();
+    
+    //set our LED on or off based on what we received from the other Arduino    
+    digitalWrite(13, rxdata.buttonstate);
+    
+    //delay
+    delay(10);
+  }
+  
+  //delay for good measure
+  delay(10);
+}

EasyTransfer/Examples/EasyTransfer_2Way_wServo_Example/EasyTransfer_2Way_wServo_Example.pde

@@ -0,0 +1,90 @@
+/*This is an example of the EasyTransfer Library 2way communications. 
+
+This sketch is for the Arduino with the servo attached to pin 9.
+
+The other Arduino has a potentiometer attached to analog pin 0.
+Both have a putton attached to pin 12 and output a status using the LED on pin 13.
+
+The idea is each arduino will read the status of the button attached to it, and send it
+to the other Arduino, which will toggle it's LED based on the others button. The button 
+should connect pin 12 to ground when pushed.
+
+And the Arduino with the potentiometer will send it's value to the one with the servo.
+The servo will move to the position based on the potentiometer.
+*/
+
+#include <Servo.h>
+#include <EasyTransfer.h>
+
+//create two objects
+EasyTransfer ETin, ETout; 
+//create servo
+Servo myservo;
+
+struct RECEIVE_DATA_STRUCTURE{
+  //put your variable definitions here for the data you want to receive
+  //THIS MUST BE EXACTLY THE SAME ON THE OTHER ARDUINO
+  int buttonstate;
+  int servoval;
+};
+
+struct SEND_DATA_STRUCTURE{
+  //put your variable definitions here for the data you want to receive
+  //THIS MUST BE EXACTLY THE SAME ON THE OTHER ARDUINO
+  int buttonstate;
+};
+
+
+//give a name to the group of data
+RECEIVE_DATA_STRUCTURE rxdata;
+SEND_DATA_STRUCTURE txdata;
+
+
+void setup(){
+  Serial.begin(9600);
+  //start the library, pass in the data details and the name of the serial port. Can be Serial, Serial1, Serial2, etc.
+  ETin.begin(details(rxdata), &Serial);
+  ETout.begin(details(txdata), &Serial);
+  
+  pinMode(13, OUTPUT);  
+  pinMode(12, INPUT);
+  //enable pull-up
+  digitalWrite(12, HIGH);
+  
+  myservo.attach(9);
+}
+
+void loop(){
+  
+  //first, lets read our button and store it in our data structure
+  if(!digitalRead(12))
+    txdata.buttonstate = HIGH;
+  else
+    txdata.buttonstate = LOW;
+  
+ //then we will go ahead and send that data out
+  ETout.sendData();
+  
+ //there's a loop here so that we run the recieve function more often then the 
+ //transmit function. This is important due to the slight differences in 
+ //the clock speed of different Arduinos. If we didn't do this, messages 
+ //would build up in the buffer and appear to cause a delay.
+ 
+  for(int i=0; i<5; i++){
+    //remember, you could use an if() here to check for new data, this time it's not needed.
+    ETin.receiveData();
+    
+    //set our LED on or off based on what we received from the other Arduino
+    digitalWrite(13, rxdata.buttonstate);
+    
+    //set our servo position based on what we received from the other Arduino
+    //we will also map the ADC value to a servo value
+    myservo.write(map(rxdata.servoval, 0, 1023, 0, 179));
+    
+    //delay
+    delay(10);
+  }
+  
+  //delay for good measure
+  delay(10);
+}

EasyTransfer/Examples/EasyTransfer_RX_Example/EasyTransfer_RX_Example.pde

@@ -0,0 +1,40 @@
+#include <EasyTransfer.h>
+
+//create object
+EasyTransfer ET; 
+
+struct RECEIVE_DATA_STRUCTURE{
+  //put your variable definitions here for the data you want to receive
+  //THIS MUST BE EXACTLY THE SAME ON THE OTHER ARDUINO
+  int blinks;
+  int pause;
+};
+
+//give a name to the group of data
+RECEIVE_DATA_STRUCTURE mydata;
+
+void setup(){
+  Serial.begin(9600);
+  //start the library, pass in the data details and the name of the serial port. Can be Serial, Serial1, Serial2, etc. 
+  ET.begin(details(mydata), &Serial);
+  
+  pinMode(13, OUTPUT);
+  
+}
+
+void loop(){
+  //check and see if a data packet has come in. 
+  if(ET.receiveData()){
+    //this is how you access the variables. [name of the group].[variable name]
+    //since we have data, we will blink it out. 
+    for(int i = mydata.blinks; i>0; i--){
+      digitalWrite(13, HIGH);
+      delay(mydata.pause * 100);
+      digitalWrite(13, LOW);
+      delay(mydata.pause * 100);
+    }
+  }
+  
+  //you should make this delay shorter then your transmit delay or else messages could be lost
+  delay(250);
+}