Matthew Doll

New HomeNet Blog

2011-03-17T08:53:00.001-07:00

I've started a new blog dedicated to HomeNet over at http://homenetme.blogspot.com/

The Virtual Home

2011-02-03T10:32:00.000-08:00

Everything these days is being virtualized so that we can interact with them through our electronic devices. We have virtualized the art of letter writing into email and opening an encyclopedia into searching Wikipedia. We have virtualized ourselves on Facebook, creating a digital representation of ourselves on the internet. We post what we like and dislike about our lives. We list our attributes, what we do, where we live and where we go to school. It's a database of our friends and a history of our lives. In video games we create 3d Avatars that represent our selves as we interact in the virtual world.

It's only logical to think that one day architecture is going to be virtualized into an electronic form. What will this look like? How do we interact with our home virtually? Who is going to design it?

These are questions I've been trying to answer over the last few weeks as I start working on building the user interface for HomeNet. Currently, I'm taking the Facebook approach, building a website that allows you to create a virtual profile of your home. The HomeNet website will allow you to create a detailed profile of your home listing all of it's rooms and properties and allow you to view and control all of the smart HomeNet devices you have. You will be able to personalize each page with photos of your house creating a unique personal link to your home.

I think that the future architect needs to not only design how one physically interacts with the building but also how one interacts with all the electronics and technology the future home will contain. The virtual world is currently dominated by Engineers and Graphic Designers. I think that architects need to get involved so that people have the same quality experience in the virtual building as the do in the physical building. I'm not sure if it's the architects role to design the virtual building but I think that the architect needs to represent the owners interests in it's construction the same way an architect works with a contractor to build a physical building.

Arduino: The Documentary

2011-01-18T10:55:00.000-08:00

This is a great video on the history of the Arduino project.

Arduino The Documentary (2010) English HD from gnd on Vimeo.

It's hard to believe that arduino didn't exist yet when I graduated high school and now it's the key piece I'm using in my Master's Project

Half way

2010-12-17T10:16:00.000-08:00

Well my thesis has officially reach the half way point with the end of Master Project 1. I presented my work to the school and had a great presentation. I had 11 demo's up and running, 8 based on JeeNode hardware and additional 3 running on Arduino (because I ran out of JeeNodes). In the coming days I'll work on posting photos, details and code demos.

Currently I'm spending a week relaxing after some stressful finals and working on fixing some minor issues. This week I added better support of interrupts and started experimenting with implementing a sleep cycle to conserve battery. Next up comes rewriting the processing script to match the updated modular Arduino code.

Google Code Setup

2010-11-30T05:29:00.000-08:00

Well I finally made the jump and got and my code setup on Google code to start sharing my HomeNet Code. You can also find some documentation on how it all works 1800 lines of code and growing...

Google Code: HomeNet

Even More Modular

2010-11-23T02:51:00.000-08:00

My last code post simplified things, but many things were hard coded in. These weekend I modularized things so you can choose which network adapters you needs as well as what devices are connected.

#include <ports.>h>
//#include <portslcd.h>
#include <rf12.>h>
#include <homenet.>h>
//#include <homenetdevices.h>
#include <homenetdevicelcd.>h>

//Start HomeNet Packet Stack
HomeNet stack(0x04);//0x01 is RF12 base station //0xFF is PC uplink

//Setup Network Adapters
//HomeNetPortSerial portSerial(PORT_SERIAL, stack);  //PORT_SERIAL tells the adpater which serial serial port to use (for future support of the arduino mega)
HomeNetPortRF12   portRF12(stack);

//Setup attached devices
HomeNetDeviceStatusLights statusLights(stack);
//HomeNetDeviceTMP37 tmp37(stack);
//HomeNetDeviceLight light(stack);
HomeNetDeviceLCD lcd(stack);

//package the setup info in a nice neat arrays
 HomeNetPort*  ports[] = {&portRF12};//,&portSerial}; 
 HomeNetDevice*  devices[] = {&statusLights,  &lcd};// &light , &tmp37};

MilliTimer sendTimer;

void setup() {
  //initize home net with the setup info
  stack.init(ports, 1, devices, 2); 
  stack.registerStatusLights(statusLights); //setup status lights
}

void loop() {
  //receive incoming packets
  stack.receive();
  
  if (sendTimer.poll(10000)){
   // PayloadBuffer buffer;
   // buffer.print("TEST NODE 3");
   // stack.addUdpPacket(0, 2, 0, CMD_STRING, buffer.payload());
    //stack.schedule(2,255,0); //type, toNode, toDevice
     
  }
  
  //process packets in the stack- send packets that ready
  stack.process();
  delay(1);

}

More Code

2010-11-18T17:52:00.000-08:00

So the code finally reached a tipping it's time to package the code up into a library. I'm calling it HomeNet because it describes its perfectly it's a new home net work and amazingly enough, there isn't anything going by the name yet.

Compared to the long mess of code posted before, Moving most of the code to a library really simplified things:

#include <ports.h>
#include <rf12.h>
#include <homenet.h>

HomeNet stack(0x04);//start stack with a node id
MilliTimer sendTimer;

void setup() {
  // put your setup code here, to run once:
  stack.init();

}

void loop() {
  // put your main code here, to run repeatedly: 
  stack.receive();
  if (sendTimer.poll(2000)){
    PayloadBuffer buffer;
    buffer.print(123,DEC);
    stack.addUdpPacket(0, 255, 2, CMD_BYTE, buffer.payload());
  }
  stack.process();
}

and the processing sketch using the library

import processing.serial.*;
import xmlrpclib.*;
import org.apache.commons.codec.binary.Base64; //part of the xmlrpclib

XmlrpcClient homeNetXmlrpcClient = new XmlrpcClient("http://matthew.sgcs.usf.edu/mcdportal/public/xmlrpc.php?api_key=dfgdfgdgdgd");
XmlrpcServer homeNetXmlrpcServer = new XmlrpcServer(8081);



final int  NODE_ID = 255;
final int PACKET_TIMEOUT = 150;
PacketStack stack = new PacketStack(NODE_ID);

Serial myPort;  // The serial port


XMLElement xmlConfig;



XMLElement commands[];
XMLElement devices[];

String findXMLid(XMLElement[] xml , int value, String rAttribute){
  String rValue = ""; 
  for(int a = 0; aif(unhex(commands[a].getAttribute("id")) == value){
      return commands[a].getAttribute(rAttribute);
    }
  }
  return rValue;
} 


void setup() {
  size(600, 400);  // Stage size
  //noStroke();      // No border on the next thing drawn
  homeNetXmlrpcServer.add("testserver", this); //setup server
  println("HomeNet XML-RPC Server started at " + homeNetXmlrpcServer.ip()+":8081/RPC2"); // Note that /RPC2 is hard-coded to URI in the Apache Library.
  
  textFont(createFont("Consolas", 14));
  //fixedFont);
  
  xmlConfig = new XMLElement(this, "config.txt");
  devices = xmlConfig.getChildren("devices/device");
  commands = xmlConfig.getChildren("commands/command");
  
  //load the above as hash table from my sevrer.
  
  // Print a list of the serial ports, for debugging purposes:
  //println(Serial.list());
  
  String portName = Serial.list()[1];
  myPort = new Serial(this, portName, 115200);
}

boolean arduinoBoot = false;
int count = 0;
long sendTimer;
void draw() {
  
  if(arduinoBoot == false){
    delay(2500);
    sendTimer = millis();
    arduinoBoot = true;;
  }
  
  if((millis() - sendTimer) > 2000){
    //DataPacket packet = build_udp_packet(NODE_ID,0,3,2,CMD_STRING,str_to_payload("Hello "+count));
    //packet.status = STATUS_READY;
    sendTimer=millis();
    count++;
  }

  stack.process();
    
  stack.tempSerialCheck(myPort); //this is temp until I add support for multiple serial ports, and pass a list of ports to the packetStack
}
void packetEvent(DataPacket packet){
  packet.status = STATUS_CLEAR;
  Hashtable send = new Hashtable();
  String packetBase64 = new String(Base64.encodeBase64(packet.payload));
  send.put("received",packet.received);
  send.put("packet", packetBase64);
  println("Server Reply: "+homeNetXmlrpcClient.execute("HomeNet.addPacket", send));
}  

void serialEvent(Serial port) {
  stack.buildSerialPacket(port);
}

Much easier to use now!

First Tests

2010-11-12T13:11:00.000-08:00

I finally completed enough of the packet code that I finally test to see if it actually works! and Amazingly enough ti works. Packets can now be sent from a remote wireless node to a receiver and passed to the computer. It also works the other way, data from the computer can be sent to a remote node. I recorded a video but I don't have it up yet.

Code after the jump

Arduino Code
packet.h

#define CMD_ERROR           0x00

#define CMD_VERSION         0x01

#define CMD_BATTERYLEVEL    0x03

#define CMD_PING            0x3E

#define CMD_PONG            0xE3

#define CMD_ACK             0x11

#define CMD_SETNODEID       0x21

#define CMD_GETNODEID       0x21

#define CMD_SETNODEID       0x22

#define CMD_GETPLUG         0x23

#define CMD_SETPLUG         0x24

#define CMD_AUTOSENDSTART   0xC1

#define CMD_AUTOSENDSTOP    0xC2

#define CMD_GETVALUE        0xD0

#define CMD_SETVALUE        0xD1

#define CMD_ON              0xE0

#define CMD_OFF             0xE1

#define CMD_LEVEL           0xE2

#define CMD_BYTE            0xF0

#define CMD_STRING          0xF1

#define CMD_INT             0xF2

#define CMD_FLOAT           0xF3

#define CMD_LONG            0xF4



#define DVC_TMP37           0x01

#define DVC_LIGHT           0x02

#define DVC_SHT21           0x03

#define DVC_DOORCONTACT     0x04

#define DVC_WINDOWCONTACT   0x05

#define DVC_MOTION          0x06

#define DVC_2LINEDISPLAY    0x07

#define DVC_POWER30         0x08

#define DVC_POWER100        0x09

#define DVC_SMARTOUTLET     0x10

#define DVC_RGBLIGHT        0x11

#define DVC_SOUND           0x12

#define DVC_SWITCH          0x13

#define DVC_STATUSLED       0x14

#define DVC_BUZZER          0x15



//decoded packet struct

typedef struct {

  uint8_t command;

 //if 255 = ready to send // 0 = resend last

  uint8_t length;

  uint8_t status;

  uint8_t settings; //01010101 //version //type direct or broadcast //ack //ttl //priority //multi

  uint8_t type; //1 single tcp, 2 single udp, 3 multipacket tcp

  uint16_t fromNode;

  uint8_t fromPlug;

  uint16_t toNode; //00 is base //xffff is broadcast

  uint8_t toPlug;

  uint8_t id;

  uint8_t ttl;

  uint8_t from;

  uint8_t payload[48];

  uint16_t checksum;

  uint8_t ptr;

} DataPacketDecoded;





//simple data packet



typedef struct {

  uint8_t ptr;

  uint8_t from;

  uint8_t status;

  uint8_t payload[56];

  uint16_t checksum;

} DataPacket;



//payload type



typedef struct {

  uint8_t length;

  uint8_t data[56];

} Payload;



//not used yet

typedef struct {

  long start;

  uint8_t waiting;

  uint8_t ptr;

} ACKStatus;

/*

typedef struct {

  uint8_t type;

  uint8_t status;

} Port;*/



//shortcuts to important bytes

//keeps from having to decode the whole thing to check simple parts

#define PACKET_LENGTH   0

#define PACKET_SETTINGS 1

#define PACKET_FROM     2

#define PACKET_TO       4

#define PACKET_TTL      4

#define PACKET_ID       6

#define PACKET_COMMAND  7

#define PACKET_PAYLOAD  8



//an enum might be better here

#define STATUS_CLEAR    0

#define STATUS_RECEVING 1

#define STATUS_RECEIVED 2

#define STATUS_WAITING  3

#define STATUS_READY    4

#define STATUS_SENDING  5

#define STATUS_SENT     6

#define STATUS_ACK      7

#define STATUS_SUCCESS  8



#define OFFSET_PACKET 10

#define OFFSET_HEADER 8

#define OFFSET_FOOTER 2

node.pde

#include h> //checksum functions

#include "protocol.h"



#include h>

#include h>



//#include 

//PortI2C myI2C (2);

//LiquidCrystalI2C lcd (myI2C);







#define NODE_ID 0x04



Port leds (1);

Port light (2);

MilliTimer sendTimer;



#define PLUG_1 DVC_STATUSLED

#define PLUG_2 DVC_2LINEDISPLAY

#define PLUG_3 0

#define PLUG_4 0



#define PACKET_BUFFER 16 //can be adujsted based on available space



#define PACKET_TIMEOUT 150



#define PORT_RF12    1

#define PORT_SERIAL  2

#define PORT_SERIAL1 3

#define PORT_SERIAL2 4

#define PORT_SERIAL3 5



#define PORT_COUNT 2

#define PORT_0 PORTTYPE_SERIAL

#define PORT_1 PORTTYPE_RF12



//#define DEBUG 1

//#define ENABLE_SERIAL 1

#define ENABLE_RF12 1

//#define ENABLE_SERIAL123 



#define PACKET_TCP       1

#define PACKET_UDP       2

#define PACKET_BROADCAST 3

//types

//ACK

//Single TCp //requires 2byte packet ID

//Single UDP

//Multi TCP //requires 2byte total ID, 2 byte Packet ID + byte current packet + byte total packets

//multi packet

//packet id

//current packets

//total packets

//

/*

Port ports[] = {{PORTTYPE_SERIAL,STATUS_CLEAR},

                {PORTTYPE_RF12,STATUS_CLEAR}};





*/

//list attached ports

//1 2 3 4 //rf12



#define COLLECT 0x20 // collect mode, i.e. pass incoming without sending acks



DataPacket data[PACKET_BUFFER];



uint16_t checksum;

byte uniqueId = 0;

byte i;

DataPacket incomingPacket; //current incoming packet





DataPacket *sendingPacket;



//probably should break this out by type

boolean sending = false;

boolean receiving = false;

long packetTimer;;



DataPacket *getNewPacket() {

  for(i=0; i < PACKET_BUFFER; i++) {

    if(data[i].status == STATUS_CLEAR){

      

      data[i].from = 0;

      return &data[i];

    } 

  }

  //Serial.println("all full");

  return 0;

}



uint8_t getId() 

{

  return uniqueId++; //loops when it overflows

}



uint16_t compressAddress(uint16_t node, uint8_t port) 

{

  return (node << 4) | (port & 0x0F);

}

//byte m = 1;

#ifdef ENABLE_SERIAL

void send_packet_serial(DataPacket *packet)

{

        #ifdef DEBUG

      Serial.println("SENDING PACKET SERIAL");

      #endif

 

  uint16_t dataChecksum = 0;

  

  for(i=0; i < (packet->payload[PACKET_LENGTH]-OFFSET_FOOTER); i++){

    dataChecksum = _crc16_update(dataChecksum, packet->payload[i]);

    Serial.print(packet->payload[i],BYTE); 

  } 

  

  packet->checksum = dataChecksum;

  Serial.print(highByte(dataChecksum),BYTE);

 // Serial.print(",");

  Serial.print(lowByte(dataChecksum),BYTE);

  packet->status = STATUS_SENT;

 //Serial.println("");

}

#endif

#ifdef ENABLE_RF12

void send_packet_rf12(DataPacket *packet)

{

  if (rf12_canSend()) { //check if radio is free

       #ifdef DEBUG

      Serial.println("SENDING PACKET RF12");

      #endif

    byte header = (packet->payload[PACKET_SETTINGS] == PACKET_TCP) ? RF12_HDR_ACK : 0;

    //Serial.print("Node Header: ");

    //Serial.println(header,DEC);

    byte toNode = get_node(packet,PACKET_TO);

    //Serial.print("Send to Node: ");

    //Serial.println(toNode,DEC);

    

    if (toNode > 0){

      if(toNode > 32){

        toNode = 1;//if port is too high send to basestation to retransmit

      }

      header |= RF12_HDR_DST | toNode;

    }   

    //rf12 does it's own check sum. no need to waste resources doing it twice

    rf12_sendStart(0, packet->payload, packet->payload[PACKET_LENGTH]-OFFSET_FOOTER);

    

    sendLed(1);

    delay(100);

    sendLed(0);

    

    packet->status = STATUS_SUCCESS;

    sending = false; 

  }

}

#endif

void process_command(DataPacket *packet)

{

  uint8_t plug = get_plug(packet,PACKET_TO);

  if(plug == 0){ //system function

    switch (packet->payload[PACKET_COMMAND]) {

      case CMD_ERROR:

        //build_udp_packet(NODE_ID, 1, 0, 0, CMD_PONG, get_payload(packet));

        break;

      case CMD_VERSION:

        //build_udp_packet(NODE_ID, 1, 0, 0, CMD_PONG, get_payload(packet));

        break;

      case CMD_BATTERYLEVEL:

        //build_udp_packet(NODE_ID, 1, 0, 0, CMD_PONG, get_payload(packet));

        break;

      case CMD_PING:

        build_udp_packet(NODE_ID, 1, 0, 0, CMD_PONG, get_payload(packet));

        break;

      case CMD_PONG:

        //build_udp_packet(NODE_ID, 1, 0, 0, CMD_PONG, get_payload(packet));

        break;

      case CMD_ACK:

        //build_udp_packet(NODE_ID, 1, 0, 0, CMD_PONG, get_payload(packet));

        break;

      case CMD_GETNODEID:

        //build_udp_packet(NODE_ID, 1, 0, 0, CMD_PONG, get_payload(packet));

        break;  

      case CMD_SETNODEID:

        //build_udp_packet(NODE_ID, 1, 0, 0, CMD_PONG, get_payload(packet));

        break;  

      case CMD_GETPLUG:

        //build_udp_packet(NODE_ID, 1, 0, 0, CMD_PONG, get_payload(packet));

        break;    

      case CMD_SETPLUG:

        //build_udp_packet(NODE_ID, 1, 0, 0, CMD_PONG, get_payload(packet));

        break;      

    }

  } else if(plug == 2){ //system function

/*  switch (packet->payload[PACKET_COMMAND]) {

    case CMD_STRING:

      Payload *p = get_payload(packet);

      lcd.setCursor(0, 1);

  // print the number of seconds since reset:

      for(int a = 0; a < p->length; a++){

        lcd.print(p->data[a]);

      }

      break;

    }*/

  } 

}



#ifdef ENABLE_RF12

//build rf12 packet

DataPacket* receive_rf12(const void* payload, uint8_t length){

  DataPacket* packet = getNewPacket();

  memcpy(packet->payload,payload, length);

  packet->status = STATUS_RECEIVED;

  packet->from = PORT_RF12;

  return packet;

}

#endif



DataPacket* clonePacket(DataPacket* packet){

  DataPacket* packet2 = getNewPacket();

  memcpy(packet2,packet, sizeof(packet)) ;

  return packet2;

}



void build_incoming_packet(uint8_t byteIn)

{

   //mark which port it is coming from

   if(incomingPacket.ptr == 0){  //Packet length

    

    if(byteIn == 0) { //resend last

      sendingPacket->status = STATUS_SENDING;

      return;

    }

    if(byteIn == 255) { //aknowledge

      sendingPacket->status = STATUS_SUCCESS;

      sending = false; //allow next packet to send

      

      return;

    }

    if (byteIn > 128) {

      Serial.flush();

      Serial.print(0,BYTE);

      return;

    }

    receiving = true;

    packetTimer = millis();

    incomingPacket.payload[PACKET_LENGTH] = byteIn;

    incomingPacket.status = STATUS_RECEVING;

    checksum = 0;

  }

  

  //checksum 

  if(incomingPacket.ptr < (incomingPacket.payload[PACKET_LENGTH] - OFFSET_FOOTER)){ //add to check sum

    incomingPacket.payload[incomingPacket.ptr] = byteIn;

    checksum = _crc16_update(checksum, byteIn);

    incomingPacket.ptr++;

    return;

  } else if(incomingPacket.ptr == (incomingPacket.payload[PACKET_LENGTH] - OFFSET_FOOTER)){ //get first byte of checksum

    incomingPacket.checksum = byteIn;

    incomingPacket.ptr++;

    return;

  } else { //get second byte and check the checksum

    incomingPacket.checksum = (incomingPacket.checksum << 8) | (byteIn & 0xFF);         

    if(checksum != incomingPacket.checksum) {

       DataPacket *p = build_udp_packet(NODE_ID, 1, 0, 0, CMD_ERROR, packet_to_payload(&incomingPacket));

       p->status = STATUS_READY;

      Serial.flush(); 

      Serial.print(1,BYTE); //tell the node to resend last

    } else {

      incomingPacket.status=STATUS_RECEIVED;

      DataPacket *packet = getNewPacket();

      incomingPacket.from = PORT_SERIAL;

      *packet = incomingPacket;

      //Serial.flush();

      Serial.print(255,BYTE); //tell the node the packet was successful

    }

    //reset incomingPacket

    receiving = false;

    incomingPacket.status=STATUS_CLEAR;

    incomingPacket.ptr = 0;

  }

}





//determine where to send packet. how to expand when we have 4 serial ports?

void process_stack(){

  //sending = false; //only send one pack per cycle

  for(i=0;i    process_packet(&data[i]);

  }

//check for packets to send



//check for packets to resend if ACKs are late



//check for data packets that can be deleted from the stack 

}







void process_packet(DataPacket *packet){

  switch (packet->status){

    case STATUS_CLEAR:

      #ifdef DEBUG

      //Serial.println("CLEAR");

      #endif

      break;

    case STATUS_RECEVING:

      #ifdef DEBUG

      Serial.println("RECEVING");

      #endif

      break;

    case STATUS_RECEIVED:

      #ifdef DEBUG

      debug_packet(packet);

      #endif 

      

      if(get_node(packet,PACKET_TO) == NODE_ID){

        process_command(packet);

        packet->status = STATUS_CLEAR;

      } else {

        packet->status = STATUS_READY;

      }

      #ifdef DEBUG

      Serial.println("RECEIVED");

      #endif

      break;

    case STATUS_WAITING:

      #ifdef DEBUG

      Serial.println("WAITING");

      #endif

      break;

    case STATUS_READY:

      //check for free port

      if(sending == false){

        packet->status = STATUS_SENDING;

        sendingPacket = packet;

        sending = true;

      }

      //if reset pointer and set to send

      #ifdef DEBUG

      Serial.println("READY");

      #endif

      break;

    case STATUS_SENDING:

      //because of the above, only one packet will be changed to sending

      #if defined(ENABLE_SERIAL) && defined(ENABLE_RF12)

      if(packet->from == 0){ //self generated send to both ports

        packet->from = PORT_RF12;

        DataPacket *packet2 = getNewPacket();

        packet2 = packet;

      }

      #endif

      #ifdef ENABLE_RF12

      if(packet->from != PORT_RF12){

        send_packet_rf12(packet); 

      }

      #endif

      

      #ifdef ENABLE_SERIAL

      if(packet->from != PORT_SERIAL){

         send_packet_serial(packet); 

         packet->status = STATUS_SENT;

      }

      #endif

      

      #ifdef DEBUG

      Serial.println("SENDING");

      #endif

      break;

    case STATUS_SENT:

      //if is a ack packet 

      if(packet->payload[PACKET_SETTINGS] == 1){

        packet->status = STATUS_ACK;

        //start packets ack timer

      } else {

        //packet->status = STATUS_SUCCESS;

      }

      #ifdef DEBUG

      sending = false; //allow next packet to send

      packet->status = STATUS_SUCCESS;

      Serial.println("SENT");

      #endif

      break;

    case STATUS_ACK:

       //if execeded timer resen

       //count resends if exceds max kill packet and add error

       #ifdef DEBUG

       Serial.println("ACK");

       #endif

      break;

    case STATUS_SUCCESS:

      //option to post status to screen

      packet->status = STATUS_CLEAR;

      #ifdef DEBUG

      Serial.println("SUCCESS");

      #endif

      break; 

  }

}



static void sendLed (byte on) {

    leds.mode(OUTPUT);

    leds.digiWrite(on);

}



static void receiveLed (byte on) {

    leds.mode2(OUTPUT);

    leds.digiWrite2(!on); // inverse, because LED is tied to VCC

}

long counter;



void setup()

{

  #if defined(ENABLE_SERIAL) || defined(DEBUG)

  Serial.begin(115200);

  #endif

   

  #ifdef ENABLE_RF12

  rf12_initialize(NODE_ID, RF12_915MHZ, 33);

  #endif

  

     #ifdef DEBUG

       Serial.println("DEBUGGING MODE");

     #endif

  /*

  lcd.begin(16, 2);

  // Print a message to the LCD.

  lcd.print("Hello, Matthew");

  lcd.backlight();*/

  counter = millis();

  sendLed(1);

  receiveLed(1);

  delay(500);

  sendLed(0);

  receiveLed(0);

  

}



void loop() {

/*

  if(counter == 100000) {

    Serial.print(availableMemory(),DEC);

   // DataPacket *p = build_udp_packet(NODE_ID, 1, 0, 0, CMD_STRING, str_to_payload("ha ha ha22222"));

   // p->status = STATUS_READY;

   // counter = 0;

  }

  counter++;*/



  process_stack();

  

  //recieve timer

  

  #ifdef ENABLE_SERIAL

  //and send command to resend last

  int byteIn;

  if (Serial.available()>0) {

    byteIn =  Serial.read();

    build_incoming_packet(byteIn);

  }

  process_stack();

  if(receiving == true) {

    if((millis() - packetTimer) > PACKET_TIMEOUT) {

      //Serial.flush();

      Serial.print(2,BYTE); //tell the node to resend last

      //DataPacket *p = build_udp_packet(NODE_ID, 1, 0, 0, CMD_ERROR, packet_to_payload(&incomingPacket));

      // p->status = STATUS_READY;

      receiving = false;

    }

  }

  #endif

  

  #ifdef ENABLE_RF12

  if (rf12_recvDone() && rf12_crc == 0) {

   // receiveLed(1);

     #ifdef DEBUG

       Serial.println("RF12 Receiving");

     #endif

    

    if ((rf12_hdr & RF12_HDR_ACK) && !(rf12_hdr & RF12_HDR_CTL) && (NODE_ID & COLLECT) == 0) {

      byte addr = rf12_hdr & RF12_HDR_MASK;

      // if request was sent only to us, send ack back as broadcast

      rf12_sendStart(rf12_hdr & RF12_HDR_DST ? RF12_HDR_CTL : RF12_HDR_CTL | RF12_HDR_DST | addr, 0, 0);

    }

    DataPacket *p = receive_rf12((void*)rf12_data,rf12_len);

    //blink led

    receiveLed(1);

    delay(100);

    receiveLed(0);

  }

  #endif

  //delay(5);  

  



  if (sendTimer.poll(5000)){

    light.mode2(INPUT);

    byte l = light.anaRead()/4;

    

    DataPacket *p = build_udp_packet(NODE_ID, 0, 3, 2, CMD_BYTE, byte_to_payload(l));

    //p->from = PORT_SERIAL;

  }

  

  

  delay(5);

}



/*FINISHED*/

Payload *get_payload(DataPacket *packet) 

{

  Payload payload;

  payload.length = packet->payload[PACKET_LENGTH] - OFFSET_PACKET;

  for(i=0; i < payload.length; i++){

    if(packet->payload[PACKET_SETTINGS] < 3) { //single packet TCP or UDP

      payload.data[i] = packet->payload[i+OFFSET_HEADER];   

     

    } else if(packet->payload[PACKET_SETTINGS] == 3) {  //broadcast

        //todo

    }

  }

  return &payload; 

}



Payload *packet_to_payload(DataPacket *packet) 

{

  Payload payload;

  payload.length = packet->payload[PACKET_LENGTH];

  for(i=0; i < (payload.length - OFFSET_FOOTER); i++){

    payload.data[i] = packet->payload[i];   

  }

  payload.data[payload.length - OFFSET_FOOTER] = highByte(packet->checksum);

  payload.data[payload.length - OFFSET_FOOTER + 1] = lowByte(packet->checksum);

  return &payload; 

}



uint16_t get_node(DataPacket *packet, uint8_t location)

{

  uint16_t node;  

  node = packet->payload[location];

  node = node << 4;

  node = node | (packet->payload[location+1] >> 4);

  return node;

}



uint8_t get_plug(DataPacket *packet, uint8_t location)

{

  return (packet->payload[location+1] & 0x0F);

}

 

Payload *str_to_payload(char string[])

{

  Payload payload;

  i=0;

  while(string[i] != 0){

    payload.data[i] = byte(string[i]); 

    i++;  

  }

  payload.length = i;

  //Serial.print("sizeOf: ");

 // Serial.println(i,DEC);

  return &payload; 

}



Payload *long_to_payload(long number)

{

  Payload payload;

  i=(sizeof(number)-1);

  payload.length = i;

  while(i != 0){

    payload.data[i] = number & 0xFF; 

    number = number >> 8;

    i--;  

  }

  return &payload; 

}



Payload *byte_to_payload(byte number)

{

  Payload payload;

  payload.length = 1;

  payload.data[0] = number & 0xFF; 

  return &payload; 

}



Payload *uint16_to_payload(uint16_t number)

{

  Payload payload;

  

   payload.length = 2;

   payload.data[0] = highByte(number);

   payload.data[1] = lowByte(number);

  

  return &payload; 

}



DataPacket *build_tcp_packet(uint16_t fromNode, uint8_t fromPlug, uint16_t toNode, uint8_t toPlug, uint8_t command, Payload *payload)

{

  DataPacket *packet = getNewPacket();

  packet->status = STATUS_READY;

  packet->payload[PACKET_LENGTH] = payload->length + OFFSET_PACKET; //header 8 crc 2

  packet->payload[PACKET_SETTINGS] = 1;

  uint16_t address = compressAddress(fromNode, fromPlug);

  packet->payload[PACKET_FROM] = (address >> 8) & 0xFF;

  packet->payload[PACKET_FROM+1] = address & 0xFF;

  address = compressAddress(toNode, toPlug);

  packet->payload[PACKET_TO ] = (address >> 8) & 0xFF;

  packet->payload[PACKET_TO+1] = address & 0xFF;

  packet->payload[PACKET_ID] = getId();

  packet->payload[PACKET_COMMAND] = command;

  

  for(i=0;i < payload->length;i++){

    packet->payload[PACKET_PAYLOAD+i] = payload->data[i];

  }



  return packet;

}



/*

 * @return DataPacket * Pointer to the New DataPacket

 */



DataPacket *build_udp_packet(uint16_t fromNode, uint8_t fromPlug, uint16_t toNode, uint8_t toPlug, uint8_t command, Payload *payload)

{

  DataPacket *packet = getNewPacket();

  packet->status = STATUS_READY;

  packet->payload[PACKET_LENGTH] = payload->length + OFFSET_PACKET; //header 8 crc 2

  packet->payload[PACKET_SETTINGS] = 2;

  uint16_t address = compressAddress(fromNode, fromPlug);

  packet->payload[PACKET_FROM] = (address >> 8) & 0xFF;

  packet->payload[PACKET_FROM+1] = address & 0xFF;

  address = compressAddress(toNode, toPlug);

  packet->payload[PACKET_TO ] = (address >> 8) & 0xFF;

  packet->payload[PACKET_TO+1] = address & 0xFF;

  packet->payload[PACKET_ID] = getId();

  packet->payload[PACKET_COMMAND] = command;

  

  for(i=0;i < payload->length;i++){

  packet->payload[PACKET_PAYLOAD+i] = payload->data[i];

  }

  

  return packet;

}



DataPacket *build_broadcast_packet(uint16_t fromNode, uint8_t fromPlug, uint8_t ttl, Payload payload)

{

  DataPacket *packet = getNewPacket();

  packet->status = STATUS_WAITING;

  return packet;

}



/**

 * turns a packet into a decoded packet

 */

DataPacketDecoded decode_packet(DataPacket *packet)

{

  DataPacketDecoded decodedPacket;

     

  decodedPacket.ttl = 0;

  

  //Set Packet length

  decodedPacket.length = packet->payload[PACKET_LENGTH];

  

  decodedPacket.status = packet->status;

  //settings 

  decodedPacket.settings = packet->payload[PACKET_SETTINGS];

  decodedPacket.type = packet->payload[PACKET_SETTINGS]; //right now these are the same things

  //From 12bit node id, 4 bit plug id

  decodedPacket.fromNode = packet->payload[PACKET_FROM];

  decodedPacket.fromNode = decodedPacket.fromNode << 4;

  decodedPacket.fromNode = decodedPacket.fromNode | (packet->payload[PACKET_FROM+1] >> 4);

  decodedPacket.fromPlug = packet->payload[PACKET_FROM+1] &0xF;

  //To 12bit node id, 4 bit plug id

  decodedPacket.toNode = packet->payload[PACKET_TO];

  decodedPacket.toNode = decodedPacket.toNode << 4;

  decodedPacket.toNode = decodedPacket.toNode | (packet->payload[PACKET_TO+1] >> 4);

  decodedPacket.toPlug = packet->payload[PACKET_TO+1] &0xF;

 //packet id

  decodedPacket.id = packet->payload[PACKET_ID];

 //Command

  decodedPacket.command = packet->payload[PACKET_COMMAND];

  

  decodedPacket.ptr = packet->payload[PACKET_LENGTH] - OFFSET_PACKET;

  

  

  Payload *payload = get_payload(packet);

   

  for(i=0; i < payload->length; i++){

    if(decodedPacket.type < 3) { //single packet TCP or UDP 

          decodedPacket.payload[i] = payload->data[i];   

    } else if(decodedPacket.type == 3) {  //broadcast

        //todo

    }

  }

  decodedPacket.checksum=packet->checksum;

  return decodedPacket;

}



void debug_packet(DataPacket *packet){

 DataPacketDecoded sendPacketedDecoded = decode_packet(packet);

  Serial.println("Decode Packet");

  Serial.print("    sent: ");

  Serial.println(sendPacketedDecoded.status,DEC);

  Serial.print("  length: ");

  Serial.println(sendPacketedDecoded.length,DEC);

  Serial.print("settings: ");

  Serial.println(sendPacketedDecoded.settings,DEC);

  Serial.print("    type: ");

  Serial.println(sendPacketedDecoded.type,DEC); 

  Serial.print("fromNode: ");

  Serial.println(sendPacketedDecoded.fromNode,DEC);

  Serial.print("fromPlug: ");

  Serial.println(sendPacketedDecoded.fromPlug,DEC);

  Serial.print("  toNode: ");

  Serial.println(sendPacketedDecoded.toNode,DEC);

  Serial.print("  toPlug: ");

  Serial.println(sendPacketedDecoded.toPlug,DEC);

  Serial.print("     ttl: ");

  Serial.println(sendPacketedDecoded.ttl,DEC);

  Serial.print("      id: ");

  Serial.println(sendPacketedDecoded.id,DEC);

  Serial.print(" command: ");

  Serial.println(sendPacketedDecoded.command,DEC);

  Serial.print(" payload: ");

  for(i=0; i < sendPacketedDecoded.ptr; i++){

    Serial.print(sendPacketedDecoded.payload[i],DEC);

    Serial.print(",");

  } 

  Serial.println("");

   Serial.print(" payload: ");

  for(i=0; i < sendPacketedDecoded.ptr; i++){

    Serial.print(sendPacketedDecoded.payload[i],BYTE);

  } 

  Serial.println("");

  Serial.print("checksum: ");

  Serial.println(sendPacketedDecoded.checksum,DEC);

  Serial.print("     ptr: ");

  Serial.println(sendPacketedDecoded.ptr,DEC);

  Serial.print("    from: ");

  Serial.println(sendPacketedDecoded.from,DEC);

}



int availableMemory() {

  int size = 2048; // Use 2048 with ATmega328

  byte *buf;



  while ((buf = (byte *) malloc(--size)) == NULL)

    ;



  free(buf);



  return size;

}

Processing code:

import processing.serial.*;



//shortcuts to important bytes

//keeps from having to decode the whole thing to check simple parts

final int PACKET_LENGTH   = 0;

final int PACKET_SETTINGS = 1;

final int PACKET_FROM     = 2;

final int PACKET_TO       = 4;

final int PACKET_TTL      = 4;

final int PACKET_ID       = 6;

final int PACKET_COMMAND  = 7;

final int PACKET_PAYLOAD  = 8;



final int CMD_PING = 0x3E;

final int CMD_PONG = 0xE3;

final int CMD_STRING = 0xF1;

//an enum might be better here

final int STATUS_CLEAR    = 0;

final int STATUS_RECEVING = 1;

final int STATUS_RECEVIED = 2;

final int STATUS_WAITING  = 3;

final int STATUS_READY    = 4;

final int STATUS_SENDING  = 5;

final int STATUS_SENT     = 6;

final int STATUS_ACK      = 7;

final int STATUS_SUCCESS  = 8;



final int OFFSET_PACKET = 10;

final int OFFSET_HEADER = 8;

final int OFFSET_FOOTER = 2;







class DataPacketDecoded {

  int command, length, status = 0, settings, type,  fromPort, toPort, id, ttl = 0, ptr = 0;

  int fromNode, toNode,  checksum = 0;

  int[] payload = new int[56];



  DataPacketDecoded(){ }

}



//simple data packet



class DataPacket {

  int ptr = 0, status = 0, checksum = 0;

  int[] payload = new int[64];

  

  DataPacket(){ }

} 



class Payload {

  int length;

  int[] data = new int[56];

  

  Payload() { }

} 



//What should master ports be?



final int  NODE_ID = 255;



final int PACKET_BUFFER  = 10;

final int PACKET_TIMEOUT = 150;





//Should be an ArrayList so we can add and remove elements

DataPacket[] data = new DataPacket[PACKET_BUFFER];

DataPacket incomingPacket = new DataPacket(); //current incoming packet



int checksum;

int uniqueId = 0;

int i;

boolean sending = false;

boolean receiving = false;

long packetTimer;



int bgcolor;			     // Background color

int fgcolor;			     // Fill color

Serial myPort;                       // The serial port

PFont myFont;



XMLElement xmlConfig;



//build rf12 packet



void build_incoming_packet(int byteIn)

{

   //mark which port it is coming from

  println("count: "+incomingPacket.ptr + " byte: " + byteIn);

 

  if(incomingPacket.ptr == 0){  //Packet length

    if(byteIn <= 2) {

      println("RESENDING LAST");

      //resend last

      sendingPacket.status = STATUS_SENDING;

      return;

    }

    if(byteIn == 255) {

      println("ACK SUCCESS");

      sendingPacket.status = STATUS_SUCCESS; 

      sending = false; //allow next packet to send

      //aknowledge

      return;

    }

    if (byteIn > 128) {

      myPort.clear();

      myPort.write(0);

      println("BYTE to high");

      return;

    }

    receiving = true;

    packetTimer = millis();

    incomingPacket.payload[PACKET_LENGTH] = byteIn;

    incomingPacket.status = STATUS_RECEVING;

    checksum = 0;

    

    println("length: " + byteIn);

  }

  

  //checksum 

  if(incomingPacket.ptr < (incomingPacket.payload[PACKET_LENGTH] - OFFSET_FOOTER)){ //add to check sum

    incomingPacket.payload[incomingPacket.ptr] = byteIn;

    checksum = _crc16_update(checksum, byteIn);

    incomingPacket.ptr++;

    return;

  } else if(incomingPacket.ptr == (incomingPacket.payload[PACKET_LENGTH] - OFFSET_FOOTER)){ //get first byte of checksum

    incomingPacket.checksum = byteIn;

    incomingPacket.ptr++;

    return;

  } else { //get second byte and check the checksum

    incomingPacket.checksum = (incomingPacket.checksum << 8) | (byteIn & 0xFF);         

    if(checksum != incomingPacket.checksum) {

      println("processing checksum: " + checksum);  

      println("    packet checksum: " + incomingPacket.checksum);   

      println("Failed CRC Check"); 

      myPort.clear();

      myPort.write(int(0));

    } else {

      println("processing checksum: " + checksum);  

      println("    packet checksum: " + incomingPacket.checksum);  

      println("Passed CRC Check");  

      incomingPacket.status=STATUS_RECEVIED;

      DataPacket packet = getNewPacket();

      packet = incomingPacket;

      

      myPort.clear();

      myPort.write(int(255));

      println("SENT ACK");

      //packet

      debug_incoming_packet(packet); 

      // incomingPacket.payload;

      

      //incomingPacket = DataPacket;

    }

    //reset incoming packet

    incomingPacket = new DataPacket();

    receiving = false;

  }

}

//determine where to send packet. how to expand when we have 4 serial ports?



void process_stack(){

  //sending = false; //only send one pack per cycle

  

  for(i=0;i    process_packet(data[i]);

  }

//check for packets to send



//check for packets to resend if ACKs are late

   

//check for data packets that can be deleted from the stack 

}



DataPacket sendingPacket;



void process_packet(DataPacket packet){



  switch (packet.status){

    case STATUS_CLEAR:

      //println("CLEAR");

      break;

    case STATUS_RECEVING:

      println("RECEVING");



      break;

    case STATUS_RECEVIED:

      //if(get_node(packet,PACKET_TO) == NODE_ID){

        //process_command(packet);

        packet.status = STATUS_CLEAR;

     // } else {

     //   packet.status = STATUS_READY; 

     // }

      println("RECEVIED");

      break;

    case STATUS_WAITING:

      println("WAITING");

      break;

    case STATUS_READY:

      //check for free port

      if(sending == false){

        packet.status = STATUS_SENDING;

        sending = true;

      }

      //if reset pointer and set to send

      println("READY");

      break;

    case STATUS_SENDING:

      //because of the above, only one packet will be changed to sending

      //if(get_node(packet,PACKET_FROM) < 30){

        // send_packet_rf12(packet); 

      //} else {

         send_packet_serial(packet); 

         sendingPacket = packet;

     // }

      packet.status = STATUS_SENT;

      println("SENDING");

      break;

    case STATUS_SENT:

      //if is a ack packet 

      if(packet.payload[PACKET_SETTINGS] == 1){

        packet.status = STATUS_ACK;

        //start packets ack timer

      } else {

        //packet.status = STATUS_SUCCESS;

      }

      println("SENT");

      break;

    case STATUS_ACK:

       //if execeded timer resen

       //count resends if exceds max kill packet and add error

       println("ACK");

      break;

    case STATUS_SUCCESS:

      //option to post status to screen

      packet.status = STATUS_CLEAR;

      println("SUCCESS");

      break; 

  }

}



String findXMLid(XMLElement[] xml , int value, String rAttribute){

  String rValue = ""; 

  for(int a = 0; a    if(unhex(commands[a].getAttribute("id")) == value){

      return commands[a].getAttribute(rAttribute);

    }

  }

  return rValue;

} 



XMLElement commands[];



XMLElement devices[];



long sendTimer;



void setup() {

  size(600, 400);  // Stage size

  //noStroke();      // No border on the next thing drawn

  myFont = createFont("Consolas", 14);

  textFont(myFont);

  

  for(i=0; i < PACKET_BUFFER; i++) {

    data[i] = new DataPacket();

    data[i].status = STATUS_CLEAR;

  }

  

  xmlConfig = new XMLElement(this, "config.txt");

  devices = xmlConfig.getChildren("devices/device");

  commands = xmlConfig.getChildren("commands/command");

  

  // Print a list of the serial ports, for debugging purposes:

  //println(PFont.list());

  

  String portName = Serial.list()[0];

  myPort = new Serial(this, portName, 115200);

}



boolean arduinoBoot = false;

int count = 0;

void draw() {

  

  if(arduinoBoot == false){

    delay(2500);

    sendTimer = millis();

    arduinoBoot = true;;

  }

  process_stack();



  if((millis() - sendTimer) > 2000){

    //DataPacket packet = build_udp_packet(NODE_ID,0,3,2,CMD_STRING,str_to_payload("Hello "+count));

   // packet.status = STATUS_READY;

    sendTimer=millis();

    count++;

  }





  if(receiving == true) {

    if((millis() - packetTimer) > PACKET_TIMEOUT) {

      myPort.clear();

      myPort.write(0); //tell the node to resend last

      

      incomingPacket = new DataPacket();

      println("bad packet");

      receiving = false;

    }

  }

}



void serialEvent(Serial myPort) {

  // read a byte from the serial port:

  int inByte = myPort.read();

  build_incoming_packet(inByte);

  //print(inByte);

  //print(",");

}



//Done

DataPacket getNewPacket() {

  for(i=0; i < PACKET_BUFFER; i++) {

    if(data[i].status == STATUS_CLEAR){

      return data[i];

    } 

  }

  println("BUFFER FULL");

  return new DataPacket();

}







int get_node(DataPacket packet, int location)

{

  int node;  

  node = packet.payload[location];

  node = node << 4;

  node = node | (packet.payload[location+1] >> 4);

  return node;

}



Payload get_payload(DataPacket packet) 

{

  Payload payload = new Payload();

  payload.length = packet.payload[PACKET_LENGTH] - OFFSET_PACKET;

  for(i=0; i < payload.length; i++){

    if(packet.payload[PACKET_SETTINGS] < 3) { //single packet TCP or UDP

      payload.data[i] = packet.payload[i+OFFSET_HEADER];   

     

    } else if(packet.payload[PACKET_SETTINGS] == 3) {  //broadcast

        //todo

    }

  }

  return payload; 

}

 

Payload str_to_payload(String string)

{

  Payload payload = new Payload();

  //println("Payload Length: "+ string.length());

  for(i=0;i    payload.data[i] = int(string.charAt(i)); 

  }

  payload.length = string.length();

  return payload; 

}



void process_command(DataPacket packet)

{

  switch (packet.payload[PACKET_COMMAND]) {

    case CMD_PING:

      

     // DataPacket reply = build_udp_packet(NODE_ID, 1, 0, 0, CMD_PONG, get_payload(packet));

     // reply.status = STATUS_READY;

      

      //change status to ready to send

      

      break;

    //default:

      //send_packet(COMMAND_ERROR,NULL,0);

   //   break;

    }

}





int _crc16_update(int crc, int a)

{

    int i;

    crc ^= a;

    for (i = 0; i < 8; ++i){

        if ((crc & 1) == 1){

            crc = (crc >> 1) ^ 0xA001;

        }else{

            crc = (crc >> 1);

        }

    }

    return crc & 0xFFFF;

}



int getId() {

  if(uniqueId == 255){

    uniqueId = 0;

  }

  return uniqueId++; //what happens when this wraps?

}



int compressAddress(int node, int port) 

{

  node = node << 4; //make space

  port = port & 0x0F;

  return node | port;

}





DataPacket build_tcp_packet(int fromNode, int fromPlug, int toNode, int toPlug, int command, Payload payload)

{

  DataPacket packet = getNewPacket();

  //*packet.status = STATUS_READY;

  packet.status = STATUS_WAITING;

  packet.payload[PACKET_LENGTH] = payload.length + OFFSET_PACKET; //header 8 crc 2

  packet.payload[PACKET_SETTINGS] = 1;

  int address = compressAddress(fromNode, fromPlug);

  packet.payload[PACKET_FROM] = (address >> 8) & 0xFF;

  packet.payload[PACKET_FROM+1] = address & 0xFF;

  address = compressAddress(toNode, toPlug);

  packet.payload[PACKET_TO ] = (address >> 8) & 0xFF;

  packet.payload[PACKET_TO+1] = address & 0xFF;

  packet.payload[PACKET_ID] = getId();

  packet.payload[PACKET_COMMAND] = command;

  

  for(i=0;i < payload.length;i++){

    packet.payload[PACKET_PAYLOAD+i] = payload.data[i];

  }



  return packet;

}



/*

 * @return DataPacket * Pointer to the New DataPacket

 */



DataPacket build_udp_packet(int fromNode, int fromPlug, int toNode, int toPlug, int command, Payload payload)

{

  DataPacket packet = getNewPacket();

  //*packet.status = STATUS_READY;

  packet.status = STATUS_WAITING;

  packet.payload[PACKET_LENGTH] = payload.length + OFFSET_PACKET; //header 8 crc 2

  packet.payload[PACKET_SETTINGS] = 2;

  int address = compressAddress(fromNode, fromPlug);

  packet.payload[PACKET_FROM] = (address >> 8) & 0xFF;

  packet.payload[PACKET_FROM+1] = address & 0xFF;

  address = compressAddress(toNode, toPlug);

  packet.payload[PACKET_TO ] = (address >> 8) & 0xFF;

  packet.payload[PACKET_TO+1] = address & 0xFF;

  packet.payload[PACKET_ID] = getId();

  packet.payload[PACKET_COMMAND] = command;

  

  for(i=0;i < payload.length;i++){

  packet.payload[PACKET_PAYLOAD+i] = payload.data[i];

  }

  

  return packet;

}



/*

uint8_t build_broadcast_packet(uint16_t fromNode, uint8_t fromPort, uint16_t toNode, uint8_t toPort, uint8_t payload[48], uint8_t length, uint8_t ttl )

{

  byte packetId = getNewPacketId();

  data[packetId].sent = 0;

  return packetId;

}

*/



boolean send_packet_serial(DataPacket packet)

{

  int dataChecksum = 0;

  for(i=0; i < (packet.payload[PACKET_LENGTH]-2); i++){

    dataChecksum = _crc16_update(dataChecksum, packet.payload[i]);

    myPort.write(packet.payload[i] & 0xFF);

    print(int((packet.payload[i] & 0xFF)) + ",");

  } 

  

  print((dataChecksum >>8)&0xFF);

  print(",");

  print(dataChecksum & 0xFF);

  

  println("");

  println("Packet Sent");

  packet.status = 1;

  myPort.write((dataChecksum >> 8) & 0xFF);	

  myPort.write(dataChecksum & 0xFF);



  return true;

}



/**

 * turns a packet into a decoded packet

 */



DataPacketDecoded decode_packet(DataPacket packet)

{

  DataPacketDecoded decodedPacket = new DataPacketDecoded();

       

  //Set Packet length

  decodedPacket.length = packet.payload[PACKET_LENGTH];

  

  decodedPacket.status = packet.status;

  

  //settings 

  decodedPacket.settings = packet.payload[PACKET_SETTINGS];

  decodedPacket.type = packet.payload[PACKET_SETTINGS]; //right now these are the same things



  //From 12bit node id, 4 bit plug id

  decodedPacket.fromNode = packet.payload[PACKET_FROM];

  decodedPacket.fromNode = decodedPacket.fromNode << 4;

  decodedPacket.fromNode = decodedPacket.fromNode | (packet.payload[PACKET_FROM+1] >> 4);

  decodedPacket.fromPort = packet.payload[PACKET_FROM+1] &0xF;

  

  //To 12bit node id, 4 bit plug id

  decodedPacket.toNode = packet.payload[PACKET_TO];

  decodedPacket.toNode = decodedPacket.toNode << 4;

  decodedPacket.toNode = decodedPacket.toNode | (packet.payload[PACKET_TO+1] >> 4);

  decodedPacket.toPort = packet.payload[PACKET_TO+1] &0xF;



 //packet id

  decodedPacket.id = packet.payload[PACKET_ID];



 //Command

  decodedPacket.command = packet.payload[PACKET_COMMAND];

  decodedPacket.checksum = packet.checksum;

  decodedPacket.ptr = packet.payload[PACKET_LENGTH] - 10;

   

  for(i=PACKET_PAYLOAD; i < packet.payload[PACKET_LENGTH]; i++){



    if(decodedPacket.type < 3) { //single packet TCP or UDP

        

          decodedPacket.payload[i-PACKET_PAYLOAD] = packet.payload[i];   

     

    } else if(decodedPacket.type == 3) {  //broadcast

        //todo

    }

  }

  return decodedPacket;

}



void debug_incoming_packet(DataPacket packet) 

{

  background(0);

  //println("show packet info");

  text("Packet Info",5,15);

  int x = 20;

  DataPacketDecoded packetDecoded = decode_packet(packet);

  text("  status: " + packetDecoded.status,10,x+=20);

  text("  length: " + packetDecoded.length,10,x+=20);

  text("settings: " + packetDecoded.settings,10,x+=20);

  text("    type: " + packetDecoded.type,10,x+=20); 

  text("fromNode: " + packetDecoded.fromNode,10,x+=20);

  text("fromPort: " + packetDecoded.fromPort,10,x+=20);

  text("  toNode: " + packetDecoded.toNode,10,x+=20);

  text("  toPort: " + packetDecoded.toPort,10,x+=20);

  text("     ttl: " + packetDecoded.ttl,10,x+=20);

  text("      id: " + packetDecoded.id,10,x+=20);

  text(" command: " + findXMLid(commands, packetDecoded.command,"code"),10,x+=20);

  

  String message = "";

  String message2 = "";

  for(i=0; i < packetDecoded.ptr; i++){

    message += int(packetDecoded.payload[i]);

    message += ",";

    message2 += char(packetDecoded.payload[i]);

  } 

  text(" payload: " + message,10,x+=20);

  text(" payload: " + message2,10,x+=20);

  

  text("checksum: " + packetDecoded.checksum,10,x+=20);

  text("     ptr: " + packetDecoded.ptr,10,x+=20);//*/

}

XML Config File

2010-11-09T04:32:00.000-08:00

Its starting to be pain to setup on the constants in both Arduino and processing and in the future php so it's time to create a configuration file that all of these different languages can use (sort of)

And here it is:

<?xml version="1.0"?>
<configuration>

<devices>
  <device id="0x01" code="DVC_TMP37">Temperature Sensor TMP37</device>
  <device id="0x02" code="DVC_LIGHT">Light Sensor LDR</device>
  <device id="0x03" code="DVC_SHT21">Temperature and Humidy Sensor SHT21</device>
  <device id="0x04" code="DVC_DOORCONTACT">Door Contact Sensor</device>
  <device id="0x05" code="DVC_WINDOWCONTACT">Window Contact Sensor</device>
  <device id="0x06" code="DVC_MOTION">Motion Sensor</device>
  <device id="0x07" code="DVC_2LINEDISPLAY">2 Line Character Display</device>
  <device id="0x08" code="DVC_POWER30">30A Current Sensor</device>
  <device id="0x09" code="DVC_POWER100">100A Current Sensor</device>
  <device id="0x10" code="DVC_SMARTOUTLET">Smart Outlet</device>
  <device id="0x11" code="DVC_RGBLIGHT">RGN LED Light</device>
  <device id="0x12" code="DVC_sound">Sound Sensor</device>
  <device id="0x13" code="DVC_SWITCH">Simple Switch</device>
  <device id="0x14" code="DVC_STATUSLED">Simple Status LEDS</device>
  <device id="0x15" code="DVC_BUZZER">Alert Buzzer</device>
</devices>

<commands>

  <!-- System Commands Port 0 -->
  <command id="0x00" code="CMD_ERROR"  payload="message" return="CMD_ACK"></command>

  <command id="0x01" code="CMD_VERSION" payload="" return="CMD_FLOAT">
    Get current version of firmware on the node
  </command>
  <command id="0x03" code="CMD_BATTERYLEVEL" payload="" return="">
    Get current battery level
  </command>
  <command id="0x3E" code="CMD_PING" payload="varies" return="CMD_PONG">
    Send Test Pack, node should reply back pong
  </command>
  <command id="0xE3" code="CMD_PONG" payload="varies" return="CMD_ACK">
    Response to a Ping Command
  </command>
  <command id="0x11" code="CMD_ACK" payload="packetid" return="CMD_BYTE">
    Acknowledge Packet, letting the sender of a packet know that data arriced safely
  </command>
  <command id="0x21" code="CMD_GETNODEID" payload="" return="CMD_BYTE">
    Get Node's current ID (node id 0 is for broadcast)
  </command>
  <command id="0x22" code="CMD_SETNODEID" payload="passcode" return="CMD_ACK">
    Changes NODE ID, used for initial setup
  </command>
  <command id="0x23" code="CMD_GETPLUG" payload="byte port" return="CMD_BYTE">
    Get the device code for what is attached on the node
  </command>
  <command id="0x24" code="CMD_SETPLUG" payload="passcode" return="CMD_ACK">
    Changes Device ID, used for initial setup
  </command>

  <!-- Plug commands Ports 1-15 -->
  <command id="0xC1" code="CMD_AUTOSENDSTART" payload="node to, int" return="CMD_ACK">
    Set up the node to automatically send sensor data to a particular node 
  </command>
  <command id="0xC2" code="CMD_AUTOSENDSTOP" payload="node to" return="CMD_ACK">
    Stop auto sending sensor data
  </command>
  <command id="0xD0" code="CMD_GETVALUE" payload="" return="Value">
    Get a value from a plug
  </command>
  <command id="0xD1" code="CMD_SETVALUE" payload="" return="Value">
    Send a value to a plug
  </command>

  <command id="0xE0" code="CMD_ON" payload="" return="CMD_ACK">
    Simple Turn on
  </command>
  <command id="0xE1" code="CMD_OFF" payload="" return="CMD_ACK">
    Simple Turn Off
  </command>
  <command id="0xE2" code="CMD_LEVEL" payload="byte" return="CMD_ACK">
    Set a light to a level 0-255
  </command>

  <!-- Value commands -->
  <command id="0xF0" code="CMD_BYTE"   payload="byte" return="CMD_ACK"></command>
  <command id="0xF1" code="CMD_STRING" payload="string" return="CMD_ACK"></command>
  <command id="0xF2" code="CMD_INT"    payload="int" return="CMD_ACK"></command>
  <command id="0xF3" code="CMD_FLOAT"  payload="float" return="CMD_ACK"></command>
  <command id="0xF4" code="CMD_LONG"   payload="long" return="CMD_ACK"></command>
</commands>

<!-- One day more stuff will be setup too  -->
<pachube>
  <apikey></apikey>
  <feeds>
    <feed name="Bedroom">
      <datastream id="0" node="" plug="" device="" />
    </feed>
  </feeds>
</pachube>

<webserver>
  <address></address>
</webserver>

</configuration>

Processing has built in tools for reading XML and this quick sketch reads the XML file a translates it in to list of #defines for the Arduino. this way as the lists of devices and commands evolve, it's very easy to translate it from one language to another.

XMLElement xml;

PFont myFont;
PrintWriter file;

int i;
String spaces(int count){
 String spaces = "";
  for(int a = 0;a<count;a++){
   
   spaces += " ";
  } 
  return spaces;
}

void setup() {
  size(200, 200);
  
  myFont = createFont("Consolas", 14);
  textFont(myFont);
  
  xml = new XMLElement(this, "config.txt"); //in txt
  file = createWriter("define.txt");
  
  XMLElement commands[] = xml.getChildren("commands/command");
  
  for(i = 0; i<commands.length;i++){
    file.println("#define "+ commands[i].getAttribute("code")+spaces(20 - commands[i].getAttribute("code").length())+commands[i].getAttribute("id"));
  }
  file.println(""); //blank line
  XMLElement devices[] = xml.getChildren("devices/device");
  
  for(i = 0; i<devices.length;i++){
    file.println("#define "+ devices[i].getAttribute("code")+spaces(20 - devices[i].getAttribute("code").length())+devices[i].getAttribute("id"));
  }
  file.flush(); // Write the remaining data
  file.close();
  exit();
}

And here is the Arduino Code the script above generated for me

#define CMD_ERROR           0x00
#define CMD_VERSION         0x01
#define CMD_BATTERYLEVEL    0x03
#define CMD_PING            0x3E
#define CMD_PONG            0xE3
#define CMD_ACK             0x11
#define CMD_SETNODEID       0x21
#define CMD_GETNODEID       0x21
#define CMD_SETNODEID       0x22
#define CMD_GETPLUG         0x23
#define CMD_SETPLUG         0x24
#define CMD_AUTOSENDSTART   0xC1
#define CMD_AUTOSENDSTOP    0xC2
#define CMD_GETVALUE        0xD0
#define CMD_SETVALUE        0xD1
#define CMD_ON              0xE0
#define CMD_OFF             0xE1
#define CMD_LEVEL           0xE2
#define CMD_BYTE            0xF0
#define CMD_STRING          0xF1
#define CMD_INT             0xF2
#define CMD_FLOAT           0xF3
#define CMD_LONG            0xF4

#define DVC_TMP37           0x01
#define DVC_LIGHT           0x02
#define DVC_SHT21           0x03
#define DVC_DOORCONTACT     0x04
#define DVC_WINDOWCONTACT   0x05
#define DVC_MOTION          0x06
#define DVC_2LINEDISPLAY    0x07
#define DVC_POWER30         0x08
#define DVC_POWER100        0x09
#define DVC_SMARTOUTLET     0x10
#define DVC_RGBLIGHT        0x11
#define DVC_sound           0x12
#define DVC_SWITCH          0x13
#define DVC_STATUSLED       0x14
#define DVC_BUZZER          0x15

Ping Pong Packets

2010-11-08T09:10:00.000-08:00

After another week of work on my packet code, I finally have a working example of call and response working. Processing sends a Ping packet to the Arduino and the Arduino replies back Pong along with the payload of the original packet. Next step is to expand this to connect to wireless nodes.

Code after the jump

Processing:

import processing.serial.*;



//Device Codes

final int DVC_LM33          = 0x01;

final int DVC_ST11          = 0x02;

final int DVC_ST15          = 0x03;

final int DVC_DOORCONTACT   = 0x04;

final int DVC_FLIPSWITCH    = 0x05;

final int DVC_LIGHT         = 0x06;

final int DVC_MOTION        = 0x07;

final int DVC_2LINECHAR     = 0x08;

final int DVC_POWER30       = 0x08;

final int DVC_POWER100      = 0x09;

final int DVC_SMARTOUTLET   = 0x10;

final int DVC_RGBLIGHT      = 0x11;



//Command Codes

final int  CMD_GET_VERSION   = 0x01;

final int  CMD_PING          = 0x3E;

final int  CMD_PONG          = 0xE3;

final int  CMD_ACK           = 0x11;

final int  CMD_READ          = 0xAA;

final int  CMD_WRITE         = 0xBB;

final int  CMD_PORTTYPE      = 0xCC;



final int  CMD_AUTOSENDSTART = 0xC1;

final int  CMD_AUTOSENDSTOP  = 0xC2;



final int  CMD_ERROR         = 0xFF;



//shortcuts to important bytes

//keeps from having to decode the whole thing to check simple parts

final int PACKET_LENGTH   = 0;

final int PACKET_SETTINGS = 1;

final int PACKET_FROM     = 2;

final int PACKET_TO       = 4;

final int PACKET_TTL      = 4;

final int PACKET_ID       = 6;

final int PACKET_COMMAND  = 7;

final int PACKET_PAYLOAD  = 8;



//an enum might be better here

final int STATUS_CLEAR    = 0;

final int STATUS_RECEVING = 1;

final int STATUS_RECEVIED = 2;

final int STATUS_WAITING  = 3;

final int STATUS_READY    = 4;

final int STATUS_SENDING  = 5;

final int STATUS_SENT     = 6;

final int STATUS_ACK      = 7;

final int STATUS_SUCCESS  = 8;



final int OFFSET_PACKET = 10;

final int OFFSET_HEADER = 8;

final int OFFSET_FOOTER = 2;







class DataPacketDecoded {

  int command, length, status = 0, settings, type,  fromPort, toPort, id, ttl = 0, ptr = 0;

  int fromNode, toNode,  checksum = 0;

  int[] payload = new int[56];



  DataPacketDecoded(){ }

}



//simple data packet



class DataPacket {

  int ptr = 0, status = 0, checksum = 0;

  int[] payload = new int[64];

  

  DataPacket(){ }

} 



class Payload {

  int length;

  int[] data = new int[56];

  

  Payload() { }

} 



//What should master ports be?



final int  NODE_ID = 0x02;



final int PORT_A = DVC_LM33;

final int PORT_B = DVC_LM33;

final int PORT_C = DVC_LM33;

final int PORT_D = DVC_LM33;



final int PACKET_BUFFER  = 10;

final int PACKET_TIMEOUT = 100;



DataPacket[] data = new DataPacket[PACKET_BUFFER];

DataPacket incomingPacket = new DataPacket(); //current incoming packet



int checksum;

int uniqueId = 0;

int i;

boolean sending = false;

boolean receiving = false;

long packetTimer;







int bgcolor;			     // Background color

int fgcolor;			     // Fill color

Serial myPort;                       // The serial port

PFont myFont;



//build rf12 packet



void build_incoming_packet(int byteIn)

{

   //mark which port it is coming from

  println("count: "+incomingPacket.ptr + " byte: " + byteIn);

 

  if(incomingPacket.ptr == 0){  //Packet length

    if(byteIn <= 1) {

      println("RESENDING LAST");

      //resend last

      sendingPacket.status = STATUS_SENDING;

      return;

    }

    if(byteIn == 255) {

      println("ACK SUCCESS");

      sendingPacket.status = STATUS_SUCCESS; 

      sending = false; //allow next packet to send

      //aknowledge

      return;

    }

    if (byteIn > 128) {

      myPort.clear();

      myPort.write(0);

      return;

    }

    receiving = true;

    packetTimer = millis();

    incomingPacket.payload[PACKET_LENGTH] = byteIn;

    incomingPacket.status = STATUS_RECEVING;

    checksum = 0;

    

    println("length: " + byteIn);

  }

  

  //checksum 

  if(incomingPacket.ptr < (incomingPacket.payload[PACKET_LENGTH] - OFFSET_FOOTER)){ //add to check sum

    incomingPacket.payload[incomingPacket.ptr] = byteIn;

    checksum = _crc16_update(checksum, byteIn);

    incomingPacket.ptr++;

    return;

  } else if(incomingPacket.ptr == (incomingPacket.payload[PACKET_LENGTH] - OFFSET_FOOTER)){ //get first byte of checksum

    incomingPacket.checksum = byteIn;

    incomingPacket.ptr++;

    return;

  } else { //get second byte and check the checksum

    incomingPacket.checksum = (incomingPacket.checksum << 8) | (byteIn & 0xFF);         

    if(checksum != incomingPacket.checksum) {

      println("processing checksum: " + checksum);  

      println("    packet checksum: " + incomingPacket.checksum);   

      println("Failed CRC Check"); 

      myPort.clear();

      myPort.write(int(0));

    } else {

      println("processing checksum: " + checksum);  

      println("    packet checksum: " + incomingPacket.checksum);  

      println("Passed CRC Check");  

      incomingPacket.status=STATUS_RECEVIED;

      DataPacket packet = getNewPacket();

      packet = incomingPacket;

      

      myPort.clear();

      myPort.write(int(255));

      println("SENT ACK");

      //packet

      debug_incoming_packet(packet); 

      // incomingPacket.payload;

      

      //incomingPacket = DataPacket;

    }

    //reset incoming packet

    incomingPacket = new DataPacket();

    receiving = false;

  }

  

  

}





//determine where to send packet. how to expand when we have 4 serial ports?



void process_stack(){

  //sending = false; //only send one pack per cycle

  

  for(i=0;i    process_packet(data[i]);

  }

//check for packets to send



//check for packets to resend if ACKs are late

   

//check for data packets that can be deleted from the stack 

}



DataPacket sendingPacket;



void process_packet(DataPacket packet){

  switch (packet.status){

    case STATUS_CLEAR:

      //println("CLEAR");

      break;

    case STATUS_RECEVING:

      println("RECEVING");



      break;

    case STATUS_RECEVIED:

      process_command(packet);

      packet.status = STATUS_CLEAR;

      println("RECEVIED");

      break;

    case STATUS_WAITING:

      println("WAITING");

      break;

    case STATUS_READY:

      //check for free port

      if(sending == false){

        packet.status = STATUS_SENDING;

        sending = true;

      }

      //if reset pointer and set to send

      println("READY");

      break;

    case STATUS_SENDING:

      //because of the above, only one packet will be changed to sending

      //if(get_node(packet,PACKET_FROM) < 30){

        // send_packet_rf12(packet); 

      //} else {

         send_packet_serial(packet); 

         sendingPacket = packet;

     // }

      packet.status = STATUS_SENT;

      println("SENDING");

      break;

    case STATUS_SENT:

      //if is a ack packet 

      if(packet.payload[PACKET_SETTINGS] == 1){

        packet.status = STATUS_ACK;

        //start packets ack timer

      } else {

        //packet.status = STATUS_SUCCESS;

      }

      println("SENT");

      break;

    case STATUS_ACK:

       //if execeded timer resen

       //count resends if exceds max kill packet and add error

       println("ACK");

      break;

    case STATUS_SUCCESS:

      //option to post status to screen

      packet.status = STATUS_CLEAR;

      println("SUCCESS");

      break; 

  }

}



long sendTimer;



void setup() {

  size(600, 400);  // Stage size

  //noStroke();      // No border on the next thing drawn

  myFont = createFont("Consolas", 14);

  textFont(myFont);

  

  for(i=0; i < PACKET_BUFFER; i++) {

    data[i] = new DataPacket();    

  }

  



  // Print a list of the serial ports, for debugging purposes:

  //println(PFont.list());

  sendTimer = millis();

  String portName = Serial.list()[1];

  myPort = new Serial(this, portName, 115200);

}



void draw() {

  process_stack();

  //process_stack();

  //process_stack();

 // process_stack();

 // process_stack();

  println("loop");

  //delay(1000);

   //text("Hello",10,10);

   //text("Z", 10, 220);

   

  // Draw the shape

  if((millis() - sendTimer) > 2500){

    DataPacket packet = build_udp_packet(0,0,1,0,CMD_PING,str_to_payload("Hello"));

    packet.status = STATUS_READY;

    sendTimer=millis();

  }



  

  //send_packet_serial(packet);

  if(receiving == true) {

    if((millis() - packetTimer) > PACKET_TIMEOUT) {

      myPort.clear();

      myPort.write(0); //tell the node to resend last

      

      incomingPacket = new DataPacket();

      println("bad packet");

      receiving = false;

    }

  }

  



}



void serialEvent(Serial myPort) {

  // read a byte from the serial port:

  int inByte = myPort.read();

  build_incoming_packet(inByte);

  //print(inByte);

  //print(",");

}



//Done

DataPacket getNewPacket() {

  for(i=0; i < PACKET_BUFFER; i++) {

    if(data[i].status == STATUS_CLEAR){

      

      return data[i];

    } 

  }

  println("BUFFER FULL");

  return new DataPacket();

}



int get_node(DataPacket packet, int location)

{

  int node;  

  node = packet.payload[location];

  node = node << 4;

  node = node | (packet.payload[location+1] >> 4);

  return node;

}



Payload get_payload(DataPacket packet) 

{

  Payload payload = new Payload();

  payload.length = packet.payload[PACKET_LENGTH] - OFFSET_PACKET;

  for(i=0; i < payload.length; i++){

    if(packet.payload[PACKET_SETTINGS] < 3) { //single packet TCP or UDP

      payload.data[i] = packet.payload[i+OFFSET_HEADER];   

     

    } else if(packet.payload[PACKET_SETTINGS] == 3) {  //broadcast

        //todo

    }

  }

  return payload; 

}

 

Payload str_to_payload(String string)

{

  Payload payload = new Payload();

  //println("Payload Length: "+ string.length());

  for(i=0;ilength();i++){

    payload.data[i] = int(string.charAt(i)); 

  }

  payload.length = string.length();

  return payload; 

}



void process_command(DataPacket packet)

{

  switch (packet.payload[PACKET_COMMAND]) {

    case CMD_PING:

      

      DataPacket reply = build_udp_packet(NODE_ID, 1, 0, 0, CMD_PONG, get_payload(packet));

      reply.status = STATUS_READY;

      

      //change status to ready to send

      

      break;

    //default:

      //send_packet(COMMAND_ERROR,NULL,0);

   //   break;

    }

}



int _crc16_update(int crc, int a)

{

    int i;

    crc ^= a;

    for (i = 0; i < 8; ++i){

        if ((crc & 1) == 1){

            crc = (crc >> 1) ^ 0xA001;

        }else{

            crc = (crc >> 1);

        }

    }

    return crc & 0xFFFF;

}



int getId() {

  if(uniqueId == 255){

    uniqueId = 0;

  }

  return uniqueId++; //what happens when this wraps?

}



int compressAddress(int node, int port) 

{

  node = node << 4; //make space

  port = port & 0x0F;

  return node | port;

}





DataPacket build_tcp_packet(int fromNode, int fromPlug, int toNode, int toPlug, int command, Payload payload)

{

  DataPacket packet = getNewPacket();

  //*packet.status = STATUS_READY;

  packet.status = STATUS_WAITING;

  packet.payload[PACKET_LENGTH] = payload.length + OFFSET_PACKET; //header 8 crc 2

  packet.payload[PACKET_SETTINGS] = 1;

  int address = compressAddress(fromNode, fromPlug);

  packet.payload[PACKET_FROM] = (address >> 8) & 0xFF;

  packet.payload[PACKET_FROM+1] = address & 0xFF;

  address = compressAddress(toNode, toPlug);

  packet.payload[PACKET_TO ] = (address >> 8) & 0xFF;

  packet.payload[PACKET_TO+1] = address & 0xFF;

  packet.payload[PACKET_ID] = getId();

  packet.payload[PACKET_COMMAND] = command;

  

  for(i=0;i < payload.length;i++){

    packet.payload[PACKET_PAYLOAD+i] = payload.data[i];

  }



  return packet;

}



/*

 * @return DataPacket * Pointer to the New DataPacket

 */



DataPacket build_udp_packet(int fromNode, int fromPlug, int toNode, int toPlug, int command, Payload payload)

{

  DataPacket packet = getNewPacket();

  //*packet.status = STATUS_READY;

  packet.status = STATUS_WAITING;

  packet.payload[PACKET_LENGTH] = payload.length + OFFSET_PACKET; //header 8 crc 2

  packet.payload[PACKET_SETTINGS] = 2;

  int address = compressAddress(fromNode, fromPlug);

  packet.payload[PACKET_FROM] = (address >> 8) & 0xFF;

  packet.payload[PACKET_FROM+1] = address & 0xFF;

  address = compressAddress(toNode, toPlug);

  packet.payload[PACKET_TO ] = (address >> 8) & 0xFF;

  packet.payload[PACKET_TO+1] = address & 0xFF;

  packet.payload[PACKET_ID] = getId();

  packet.payload[PACKET_COMMAND] = command;

  

  for(i=0;i < payload.length;i++){

  packet.payload[PACKET_PAYLOAD+i] = payload.data[i];

  }

  

  return packet;

}



/*

uint8_t build_broadcast_packet(uint16_t fromNode, uint8_t fromPort, uint16_t toNode, uint8_t toPort, uint8_t payload[48], uint8_t length, uint8_t ttl )

{

  byte packetId = getNewPacketId();

  data[packetId].sent = 0;

  return packetId;

}

*/



boolean send_packet_serial(DataPacket packet)

{

  int dataChecksum = 0;

  for(i=0; i < (packet.payload[PACKET_LENGTH]-2); i++){

    dataChecksum = _crc16_update(dataChecksum, packet.payload[i]);

    myPort.write(packet.payload[i] & 0xFF);

    print(int((packet.payload[i] & 0xFF)) + ",");

  } 

  

  print((dataChecksum >>8)&0xFF);

  print(",");

  print(dataChecksum & 0xFF);

  

  println("");

  println("Packet Sent");

  packet.status = 1;

  myPort.write((dataChecksum >> 8) & 0xFF);	

  myPort.write(dataChecksum & 0xFF);

  

 

  

  return true;

}



/**

 * turns a packet into a decoded packet

 */



DataPacketDecoded decode_packet(DataPacket packet)

{

  DataPacketDecoded decodedPacket = new DataPacketDecoded();

       

  //Set Packet length

  decodedPacket.length = packet.payload[PACKET_LENGTH];

  

  decodedPacket.status = packet.status;

  

  //settings 

  decodedPacket.settings = packet.payload[PACKET_SETTINGS];

  decodedPacket.type = packet.payload[PACKET_SETTINGS]; //right now these are the same things



  //From 12bit node id, 4 bit plug id

  decodedPacket.fromNode = packet.payload[PACKET_FROM];

  decodedPacket.fromNode = decodedPacket.fromNode << 4;

  decodedPacket.fromNode = decodedPacket.fromNode | (packet.payload[PACKET_FROM+1] >> 4);

  decodedPacket.fromPort = packet.payload[PACKET_FROM+1] &0xF;

  

  //To 12bit node id, 4 bit plug id

  decodedPacket.toNode = packet.payload[PACKET_TO];

  decodedPacket.toNode = decodedPacket.toNode << 4;

  decodedPacket.toNode = decodedPacket.toNode | (packet.payload[PACKET_TO+1] >> 4);

  decodedPacket.toPort = packet.payload[PACKET_TO+1] &0xF;



 //packet id

  decodedPacket.id = packet.payload[PACKET_ID];



 //Command

  decodedPacket.command = packet.payload[PACKET_COMMAND];

  decodedPacket.checksum = packet.checksum;

  decodedPacket.ptr = packet.payload[PACKET_LENGTH] - 10;

   

  for(i=PACKET_PAYLOAD; i < packet.payload[PACKET_LENGTH]; i++){



    if(decodedPacket.type < 3) { //single packet TCP or UDP

        

          decodedPacket.payload[i-PACKET_PAYLOAD] = packet.payload[i];   

     

    } else if(decodedPacket.type == 3) {  //broadcast

        //todo

    }

  }

  return decodedPacket;

}



void debug_incoming_packet(DataPacket packet) 

{

  background(0);

  //println("show packet info");

  text("Packet Info",5,15);

  int x = 20;

  DataPacketDecoded packetDecoded = decode_packet(packet);

  text("  status: " + packetDecoded.status,10,x+=20);

  text("  length: " + packetDecoded.length,10,x+=20);

  text("settings: " + packetDecoded.settings,10,x+=20);

  text("    type: " + packetDecoded.type,10,x+=20); 

  text("fromNode: " + packetDecoded.fromNode,10,x+=20);

  text("fromPort: " + packetDecoded.fromPort,10,x+=20);

  text("  toNode: " + packetDecoded.toNode,10,x+=20);

  text("  toPort: " + packetDecoded.toPort,10,x+=20);

  text("     ttl: " + packetDecoded.ttl,10,x+=20);

  text("      id: " + packetDecoded.id,10,x+=20);

  text(" command: " + packetDecoded.command,10,x+=20);

  

  String message = "";

  String message2 = "";

  for(i=0; i < packetDecoded.ptr; i++){

    message += int(packetDecoded.payload[i]);

    message += ",";

    message2 += char(packetDecoded.payload[i]);

  } 

  text(" payload: " + message,10,x+=20);

  text(" payload: " + message2,10,x+=20);

  

  text("checksum: " + packetDecoded.checksum,10,x+=20);

  text("     ptr: " + packetDecoded.ptr,10,x+=20);//*/

}

Arduino

Protocol.h

//Device Codes



#define DVC_LM33           0x01

#define DVC_ST11           0x02

#define DVC_ST15           0x03

#define DVC_DOORCONTACT    0x04

#define DVC_FLIPSWITCH     0x05

#define DVC_LIGHT          0x06

#define DVC_MOTION         0x07

#define DVC_2LINECHAR      0x08

#define DVC_POWER30        0x08

#define DVC_POWER100       0x09

#define DVC_SMARTOUTLET    0x10

#define DVC_RGBLIGHT       0x11



//Command Codes



#define CMD_GET_VERSION    0x01

#define CMD_PING           0x3E

#define CMD_PONG           0xE3



#define CMD_ACK            0x11



#define CMD_READ           0xAA

#define CMD_WRITE          0xBB



#define CMD_PORTTYPE       0xCC



#define CMD_AUTOSENDSTART  0xC1

#define CMD_AUTOSENDSTOP   0xC2



#define CMD_VALUE          0x02



#define CMD_ERROR          0xFF



//@todo commands for different data types?



//decoded packet struct



typedef struct {

  uint8_t command;

 //if 255 = ready to send // 0 = resend last

  uint8_t length;

  uint8_t status;

  uint8_t settings; //01010101 //version //type direct or broadcast //ack //ttl //priority //multi

  uint8_t type; //1 single tcp, 2 single udp, 3 multipacket tcp

  uint16_t fromNode;

  uint8_t fromPlug;

  uint16_t toNode; //00 is base //xffff is broadcast

  uint8_t toPlug;

  uint8_t id;

  uint8_t ttl;

  

  uint8_t payload[48];

  uint16_t checksum;

  uint8_t ptr;

} DataPacketDecoded;





//simple data packet



typedef struct {

  uint8_t ptr;

  uint8_t port;

  uint8_t status;

  uint8_t payload[56];

  uint16_t checksum;

} DataPacket;



//payload type



typedef struct {

  uint8_t length;

  uint8_t data[56];

} Payload;



typedef struct {

  long start;

  uint8_t waiting;

  uint8_t ptr;

} ACKStatus;



typedef struct {

  uint8_t type;

  uint8_t status;

} Port;







//shortcuts to important bytes

//keeps from having to decode the whole thing to check simple parts

#define PACKET_LENGTH   0

#define PACKET_SETTINGS 1

#define PACKET_FROM     2

#define PACKET_TO       4

#define PACKET_TTL      4

#define PACKET_ID       6

#define PACKET_COMMAND  7

#define PACKET_PAYLOAD  8



//an enum might be better here

#define STATUS_CLEAR    0

#define STATUS_RECEVING 1

#define STATUS_RECEVIED 2

#define STATUS_WAITING  3

#define STATUS_READY    4

#define STATUS_SENDING  5

#define STATUS_SENT     6

#define STATUS_ACK      7

#define STATUS_SUCCESS  8



#define OFFSET_PACKET 10

#define OFFSET_HEADER 8

#define OFFSET_FOOTER 2

Basenode.pde

#include h> //checksum functions

#include "protocol.h"



#define NODE_ID 0x02



#define PLUG_A DVC_LM33

#define PLUG_B DVC_LM33

#define PLUG_C DVC_LM33

#define PLUG_D DVC_LM33



#define PACKET_BUFFER 10 //can be adujsted based on availbe space



//#define DEBUG 1;

#define PACKET_TIMEOUT 100



#define PORTTYPE_SERIAL 0

#define PORTTYPE_RF12   1



#define PORT_COUNT 2

#define PORT_0 PORTTYPE_SERIAL

#define PORT_1 PORTTYPE_RF12



//types

//ACK

//Single TCp //requires 2byte packet ID

//Single UDP

//Multi TCP //requires 2byte total ID, 2 byte Packet ID + byte current packet + byte total packets

//multi packet

//packet id

//current packets

//total packets

//



Port ports[] = {{PORTTYPE_SERIAL,STATUS_CLEAR},

                {PORTTYPE_RF12,STATUS_CLEAR}};







//list attached ports

//1 2 3 4 //rf12



DataPacket data[PACKET_BUFFER];



uint16_t checksum;

byte uniqueId = 0;

byte i;

DataPacket incomingPacket; //current incoming packet

//incomingPacket.ptr = 0;



DataPacket *sendingPacket;



boolean sending = false;

boolean receiving = false;

long packetTimer;;



DataPacket *getNewPacket() {

  for(i=0; i < PACKET_BUFFER; i++) {

    if(data[i].status == STATUS_CLEAR){

      

      return &data[i];

    } 

  }

  //Serial.println("all full");

  return 0;

}



uint8_t getId() 

{

  return uniqueId++; //loops when it overflows

}



uint16_t compressAddress(uint16_t node, uint8_t port) 

{

  return (node << 4) | (port & 0x0F);

}

//byte m = 1;

void send_packet_serial(DataPacket *packet)

{

  uint16_t dataChecksum = 0;

  //cause a problem

 

 // m++;

  

  for(i=0; i < (packet->payload[PACKET_LENGTH]-OFFSET_FOOTER); i++){



    dataChecksum = _crc16_update(dataChecksum, packet->payload[i]);

     //if((m == 3) && (i == 0)){

    //  Serial.print(packet->payload[0]-5,BYTE);

    // } else {

      Serial.print(packet->payload[i],BYTE); 

    // }

    //Serial.print(",");

  } 

  

  packet->checksum = dataChecksum;

  Serial.print(highByte(dataChecksum),BYTE);

 // Serial.print(",");

  Serial.print(lowByte(dataChecksum),BYTE);

  packet->status = STATUS_SENT;

 //Serial.println("");

}



void send_packet_rf12(DataPacket *packet)

{

  /** //check address only 0-30 allowed

  

  *  @todo

  */

}



void process_command(DataPacket *packet)

{

  switch (packet->payload[PACKET_COMMAND]) {

    case CMD_PING:

      

      DataPacket *reply = build_udp_packet(NODE_ID, 1, 0, 0, CMD_PONG, get_payload(packet));

      reply->status = STATUS_READY;

      

      //change status to ready to send

      

      break;

    //default:

      //send_packet(COMMAND_ERROR,NULL,0);

   //   break;

    }

}



//build rf12 packet





void build_incoming_packet(uint8_t byteIn)

{

   //mark which port it is coming from

 

  if(incomingPacket.ptr == 0){  //Packet length

  

    if(byteIn == 0) {

      //resend last

      sendingPacket->status = STATUS_SENDING;

    

    

    return;

    }

    if(byteIn == 255) {

      sendingPacket->status = STATUS_SUCCESS;

      sending = false; //allow next packet to send

      //aknowledge



      return;

    }

    if (byteIn > 128) {

      //Serial.flush();

      Serial.print(0,BYTE);

      

      return;

    }

    receiving = true;

    packetTimer = millis();

    incomingPacket.payload[PACKET_LENGTH] = byteIn;

    incomingPacket.status = STATUS_RECEVING;

    checksum = 0;

  }

  

  //checksum 

  if(incomingPacket.ptr < (incomingPacket.payload[PACKET_LENGTH] - OFFSET_FOOTER)){ //add to check sum

    incomingPacket.payload[incomingPacket.ptr] = byteIn;

    checksum = _crc16_update(checksum, byteIn);

    incomingPacket.ptr++;

    return;

  } else if(incomingPacket.ptr == (incomingPacket.payload[PACKET_LENGTH] - OFFSET_FOOTER)){ //get first byte of checksum

    incomingPacket.checksum = byteIn;

    incomingPacket.ptr++;

    return;

  } else { //get second byte and check the checksum

    incomingPacket.checksum = (incomingPacket.checksum << 8) | (byteIn & 0xFF);         

    if(checksum != incomingPacket.checksum) {

      //Serial.println(checksum, DEC);  

      //Serial.println(incomingPacket.checksum, DEC);   

      

       DataPacket *p = build_udp_packet(NODE_ID, 1, 0, 0, CMD_ERROR, packet_to_payload(&incomingPacket));

       p->status = STATUS_READY;

      Serial.flush(); 

      Serial.print(1,BYTE); //tell the node to resend last

      

      

    } else {

      incomingPacket.status=STATUS_RECEVIED;

      DataPacket *packet = getNewPacket();

      *packet = incomingPacket;

      //Serial.flush();

      Serial.print(255,BYTE); //tell the node the packet was successful

      

    }

    //reset incomingPacket

    receiving = false;

    incomingPacket.status=STATUS_CLEAR;

    incomingPacket.ptr = 0;

  }

  

  



}





//determine where to send packet. how to expand when we have 4 serial ports?



void process_stack(){

  

  //sending = false; //only send one pack per cycle

  

  for(i=0;i    process_packet(&data[i]);

  }

//check for packets to send





//check for packets to resend if ACKs are late

  

  

//check for data packets that can be deleted from the stack 

}







void process_packet(DataPacket *packet){

  switch (packet->status){

    case STATUS_CLEAR:

      #ifdef DEBUG

      Serial.println("CLEAR");

      #endif

      break;

    case STATUS_RECEVING:

      #ifdef DEBUG

      Serial.println("RECEVING");

      #endif

      break;

    case STATUS_RECEVIED:

      process_command(packet);

      packet->status = STATUS_CLEAR;

      #ifdef DEBUG

      Serial.println("RECEVIED");

      #endif

      break;

    case STATUS_WAITING:

      #ifdef DEBUG

      Serial.println("WAITING");

      #endif

      break;

    case STATUS_READY:

      //check for free port

      if(sending == false){

        packet->status = STATUS_SENDING;

        sendingPacket = packet;

        sending = true;

      }

      //if reset pointer and set to send

      #ifdef DEBUG

      Serial.println("READY");

      #endif

      break;

    case STATUS_SENDING:

      //because of the above, only one packet will be changed to sending

      //if(get_node(packet,PACKET_FROM) < 30){

        // send_packet_rf12(packet); 

      //} else {

         send_packet_serial(packet); 

     // }

      packet->status = STATUS_SENT;

      #ifdef DEBUG

      

      Serial.println("SENDING");

      #endif

      break;

    case STATUS_SENT:

      //if is a ack packet 

      if(packet->payload[PACKET_SETTINGS] == 1){

        packet->status = STATUS_ACK;

        //start packets ack timer

      } else {

        //packet->status = STATUS_SUCCESS;

      }

      #ifdef DEBUG

      sending = false; //allow next packet to send

      packet->status = STATUS_SUCCESS;

      Serial.println("SENT");

      #endif

      break;

    case STATUS_ACK:

       //if execeded timer resen

       //count resends if exceds max kill packet and add error

       #ifdef DEBUG

       Serial.println("ACK");

       #endif

      break;

    case STATUS_SUCCESS:

      //option to post status to screen

      packet->status = STATUS_CLEAR;

      #ifdef DEBUG

      Serial.println("SUCCESS");

      #endif

      break; 

  }

}



unsigned counter = 0;



void setup()

{

  Serial.begin(115200);

  //Serial.println("Ping:");

 //Serial.print("nodeID: ");

 // Serial.println(NODE_ID,DEC);

 // int sendPacketId =  build_udp_packet(NODE_ID, 1, 0, 0, CMD_PING, (byte*)"TEST TEST TEST", 1);

 // int sendPacketId2 = build_udp_packet(NODE_ID, 1, 0, 0, CMD_PONG, (byte*)"HA HA HA", 8);

  

  //send_packet_serial(sendPacketId);

  //Serial.println("");

  /**/

  //DataPacket *p = build_udp_packet(NODE_ID, 1, 0, 0, CMD_PONG, str_to_payload("TEEEST"));

 // send_packet_serial(p);

 // debug_packet(p);

  

}



void loop() {

 

  //byte message[1] = {uniqueId};

  //message[15] = uniqueId;

  //int sendPacketId =  build_udp_packet(NODE_ID, 1, 0, 0, CMD_PING, message, 1);

  // int sendPacketId2 = build_udp_packet(NODE_ID, 1, 0, 0, CMD_PONG, (byte*)"HA HA HA", 8);



  if(counter > 50000) {

    DataPacket *p = build_udp_packet(NODE_ID, 1, 0, 0, CMD_VALUE, str_to_payload("ha ha ha22222"));

    p->status = STATUS_READY;

    counter = 0;

  }

  counter++;



  process_stack();

  

  //recieve timer

  

  

  //and send command to resend last

  int byteIn;

  if (Serial.available()>0) {

    byteIn =  Serial.read();

    build_incoming_packet(byteIn);

  }

  process_stack();

  if(receiving == true) {

    if((millis() - packetTimer) > PACKET_TIMEOUT) {

      //Serial.flush();

      Serial.print(2,BYTE); //tell the node to resend last

      //DataPacket *p = build_udp_packet(NODE_ID, 1, 0, 0, CMD_ERROR, packet_to_payload(&incomingPacket));

      // p->status = STATUS_READY;

      receiving = false;

    }

  }



  //delay(5);     

}



/*FINISHED*/

Payload *get_payload(DataPacket *packet) 

{

  Payload payload;

  payload.length = packet->payload[PACKET_LENGTH] - OFFSET_PACKET;

  for(i=0; i < payload.length; i++){

    if(packet->payload[PACKET_SETTINGS] < 3) { //single packet TCP or UDP

      payload.data[i] = packet->payload[i+OFFSET_HEADER];   

     

    } else if(packet->payload[PACKET_SETTINGS] == 3) {  //broadcast

        //todo

    }

  }

  return &payload; 

}



Payload *packet_to_payload(DataPacket *packet) 

{

  Payload payload;

  payload.length = packet->payload[PACKET_LENGTH];

  for(i=0; i < (payload.length - OFFSET_FOOTER); i++){

    payload.data[i] = packet->payload[i];   

  }

  payload.data[payload.length - OFFSET_FOOTER] = highByte(packet->checksum);

  payload.data[payload.length - OFFSET_FOOTER + 1] = lowByte(packet->checksum);

  return &payload; 

}

 

uint16_t get_node(DataPacket *packet, uint8_t location)

{

  uint16_t node;  

  node = packet->payload[location];

  node = node << 4;

  node = node | (packet->payload[location+1] >> 4);

  return node;

}

 

 

Payload *str_to_payload(char string[])

{

  Payload payload;

  i=0;

  while(string[i] != 0){

    payload.data[i] = byte(string[i]); 

    i++;  

  }

  payload.length = i;

  //Serial.print("sizeOf: ");

 // Serial.println(i,DEC);

  return &payload; 

}



Payload *long_to_payload(long number)

{

  Payload payload;

  i=(sizeof(number)-1);

  payload.length = i;

  while(i != 0){

    payload.data[i] = number & 0xFF; 

    number = number >> 8;

    i--;  

  }

  return &payload; 

}



Payload *uint16_to_payload(uint16_t number)

{

  Payload payload;

  

  payload.length = 2;

   payload.data[0] = highByte(number);

   payload.data[1] = lowByte(number);

  

  return &payload; 

}



DataPacket *build_tcp_packet(uint16_t fromNode, uint8_t fromPlug, uint16_t toNode, uint8_t toPlug, uint8_t command, Payload *payload)

{

  DataPacket *packet = getNewPacket();

  //*packet.status = STATUS_READY;

  packet->status = STATUS_WAITING;

  packet->payload[PACKET_LENGTH] = payload->length + OFFSET_PACKET; //header 8 crc 2

  packet->payload[PACKET_SETTINGS] = 1;

  uint16_t address = compressAddress(fromNode, fromPlug);

  packet->payload[PACKET_FROM] = (address >> 8) & 0xFF;

  packet->payload[PACKET_FROM+1] = address & 0xFF;

  address = compressAddress(toNode, toPlug);

  packet->payload[PACKET_TO ] = (address >> 8) & 0xFF;

  packet->payload[PACKET_TO+1] = address & 0xFF;

  packet->payload[PACKET_ID] = getId();

  packet->payload[PACKET_COMMAND] = command;

  

  for(i=0;i < payload->length;i++){

    packet->payload[PACKET_PAYLOAD+i] = payload->data[i];

  }



  return packet;

}



/*

 * @return DataPacket * Pointer to the New DataPacket

 */



DataPacket *build_udp_packet(uint16_t fromNode, uint8_t fromPlug, uint16_t toNode, uint8_t toPlug, uint8_t command, Payload *payload)

{

  DataPacket *packet = getNewPacket();

  //*packet.status = STATUS_READY;

  packet->status = STATUS_WAITING;

  packet->payload[PACKET_LENGTH] = payload->length + OFFSET_PACKET; //header 8 crc 2

  packet->payload[PACKET_SETTINGS] = 2;

  uint16_t address = compressAddress(fromNode, fromPlug);

  packet->payload[PACKET_FROM] = (address >> 8) & 0xFF;

  packet->payload[PACKET_FROM+1] = address & 0xFF;

  address = compressAddress(toNode, toPlug);

  packet->payload[PACKET_TO ] = (address >> 8) & 0xFF;

  packet->payload[PACKET_TO+1] = address & 0xFF;

  packet->payload[PACKET_ID] = getId();

  packet->payload[PACKET_COMMAND] = command;

  

  for(i=0;i < payload->length;i++){

  packet->payload[PACKET_PAYLOAD+i] = payload->data[i];

  }

  

  return packet;

}



DataPacket *build_broadcast_packet(uint16_t fromNode, uint8_t fromPlug, uint8_t ttl, Payload payload)

{

  DataPacket *packet = getNewPacket();

  packet->status = STATUS_WAITING;

  return packet;

}



/**

 * turns a packet into a decoded packet

 */

DataPacketDecoded decode_packet(DataPacket *packet)

{

  DataPacketDecoded decodedPacket;

     

  decodedPacket.ttl = 0;

  

  //Set Packet length

  decodedPacket.length = packet->payload[PACKET_LENGTH];

  

  decodedPacket.status = packet->status;

  //settings 

  decodedPacket.settings = packet->payload[PACKET_SETTINGS];

  decodedPacket.type = packet->payload[PACKET_SETTINGS]; //right now these are the same things

  //From 12bit node id, 4 bit plug id

  decodedPacket.fromNode = packet->payload[PACKET_FROM];

  decodedPacket.fromNode = decodedPacket.fromNode << 4;

  decodedPacket.fromNode = decodedPacket.fromNode | (packet->payload[PACKET_FROM+1] >> 4);

  decodedPacket.fromPlug = packet->payload[PACKET_FROM+1] &0xF;

  //To 12bit node id, 4 bit plug id

  decodedPacket.toNode = packet->payload[PACKET_TO];

  decodedPacket.toNode = decodedPacket.toNode << 4;

  decodedPacket.toNode = decodedPacket.toNode | (packet->payload[PACKET_TO+1] >> 4);

  decodedPacket.toPlug = packet->payload[PACKET_TO+1] &0xF;

 //packet id

  decodedPacket.id = packet->payload[PACKET_ID];

 //Command

  decodedPacket.command = packet->payload[PACKET_COMMAND];

  

  decodedPacket.ptr = packet->payload[PACKET_LENGTH] - OFFSET_PACKET;

  

  

  Payload *payload = get_payload(packet);

   

  for(i=0; i < payload->length; i++){

    if(decodedPacket.type < 3) { //single packet TCP or UDP 

          decodedPacket.payload[i] = payload->data[i];   

    } else if(decodedPacket.type == 3) {  //broadcast

        //todo

    }

  }

  decodedPacket.checksum=packet->checksum;

  return decodedPacket;

}



void debug_packet(DataPacket *packet){

 DataPacketDecoded sendPacketedDecoded = decode_packet(packet);

  

  Serial.print("    sent: ");

  Serial.println(sendPacketedDecoded.status,DEC);

  Serial.print("  length: ");

  Serial.println(sendPacketedDecoded.length,DEC);

  Serial.print("settings: ");

  Serial.println(sendPacketedDecoded.settings,DEC);

  Serial.print("    type: ");

  Serial.println(sendPacketedDecoded.type,DEC); 

  Serial.print("fromNode: ");

  Serial.println(sendPacketedDecoded.fromNode,DEC);

  Serial.print("fromPlug: ");

  Serial.println(sendPacketedDecoded.fromPlug,DEC);

  Serial.print("  toNode: ");

  Serial.println(sendPacketedDecoded.toNode,DEC);

  Serial.print("  toPlug: ");

  Serial.println(sendPacketedDecoded.toPlug,DEC);

  Serial.print("     ttl: ");

  Serial.println(sendPacketedDecoded.ttl,DEC);

  Serial.print("      id: ");

  Serial.println(sendPacketedDecoded.id,DEC);

  Serial.print(" command: ");

  Serial.println(sendPacketedDecoded.command,DEC);

  Serial.print(" payload: ");

  for(i=0; i < sendPacketedDecoded.ptr; i++){

    Serial.print(sendPacketedDecoded.payload[i],DEC);

    Serial.print(",");

  } 

   Serial.print(" payload: ");

  for(i=0; i < sendPacketedDecoded.ptr; i++){

    Serial.print(sendPacketedDecoded.payload[i],BYTE);

    Serial.print(",");

  } 

  Serial.println("");

  Serial.print("checksum: ");

  Serial.println(sendPacketedDecoded.checksum,DEC);

  Serial.print("     ptr: ");

  Serial.println(sendPacketedDecoded.ptr,DEC);

}

Goals and Issues

2010-11-03T00:08:00.000-07:00

Below is current look at some of goals and issues I'm currently dealing with-

So far my project has three main components:

Sensor Network <-> Base Station <-> Web Interface

They are interconnected and pass data between each other.

Sensor Network

The sensor network is gathering the sensor data is currently based on Jeenodes which are Arduino based nodes.

Status: Hardware has been solder together, sensors have been purchased and the code for the protocol has been written.

Goals

Create robust adaptable nodes that can easily be reconfigured
Create Wired and Wireless Links
Create a Mesh Network

Current Issues

How to design so an average user can configure a node? Pre programed ROM? Dip switches? Web interface?

Solution: Processing sketch that directly communicates with node to set address and sensor configuration to the Arduino ROM

Current Wireless Chip doesn't do mesh networking: cost prohibitive

Base Station

A Server program running on a PC reads packets of data from the sensor network and passes them on to a web interface. Currently using a Processing.org Java Program

Status: Protocol code has been ported to java. Actual interface still needs to be built.

Goals

Be user configurable
Easy to deploy/setup

Current Issues

How to Connect to Web server?

XML-RPC seems like the simplest solution right now and offers a lot of flexibility.
Using EEML like pachube might work too but would require a lot more code.

How to save settings? flat file, SQL database, remotel?

I haven't decided how to solve this yet. Some settings must be saved locally, ie web server address, Pachube api key. Using an XML file is the best soultion for this.
Other settings like node and sensors names would be better stored in a better database if it is to scale to thousands of sensors. Can it call a remote server to get this info or should it be local?

How to store data if Internet Connection goes down?

Store it memory is the easiest, SQL would be better

Web Interface

Status: In planning.

The web interface right now is going to be using LAMP Linux, Apache, mySQL and PHP. The code is going to based on the Zend Framework and a UI library I started writng a while back. The front end is going to use jQuery and jQueryUI. Graphs will use the Google Graph API.

Goals

Work on a varety of platforms and screen sizes
Use Web 2.0 Ajax etc. Jquery
Create an interactive Remote for the network

Current Issues

Server local or remote?

A good webserver is hard for an average user to setup. A remote server can also handle more users. User can also access the remote to get info about power/data outages

XML-RPC A better way to connect Processing and the Web

2010-11-02T17:15:00.000-07:00

After yesterdays post about how to connect the webserver to the processing sketch, I thought that there had to be a better way and there is.

There is a nice XML-RPC Library for Processing that someone at MIT wrote. XML-RPC is very common on the web so there are multiple ways to implement in php, ~~the best way is probably with the built in XML-RPC Class~~. After reading the documentation the built in funtions aren't well documented. It looks like I will be using the ZendFramework XML-RPC Module

First Packet Test

2010-11-01T20:56:00.000-07:00

The Arduino sends test packets to processing which decodes them on screen

Code after the jump

Arduino Code

//protocol.h
//Device Codes

#define DVC_LM33           0x01
#define DVC_ST11           0x02
#define DVC_ST15           0x03
#define DVC_DOORCONTACT    0x04
#define DVC_FLIPSWITCH     0x05
#define DVC_LIGHT          0x06
#define DVC_MOTION         0x07
#define DVC_2LINECHAR      0x08
#define DVC_POWER30        0x08
#define DVC_POWER100       0x09
#define DVC_SMARTOUTLET    0x10
#define DVC_RGBLIGHT       0x11

//Command Codes

#define CMD_GET_VERSION    0x01
#define CMD_PING           65
#define CMD_PONG           0xE3

#define CMD_ACK            0x11

#define CMD_READ           0xAA
#define CMD_WRITE          0xBB

#define CMD_PORTTYPE       0xCC

#define CMD_AUTOSENDSTART  0xC1
#define CMD_AUTOSENDSTOP   0xC2

#define CMD_ERROR          0xFF

//@todo commands for different data types?

//decoded packet struct
typedef struct {
  uint8_t command;
 //if 255 = ready to send // 0 = resend last
  uint8_t length;
  uint8_t sent;
  uint8_t settings; //01010101 //version //type direct or broadcast //ack //ttl //priority //multi
  uint8_t type; //1 single tcp, 2 single udp, 3 multipacket tcp
  uint16_t fromNode;
  uint8_t fromPort;
  uint16_t toNode; //00 is base //xffff is broadcast
  uint8_t toPort;
  uint8_t id;
  uint8_t ttl;
  
  uint8_t payload[48];
  uint16_t checksum;
  uint8_t ptr;
} DataPacketDecoded;


//simple data packet
typedef struct {
  uint8_t ptr;
  uint8_t sent;
  uint8_t payload[56];
  uint16_t checksum;
} DataPacket;

//shortcuts to important bytes
//keeps from having to decode the whole thing to check simple parts
#define PACKET_LENGTH   0
#define PACKET_SETTINGS 1
#define PACKET_FROM     2
#define PACKET_TO       4
#define PACKET_TTL      4
#define PACKET_ID       6
#define PACKET_COMMAND  7
#define PACKET_PAYLOAD  8


//send_test_packet.pde
#include h> //checksum functions
#include "protocol.h"

#define NODE_ID 0x02

#define PORT_A DVC_LM33
#define PORT_B DVC_LM33
#define PORT_C DVC_LM33
#define PORT_D DVC_LM33

#define PACKET_BUFFER 4 //can be adujsted based on availbe space

#define debug 1;

//types
//ACK
//Single TCp //requires 2byte packet ID
//Single UDP
//Multi TCP //requires 2byte total ID, 2 byte Packet ID + byte current packet + byte total packets
//multi packet
//packet id
//current packets
//total packets
//

DataPacket data[PACKET_BUFFER];
DataPacketDecoded dataDecoded[2];
byte dataPtr = 0;
uint16_t checksum;
byte dataId = 0;
byte packetIds = 0;
byte uniqueId = 0;
byte i;
DataPacket incomingPacket; //current incoming packet
//incomingPacket.ptr = 0;

byte getNewPacketId() {
  for(i=0; i < PACKET_BUFFER; i++) {
    if(data[i].payload[PACKET_SETTINGS] == 0){
      return i;
    } 
  }
}

byte getId() {
  return uniqueId++; //what happens when this overflows?
}

uint16_t compressAddress(uint16_t node, uint8_t port) 
{
  return (node << 4) | (port & 0x0F);
}


boolean send_packet_serial(uint8_t packetId)
{
  uint16_t dataChecksum = 0;
  for(i=0; i < (data[packetId].payload[PACKET_LENGTH]-2); i++){
    dataChecksum = _crc16_update(dataChecksum, data[packetId].payload[i]);
    Serial.print(data[packetId].payload[i],BYTE);
    // Serial.print(",");
  } 
  data[packetId].status = 1;
  data[packetId].checksum = dataChecksum;
  //Serial.println("");
 // Serial.print("checksum: ");
  //Serial.print(dataChecksum,BYTE);

  //Serial.print("checksum: ");
  Serial.print(highByte(dataChecksum),BYTE);
 // Serial.print(",");
  Serial.print(lowByte(dataChecksum),BYTE);//*/
   
}

uint8_t build_tcp_packet(uint16_t fromNode, uint8_t fromPort, uint16_t toNode, uint8_t toPort, uint8_t command, uint8_t payload[48], uint8_t length)
{
  byte packetId = getNewPacketId();
  data[packetId].status = 0;
  data[packetId].payload[PACKET_LENGTH] = length + 10; //header 8 crc 2
  data[packetId].payload[PACKET_SETTINGS] = 1;
  uint16_t address = compressAddress(fromNode, fromPort);
  data[packetId].payload[PACKET_FROM] = highByte(address);
  data[packetId].payload[PACKET_FROM+1] = lowByte(address);
  address = compressAddress(toNode, toPort);
  data[packetId].payload[PACKET_TO ] = highByte(address);
  data[packetId].payload[PACKET_TO+1] = lowByte(address);
  data[packetId].payload[PACKET_ID] = getId();
  data[packetId].payload[PACKET_COMMAND] = command;
  
  for(i=0;i < length;i++){
    data[packetId].payload[PACKET_PAYLOAD+i] = payload[i];
  }

  return packetId;
}
byte build_udp_packet(uint16_t fromNode, uint8_t fromPort, uint16_t toNode, uint8_t toPort, uint8_t command, uint8_t payload[48], uint8_t length)
{
  byte packetId = getNewPacketId();
  data[packetId].status = 0;
  data[packetId].payload[PACKET_LENGTH] = length + 10;
  data[packetId].payload[PACKET_SETTINGS] = 2;
  uint16_t address = compressAddress(fromNode, fromPort);
  data[packetId].payload[PACKET_FROM] = highByte(address);
  data[packetId].payload[PACKET_FROM+1] = lowByte(address);
  address = compressAddress(toNode, toPort);
  data[packetId].payload[PACKET_TO ] = highByte(address);
  data[packetId].payload[PACKET_TO+1] = lowByte(address);
  data[packetId].payload[PACKET_ID] = getId();
  data[packetId].payload[PACKET_COMMAND] = command;
  
  for(i=0;i < length;i++){
    data[packetId].payload[PACKET_PAYLOAD+i] = payload[i];
  }
  return packetId; 
}

uint8_t build_broadcast_packet(uint16_t fromNode, uint8_t fromPort, uint16_t toNode, uint8_t toPort, uint8_t payload[48], uint8_t length, uint8_t ttl )
{
  byte packetId = getNewPacketId();
  data[packetId].status = 0;
  return packetId;
}

void process_command(DataPacketDecoded packet)
{
  switch (packet.command) {
    case CMD_PING:

      //replyPacket.payload = packet.payload;
      //replyPacket.command = CMD_PONG;
      //replyPacket.fromNode = NODE_ID;
      //send_packet(packet);
      break;
    default:
      //send_packet(COMMAND_ERROR,NULL,0);
      break;
    }
}

/**
 * turns a packet into a decoded packet
 */

DataPacketDecoded decode_packet(DataPacket packet)
{
  DataPacketDecoded decodedPacket;
     
  decodedPacket.ttl = 0;
  
  //Set Packet length
  decodedPacket.length = packet.payload[PACKET_LENGTH];
  
  decodedPacket.status = packet.status;
  
  //settings 
  decodedPacket.settings = packet.payload[PACKET_SETTINGS];
  decodedPacket.type = packet.payload[PACKET_SETTINGS]; //right now these are the same things


  //From 12bit node id, 4 bit plug id
  decodedPacket.fromNode = packet.payload[PACKET_FROM];
  decodedPacket.fromNode = decodedPacket.fromNode << 4;
  decodedPacket.fromNode = decodedPacket.fromNode | (packet.payload[PACKET_FROM+1] >> 4);
  decodedPacket.fromPort = packet.payload[PACKET_FROM+1] &0xF;
  
  //To 12bit node id, 4 bit plug id
  decodedPacket.toNode = packet.payload[PACKET_TO];
  decodedPacket.toNode = decodedPacket.toNode << 4;
  decodedPacket.toNode = decodedPacket.toNode | (packet.payload[PACKET_TO+1] >> 4);
  decodedPacket.toPort = packet.payload[PACKET_TO+1] &0xF;

 //packet id
  decodedPacket.id = packet.payload[PACKET_ID];

 //Command
  decodedPacket.command = packet.payload[PACKET_COMMAND];
  
  decodedPacket.ptr = packet.payload[PACKET_LENGTH] - 8;
   
  for(i=PACKET_PAYLOAD; i < (packet.payload[PACKET_LENGTH] - 2); i++){

    if(decodedPacket.type < 3) { //single packet TCP or UDP
        
          decodedPacket.payload[i-PACKET_PAYLOAD] = packet.payload[i];   
     
    } else if(decodedPacket.type == 3) {  //broadcast
        //todo
    }
  }
  decodedPacket.checksum=packet.checksum;
  return decodedPacket;
}

void build_incoming_packet(uint8_t bIn)
{
  if(incomingPacket.ptr == 0){  //Packet length
    if(bIn == 0) {
    //resend last
    return;
    }
    if(bIn == 255) {
      //aknowledge
      //delete packet from que
      //reset last pointer
      return;
    }
    if (bIn > 128) {
      //stop sending current packet
      //flush
      return;
    }
    incomingPacket.payload[PACKET_LENGTH] = bIn;
    uint16_t temp;
    checksum = 0;
  }
  
  //checksum 
  if(incomingPacket.ptr < incomingPacket.payload[PACKET_LENGTH]){ //add to check sum
    incomingPacket.payload[incomingPacket.ptr] = bIn;
    checksum = _crc16_update(checksum, bIn);
  } else if(incomingPacket.ptr == incomingPacket.payload[PACKET_LENGTH]){ //get first byte of checksum
    incomingPacket.checksum = bIn;
  } else { //get second byte and check the checksum
    incomingPacket.checksum = (incomingPacket.checksum << 8) | bIn;         
    if(checksum != incomingPacket.checksum) {
      //Serial.println(checksum, DEC);  
      //Serial.println(incomingPacket.checksum, DEC);   
      //Serial.println("Failed CRC Check"); 
      incomingPacket.ptr=0;
    } else {
      i = getNewPacketId();
      data[i] = incomingPacket;
      incomingPacket.ptr=0;
    }
  }
  
  incomingPacket.ptr++;

}

void setup()
{
  Serial.begin(115200);
}

void loop() {
  
  byte message[1] = {uniqueId};
  int sendPacketId =  build_udp_packet(NODE_ID, 1, 0, 0, CMD_PING, message, 1);

  
  send_packet_serial(sendPacketId);

  delay(2000);
      
        
}

Processing Code

//Device Codes

final int DVC_LM33          = 0x01;
final int DVC_ST11          = 0x02;
final int DVC_ST15          = 0x03;
final int DVC_DOORCONTACT   = 0x04;
final int DVC_FLIPSWITCH    = 0x05;
final int DVC_LIGHT         = 0x06;
final int DVC_MOTION        = 0x07;
final int DVC_2LINECHAR     = 0x08;
final int DVC_POWER30       = 0x08;
final int DVC_POWER100      = 0x09;
final int DVC_SMARTOUTLET   = 0x10;
final int DVC_RGBLIGHT      = 0x11;

//Command Codes

final int  CMD_GET_VERSION   = 0x01;
final int  CMD_PING          = 65;
final int  CMD_PONG          = 0xE3;
final int  CMD_ACK           = 0x11;
final int  CMD_READ          = 0xAA;
final int  CMD_WRITE         = 0xBB;
final int  CMD_PORTTYPE      = 0xCC;

final int  CMD_AUTOSENDSTART = 0xC1;
final int  CMD_AUTOSENDSTOP  = 0xC2;

final int  CMD_ERROR         = 0xFF;




class DataPacketDecoded {
  int command, length, status = 0, settings, type,  fromPort, toPort, id, ttl = 0, ptr = 0;
  int fromNode, toNode,  checksum = 0;
  int[] payload = new int[56];

  DataPacketDecoded() {
   
  }
  
 
}


//simple data packet

class DataPacket {
  int ptr = 0, status = 0, checksum = 0;
  int[] payload = new int[64];
  
  DataPacket() {
  }
} 


//shortcuts to important bytes
//keeps from having to decode the whole thing to check simple parts
final int PACKET_LENGTH   = 0;
final int PACKET_SETTINGS = 1;
final int PACKET_FROM     = 2;
final int PACKET_TO       = 4;
final int PACKET_TTL      = 4;
final int PACKET_ID       = 6;
final int PACKET_COMMAND  = 7;
final int PACKET_PAYLOAD  = 8;

int _crc16_update(int crc, int a)
{
    int i;
    crc ^= a;
    for (i = 0; i < 8; ++i){
        if ((crc & 1) == 1){
            crc = (crc >> 1) ^ 0xA001;
        }else{
            crc = (crc >> 1);
        }
    }
    return crc & 0xFFFF;
}

int getId() {
  return uniqueId++; //what happens when this wraps?
}

int compressAddress(int node, int port) 
{
  node = node << 4; //make space
  port = port & 0x0F;
  return node | port;
}




import processing.serial.*;

//What should master ports be?

final int  NODE_ID = 0x02;

final int PORT_A = DVC_LM33;
final int PORT_B = DVC_LM33;
final int PORT_C = DVC_LM33;
final int PORT_D = DVC_LM33;

DataPacket data[];

int dataPtr = 0;
int checksum;
int dataId = 0;
int packetIds = 0;
int uniqueId = 0;
int i;

DataPacket incomingPacket = new DataPacket(); //current incoming packet

int bgcolor;        // Background color
int fgcolor;        // Fill color
Serial myPort;                       // The serial port
int[] serialInArray = new int[3];    // Where we'll put what we receive
int serialCount = 0;                 // A count of how many bytes we receive

boolean firstContact = false;        // Whether we've heard from the microcontroller
PFont myFont;

void setup() {
  size(400, 400);  // Stage size
  //noStroke();      // No border on the next thing drawn
  myFont = createFont("Consolas", 14);
  textFont(myFont);
  

  // Print a list of the serial ports, for debugging purposes:
  //println(PFont.list());

  String portName = Serial.list()[1];
  myPort = new Serial(this, portName, 115200);
}

void draw() {
  
   //text("Hello",10,10);
   //text("Z", 10, 220);
   
  // Draw the shape

}

void serialEvent(Serial myPort) {
  // read a byte from the serial port:
  int inByte = myPort.read();
  build_incoming_packet(inByte);
}

//#include  //checksum functions



boolean send_packet_serial(DataPacket packet)
{
  int dataChecksum = 0;
  for(i=0; i < (packet.payload[PACKET_LENGTH]-2); i++){
    dataChecksum = _crc16_update(dataChecksum, packet.payload[i]);
    myPort.write(packet.payload[i] & 0xFF);
  } 
  packet.status = 1;
  myPort.write(dataChecksum & 0xFFFF); 
  return true;
}

DataPacket build_tcp_packet(int fromNode, int fromPort, int toNode, int toPort, int command, int payload[])
{
  DataPacket packet = new DataPacket();
  //packet.payload[PACKET_LENGTH] = length + 8;
  packet.payload[PACKET_SETTINGS] = 1;
  int address = compressAddress(fromNode, fromPort);
  packet.payload[PACKET_FROM] = (address >> 8) & 0xFF;
  packet.payload[PACKET_FROM+1] = address & 0xFF;
  address = compressAddress(toNode, toPort);
  packet.payload[PACKET_TO ] = (address >> 8) & 0xFF;
  packet.payload[PACKET_TO+1] = address & 0xFF;
  packet.payload[PACKET_ID] = getId();
  packet.payload[PACKET_COMMAND] = command;
  
  for(i=0;i < payload.length;i++){
    packet.payload[PACKET_PAYLOAD+i] = payload[i];
  }

  return packet;
}
DataPacket build_udp_packet(int fromNode, int fromPort, int toNode, int toPort, int command, int payload[])
{
  DataPacket packet = new DataPacket();
  //packet.payload[PACKET_LENGTH] = length + 8;
  packet.payload[PACKET_SETTINGS] = 2;
  int address = compressAddress(fromNode, fromPort);
  packet.payload[PACKET_FROM] = (char)(address >> 8) & 0xFF;
  packet.payload[PACKET_FROM+1] = (char)address & 0xFF;
  address = compressAddress(toNode, toPort);
  packet.payload[PACKET_TO ] = (char)(address >> 8) & 0xFF;
  packet.payload[PACKET_TO+1] = (char)address & 0xFF;
  packet.payload[PACKET_ID] = getId();
  packet.payload[PACKET_COMMAND] = command;
  
  for(i=0;i < payload.length;i++){
    packet.payload[PACKET_PAYLOAD+i] = payload[i];
  }
  return packet; 
}
/*
uint8_t build_broadcast_packet(uint16_t fromNode, uint8_t fromPort, uint16_t toNode, uint8_t toPort, uint8_t payload[48], uint8_t length, uint8_t ttl )
{
  byte packetId = getNewPacketId();
  data[packetId].sent = 0;
  return packetId;
}
*/
void process_command(DataPacketDecoded packet)
{
  switch (packet.command) {
    case CMD_PING:

      //replyPacket.payload = packet.payload;
      //replyPacket.command = CMD_PONG;
      //replyPacket.fromNode = NODE_ID;
      //send_packet(packet);
      break;
    default:
      //send_packet(COMMAND_ERROR,NULL,0);
      break;
    }
}

/**
 * turns a packet into a decoded packet
 */

DataPacketDecoded decode_packet(DataPacket packet)
{
  DataPacketDecoded decodedPacket = new DataPacketDecoded();
       
  //Set Packet length
  decodedPacket.length = packet.payload[PACKET_LENGTH];
  
  decodedPacket.status = packet.status;
  
  //settings 
  decodedPacket.settings = packet.payload[PACKET_SETTINGS];
  decodedPacket.type = packet.payload[PACKET_SETTINGS]; //right now these are the same things


  //From 12bit node id, 4 bit plug id
  decodedPacket.fromNode = packet.payload[PACKET_FROM];
  decodedPacket.fromNode = decodedPacket.fromNode << 4;
  decodedPacket.fromNode = decodedPacket.fromNode | (packet.payload[PACKET_FROM+1] >> 4);
  decodedPacket.fromPort = packet.payload[PACKET_FROM+1] &0xF;
  
  //To 12bit node id, 4 bit plug id
  decodedPacket.toNode = packet.payload[PACKET_TO];
  decodedPacket.toNode = decodedPacket.toNode << 4;
  decodedPacket.toNode = decodedPacket.toNode | (packet.payload[PACKET_TO+1] >> 4);
  decodedPacket.toPort = packet.payload[PACKET_TO+1] &0xF;

 //packet id
  decodedPacket.id = packet.payload[PACKET_ID];

 //Command
  decodedPacket.command = packet.payload[PACKET_COMMAND];
  decodedPacket.checksum = packet.checksum;
  decodedPacket.ptr = packet.payload[PACKET_LENGTH] - 10;
   
  for(i=PACKET_PAYLOAD; i < packet.payload[PACKET_LENGTH]; i++){

    if(decodedPacket.type < 3) { //single packet TCP or UDP
        
          decodedPacket.payload[i-PACKET_PAYLOAD] = packet.payload[i];   
     
    } else if(decodedPacket.type == 3) {  //broadcast
        //todo
    }
  }
  return decodedPacket;
}

void build_incoming_packet(int bIn)
{
  //add timout to reset if packets get jamed
  println("count: "+incomingPacket.ptr + " byte: " + bIn);
  if(incomingPacket.ptr == 0){  //Packet length
    if(bIn == 0) {
      //resend last
      return;
    }
    if(bIn == 255) {
      //aknowledge
      //delete packet from que
      //reset last pointer
      return;
    }
    if (bIn > 66) {
      //stop sending current packet
      //flush
      return;
    }
    incomingPacket.payload[PACKET_LENGTH] = bIn;
    println("length: "+bIn);
    checksum = 0;
  }

  //checksum 
  if(incomingPacket.ptr < (incomingPacket.payload[PACKET_LENGTH]-2)){ //add to check sum
    incomingPacket.payload[incomingPacket.ptr] = bIn;
    checksum = _crc16_update(checksum, bIn);

  } else if(incomingPacket.ptr == (incomingPacket.payload[PACKET_LENGTH]-2)){ //get first byte of checksum

    incomingPacket.checksum = bIn;
  } else { //get second byte and check the checksum
    incomingPacket.checksum = (incomingPacket.checksum << 8) | (bIn & 0xFF); 
     
    if(checksum != incomingPacket.checksum) {
      println("processing checksum: " + checksum);  
      println("    packet checksum: " + incomingPacket.checksum);   
      println("Failed CRC Check"); 
    } else {
      println("processing checksum: " + checksum);  
      println("    packet checksum: " + incomingPacket.checksum);  
     println("Passed CRC Check");  
      debug_incoming_packet(incomingPacket);
      //check packet address, if it matches, process command, if not add to queue to resend to other nodes
      //i = getNewPacketId();
      //data[i] = incomingPacket;
      //process_command(incomingPacket);
      
      //incomingPacket = DataPacket;
    }
    //reset incoming packet
    incomingPacket = new DataPacket();
    return;
  }

  incomingPacket.ptr++;
}

void debug_incoming_packet(DataPacket packet) 
{
  background(0);
  println("show packet info");
  text("Packet Info",5,15);
  int x = 20;
  DataPacketDecoded packetDecoded = decode_packet(packet);
  text("  status: " + packetDecoded.status,10,x+=20);
  text("  length: " + packetDecoded.length,10,x+=20);
  text("settings: " + packetDecoded.settings,10,x+=20);
  text("    type: " + packetDecoded.type,10,x+=20); 
  text("fromNode: " + packetDecoded.fromNode,10,x+=20);
  text("fromPort: " + packetDecoded.fromPort,10,x+=20);
  text("  toNode: " + packetDecoded.toNode,10,x+=20);
  text("  toPort: " + packetDecoded.toPort,10,x+=20);
  text("     ttl: " + packetDecoded.ttl,10,x+=20);
  text("      id: " + packetDecoded.id,10,x+=20);
  text(" command: " + packetDecoded.command,10,x+=20);
  
  String message = "";
  for(i=0; i < packetDecoded.ptr; i++){
    message += int(packetDecoded.payload[i]);
    //message += char(packetDecoded.payload[i]);
  } 
  text(" payload: " + message,10,x+=20);
  
  text("checksum: " + packetDecoded.checksum,10,x+=20);
  text("     ptr: " + packetDecoded.ptr,10,x+=20);//*/
}

From Processing to the Web

2010-11-01T19:58:00.000-07:00

An Arduino is connected to a PC that is running a program created in Processing. It reads the data stream from the arduino and then it can publish the data to an online service like pachube or my own server.

The main user interface of my project is going to be web based so it can be used on all sorts of devices from laptops to cellphones. Processing doesn't make a very good webserver to build an interface around however there is some really good webserver software - Apache, PHP and MySQL.

Linking the webserver to the Processing program is a bit of challenge. A webserver doesn't typically have a program always running, rather the program runs only when generating a web page. To send data to the webserver involved calling a webpage with get/post data. For the webserver to send data to the Processing sketch involves using a simple socket server. I haven't found any example of this online but I think I can combine some of this processing code and some of this php code and make it work.

Update: there is a better way to connect things- XML RPC

Communication Protocol

2010-11-01T14:47:00.000-07:00

One of the big steps is developing a language for how all the nodes talk to each other.

There are several existing protocols like BACnet and LonWorks. These a both full featured but almost too complex for what I need right now. I looked to see if anyone had used an arduino with either of these protocols but my search turned up blank. So I decided to write my own.

Data is sent in packets. Each packet is like a letter that has a to and from address and carries a payload inside.

There are several types of packets based on what sort of data is being carried

The first three I plan on implementing are

TCP Packet - based on the Transmission Control Protocol, well a very simplified version but when a node receives one of these packets it sends a ack (acknowledgment) packet letting the sender know that the packet reached it destination.
UDP Packet - Based on the User Datagram Protocol, again a simplified version. These are packets that don't need acknowledgment. These is used when data is constantly being sent and lost packets would be outdated by the time they were resent
Broadcast - this is variant of UDP that doesn't have a set destination, rather it has a max number of hops that the packet will take and all nodes will take a look at it's data

Each packet has a 8 byte header and 2 byte footer. this a lot smaller than the 20 byte header of a standard TCP packet.

8 bits = 1 byte

So far my protocol looks like this

8 bits - Length of Packet (could be shorter if we don't need big packets
8 bits - Settings (could be smaller only using 2 bits right now
12 bits - From node, allows for 4096 nodes
4 bits - From ports (allows 16 ports on a node)
12 bits - To Node (or ttl Time to live, if broadcast)
4 bits - From Port
8 bits - Packet ID; So that packets can be put back in the right order
8 bits - Command; read, write, etc (could be shorter)
56 bytes Payload
16 bits - Checksum (verifies data didn't get corrupted in transmission)

Midterm Powerpoint

2010-10-20T18:42:00.000-07:00

A Little Bit of Privacy

2010-10-20T13:14:00.000-07:00

Soldering Fun

2010-10-19T23:27:00.001-07:00

A while back I got a free sample of some power meter chips. These awesome little chips can very accurately measure power consumption. I really want to build my own smart outlet and hook it up to my network. These chips will enable me to do it.

they are tiny surface mount chips

to test one out on breadboard i had to solder an adapter board. And success! One side is perfect and the other side was close, 3 pin got bridged with solder but it was easy to fix. So far this is the smallest thing I've hand soldered.

Where good Ideas come from...

2010-10-13T18:08:00.000-07:00

There was also an Article in the Wall Street Journal about Ideas

The premise that innovation prospers when ideas can serendipitously connect and recombine with other ideas may seem logical enough, but the strange fact is that a great deal of the past two centuries of legal and folk wisdom about innovation has pursued the exact opposite argument, building walls between ideas. Ironically, those walls have been erected with the explicit aim of encouraging innovation. They go by many names: intellectual property, trade secrets, proprietary technology, top-secret R&D labs. But they share a founding assumption: that in the long run, innovation will increase if you put restrictions on the spread of new ideas, because those restrictions will allow the creators to collect large financial rewards from their inventions. And those rewards will then attract other innovators to follow in their path.

The problem with these closed environments is that they make it more difficult to explore the adjacent possible, because they reduce the overall network of minds that can potentially engage with a problem, and they reduce the unplanned collisions between ideas originating in different fields. This is why a growing number of large organizations—businesses, nonprofits, schools, government agencies—have begun experimenting with more open models of idea exchange.

[WSJ]

Smart Mirrors

2010-10-13T12:45:00.000-07:00

[Engadget]

Testing the JeeNodes

2010-10-10T11:51:00.000-07:00

This week I finished Soldering together my first set of JeeNodes and I tested out them out by running the PingPong test program.

Adding to my Room Sensor

2010-10-10T11:41:00.000-07:00

I also bought an ambient light sensor that suppose to be more sensitive than a Light Dependent Resistors. I needed my small arduino for another experiment so I moved everything over to a arduino mega. i2c is in a different spot so that's why the Temp/Humidity sensor moved.

Here is the arduino code

#include <Wire.h>
#include 
#define samples 5

float H[samples];
float T[samples];
int   L[samples];
byte current = 0;

LibHumidity humidity=LibHumidity(0);

boolean readSerial()
{
  if(Serial.available() && (Serial.read()==65)) {
    return true;
  }

  Serial.flush();
  return false;
}

void setup(){
  Serial.begin(9600);
  pinMode(58, OUTPUT);
  pinMode(59, OUTPUT);
  digitalWrite(58, HIGH);
  digitalWrite(59, LOW);
}
void loop(){
  H[current]=(float)humidity.GetHumidity();
  T[current]=(float)(humidity.GetTemperature() * 1.8 )+32;
  L[current] = analogRead(3);
  current++;
  if(current == samples){
    current = 0;
  }
  
  if(readSerial() == true){
    float h2 = 0;
    float t2 = 0;
    int l2 = 0;
    
    for(byte a=0;aSerial.print(h2/samples);
    Serial.print(',',BYTE);
    Serial.print(t2/samples);
    Serial.print(',',BYTE);
    Serial.println(l2/samples);
  }
  delay(1000);
}

And here is the Processing code that uploads the data to Pachube

import processing.serial.*;
import eeml.*;

DataOut dOut;
float lastUpdate;

Serial myPort;      // The serial port
int whichKey = -1;  // Variable to hold keystoke values
String inByte;// = ' ';    // Incoming serial data
String[] message;

float humidity;
float temp;
int light;

void setup() {
  size(400, 300);
  // create a font with the third font available to the system:
  PFont myFont = createFont(PFont.list()[2], 14);
  textFont(myFont);

  println(Serial.list());   // List all the available serial ports:

  String portName = Serial.list()[2];
  myPort = new Serial(this, portName, 9600);
  myPort.bufferUntil(10);
    
  // set up DataOut object; requires URL of the EEML you are updating, and your Pachube API key   
  dOut = new DataOut(this, "http://api.pachube.com/v2/feeds/10505.xml", "API KEY GOES HERE");   
  
  //  and add and tag a datastream    
  dOut.addData(0,"Humidity");
  dOut.addData(1,"Temperature");
  dOut.addData(2,"Light");
}

void draw() {
  background(0);
  text("Light: " + light, 10, 220);
  text("Temp: " + temp, 10, 190);
  text("Humidity: " + humidity, 10, 160);
  text("Last Received: " + inByte, 10, 130);
  text("Last Sent: " + lastUpdate, 10, 100);
 
  if ((millis() - lastUpdate) > 60000){
        myPort.write(65);
        delay(5000);
        println("ready to POST: ");
        dOut.update(0, humidity); // update the datastream 
        dOut.update(1, temp); // update the datastream 
        dOut.update(2, light); // update the datastream 
        int response = dOut.updatePachube(); // updatePachube() updates by an authenticated PUT HTTP request
        println(response); // should be 200 if successful; 401 if unauthorized; 404 if feed doesn't exist
        lastUpdate = millis();
  }   
}

void serialEvent(Serial myPort) {
  inByte = trim(myPort.readString());
  message = split(inByte,',');
  humidity = float(message[0]);//float(myPort.readStringUntil(','));
  temp = float(message[1]);//float(myPort.readString());
  light = int(message[2]);
}

void keyPressed() {
  // Send the keystroke out:
  myPort.write(65);
  whichKey = key;
}

Soldering Fun

2010-10-01T07:06:00.000-07:00

I got my new soldering Iron Yesterday so I got right to work soldering one of the JeeNodes Together

Haven't tested it yet. Saving that fun for later.

First Experiment: A Success!

2010-10-01T00:26:00.000-07:00

Today I officially started my Internet of Things.

Arduino with a Humidity/Temperature Sensor

Basic Processing Script uploads the Humidity/Temperature of my Apartment to Pachube

Humidity

Temperature

Check out the Live feed

Reading: Interactive Architecture

2010-09-28T22:28:00.000-07:00

Interactive Architecture
"Interactive Architecture" by Michael Fox and Miles Kemp, 2009.

This book is amazing. It covers the changing paradigm of architecture in the 21st century. The book covers many aspects of my Master's Project from. the embedded computing to it's environmental impact and it's effect on the sociological and psychological implications. through the next week, I write about each of it's sections and my thoughts.

Physical Change - Kinetic Architecture

Embedded Computation

Project Landscape - Adaptable Space; Living, Working, Entertainment and Public Environments

Environmental Impact - Energy Efficiency, Sustainable Solutions, Environmental Cognizance

Enhancing and Extending Activities - Active Participation

Sociological and Psychological Implications - Changing Lifestyle Patterns, Behavior Awareness, Building Awareness, Sense of Place, Control of Space, Attachment to Space

Design and the Profession - Designing Interactive Systems, Economic Feasibility

New Horizons - Technology Transfer, Interface Design, Autonomous Robotics, Evolutionary Systems

“A new epoch has begun!”

Article: 6 Ways to Better Living: Inside an Internet of Things Home

2010-09-28T14:29:00.000-07:00

I did some more research on the web today on the "Internet of Things" and found this great article that summarized some of the things a web enabled house can do. Read online at ReadWriteWeb (quoted below)

What if we took the leading sensor-based products currently being developed or already on the market, put them all under one roof, and added a typical American family? Would they just be the techiest family on the block, or would it have a significant impact on their lives?
Here are six ways this Internet of Things family can see their lives change. They exercise more, save energy and water, budget better, know where their kids are at any moment, and they'll always have the right lighting for activities in the house.

Bank Account-based Motivation
We talked last month about Green Goose, which is a green egg with an ethernet connection that can sense how many miles a person has ridden on their bicycle instead of a car. This data ultimately could be synced up with each family members' bank account. So if they chose to ride a bike instead of a car, an automatic transfer of the allotted monthly gas money saved goes from a checking account into a savings account. Green Goose has plans for other similar sensors.

Health and Fitness
When it comes to physical fitness, this family has all the devices we explained in our sensors to keep you fit post. From Nike Plus running shoes, which sends running data to Mom's iPod via a sensor, to grandpa's exercise games via Wii Fit to their youngest son's training program via NordicTracks iFit, to Dad's miCoach pacer, this family is being encouraged by sensors to better understand and improve their physical health.

Water Conservation
The Waterpebble is a simple sensor that's placed in the shower. It measures the duration of the first shower, and when the next person takes a shower a green light inside the pebble will turn to orange to let the person know that their shower-time is half way up. Once the shower goes longer than the recorded time, the pebble gives off a red light. The best part is that after each shower the Waterpebble will fractionally reduce the amount of time the person will be allowed to shower. There's also a reset button for when someone in the family is having a bad day and needs a longer shower.

Energy Use Scoreboard
All electrical appliances in this house plug into Picowatt Wi-Fi smart plugs, which allow the family to communicate and control energy usage via a command center like Intel's prototype home energy monitor. This monitor is what the New York Times refers to as an Energy Use Scoreboard, which calculates energy usage and displays costs in real-time. Once this technology hits the market, the family will be able to add a few goal-setting apps to the control panel and they'll have the tools they need to minimize their energy use.

Alert Services
Last January we reported on Trackle and the emerging era of alert services. In the Internet of Things house not only does Trackle alert the family about vital events and information going on in their neighborhood, but when Mom wants to make sure her daughter gets safely home from school on her own, she simply puts a Touchatag RFID tag in her backpack, which alerts Mom when her daughter is safely home.

Lighting Optimization
Finally, this home's lighting can be regulated by Pachube (pronounced patch-bay) and Arduino. As we reported last summer, light sensors can be connected to Arduino, which is an open-source electronics prototyping platform. The light sensor data is then sent to Pachube, which connects the sensor data to the Web where the lighting can be controlled via twitter or via a home energy monitor.
Overall, it's important to remember that we're still in the early days of Internet of Things. As these products continue to develop we'll find more and more ways for our devices to coax us to refine our health and our environment.

[ReadWriteWeb]

2010-09-28T01:27:00.000-07:00

My first order of electronic parts came in today! Time to start experimenting!

Ah the unboxing.

Electronic parts look so much smaller in real life.

I liked the boards from Jee Labs that I ordered a bunch a stuff from them. All of them require assembly. My new Soldering iron won't be here until Wednesday :( (I fried my last one) So it's going to be a couple of days until I have these ready to play with.

Reading: Refabricating Architecture

2010-09-28T00:25:00.000-07:00

"Refabricating Architecture" by Stephen Kieran and James Timberlake, 2004

How Manufacturing Methodologies Are Poised to Transform Building Construction

I first read this book three years ago while researching modular construction and the KieranTimberlake's Loblolly House Project.

The book looks at how we can apply ideas from other types of manufacturing like ships and cars to building construction. It got me started at looking at how building construction is lagging behind other types of construction in speed, efficiency, and technology.

My favorite example is looking at how today car's are filled with complex technology. Sensors are integrated through out the car, detecting tire air pressure, engine performance, and even a crash- all to provide a safer, more efficient vehicle. If anything thing goes wrong the cars tells us through a warning light and some now even have the ability to send information straight to your smart phone.

I think it's time we started looking at how we can integrate technology into the core of architecture to create new buildings that respond to their occupants and to the environment around them.

Precedent: Media House Project

2010-09-27T11:25:00.000-07:00

I first read about this project as a short article in an architecture magazine, the details were sparse but I really like the ideas. I looked a little deeper and I discovered that the people behind the project had published an entire book detailing the project.

This project, more than any other, is what inspired my thesis.

The Media House Project was a joint project between UPC. Barcelona Tech and the MIT Media Lab back 2001-2002. MIT focused on developing new technology for the home and Barcelona Tech did a series of studies on how integrate MIT's work into a new Architecture.

The House is the Computer
The Structure is the network

This statement sets the framework for the project. Instead of the computer being separate from the house, it is integrated into the structure of the building

Most of the book was student essays detailing different aspects of the project.
Some of my favorite essays were:

Intelligent Environment: This looked at how we can augment our lives with microcomputers.

Housing X-Ray: A photo essay that deconstructed the lives of several families to show how they live in their homes. It also looked at all of the stuff, furniture, knickknacks, toys, we place inside of our homes.

Intelligent Space: Discussed the MIT Smart Rooms Project, and how it can be incorporated into a building

Structural Model: discussed network layouts: MegaBus - Devices share a common pipeline. Ring - devices are on a ring and pass data in circular fashion. Star, Structure and Relations - devices branch off of a central node.

Structure Vs Infrastructure: How MIT integrated their Internet 0 network into the the structure of the full scale demonstration Model. They used a system similar to that used in track lighting, where devices could be added as needed to the structure.

Media Kitchen: This proposed an early version of the Microsoft Surface. They proposed using them in the kitchen as a way to organize food, layout meals, display cookbooks and more.

Play place - a show case of technology for educating and entertaining children in the house. It's a lot like Microsoft Kinect for Xbox

Chromotherapy - An experiment of using Colored Light to affect the mood of the people in the dwelling

Domos House Website - Discussed a web interface for the House, Lots of great ideas, but a lot has changed in webdesign since this book was written.

Presentation - I love the way the presented this project to the public. They built a full scale model of their experiments and then put on a performance, like a stage show, with the students showing how their piece of the project works

Agenda for the Informational Home - The Closing statement of the book laid out 6 areas for the "Future Informational Home", (i would simply call it a smart house).
1) Internet 0: the house a great brain,
2) Internet 2: large format video.
3) Informational structures (building the network into structure of the house)
4) Manufacturing dwellings,
5) Open dwelling: flexibility of distribution,
6) The house's website

These are the 6 areas I am focusing my Thesis on. My Plans:

1) Build a simple network using off the shelf parts (Arduino).
2) Not critical but worth noting: Youtube, gigiabit lan and fiber optics already exist today, and Internet 2 is well on it's way.
3 & 4) I think these go hand in hand, the future of housing is in modular construction. I think any sort of sensor network could easily be integrated inside of these modular parts and be snapped together onsite.
5) My proposed sensor network makes traditional wiring obsolete. Switches and Light bulbs are independent, and can be reconfigured on the fly.
6) I think the interface to the house is one of the most important parts. How do you see the information the house is producing while your at home? at Work? away at vacation? How do show off your greeness online on Social Media?

Arduino's used in an Actual Building

2010-09-26T22:06:00.000-07:00

They revamped the Arduino blog and they are posting some interesting stories.

Some time ago I was informed that the surfaces of the amazing Media-TIC building (from Cloud 9 / Enric Ruiz Geli) were Arduino-based, sensing the environment/atmospheric changes and offering a 20% saving on climate control:
The building is in the shape of a cube and formed by large iron beams covered in a plastic coating of inflatable bubbles, which offer glimpses of the fluorescent structure of the building. The attractive covering also has a functional utility as a way of regulating light and temperature, primarily preventing 114 tons of CO2 a year from escaping from the building, and offering a 20% saving on climate control.

Every facade of the Media-TIC is different: from the outside, they reveal parts of their interior spaces and give a diverse plasticity, while from the inside they offer spectacular views.

I did a quick search for more info on how they integrated arduino's but I haven't found anything so far

Another interesting thing from the blog is that someone has created a arduino plugin for Rhino's GrassHopper

Firefly for Grasshopper / Arduino from Jason K Johnson on Vimeo.

This is definitely something I will look at using in the future

[Arduino Blog]

New Arduino's

2010-09-26T21:49:00.000-07:00

At MakerFaire NY the folks at Arduino annouced new boards: The arduino uno, a replacement for the Duemilanove and the Arduino Uno Mega, A replacement for the mega.

The main change is a new USB to serial Chip onboard that will open up a lot of new possibilities and the mega has an even more memory. The best part is the older boards are now going on sale! Once the old Mega drops to $40 I might buy a few more...

[Arduino Blog]

Video: IBM- The Internet of Things

2010-09-24T23:51:00.001-07:00

Sometimes youtube is a waste of time, sometimes you can find cool videos

You Too Can Join the Internet Of Things

2010-09-24T22:59:00.000-07:00

I read a lot news online and this one relates: You Too Can Join the Internet Of Things . It talks about the growing open source community behind the Internet of Things. In this case using mbed.org a ARM based development kit. ARM chips are faster than the AVR chip found on the arduinos I'm using but right now the cost is much higher and their not a whole lot of code written for them yet.

For many years now, Silicon Valley has hyped a concept known as the Internet of Things.

The thinking goes that just about everything, be it a shirt, toy, wall or milk jug, will have a chip or some kind of sensor in it that transmits information. People talk about refrigerators that can discern what’s inside of them and recommend recipes or order more milk for delivery just as that gallon jug begins to run out. Or maybe a restaurant gleans some kind of information about its wait staff based on the movement of plates.

A lot of the stuff sounds hokey and adds complexity to situations where the current order of things works just fine. But advocates of the Internet of Things argue that it’s tough for us to really grasp what useful creations people will build with the sensors in these early days with the technology.

[New York Times]

Update: Wired Posted a followup

Will the Internet of Things Be Open or Closed?

Now, at Adafruit Industries’ blog, DIY-engineering all-star Limor Fried counters the Times’ warm enthusiasm for ARM’s approach with some ice-water skepticism: “mbed requires an online compiler, so that you are dependent on them forever. You cannot do anything without using their online site, ever.”

[Wired]

Reading: Smart Rooms

2010-09-24T22:33:00.000-07:00

"Smart Rooms" by Alex P. Pentland, Scientific American April 1996, pages 68-76

"In creating computer systems that can identify people and interpret their actions, researchers have come one step closer to building helpful home and work environments"

This is an older article but it has some very relevant ideas. They discuss using cameras to read human movement and behavior to interact with a virtual environment. The funny thing is this is becoming a reality this year when Microsoft releases "Kinect" for the Xbox 360 for Christmas.

I think this sort of interface is whats next for how humans will interact with computers. It opens a lot of new possibilities for how one's house can "see" it occupants and connect with them.

Reading: Internet 0, Interdevice Internetworking

2010-09-24T21:22:00.000-07:00

"Internet 0, Interdevice Internetworking" by Neil Gershenfeld, and Danny Cohen, IEEE Circuits & Devices September/October 2006, pages 48-55 (read online pdf)

This article goes over the technical aspects of the proposed Internet-0 but It also goes over some of the background. They developed Internet-0 to be an open standard to replace the 10+ that exist currently. This would enable competition in the market so devices made by different companies could communicate with each other much like how different brand computers can connect to the same internet. I think this is great idea but looking at this 6 years later, it doesn't seem the idea has taken off.

Reading: The Internet of Things

2010-09-24T21:03:00.000-07:00

"The Internet of Things" by Neil Gershenfeld, Raffi Krikorian and Danny Cohen, Scientific American October 2004, pages 76-82.

"The principles that gave rise to the internet are now leading to a new kind of network of everyday devices, an Internet-0"

"Giving everyday objects the ability to connect to a data network would have a range of benefits: making it easier for homeowners to configure their lights and switches, reducing the cost and complexity of building construction, assisting with home health care. Many alternative standards currently compete to do just that— a situation reminiscent of the early days of the Internet, when computers and networks came in multiple incompatible types."

"To eliminate this technological Tower of Babel, the data protocol that is at the heart of the Internet can be adopted to represent information in whatever form it takes: pulsed electrically, flashed optically, clicked acoustically, broadcast electromagnetically or printed mechanically."

"Using this “Internet-0” encoding, the original idea of linking computer networks into a seamless whole—the “Inter” in “Internet”—can be extended to networks of all types of devices, a concept known as interdevice internetworking."

This article details the network I first read about in the "Media House Project". Internet 0 is a simplified version of Internet 1 for connecting simple devices like light switches, thermostats, locks, security sensors. They don't have need for a speed network, with expensive electronics, they only require a basic network and that can be accomplished with cheap chips.

I really like this system but I think they overcomplicated things. A little background- Data over a network is sent in packets, each one has a header with information about where that bit of data is from and where is is suppose to go. In system described in the article, they used the same header that is used in Internet-1, It's great for sending large packets to billions of computers but on a simple network, it's overkill. I propose using the same ideas of the Internet-1 header but scaled down.

Smart Sensors to Network the World

2010-09-24T20:31:00.000-07:00

"Smart Sensors to Network the World" by David E. Culler and Hans Mulder, Scientific American June 2004, pages 84-91.

"An emerging class of pillbox-size computers, outfitted with sensors and linked together by radios, can form perceptive networks able to monitor a factory, a store— even an ecosystem. Such devices will more intimately connect the cyberworld to the real world"

"Thumb-size computers called motes combine microprocessors and memory with radio transceivers, onboard power supplies and a variety of sensors."

"Motes are inexpensive enough to deploy by the thousands in factories, farms or wildernesses. Each mote can collect and analyze sensor readings independently but can also link up with neighboring motes in a mesh like perceptive network."

"Motes are already being manufactured by Crossbow, Intel and others. Early prototype systems have helped biologists study seabird nests and redwood groves. Perceptive networks are also being developed to monitor vibrations of manufacturing equipment, strain on bridges, and people in retirement homes."

This article discussed several practical examples of sensor networks being built by UC Berkely and Intel. They used small microcontrollers with wireless transmitters to gather environmental data. One system being built by Intel was designed to measure the environment inside of an Intel factory monitoring temperature, humidity and vibration to detect problems before it production was affected. The article predicts that these kinds of computers will soon be found in our homes, workplaces, and public spaces and it will likely raise substantial privacy concerns.

Reading: Building around the Mind

2010-09-24T17:59:00.000-07:00

"Building around the Mind" by Emily Anthes, Scientific American Mind April/May 2009, pages 52-59

"Brain research can help us craft spaces that relax, inspire, awaken, comfort and heal"

"Architects have long intuited that the places we inhabit can affect our thoughts, feelings and behaviors. Now behavioral scientists are giving their hunches an empirical basis."

"Scientists are unearthing tantalizing clues about how to design spaces that promote creativity, keep students focused and alert, and lead to relaxation and social intimacy. The results inform architectural and design decisions such as the height of ceilings, the view from windows, the shape of furniture, and the type and intensity of lighting."

This article discussed the effects of architecture on the human mind. It had in interesting story about how Jonas Stalk and how he teamed up with Louis Kahn to build the Salk Institute as the place to creative scientific breakthroughs. A study in 2007 proved that people are more creative in spaces with taller ceilings. It makes us feel less physically constrained and able to think bigger. Another study published in 2000 showed that having windows to the outside improves scored higher on tests. It proved that having a view to nature has a calming effect and improves focus.

For me, this article continued my thinking about how adding technology to our environment will affect us. Will the technology be beneficial to our well being or will it just cause us stress?

OnStar Tv Ad

2010-09-24T13:48:00.000-07:00

A lot of this project is has been inspired about how our cars are becoming smarter and I just saw a new TVad from OnStar that they have created an app to remotely monitor your car. I think we should have the same thing to monitor our homes. (app preview starts at 0:25)

Reading: No Place like Home

2010-09-23T09:36:00.000-07:00

"No Place like Home" by Antje Flade, Scientific American Mind February/March 2007 pages 70-75.

"What makes a house feel like home?"

"What makes for a “good home”? Generally speaking,
five criteria seem especially important: contact with
neighbors, privacy, flexible usage, opportunities for personalization,
and security."

"That said, people have very different ideas about what
living accommodations should offer. These preferences
depend on age, culture, life circumstances and previous
housing experiences."

This article got me thinking about how whether adding more technology to our homes is a good idea. Do we want increased control or is it just increased complexity. Will adding technology takeaway our feeling of home? Will it enhance our feeling of home or will it cause us frustration? Perhaps there is a middle ground? I think it varies a lot from person to person. Some people want to always know whats going on in their house, but others want to leave out in the woods with only the basics.

I see my system as a way to simplify home maintenance and enable an owner to take better care of their house. I admit that it adds an additional layer of complexity to ones house but think as a society we will accept this increase. New cars today are a great example; the are becoming more and more automated. We are made instantly aware if there is an issue with the engine or if a tire has low air pressure. Most drivers are oblivious to all the work car's computer does and I see my system doing the same thing for buildings.