Objects in my ArrayList seem to auto-inherit previous properties...?

Programming Questions

01rsrow

Objects in my ArrayList seem to auto-inherit previous properties...?

in Programming Questions • 2 years ago

Hey all, new to the forum, but have been knocking about with Processing for a while.

I am using an Arduino based XBee network for wireless sensor data transfer. The XBee connected to the computer handles incoming 'packets'. It simply gets a packet then unpacks it. Depending on the 16 bit network address of the XBee modem that send the message, it should then evaluate whether it has spoken to it before by unpacking every node (or XBee modem) from the ArrayList and comparing it's stored address with the incoming one.

The problem starts in Line 61 below. Upon unpacking the position 0 object in the list, and then instantly printing out its address, it has already managed to gain the incoming address from the computerGateway object!

Which means that all the comparisons afterwards will always say that the current Node has already been found.

I can only imagine that there is some sort of problem in the class code for the XBee, which I will attach in the next post.

I appreciate that the stuff I'm working on is probably a bit messy and therefore confusing, but any light on why an object that I created last time through the loop, thinks that it has the properties of one that should be about to be created this time, would be really helpful!

import processing.serial.*;
Serial port;
// make an ArrayList that will store all Nodes that join the network.
ArrayList nodeList = new ArrayList();
// instead of just creating a 'Gateway' here, we can queery the local modem for it's profile then create it?
int[] computerGatewayAddress64 = {0x00,0x13,0xA2,0x00,0x40,0x7A,0x1F,0x67} ;
int[] computerGatewayAddress16 = {0xFF,0xFE} ;
Xbee computerGateway = new Xbee(computerGatewayAddress64,computerGatewayAddress16);
//SystemTime SystemTime = new SystemTime();
PFont f;
void setup() {
size(500, 500);
println("");
println("Available serial ports:");
println(Serial.list());
port = new Serial(this, Serial.list()[1], 9600);
println("");
f = loadFont("ArialMT-16.vlw");
textFont(f,16);
fill(0);
text("Wireless Environment Sensor Network",10,20);
// add a dummy Node...
// nodeList.add(new Xbee(computerGatewayAddress64,computerGatewayAddress16)) ;
}
void draw() {
background(255);
// check if packets are incoming...
if (port.available() < 1) {
// no incoming info so proceed as normal
}
else {
// there's incoming activity, check to see if it's a packet!
computerGateway.getPacket();
// ONLY CONTINUE IF WE GOT A GOOD PACKET?
if (computerGateway.packet != null) {
// extract all the data from the new packet
computerGateway.unPackage();
// check to see if we havn't found any nodes yet...
if (nodeList.size() == 0) {
println("First contact with network! Making a Node...") ;
nodeList.add(new Xbee(computerGateway.incomingAddress64, computerGateway.incomingAddress16)) ;
}
if (nodeList.size() != 0) {
println("We have " + nodeList.size() + " Nodes. Checking to see if incoming is new...");
}
// check to see if new address
boolean foundNewNode = false ;
for (int i = nodeList.size()-1; i >= 0; i--) {
int similarBytes = 0 ;
Xbee tempoaryNode = (Xbee) nodeList.get(i) ;
println("Opened Node " + i);
println("16 Bit Address of: " + hex(tempoaryNode.address16[0],2) + hex(tempoaryNode.address16[1],2)) ;
// why is this magically equal to the new incoming address?!?!?!
for (int j=0; j<2; j++) {
if (computerGateway.incomingAddress16[j] == tempoaryNode.address16[j]) {
// we have found a match, but doesn't mean the whole address is the same!
similarBytes ++ ;
}
if (computerGateway.incomingAddress16[j] != tempoaryNode.address16[j]) {
// the bytes are different, this is enough to prove that the incoming message isn't from the tempoaryNode
foundNewNode = true ;
break ;
}
if (similarBytes == 2) {
// found an existing Node
foundNewNode = false ;
// load the Node for update / interaction
Xbee currentNode = (Xbee) nodeList.get(i) ;
println("Opened existing Node!") ;
println("") ;
break;
}
}
}
if (foundNewNode) {
// make an object for it and add it to the list
nodeList.add(new Xbee(computerGateway.incomingAddress64, computerGateway.incomingAddress16)) ;
// then load the Node for update / interaction
Xbee currentNode = (Xbee) nodeList.get(nodeList.size()-1) ;
println("Made and opened a new Node!") ;
println("") ;
}
// save the data in the packet into the archive file for the relevant node
}
}
// data has now been discovered, decoded, assigned to an object relating to it's origin and archived accordingly.
// END OF RECEIVING DATA FROM THE NETWORK
for (int i = nodeList.size()-1; i >= 0; i--) {
Xbee renderNode = (Xbee) nodeList.get(i) ;
renderNode.render(i) ;
}
text("Number of Nodes found:",10,20);
text(nodeList.size(),10,35);
}

Replies(1)

01rsrow

Re: Objects in my ArrayList seem to auto-inherit previous properties...?

2 years ago

And the class code for Xbee:

class Xbee {
int[] packet;
int packetLength = -1;
int[] dataframe;
int dataframeLength = -1;
int[] payload;
int payloadLength = -1;
int checksum; // incoming checksum
int localCheckSum; // calculated checksum
int apiID; // XBee API ID
int sapiID; // WESN API ID
int frameID; // acknowledgements enabled
int broadcastRadius; // broadcast radius set to maximum number of hops
int sendOptions; // set to 0x00 for simplicity
int receiveOptions;
// stores module addresses
int[] address64 = new int [8] ;
int[] address16 = new int [2] ;
// stores incoming module addresses
int[] incomingAddress64 = new int [8] ;
int[] incomingAddress16 = new int [2] ;
Xbee(int[] _newaddress64, int[] _newaddress16) {
// when initialising an XBee object we need to know particular module properties
address64 = _newaddress64 ;
address16 = _newaddress16 ;
}
void makePayload() {
// the contents of the payload will depend upon the type of frame being sent,
// this is determined from the API ID (build in functionality to user input this)
print(" API ID Selected = ");
println(hex(apiID, 2));
switch (apiID) {
case 0x00: // Idle
// do nothing
print("No API ID selected, IDLE!");
break;
case 0x10: // XBee Transmit Request
// Every Transmit Request has 14 bytes of data in a similar structure.
// This will be added after the payload has been populated below.
// Transmit Requests allow the XBee's to send user defined data to one another.
// For this reason a Sub API (SAPI) has been implemented at this level
// allowing commands unique to WESN to be transmitted.
switch (sapiID) {
case 0x00: // Standard XBee Transmit Request follows:
break;
case 0x01: // WESN Sensor Reading
println("!! Sensor reading isn't permitted from Computer !!");
apiID = 0x00; // return to Idle.
break;
case 0x02: // WESN Time Check
// sending 0x02 activates local code on the Smart Node to send back the current time.
print("SAPI ID = ");
println(hex(sapiID, 2));
payloadLength = 1;
payload = new int [payloadLength];
payload[0] = 0x02;
break;
case 0x03: // WESN Time Update
// sending 0x03 activates local code on the Smart Node to allow the next XX bytes to be written to the RTC as the current time.
print("SAPI ID = ");
println(hex(sapiID, 2));
break;
case 0x04: // WESN Sample Frequency Update
// sending 0x04 activates local code on the Smart Node to allow the next XX bytes to be written to the variable ??sampleFrequency??
break;
default:
println("!! Unrecognised SAPI ID for transmit! SAPI ID = ");
print(hex(sapiID, 2));
println("");
break;
}
// Now that we have created the payload we can create the dataframe and combine the two:
dataframeLength = payloadLength + 14;
dataframe = new int [dataframeLength];
dataframe[0] = apiID;
dataframe[1] = frameID;
for (int currentByte = 0; currentByte < 8; currentByte ++) {
dataframe[currentByte + 2] = address64[currentByte];
}
for (int currentByte = 0; currentByte < 2; currentByte ++) {
dataframe[currentByte + 10] = address16[currentByte];
}
dataframe[12] = broadcastRadius;
dataframe[13] = sendOptions;
for (int currentByte = 0; currentByte < payloadLength; currentByte++) {
dataframe[currentByte + 14] = payload[currentByte];
}
// dataframe[] is then passed on to makePacket() by void draw()
break; // END of 0x10, Transmit Request.
case 0x17: // Remote AT Command Request
break;
default:
print("Unrecognised API ID for transmit! API ID = ");
println(hex(apiID, 2));
break; // END of switching based on API ID.
}
}
void makePacket() {
// add on space for: frame delimiter + length (2 bytes) + checksum:
packetLength = dataframeLength + 4;
// setup the packet array:
packet = new int [packetLength];
// start to fill the packet, delimiter first:
packet[0] = 0x7E;
// MSB and LSB of length:
packet[1] = dataframeLength / 256;
packet[2] = dataframeLength % 256;
// include the payload:
for (int currentByte = 0; currentByte < dataframeLength; currentByte++) {
packet[currentByte+3] = dataframe[currentByte];
}
// now calculate the checksum of the dataframe(start delimiter, length and checksum are not included)
localCheckSum = calcCheckSum(dataframe);
// and add it to the packet as the last byte:
packet[packetLength - 1] = localCheckSum;
// packet is now constructed!!
}
int calcCheckSum(int[] _arrayToSum) {
/* used to calculate the checksum of an incoming or outgoing data packet
defined in the XBee Series 2 Manual by:
To Calculate: Not including delimiter and length, add all bytes together and keep only the last 8 bits of the result. Subtract this value from 0xFF.
To Verify: Add all bytes (including checksum but not including the delimiter and length). If the checksum is correct then the sum will equal 0xFF.
*/
int[] arrayToSum = _arrayToSum;
int ck = 0;
for (int i = 0; i < arrayToSum.length; i++) {
ck += arrayToSum[i];
}
// after adding together all bytes ensure that we have only the last 8 bits with a bitmask:
ck = (0xFF & ck);
// subtract the result from 0xFF:
ck = (0xFF - ck);
localCheckSum = (int)(ck);
return localCheckSum;
}
void sendPacket() {
// called to send a packet that has been constructed previously into the packet[] array.
// simply print to the serial port.
print("Sending the following packet: ");
for (int currentByte = 0; currentByte < packetLength; currentByte ++) {
port.write(packet[currentByte]);
print(hex(packet[currentByte], 2));
}
println("");
}
void getPacket() {
boolean gotAPacket = false;
// look for the start delimiter 0x7E
if (port.read() == 0x7E) {
// we've found a packet header
println("found a packet!!!") ;
gotAPacket = true;
}
// if we found a packet header, then read the rest:
if (gotAPacket) {
// grab the next two bytes (length bytes)
while (port.available () < 2) {
; // wait for the next two bytes
}
int lengthMSB = port.read(); // high byte of length
int lengthLSB = port.read(); // low byte of length
// convert inward bytes to packet length
packetLength = (lengthLSB + (lengthMSB << 8));
println("decimal length: " + packetLength + ". HEX length: 0x" + hex(packetLength, 4));
//now that we know the length we can read the remaining number of bytes in:
while (port.available () < packetLength) {
; // do nothing whilst we wwait for the rest of the packet to come in.
}
// setup the array for incoming data:
packet = new int [packetLength];
// print out the data, incldue 0x Hex notation
print("0x ");
// because we are starting at 'byte 0' we must stop before packetLength
for (int currentByte = 0 ; currentByte < packetLength; currentByte ++) {
packet[currentByte] = port.read();
print(hex(packet[currentByte], 2));
}
println(""); // put a newline in
// which means that the next byte is the checksum!
while (port.available () < 1) {
; // do nothing whilst we wait for the checksum byte to arrive
}
checksum = port.read();
// calculate the checksum of the received array:
localCheckSum = calcCheckSum(packet);
println("Received Checksum = " + checksum + ". Calculated Checksum = " + localCheckSum);
// compare the calculated to the received:
if (localCheckSum != checksum) {
println("Bad checksum, package discarded!");
packet = null ;
}
// reset the fact that we got a packet for next time!
gotAPacket = false;
}
else {
// the serial activity didn't contain a new packet
println("Unknown serial activity, no delimiter found!");
}
}
void unPackage() {
// due to the way in which we filled our packet, we know that the first byte dictates the type of packet we received.
// we can use it as a Case Selector to perform different action based on frame type.
apiID = packet[0] ;
println("API ID = 0x " + hex(apiID, 2));
switch(apiID) {
case 0x90: //0x90
println("Received Rx Packet:") ;
// we know that an Rx packet has one byte of API ID, 8 bytes of 64 bit sender address, 2 bytes of 16 bit sender address, 1 byte of receive options...
// ...finally the payload is made up of the remaining bytes.
// we can extract this information byte by byte:
// use a for loop to extract the 64 bit address, add each byte to the array.
for (int currentByte = 0; currentByte < 8; currentByte ++) {
incomingAddress64[currentByte] = packet[currentByte+1] ;
}
// print the address to screen
print("Incoming 64-Bit Address = 0x");
for (int currentByte = 0; currentByte < 8; currentByte ++) {
print(hex(incomingAddress64[currentByte], 2)) ;
}
println("") ;
// the next two bytes are the 16-Bit address
incomingAddress16[0] = packet[9] ;
incomingAddress16[1] = packet[10] ;
// print the address to screen
println("Incoming 16-Bit Address = 0x" + hex(incomingAddress16[0], 2) + hex(incomingAddress16[1], 2));
// just print receive options
println("Receive Options = 0x" + hex(packet[11], 2));
// use for loop to get the payload
print("Payload = 0x");
payloadLength = packetLength - 12;
payload = new int [payloadLength];
for (int currentByte = 12 ; currentByte < packetLength; currentByte ++) {
payload[currentByte - 12] = packet[currentByte];
print( hex(packet[currentByte], 2));
}
println("");
println("");
// convert two byte chunks into values
// first date:
int inInt = payload[0] << 8 | payload[1];
print(inInt);
print("/");
// now month:
inInt = payload[2] << 8 | payload[3];
print(inInt);
print("/");
// now year:
inInt = payload[4] << 8 | payload[5];
print(inInt);
print(" ");
// now hour:
inInt = payload[6] << 8 | payload[7];
print(inInt);
print(":");
// now minute:
inInt = payload[8] << 8 | payload[9];
print(inInt);
print(":");
// now second:
inInt = payload[10] << 8 | payload[11];
println(inInt);
// now temperature:
inInt = payload[12] << 8 | payload[13];
float inFloat = ((float)inInt) / 100;
println("Temperature = " + inFloat + " C");
// now humidity:
inInt = payload[14] << 8 | payload[15];
inFloat = ((float)inInt) / 100;
println("Humidity = " + inFloat + " %");
// now dewpoint:
inInt = payload[16] << 8 | payload[17];
inFloat = ((float)inInt) / 100;
println("Dewpoint = " + inFloat + " C");
break;
default:
println(">>ERROR<<");
println("Unkown API ID found!");
break;
}
}
void saveData() {
println("This is when we save to file!") ;
}
void render(int _position) {
int drawPosition = _position + 1 ;
drawPosition = drawPosition * 20 ;
stroke(0);
ellipse(drawPosition,50,10,10);
}
}

Top Reply