I made some progress today, here’s a video:

</div>
<div>

#include <SoftwareSerial.h>
SoftwareSerial xbee_serial(2, 3);

int pot_1 = 0;
int LED_1 = 5; //this will serve as an LED to compare to
int sendval;

void setup(){
 pinMode(pot_1, INPUT);
 pinMode(LED_1, OUTPUT);
 Serial.begin(9600);
 xbee_serial.begin(9600);
}

void loop(){
 Serial.println(analogRead(pot_1));
 sendval = map(analogRead(pot_1), 0, 1023, 0, 255);
 xbee_serial.print(sendval); // Value that it sends over the serial
 xbee_serial.print(",");
 xbee_serial.print("100"); //This second byte is for the purpose of the program, it is not being used.
 xbee_serial.print("."); //EOP marker
 analogWrite(LED_1,sendval);
 //delay(100);
}

</div>
<div>

#include <SoftwareSerial.h>
SoftwareSerial xbee_serial(2, 3);
#include <string.h> // we'll need this for subString
#define MAX_STRING_LEN 20 // like 3 lines above, change as needed.

int LED_1 = 5;

int led_val;

//serial stuff
const char EOPmarker = '.'; //This is the end of packet marker
char serialbuf[32]; //This gives the incoming serial some room. Change it if you want a longer incoming.

void setup(){
 pinMode(LED_1, OUTPUT);
 Serial.begin(9600);
 xbee_serial.begin(9600);
}

void loop(){
 if (xbee_serial.available() > 0) {
 static int bufpos = 0;
 char inchar = xbee_serial.read();
 if (inchar != EOPmarker) {
 serialbuf[bufpos] = inchar;
 bufpos++;
 }
 else {
 serialbuf[bufpos] = 0; //restart the buff
 bufpos = 0; //restart the position of the buff

Serial.println(atoi(subStr(serialbuf, "," , 1)));
 analogWrite(LED_1, atoi(subStr(serialbuf, "," , 1)));
 }
 }
}

char* subStr (char* input_string, char *separator, int segment_number) {
 char *act, *sub, *ptr;
 static char copy[MAX_STRING_LEN];
 int i;

 strcpy(copy, input_string);

for (i = 1, act = copy; i <= segment_number; i++, act = NULL) {

 sub = strtok_r(act, separator, &ptr);
 if (sub == NULL) break;
 }
 return sub;

}

So the first round of parts have come in for the plane, including the Xbees and the UartSBee V4s. My life is going to be very scattered over the next 4 or 5 months, so I’m going to be making frequent rudimentary posts for my own benefit.

Here’s a video:

First thing’s first I want to outline how everything’s connected.

The first xbee is connected to the first UartSBee which is connected to an Ardunio Uno which is connected to the first computer which has the console open and is looking at the serial stream at 9600 baud. The xbee is connected to the uno via Software Serial which is detailed in the code below. Here’s a picture:

The second setup is identical, except i’m using an Ardunio nano.

Here’s the code, I’m using the SoftwareSerial library to accomplish this. Both Arduinos are running the same thing.

</p>
#include <SoftwareSerial.h>

SoftwareSerial mySerial(10, 11); // RX, TX

void setup()
{
 // Open serial communications and wait for port to open:
 Serial.begin(9600);
 while (!Serial) {
 ; // wait for serial port to connect. Needed for Leonardo only
 }
 Serial.println("Goodnight moon!");

// set the data rate for the SoftwareSerial port
 mySerial.begin(9600);
 mySerial.println("Hello, world?");
}

void loop() // run over and over
{
 if (mySerial.available())
 Serial.write(mySerial.read());
 if (Serial.available())
 mySerial.write(Serial.read());
}
<p style="text-align: left;">

Here are a few pictures of the X-TCU setup. The baud is at 9600 and the pan ID is 115. The UartSbee itself is running at 115200 baud connected to the computer.

Thanks for reading!

First of all, here’s a video of this device in action.

So things are really starting to take shape with the plane (still unnamed…) and I’ve got a really solid framework for an auto-balancing system. Basically the program below maps the x value given from the ADXL335 to a value from 1-180 on the servo. A lot of this code is for debug, but that portion can be switched off.

</pre>
#include <Servo.h>

Servo myservo;

int raw_val;
int ref_val;
int mid_val = 336;

int left_tilt = 260;
int rght_tilt = 405;

int min_switch = 2;
int max_switch = 3;
int mid_switch = 5;
int mode_switch = 4;

int debug_switch = 6;

int bounds_LED = 10;
int mid_LED = 11;

int debug_LED = 7;
int normal_LED = 8;

void setup(){

 pinMode(min_switch, INPUT);
 pinMode(max_switch, INPUT);
 pinMode(mid_switch, INPUT);
 pinMode(debug_switch, INPUT);

 pinMode(mode_switch, INPUT);

 pinMode(bounds_LED, OUTPUT);
 pinMode(mid_LED, OUTPUT);

 pinMode(debug_LED, OUTPUT);
 pinMode(normal_LED, OUTPUT);

 Serial.begin(9600);
 myservo.attach(9);
}

void loop(){
 if (digitalRead(debug_switch) == HIGH) {

 digitalWrite(debug_LED, HIGH);
 digitalWrite(normal_LED, LOW);

 raw_val = analogRead(0);

 if (digitalRead(mode_switch) == HIGH) {

 digitalWrite(bounds_LED, HIGH);
 digitalWrite(mid_LED, LOW);

 Serial.print("BOUNDS MODE: ");

 ref_val = map(raw_val, left_tilt, rght_tilt, 0, 180);

 myservo.write(ref_val);

 if (digitalRead(min_switch) == HIGH){
 Serial.print("LEFT HGH");
 left_tilt = raw_val;
 }

 if (digitalRead(min_switch) == LOW){
 Serial.print("LEFT LOW");
 }

 Serial.print(" , ");

 if (digitalRead(max_switch) == HIGH){
 Serial.print("RGHT HGH");
 rght_tilt = raw_val;
 }

 if (digitalRead(max_switch) == LOW){
 Serial.print("RHGT LOW");
 }

 Serial.print(" , ");

 Serial.print("Left Tilt: ");
 Serial.print(left_tilt);

 Serial.print("Rght Tilt: ");
 Serial.print(rght_tilt);

 }

 if (digitalRead(mode_switch) == LOW) {

 Serial.print("MID MODE:");

 if (digitalRead(mid_switch) == HIGH){
 mid_val = raw_val;
 }

 int MLeft_val = mid_val - 75;
 int MRght_val = mid_val + 75;

 ref_val = map(raw_val, MLeft_val, MRght_val, 0, 180);
 myservo.write(ref_val);

 digitalWrite(bounds_LED, LOW);
 digitalWrite(mid_LED, HIGH);

 Serial.print(" , ");
 Serial.print("Left Most Value: ");
 Serial.print(MLeft_val);
 Serial.print(" , ");
 Serial.print("Rght Most Value: ");
 Serial.print(MRght_val);
 Serial.print(" , ");
 Serial.print(mid_val);

 }
 Serial.print(" , ");
 Serial.print("Raw Value: ");
 Serial.print(raw_val);
 Serial.print(" , ");
 Serial.print("Current Servo Value: ");
 Serial.print(ref_val);

 Serial.println("");
}

 if (digitalRead(debug_switch) == LOW) {

 digitalWrite(debug_LED, LOW);
 digitalWrite(normal_LED, HIGH);

 raw_val = analogRead(0);
 if (digitalRead(mode_switch) == HIGH) {
 digitalWrite(bounds_LED, HIGH);
 digitalWrite(mid_LED, LOW);
 ref_val = map(raw_val, left_tilt, rght_tilt, 0, 180);
 myservo.write(ref_val);
 if (digitalRead(min_switch) == HIGH){
 left_tilt = raw_val;
 }
 if (digitalRead(max_switch) == HIGH){
 rght_tilt = raw_val;
 }
 }

 if (digitalRead(mode_switch) == LOW) {
 if (digitalRead(mid_switch) == HIGH){
 mid_val = raw_val;
 }<a href="https://esologic.com/wp-content/uploads/2012/12/2012-12-27_14-20-51_644.jpg">
</a>
 int MLeft_val = mid_val - 75;
 int MRght_val = mid_val + 75;
 ref_val = map(raw_val, MLeft_val, MRght_val, 0, 180);
 myservo.write(ref_val);
 digitalWrite(bounds_LED, LOW);
 digitalWrite(mid_LED, HIGH);
 }
 }
}

Sorry for the lack of comments in this code, it’s pretty intuitive though, at it’s core its all about the map command.

Here’s a picture of what my desk looks like:

Here’s a picture of the fritzing document, which can be found: here

Thanks for reading!