Back to the future with Wall-E2. Wall-following Part IV

Posted 30 April 2019

In two previous posts (here & here) I described my efforts to upgrade Wall-E2’s wall following performance using a PID control algorithm. The results of my efforts to date in this area have not been very spectacular – a better description might actually be ‘dreadful’ :-(.

After some additional analysis, I came to believe that the reason the PID approach doesn’t work very well is a fundamental feature of the way Wall-E2 measures distance to the nearest wall. Wall-E2 has two acoustic sonar units fixed to its upper deck, and they measure the distance perpendicular to the robot’s longitudinal axis. What this means, however, is that when the robot is angled with respect to the nearest wall, the distance measured isn’t the perpendicular distance, but rather the hypotenuse of the right triangle with the right angle at the wall. So, when Wall-E2 turns toward or away from the wall, the measured distance increases even though the robot hasn’t actually moved toward or away. Conversely, if the robot is angled in toward the wall and then turns to be parallel, the measured distance decreases even if the robot hasn’t moved at all relative to that wall. The situation is shown in the sketch below:

Using Excel, I ran a simulation of the ping distance versus the actual distance for a range of angle offsets from 0 to 30 degrees, as shown below:

As shown above, the ping distance for a constant 25 cm offset ranges from 25 (robot longitudinal axis parallel to the wall) to almost 29 cm for a 30 degree off-axis heading. These values translate to a percentage error of zero to approximately 15%, independent of the initial parallel distance.

So, it becomes obvious why a standard PID algorithm has trouble; if the ping distance goes up slightly, the PID algorithm attempts to compensate by turning toward the wall. However, this causes the ping distance to increase rather than decrease, causing the algorithm to command an even greater angle toward the wall, which in turn causes a further increase in ping distance – entirely backward. The reverse happens for an initial decrease in the ping distance starting from a parallel orientation. The algorithm commands a turn away from the wall, which causes the ping distance to increase immediately, even though the actual distance hasn’t changed. This causes the algorithm to seriously overcorrect in one case, and seriously undercorrect in the other. Not good.

What I need is a way to compensate for the changes in ping distance caused by Wall-E2’s angular orientation with respect to the wall being tracked. If Wall-E2 is oriented parallel to the wall, then no correction is needed; if not,then a correction is required. Fortunately for the good guys, Wall-E2 now has a way of providing the needed heading information, with the integration of the MPU6050-based 6DOF IMU module described in this post from last September.

To investigate this idea, I modified an old test program to have Wall-E2 perform a series of mild S-turns in my test hallway while capturing heading and ping distance data. The S-turns were tweaked so that Wall-E2 stayed a fairly constant 50 cm from the right-hand wall, as shown in the following movie clip.

Start of test area showing tape measure for offset distance measurement

Using Excel, I plotted the reported ping distance, the commanded heading, and the actual heading versus time, as shown below:

In the above plot, the initial CCW turn (away from the wall) was a 10° change, and all the rest were approximately 20° to maintain a more-or-less straight line. At the end of the second (the first CW turn) and subsequent heading changes, there is an approximately 0.5 sec straight period, during which no data was captured. As can be seen, the ping distance (gray curve) goes up slightly as the first CCW turn starts, then levels off during the changeover from CCW to CW turns, and then precipitously declines as the CW turn sweeps the ping sensor toward the perpendicular point. Part of this decline is actual distance change caused by the 0.5 sec straight period that moves the robot toward the wall. After the next (CCW) heading change is commanded, the robot starts to turn away from the wall causing the ping distance to increase, but this is partially cancelled by the fact that the robot continues to travel toward the wall during the S-turn. As soon as the robot gets parallel to the wall, then the ping distance goes up quickly as the heading continues to change in a CCW direction. This behavior repeats for each S-turn until the end of the run.

As an exercise, I added another column to the spreadsheet – “perpendicular distance”, and set up a formula to compute the adjusted distance from the robot to the wall, using the recorded angular offset. This computation presumes that the robot started off parallel to the wall (confirmed via the video clip). The result is shown on the yellow line in the plot below:

Ping distance and heading vs time, with calculated perpendicular distance added

As can be seen from the above plot and video, the compensated distance looks like it might be a good match with the perpendicular distance estimated from the video. For instance, at 17 sec into the video, the robot has just finished the first clockwise turn and straight run, and is just starting the second counter-clockwise turn. At this point the robot is oriented parallel to the wall, and the ping distance and the perpendicular distance should match. The video shows that distance should be about 33-35 cm, and the recorded ping distance at this point is 36 cm. However, the calculated distance went directly from 45 cm at point 11 to 34 cm at point 12 and basically stayed at that value before changing rapidly from 34 to 45 over points 19 & 20. Again at 19 seconds into the video, the robot is approximately 42-44 cm from the wall and parallel to it; both the actual ping distance and the calculated perpendicular distance agree at this point at 45 cm – a close match to the estimate from the video.

So now the question is – can I use the calculated perpendicular wall distance to assist wall-following operations? A significant issue may be knowing when the robot is actually parallel to the wall, to establish a heading baseline for compensation calcs.

When is the robot parallel to the wall?

A unique feature of the point or points where the robot is parallel to the wall is that the ping distance and the calculated distance are equal. However, that’s a bit of ‘chicken and the egg’ as one has to know the robot is parallel in order to use an offset angle of 0 degrees for the compensation calc to work out. Since the heading information available from the MPU6050 IMU is only relative, the heading value for the parallel condition can be anything, and can vary arbitrarily from run to run. So, what to do? One thought would be to have the robot make a short S-turn at the start of any tracking run to establish the heading for which the ping distance goes through a minimum or maximum – the heading for the max/min point would be the parallel heading. From there on, that heading should be reliably constant until the next time the robot’s power is cycled. Of course, a new parallel heading value would be required each and every time Wall-E2’s tracking situation changes (obstacle recovery, step-turns and reversals at the end of a hallway, changing from the left wall to the right one, etc). Maybe a hybrid mode would be feasible, whereby the robot uses uncompensated heading-based S-turns instead of the current ‘bang-bang’ system for initial wall tracking, shifting to a compensation algorithm after a suitable parallel heading is determined.

Looking at the above plots, it may not be all that useful to look for maxima and/or minima, as there are multiple headings for which the ping distance is constant, so which one is the parallel heading? Thinking about ways to rapidly find the parallel heading, it occurred to me that my previous work on quickly finding the mathematical variance of a set of values might be useful here. I plugged the above ping distance numbers into the Excel spreadsheet I used before, and got the following plot of ping distance and 3-element running variance vs time.

So, looking at the above plot, it is encouraging that a 3-point running variance calculation shows near-zero values when the robot is most probably parallel or nearly parallel to the wall. Adding the heading information to the spreadsheet gives the plot shown below

and now it is clear that the large variance values are associated with the changes from one heading to another, and the low variance values are associated with the middle section of each linear heading change (S-turn) segment. If I further enhance the plot by putting the variance plot on a secondary scale and zooming in on the low variance sections, we get the plot shown below:

Variance scale modified to show 0-5 range only

In the above plot, the variance line is zoomed in to the 0-5 range only, emphasizing the 0-0.5 unit variance range. In this plot it can be seen that the variance actually has a distinct minimum very near zero at time points 7, 16, 22, 28-30, and 35-38. These time values correspond to robot heading values of 64, 61, 63, 61-67. and 70-65. Discarding the last set as bad data (this is where the robot literally ‘hit the wall’ at the end of the run), we can compute an approximate parallel heading value as the average of all these values, or the average of 64, 61, 63, 64 (average of 61-67) = 63 degrees. From the video we can see that the robot started out parallel to the wall, and the first heading reading was 62 degrees – a very good match to the calculated parallel heading value.

The next step, I think, is to run some more field tests against a wall, with wall-following and heading assist integrated into the code.

Frank

MPU6050 IMU Motor Noise Troubleshooting

Leave a reply

Posted 24 July 2019

For a while now I’ve been investigating ways of improving the wall following performance of my autonomous wall-following robot Wall-E2. At the heart of the plan is the use of a MPU6050 IMU to sense relative angle changes of the robot so that changes in the distance to the nearest wall due only to the angle change itself can be compensated out, leaving only the actual offset distance to be used for tracking.

As the test vehicle for this project, I am using my old 2-motor robot, fitted with new Pololu 125:1 metal-geared DC motors and Adafruit DRV8871 motor drivers, as shown in the photo below.

2-motor test vehicle on left, Wall-E2 on right

The DFRobots MPU6050 IMU module is mounted on the green perfboard assembly near the right wheel of the 2-motor test robot, along with an Adafruit INA169 high-side current sensor and an HC-05 Bluetooth module used for remote programming and telemetry.

This worked great at first, but then I started experiencing anomalous behavior where the robot would lose track of the relative heading and start turning in circles. After some additional testing, I determined that this problem only occurred when the motors were running. It would work fine as long as the motors weren’t running, but since the robot had to move to do its job, not having the ability to run the motors was a real ‘buzz-kill’. I ran some experiments on the bench to demonstrate the problem, as shown in the Excel plots below:

Troubleshooting:

There were a number of possibilities for the observed behavior:

The extra computing load required to run the motors was causing heading sensor readings to get missed (not likely, but…)
Motor noise of some sort was feeding back into the power & ground lines
RFI created by the motors was getting into the MPU6050 interrupt line to the Arduino Mega and causing interrupt processing to overwhelm the Mega
RFI created by the motors was interfering with I2C communications between the Mega and the MPU6050
Something else

Extra Computing Load:

This one was pretty easy to eliminate. The main loop does nothing most of the time, and only updates system parameters every 200 mSec. If the extra computing load was the problem, I would expect to see no ‘dead time’ between adjacent adjustment function blocks. I had some debug printing code in the program that displayed the result of the ‘millis()’ function at various points in the program, and it was clear that there was still plenty of ‘dead time’ between each 200 mSec adjustment interval.

Motor noise feeding back into power/ground:

I poked around on the power lines with my O’scope with the motors running and not running, but didn’t find anything spectacular; there was definitely some noise, but IMHO not enough to cause the problems I was seeing. So, in an effort to completely eliminate this possibility, I removed the perfboard sub-module from the robot entirely, and connected it to a separate Mega microcontroller. Since this setup used completely different power circuits (the onboard battery for the robot, PC USB cable for the second Mega), power line feedback could not possibly be a factor. With this setup I was able to demonstrate that the MPU6050 output was accurate and reasonable until I placed the perfboard sub-module in close proximity to the robot; then it started acting up just as it did when mounted on the robot.

So it was clear that the interference is RFI, not conducted through any wiring.

RFI created by the motors was getting into the MPU6050 interrupt line to the Arduino Mega and causing interrupt processing to overwhelm the Mega

This one seemed very possible. The MPU6050 generates interrupts at a 20Hz rate, but I only use measurements at a 5Hz (200mSec) rate. Each interrupt causes the Interrupt Service Routine (ISR) to fire, but the actual heading measurement only occurs every 200 mSec. I reasoned that if motor-generated RFI was causing the issue, I should see many more activations of the ISR than could be explained by the 20Hz MPU6050 interrupt generation rate. To test this theory, I placed code in the ISR that pulsed a digital output pin, and then monitored this pin with my O’scope. When I did this, I saw many extra ISR activations, and was convinced I had found the problem. In the following short video clip, the top trace is the normal interrupt line pulse frequency, and the bottom trace is the ISR-generated pulse train. In normal operation, these two traces would be identical, but as can be seen, many extra ISR activations are occurring when the motors are running.

So now I had to figure out what to do with this information. After Googling around for a while, I ran across some posts that described using the MPU6050/DMP setup without using the interrupt output line from the module; instead, the MPU6050 was polled whenever a new reading was required. As long as this polling takes place at a rate greater than the normal DMP measurement frequency, the DMP’s internal FIFO shouldn’t overflow. If the polling rate is less than the normal rate, then FIFO management is required. After thinking about this for a while, I realized I could easily poll the MPU/DMP at a higher rate than the configured 20Hz rate by simply polling it each time through the main loop – not waiting for the 200mSec/5Hz motor speed adjustment interval. I would simply poll the MPU/DMP as fast as possible, and whenever new data was ready I would pull it off the FIFO and put it into a global variable. The next time the motor adjustment function ran, it would use the latest relative heading value and everyone would be happy.

So, I implemented this change and tested it off the robot, and everything worked OK, as shown in the following Excel plot.

And then I put it on the robot and ran the motors

Crap! I was back to the same problem! So, although I had found evidence that the motor RFI was causing additional ISP activations, that clearly wasn’t the entire problem, as the polling method completely eliminates the ISP.

RFI created by the motors was interfering with I2C communications between the Mega and the MPU6050

I knew that the I2C control channel could experience corruption due to noise, especially with ‘weak’ pullup resistor values and long wire runs. However, I was using short (15cm) runs and 2.2K pullups on the MPU6050 end of the run, so I didn’t think that was an issue. However, since I now knew that the problem wasn’t related to wiring issues or ISR overload, this was the next item on the list. So, I shortened the I2C runs from 15cm to about 3cm, and found that this did indeed suppress (but not eliminate) the interference. However, even with this modification and with the MPU6050 module located as far away from the motors as possible, the interference was still present.

Something else

So, now I was down to the ‘something else’ item on my list, having run out of ideas for suppressing the interference. After letting this sit for a few days, I realized that I didn’t have this problem (or at least didn’t notice it) on my 4-motor Wall-E2 robot, so I started wondering about the differences between the two robot configurations.

Wall-E2 uses plastic-geared 120:1 ‘red cap’ motors, while the 2-motor robot uses pololu 125:1 metal-geared motors
Wall-E2 uses L298N linear drivers while the 2-motor version uses the Adafruit DRV8871 switching drivers.

So, I decided to see if I could isolate these two factors and see if it was the motors, or the drivers (or both/neither?) responsible for the interference. To do this, I used my new DPS5005 power supply to generate a 6V DC source, and connected the power supply directly to the motors, bypassing the drivers entirely. When I did this, all the interference went away! The motors aren’t causing the interference – it’s the drivers!

In the first plot above, I used a short (3cm) I2C wire pair and the module was located near, but not on, the robot. As can be seen, no interference occurred when the motors were run. In the second plot I used a long (15cm) I2C wire pair and mounted the module directly on the robot in its original position. Again, no interference when the motors were run.

So, at this point it was pretty definite that the main culprit in the MPU6050 interference issue is the Adafruit DRV8871 switch-mode driver. Switch-mode drivers are much more efficient than L298N linear-mode drivers, but the cost is high switching transients and debilitating interference to any I2C peripherals.

As an experiment, I tried reducing the cable length from the drivers to the motors, reasoning that the cables must be acting like antennae, and reducing their length should reduce the strength of the RFI. I re-positioned the drivers from the top surface of the robot to the bottom right next to the motors, thereby reducing the drive cable length from about 15cm to about 3 (a 5:1 reduction). Unfortunately, this did not significantly reduce the interference.

So, at this point I’m running out of ideas for eliminating the MPU6050 interference due to switch-mode driver use.

I read at least one post where the poster had eliminated motor interference by eliminating the I2C wiring entirely – he used a MPU6050 ‘shield’ where the I2C pins on the MPU6050 were connected directly to the I2C pins on the Arduino microcontroller. The poster didn’t mention what type of motor driver (L298N linear-mode style or DRV8871 switch-mode style), but apparently a (near) zero I2C cable length worked for him. Unfortunately this solution won’t work for me as Wall-E2 uses three different I2C-based sensors, all located well away from the microcontroller.
It’s also possible that the motors and drivers could be isolated from the rest of the robot by placing them in some sort of metal box that would shield the rest of the robot from the switching transients caused by the drivers. That seems a bit impractical, as it would require metal fabricating unavailable to me. OTOH, I might be able to print a plastic enclosure, and then cover it with metal foil of some sort. If I go this route, I might want to consider the use of optical isolators on the motor control lines, in order to break any conduction path back to the microcontroller, and capacitive feed-throughs for the power lines.

27 July 19 Update:

I received a new batch of GY-521 MPU6050 breakout boards, so I decided to try a few more experiments. With one of the GY-521 modules, I soldered the SCL/SDA header pins to the ‘bottom’ (non-label side) and the PWR/GND pins to the ‘top’. With this setup I was able to plug the module directly into the Mega’s SCL/SDA pins, thereby reducing the I2C cable length to zero. The idea was that if the I2C cable length was contributing significantly to RFI susceptibility, then a zero length cable should reduce this to the minimum possible, as shown below:

MPU6050 directly on Mega pins, normal length power wiring

In the photo above, the Mega with the MPU6050 connected is sitting atop the Mega that is running the motors. The GND and +5V leads are normal 15cm jumper wires. As shown in the plots below, this configuration did reduce the RFI susceptibility some, but not enough to allow normal operation when lying atop the robot’s Mega.

GY-521 MPU6050 module mounted directly onto Mega, normal length power leads

I was at least a little encouraged by this plot, as it showed that the MPU6050 (and/or the Mega) was recovering from the RFI ‘flooding’ more readily than before. In previous experiments, once the MPU6050/Mega lost sync, it never recovered.

Next I tried looping the power wiring around an ‘RF choke’ magnetic core to see if raising the effective impedance of the power wiring to high-frequency transients had any effect, as shown in the following photo.

GND & +5V leads looped through an RF Choke.

Unfortunately, as far as I could tell this had very little positive effect on RFI susceptibility.

Next I tried shortening the GND & +5V leads as much as possible. After looking at the Mega pinout diagram, I realized there was GND & +5V very close to the SCL/SDA pins, so I fabricated the shortest possible twisted-pair cable and installed it, as shown in the following photo.

MPU6050 directly on Mega pins, shortest possible length power wiring

With this configuration, I was actually able to get consistent readings from the MPU6050, whether or not the motors were running – yay!!

In the plot above, the vertical scale is only from -17 deg to -17.8 deg, so all the variation is due to the MPU6050, and there is no apparent deleterious effects due to motor RFI – yay!

So, at this point it’s pretty clear that a significant culprit in the MPU6050’s RFI susceptibility is the GND/+5V and I2C cabling acting as antennae and conducting the RFI into the MPU6050 module. Reducing the effective length of the antennas was effective in reducing the amount of RFI present on the module.

With the above in mind, I also tried adding a 0.01uF ‘chip’ capacitor directly at the power input leads, thinking this might be just as effective (if not more so) than shortening the power cabling. Unfortunately, this experiment was inconclusive. The normal length power cabling with the capacitor seemed to cause just as much trouble as the setup without the cap, as shown in the following plot.

Having determined that the best configuration so far was the zero-length I2C cable and the shortest possible GND/+5V cable, I decided to try moving the MPU6U6050 module from the separate test Mega to the robot’s Mega. This required moving the motor drive lines to different pins, but this was easily accomplished. Unfortunately, when I got everything together, it was apparent that the steps taken so far were not yet effective enough to prevent RFI problems due the switch-mode motor drivers

The good news, such as it is, is that the MPU6050/Mega seems to recover fairly quickly after each ‘bad data’ excursion, so maybe we are most of the way there!

As a next step, I plan to replace the current DRV8871 switch-mode motor drivers with a single L298N dual-motor linear driver, to see if my theory about the RFI problem being mostly due to the high-frequency transients generated by the drivers and not the motors themselves. If my theory holds water, replacing the drivers should eliminate (or at least significantly suppress) the RFI problems.

28 July 2019 Update:

So today I got the L298N driver version of the robot running, and I was happy (but not too surprised) to see that the MPU6050 can operate properly with the motors ON or OFF when mounted on the robot’s Mega controller, as shown in the following photo and Excel plots

2-motor robot with L298N motor driver installed.

However, there does still seem to be one ‘fly in the ointment’ left to consider. When I re-installed the wireless link to allow me to reprogram the 2-motor robot remotely and to receive wireless telemetry, I found that the MPU6050 exhibited an abnormally high yaw drift rate unless I allowed it to stabilize for about 10 sec after applying power and before the motors started running, as shown in the following plots.

2-motor robot with HC-05 wireless link re-installed.

I have no idea what is causing this behavior.

31 July 2019 Update

So, I found a couple of posts that refer to some sort of auto-calibration process that takes on the order of 10 seconds or so, and that sounds like what is happening with my project. I constructed the following routine that waited for the IMU yaw output values to settle

int numdots = 0;
while (!bMPU6050Settled && numvals < MAX_MPU6050_SETTLING_VALUES)
{
	uint8_t IntStat = mpu.getIntStatus();
	if (IntStat & 0x10)
	{
		mpu.resetFIFO();
	}
	else if (IntStat == 0x02)
	{
		mpu.getFIFOBytes(fifoBuffer, DMPpacketSize);
		GetIMUHeadingDeg();

		//if necessary, initialize the yaw running average array
		if (numvals < HDG_RUNNING_AVG_ARRAY_SIZE)
		{
			aHeading[numvals] = global_yawval;
			//mySerial.printf("%lu: numvals = %d, yawval = %3.3f\n", millis(), numvals, global_yawval);
			mySerial.printf(".");
			numvals++;
		}
		else
		{
			UpdateHeadingArray();
			bMPU6050Settled = IsMPU6050Settled();
			//mySerial.printf("%2.2f\t%2.3f\t%2.3f\t%2.3f\n", millis() / 1000.f, global_yawval, delta_yaw, deg_per_sec);
			mySerial.printf(".");
			numdots++;
			if (numdots >= 3*numvals)
			{
				mySerial.printf("\n");
				numdots = 0;
			}
		}

	}
}

int numdots = 0;

while (!bMPU6050Settled && numvals < MAX_MPU6050_SETTLING_VALUES)

{

uint8_t IntStat = mpu.getIntStatus();

if (IntStat & 0x10)

{

mpu.resetFIFO();

}

else if (IntStat == 0x02)

{

mpu.getFIFOBytes(fifoBuffer, DMPpacketSize);

GetIMUHeadingDeg();

//if necessary, initialize the yaw running average array

if (numvals < HDG_RUNNING_AVG_ARRAY_SIZE)

{

aHeading[numvals] = global_yawval;

//mySerial.printf("%lu: numvals = %d, yawval = %3.3f\n", millis(), numvals, global_yawval);

mySerial.printf(".");

numvals++;

}

else

{

UpdateHeadingArray();

bMPU6050Settled = IsMPU6050Settled();

//mySerial.printf("%2.2f\t%2.3f\t%2.3f\t%2.3f\n", millis() / 1000.f, global_yawval, delta_yaw, deg_per_sec);

mySerial.printf(".");

numdots++;

if (numdots >= 3*numvals)

{

mySerial.printf("\n");

numdots = 0;

}

This was very effective in determining when the MPU6050 output had settled, but it turned out to be unneeded for my application. I’m using the IMU output for relative yaw values only, and over a very short time frame (5-10 sec), so even high yaw drift rates aren’t deleterious. In addition, this condition only lasts for a 10-15 sec from startup, so not a big deal in any case.

At this point, the MPU6050 IMU on my little two-motor robot seems to be stable and robust, with the following adjustments (in no particular order of significance)

Changed out the motor drivers from 2ea switched-mode DRV8871 motor drivers to a single dual-channel L298N linear mode motor driver. This is probably the most significant change, without which none of the other changes would have been effective. This is a shame, as the voltage drop across the L298N is significantly higher than with the switch-mode types.
Shortened the I2C cable to zero length by plugging the GY-521 breakout board directly into the I2C pins on the Mega. This isn’t an issue on my 2-motor test bed, but will be on the bigger 4-motor robot
Shortened the IMU power cable from 12-15cm to about 3cm, and installed a 10V 1uF capacitor right at the PWR & GND pins on the IMU breakout board. Again, this was practical on my test robot, but might not be on my 4-motor robot.
Changed from an interrupt driven architecture to a polling architecture. This allowed me to remove the wire from the module to the Mega’s interrupt pin, thereby eliminating that possible RF path. In addition, I revised the code to be much stricter about using only valid packets from the IMU. Now the code first clears the FIFO, and then waits for a data ready signal from the IMU (available every 50 mSec at the rate I have it configured for). Once this signal is received, the code immediately reads a packet from the FIFO if and only if it contains exactly one packet (42 bytes in this configuration). The code shown below is the function that does all of this.

bool GetIMUHeadingDeg()
{
	//Purpose: Retrieve a heading value from the IMU
	//Inputs: None
	//Outputs: 
	//	returns true if successful, false otherwise
	//	if successful, updates global_yawval
	//Plan:
	//	Step1: reset the FIFO to clean out any garbage
	//	Step2: get valid DMP packet from FIFO if it contains exactly DMPpacketSize bytes
	//	Step3: compute yaw value from FIFO contents
	//Notes:
	//	07/31/19 rewritten to incorporate FIFO wait feature

//Step1: reset the FIFO to clean out any garbage
	mpu.resetFIFO(); 

//Step2: get valid DMP packet from FIFO if it contains exactly DMPpacketSize bytes
	int FIFOWaitLoops = 0; //loop termination counter
	bool bGotDmpPacket = false;
	while (!bGotDmpPacket && FIFOWaitLoops < MAX_FIFO_WAIT_LOOP_COUNT)
	{
		uint8_t IntStat = mpu.getIntStatus();
		if (IntStat & 0x10) //FIFO overflow
		{
			mpu.resetFIFO();
			//mySerial.printf("xxx %d\n",fifoCount);
		}
		else if (IntStat == 0x02) //data ready
		{
			fifoCount = mpu.getFIFOCount();
			if (fifoCount == DMPpacketSize)
			{
				//success... I hope!
				mpu.getFIFOBytes(fifoBuffer, DMPpacketSize);
				bGotDmpPacket = true; //terminate the loop
			}
			else //try again
			{
				mpu.resetFIFO();
			}
		}

		FIFOWaitLoops++; //backup termination counter
	}

	//check for error exit
	if (FIFOWaitLoops >= MAX_FIFO_WAIT_LOOP_COUNT)
	{
		mySerial.printf("Init Hdg Loop timed out! %lu\t%d\t%3.2f\t%d\n",
			millis(), fifoCount, global_yawval, FIFOWaitLoops);
		return false;  //report the error back to calling pgm
	}

//Step3: compute yaw value from FIFO contents
	mpu.dmpGetQuaternion(&q, fifoBuffer);
	mpu.dmpGetGravity(&gravity, &q);
	mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
	global_yprzero = ypr[0];
	global_yawval = ypr[0] * 180 / M_PI;
	return true; //success!
}

bool GetIMUHeadingDeg()

{

//Purpose: Retrieve a heading value from the IMU

//Inputs: None

//Outputs:

// returns true if successful, false otherwise

// if successful, updates global_yawval

//Plan:

// Step1: reset the FIFO to clean out any garbage

// Step2: get valid DMP packet from FIFO if it contains exactly DMPpacketSize bytes

// Step3: compute yaw value from FIFO contents

//Notes:

// 07/31/19 rewritten to incorporate FIFO wait feature

//Step1: reset the FIFO to clean out any garbage

mpu.resetFIFO();

//Step2: get valid DMP packet from FIFO if it contains exactly DMPpacketSize bytes

int FIFOWaitLoops = 0; //loop termination counter

bool bGotDmpPacket = false;

while (!bGotDmpPacket && FIFOWaitLoops < MAX_FIFO_WAIT_LOOP_COUNT)

{

uint8_t IntStat = mpu.getIntStatus();

if (IntStat & 0x10) //FIFO overflow

{

mpu.resetFIFO();

//mySerial.printf("xxx %d\n",fifoCount);

}

else if (IntStat == 0x02) //data ready

{

fifoCount = mpu.getFIFOCount();

if (fifoCount == DMPpacketSize)

{

//success... I hope!

mpu.getFIFOBytes(fifoBuffer, DMPpacketSize);

bGotDmpPacket = true; //terminate the loop

}

else //try again

{

mpu.resetFIFO();

}

FIFOWaitLoops++; //backup termination counter

}

//check for error exit

if (FIFOWaitLoops >= MAX_FIFO_WAIT_LOOP_COUNT)

{

mySerial.printf("Init Hdg Loop timed out! %lu\t%d\t%3.2f\t%d\n",

millis(), fifoCount, global_yawval, FIFOWaitLoops);

return false; //report the error back to calling pgm

}

//Step3: compute yaw value from FIFO contents

mpu.dmpGetQuaternion(&q, fifoBuffer);

mpu.dmpGetGravity(&gravity, &q);

mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);

global_yprzero = ypr[0];

global_yawval = ypr[0] * 180 / M_PI;

return true; //success!

}

Here’s a short video of the robot making some planned turns using the MPU6050 for turn management. In the video, the robot executes the following set of maneuvers:

Straight for 2 seconds
CW for 20 deg, starting an offset maneuver to the right
CCW for 20 deg, finishing the maneuver
CCW for 20 deg, starting an offset maneuver to the left
CW for 20 deg, finishing the maneuver
180 deg turn CW
Straight for 3 sec
20 deg turn CCW, finishing at the original start point

So, I think it’s pretty safe to say at this point that although both the DFRobots and GY-521 MPU6050 modules have some serious RFI/EMI problems, they can be made to be reasonably robust and reliable, at least with the L298N linear mode motor drivers. Maybe now that I have killed off this particular ‘alligator’, I can go back to ‘draining the swamp’ – i.e. using relative heading information to make better decisions during wall-following operations.

Stay tuned!

Frank

Arduino Remote Programming Using A HC-05 Bluetooth Module

Leave a reply

Posted 10 June 2019

As part of my recent Wall-E2 Motor Controller Study, I reincarnated my old 2-motor robot as a test platform for Pololu’s ’20D’ metal gear motors. When I got the robot put together and started testing the motors, I realized I needed a way to remotely program the Arduino controller and remotely receive telemetry, just as I currently do with my 4-wheel Wall-E2 robot.

On my Wall-E2 robot, remote programming/telemetry is accomplished using the very nice Pololu Wixel Shield. However, I have been playing around with the cheap and small HC-05 Bluetooth module, and decided to see if there was maybe a way to use this module as a replacement for the Wixel.

As I usually do, I started with LOTS of web research. I found some posts claiming to have succeeded in remotely programming an Arduino using a HC-05 module, but the information was sketchy and incomplete, so I decided I would try and pull all the various sources together into a (hopefully) more complete tutorial for folks like me who want to use a HC-05 module for this purpose.

Overall Approach:

In order to remotely program an Arduino using a HC-05, the following basic parts are required:

A wireless link (obviously) between the PC and the HC-05.
A serial link between the PC and the Arduino and between the Arduino and the HC-05. This part is also well established, and the Arduino-to-HC-05 link can be done with either a hardware port (as with the Mega 2560) or a SoftwareSerial port using the SoftwareSerial library. My tutorial uses the Mega 2560, so I use Tx/Rx1 (pins 18/19) for the Arduino-to-HC-05 link
A way of resetting the Arduino to put it back into programming mode, so the new firmware can be uploaded.
A serial connection between the HC-05 and Tx/Rx0 on the microcontroller – more about this later.

The Wireless Link

The HC-05 is a generic Bluetooth device, and as such is compatible with just about everybody’s Bluetooth setup – phones and PC’s. I plan to use this with my Dell XPS15 9570 laptop, and I can pair with the HC-05 no problem. Here’s a link to a tutorial on pairing with the HC-05, and here’s another. As another poster mentioned, the pairing mechanism creates multiple ‘outgoing’ and ‘incoming’ COM ports, and it’s hard for me to figure out which to use. In this last iteration, I found that I could remove the two ‘incoming’ COM ports and use just the ‘outgoing’ one. Don’t know if that is the right thing, but….

A serial link between the PC, the Arduino and the HC-05

This part is discussed and demoed in many tutorials, but the piece that is almost always missing is why you need to have this link in the first place. The reason is that several AT commands must be used in order to configure the HC-05 correctly for wireless Arduino program upload, and (as I understand it anyway), AT commands can only be communicated to the HC-05 via it’s hardware serial lines, and only when the HC-05 is in ‘Command’ or ‘AT’ mode. The configuration step is a one-time deal; once the HC-05 is configured, it does not need to be done again unless the application requirements change.

A way of resetting the Arduino to accept firmware uploads

This is the tricky part. As ‘gabinix’ said in this post:

Quote from: gabenix on Feb 15, 2014, 02:18 pm

Hi Paul… To be honest I couldn’t find any tutorials to explain how to program/upload sketches with the HC-05. In fact, the conclusion you came up with is in-line with all the information out there. But it’s actually an extremely simple solution.
The only thing that keeps the HC-05 from uploading a program to arduino is that it doesn’t have a DTR (Data Terminal Ready) pin which tells the arduino to reset and accept a new sketch.
The solution is to re-purpose the “state” pin (PI09) on the breakout board. It’s purpose is to attach to an LED and indicate the connection status. It’s default setting is to send the pin HIGH when a connection is made, but you can simply enter into command mode of the HC-05 and use an AT COMMAND to tell it to send the pin LOW when a connection is made.
Voila! In about 1 minute of time you have successfully re-purposed the LED pin to a DTR pin which will reset your arduino to accept a new sketch when you hit the upload button.
A couple things to note… This will work for a pro-mini without additional hardware by connecting to the DTR pin. If you’re using an UNO or similar, you will need a capacitor in between our custom “state” pin and the reset pin on the uno. The reason is that the HC-05 will drive our custom pin LOW for the entire connection which would essentially be the same as holding the reset button the entire time. Having the cap in between solves that problem.
It a quick easy fix, takes about a minute to do. It’s just a lot harder to explain the steps to do it in a couple sentences.
Here’s a link to the AT COMMAND set —> http://robopoly.epfl.ch/files/content/sites/robopoly/files/Tutoriels/bluetooth/hc-05-at_command_set.pdf
and here’s a link to a tutorial, video, and sketch on how to enter the AT COMMANDS. —> ~~http://www.techbitar.com/modify-the-hc-05-bluetooth-module-defaults-using-at-commands.html~~ <<< no longer available 🙁

So, the trick is to re-purpose the STATE output (PI09, AKA Pin 32, AKA LED2, see this link) via the AT+POLAR(X,0) command to go LOW when the connection to upload the program is first started. This signal is then connected to the Arduino’s RESET pin via the capacitor noted above (to make this signal momentary). The ‘Instructables’ tutorial on this subject at this link actually gets most of this right, except it doesn’t explain why the AT commands are being entered or what they do – so I found it a bit mysterious. In addition, it recommends soldering a wire directly to pin 32 rather than re-purposing the STATE output pin (re-purposing the STATE pin allows a no-solder setup). Eventually I ran across this link which contains a very good explanation of the AT commands used by the HC-05. The required AT commands are:

AT+ORGL  // resets the HC-05 to its original default state. AT mode must be re-established after this command

AT+ROLE=0 // sets it to 'slave' mode (prob not necessary as this is the default, but...

AT+POLAR=1,0 // sets the LED2/Pin32/STATE 'Connection' output to active LOW.

AT+UART=115200,0,0 // changes HC-05 'Data' (Bluetooth) Mode baud rate from the default 9600 to 115,200/0/0. Does not affect wired 'Command' (AT) Mode

AT+INIT // Initialize SPP Profile.

My module is the variety with a small pushbutton already installed on the ‘EN’ pin, so entering ‘Command’ mode is accomplished by holding the pushbutton depressed while cycling the power, and then releasing the button once power has been applied.

When this is done, the LED will change from fast-blink to a very slow (like 2 sec ON, 2 sec OFF) blink mode, as shown in the following short video:

This indicates the HC-05 is in ‘Command’ mode and will accept AT commands. If you have the style without the pushbutton, you’ll have to figure out a way to short across the pads where the pushbutton should be, while cycling the power.

The screenshot below shows the result of executing these commands using the wired USB connection to the Arduino and the hard-wired serial connection between the Mega’s Tx1/Rx1 port and the HC-05 running in ‘Command’ mode.

HC-05 configuration using the wired serial port connection to the HC-05

NOTE: The various posts and tutorials on the HC-05 describe separate AT ‘mini’ and ‘full’ command modes; the ‘mini’ mode only recognizes a small subset of all AT commands, while ‘full’ recognizes them all. ‘Mini’ mode is entered by momentarily applying VCC to pin 34, and ‘full’ mode is entered by holding pin 34 at VCC for the entire session. One poster described this as a flaw in the HC-05 version 2 firmware which might be corrected in later versions. It appears this may have been the case, as the HC-05 module I used responded with VERSION:3.0-20170601 and recognized all the commands I gave it (not a comprehensive test, but enough to make me think this problem has gone away).

Wiring Layout for HC-05 Configuration via AT commands

I decided that this post was my chance to learn how to make ‘pictoral’ wiring diagrams using the Fritzing app. I had seen other posts with this kind of layout, and initially thought it was kinda childish. However, when I started working with Fritzing (in English, ‘Fritzing’ sounds like an adverb, not a proper noun – so a bit strange to my ears…), I realized it has a LOT of power, so now I’m a convert ;-).

HC-05 wired for initial configuration using AT commands

In the diagram above, I’m using the Rx1/Tx1 (pins 19/18) hardware serial port available on the Mega. If you are using a Uno, you’ll need to use SoftwareSerial to configure a second port for connection to the HC-05. A 2.2K/1.0K voltage divider is used to drop Arduino Tx output voltages to HC-05 Rx input levels, but no conversion is required in the other direction. The HC-05 can be powered directly from Arduino +5V, as the HC-05 has an onboard regulator.

Initial AT Configuration Arduino Sketch

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

void loop()
{
	if (Serial1.available())
	{
		Serial.write(Serial1.read());
	}
	if (Serial.available())
	{
		Serial1.write(Serial.read());
	}
}

All the code above does is transfer keystrokes from the Arduino to the HC-05, and vice versa. This is all that is required to configure the HC-05 using AT commands.

Serial Connection between the HC-05 and Tx/Rx0 for Program Uploads

Most Arduino microcontrollers are shipped with a small program called a ‘bootloader’ already installed. This small program is only active for a few seconds after a board reset occurs, and it’s job is to detect when a new program is being uploaded. If the bootloader sees activity on whatever serial port it is watching, it writes the incoming data into program memory and then transfers control to the user program. The stock Arduino bootloader only monitors Tx/Rx0 for this; activity on other ports (specifically Rx1 in my case) will be ignored and program uploads will fail. After the HC-05 has been initially configured via AT commands over the PC-to-Arduino-to-HC-05 serial links, the connection from the HC-05 to the Arduino must be changed so that PC-to-HC-05 data transferred over the Bluetooth link arrives at the Arduino’s Rx0 port so the stock bootloader will see it and write it to the Arduino’s program memory. This minor point wasn’t at all clear (at least not to me) in the various tutorials, so I wasted a LOT of time trying to figure out why I couldn’t get the last part of the puzzle to fit – ugh!

Shown below is my Fritzing diagram for the final configuration of my test setup, showing the Tx/Rx lines changed from Tx/Rx1 (pins 18/19) to Tx/Rx0 (pins 1/0). The HC-05 STATE output is connected to Arduino reset via a 0.22uF capacitor, with resistors to form a simple one-shot circuit. The STATE line goes LOW (after reconfiguration via the AT+POLAR=1,0 command) which causes a momentary LOW on the Arduino reset line. This is the magic required to upload programs to the Arduino wirelessly. When the Bluetooth connection is terminated, the STATE line goes HIGH again and the Arduino end of the now-charged capacitor jumps to well above 5V. The diode shown on the diagram clamps this signal to within a volt or so above +5V to avoid damage to the Arduino Reset line when this happens. This diode isn’t shown on any of the other tutorials I found, so it is possible the Arduino Reset line is clamped internally (good). It’s also possible it isn’t protected, in which case not having this diode will eventually kill the Arduino (bad).

HC-05 wired for remote program upload. Note that the Tx & Rx lines have been moved from Tx/Rx1 to Tx/Rx0

Testing

The first thing I did after configuring the HC-05 (using the above AT commands) was to see if I could still connect to and communicate with it over Bluetooth from my laptop. I used RealTerm, although any terminal program (including the Arduino IDE serial monitor) should do. The very first thing that happened is I had to re-pair the laptop with the HC-05, and the name given by the HC-05 was markedly different, as shown in the captured pairing dialog.

Pairing dialog on my Dell XPS15 9570 laptop

The next thing was to see if I could get characters from my BT serial connection through to my Arduino serial port. After fiddling around with the baud rates for a while, I realized that now I had to change the BT serial terminal baud rate from 9600 to 115200, and the Arduino-to-HC-05 baud rate from 38400 (the default ‘Command’ mode rate) to 115200. Once I did this, I could transmit characters back and forth between RealTerm (connected to the HC-05 via Bluetooth) and my Visual Studio/Visual Micro setup (connected to Arduino via the wired USB cable) – yay!

For the next step in the testing, I need to remove the hard-wired USB connection and power the Arduino from an external power source. When I did this by first removing the USB connector (thereby removing power from the HC-05) and then plugged in external power, I noticed that the HC-05 was no longer connected to my laptop (the HC-05 status LED was showing the ‘fast blink’ status, and my connection indicator LED was OFF). I checked in my BT settings panel, and the HC-05 (now announcing itself as ‘H-C-2010-06-01’) was still paired with my laptop, but just transmitting some characters from my RealTerm BT serial monitor did not re-establish the connection. However, when I changed the port number away from and then back to the BT COM port, this did re-establish the connection; the HC-05 status LED changed to the 2-blinks-pause-2-blinks cycle, and my connection LED illuminated.

So, now I connected the output of my STATUS line one-shot circuit to the Arduino reset line and changed my VS2017/VM programming port from the wired USB port to the BT port (interestingly it was still shown as ‘HC-05’ in Visual Studio/Visual Micro). After some initial problems, I got the ‘Connected’ status light, but the upload failed with the error message “avrdude: stk500v2_getsync(): timeout communicating with programmer” and the communication status changed back to ‘not connected’.

At this point I realized I was missing something critical, and yelled (more like ‘pleaded’) for help on the Arduino forum. On the forum I got a lot of detailed feedback from very knowledgeable users, most notably ‘dmjlambert’. Unfortunately dmjlambert was ultimately unsuccessful in solving the problem, but he was able to validate that the steps I had taken so far were correct as far as they went, and ‘it should just work’. To paraphrase the Edison approach to innovation, “we didn’t know what worked, but we eliminated most potential failure modes”. See this forum post for the details.

After this conversation (over several days), I decided to put the problem down for a few days and do other things, hoping that a fresh look at things with a clear head might provide some insight. A few days later when I came back to the project, I ran some tests suggested by dmjlambert to verify that the connection to the Arduino RESET pin via the 0.22uF capacitor did indeed reset the Arduino when the STATE line transitioned from HIGH to LOW. To do this I created a modified ‘Blink’ program that blinked 10 times rapidly and then transitioned to a steady slow blink. Using this program I could see that that the Arduino did indeed reset each time a Bluetooth connection to the HC-05 was established.

So, the problem had to be elsewhere, and about this time I realized I was assuming (aka ‘making an ass out of you and me’) that the program upload data being received over the Bluetooth link was somehow magically making it to the bootloader program. This had been nagging at me the whole time, but I ‘assumed’ (there’s that word again) that since this problem had never been mentioned in any of the tutorials or even in the responses to my forum posts, it must not be a problem – oops!

Anyway, to make a long story short, I moved the HC-05 – to – Arduino connection from Rx/Tx1 to Rx/Tx0 and program uploads started working immediately – YAY!!

I went back through the tutorials I had been following to see if I had missed this magic step, and didn’t find any references to moving the serial connection at all. So, if you are doing this with a UNO, you’ll need to move the serial connection from whatever pins you were using (via SoftwareSerial) to Rx/Tx0 as the last step. If you are using an Arduino Mega or other uino controller that supports additional hardware serial ports as I did, you’ll have to move the connection from Rx/Tx-whatever to Rx/Tx0 as the last step.

This tutorial was put together in the hope that I could maybe help others who are interested in using the HC-05 Bluetooth module for remote program uploads to a Arduino-compatible microcontroller, and maybe save them from some of the frustration I experienced. Please feel free to comment on this post, especially if you see something that I got wrong or missed.

13 Aug 2019 Update:

Here’s a short video showcasing the ability to program an Arduino Mega 2560 wirelessly from my Windows 10 PC using the HC-05 Bluetooth module

At the start of the video, the HC-05 status light is blinking rapidly, signalling the ‘No Connection’ state. Then, at about 2 seconds, the light changes to the slow double-blink ‘Connected’ state, the yellow LED on the Mega blinks OFF & then ON again, signalling that the Mega has been reset and is now awaiting program upload, followed immediately by rapid blinking as the new program is uploaded to the Mega’s program memory. During the upload, the HC-05 status LED continues to show the slow double-blink ‘Connected’ status. Then, at about 18 seconds, the program upload terminates and the HC-05 returns to the ‘No Connection’ state.

The small white part on the green perf-board is the 220 nF capacitor. The other two modules on the perf-board are a MPU6050 IMU and a high-side current sensor.

Stay tuned!

Frank

25 October 2021 Update:

I came back to this post to refresh my memory when trying to initialize and use a new HC-05 module for my new Wall-E3 project, and failing badly. I finally got something to work, but only after screwing around a lot. I realized I didn’t have a good handle on what mode the HC-05 was in – even though the onboard LED changes behavior to indicate the mode. So, here is a short video showing the LED behavior for the ‘disconnected’ and ‘connected’ modes.

HC-05 LED indications for ‘connected’ and ‘disconnected’ modes

In the above video, the HC-05 starts out in the normal power-on ‘disconnected’ state (rapidly flashing LED). Then after a few seconds a BT connection is established, and the LED behavior changes to ‘connected’ (two short blinks and a long pause). Then after a few more seconds the connection is dropped and the LED behavior changes back to ‘disconnected’ (rapidly flashing)

Wall-E2 Motor Controller Study

Leave a reply

Posted 19 May 2019

Over the last few weeks I have noticed that Wall-E2, my wall-following robot, seems to be suffering from a general lack of energy. I’ve been doing some testing involving a series of 45 degree S-turns, and Wall-E2 is having trouble moving at all, and when it does move, it does so very slowly. At first I thought this might be due to a low battery condition, but it exhibits the same behavior even with a fully charged battery pack. Then I thought it might be the battery pack itself dying, but now that I can monitor Wall-E2’s operating current and voltage ‘on the fly’ it is apparent that the battery pack is healthy and delivering rated power – it’s just that the power doesn’t seem to be getting to the motors. About this same time I began noticing that the cheap L298N motor drivers I have been using were getting pretty hot; enough to burn my finger, and enough to cause a ‘burning insulation’ smell.

So, I decided to go back to the drawing board and see what else is out there in terms of ‘better’ (whatever that means) motor and motor driver technology. As usual I started with a broad internet search and then started narrowing down to specific technologies and modules as I learned more. What I learned right away is that the L298n technology is notoriously inefficient, as it uses a bipolar transistor H-bridge which pretty much guarantees 1-2V voltage drop between the motor power supply and the motors themselves. This technology has been superceded by MOSFET-based H-bridge modules with much lower voltage drops and commensurately higher efficiencies. In fact, most of the modules I found no longer require heat sinks due to the much lower power dissipation.

VNH5019 Motor Driver Carrier

The Pololu VNH5019 Motor Driver Carrier is a single-channel motor driver based on the STMicroelectronics VNH5019 chip, with the following major features:

Relatively high cost compared to other products – about $25 ea.
5.5 – 24V operating range. This matches well with Wall-E2’s battery output range of 7-8.4V.
Very low Rds(ON) – less than 100mΩ. This means almost no voltage drop at the typical motor operating current of 100-200mA, and only about 0.2V at 2A stall current, or 0.4W power dissipation, worst case.
Peak operating current of 12A – way more than I’ll need.
There is also a current sensing output, but it’s only accurate during the active drive portion of the PWM waveform. Although I could probably deal with this by timing measurements to coincide with the drive cycle, I probably won’t bother, as I already have independent current measurement capability.
Very simple operation – essentially identical to the L298n scheme.

There are, however, two major drawbacks to this option; the first is that the modules are single-channel only, so I either need to use four (one for each motor) or run two motors in parallel. The second is that they are much more expensive (like an order of magnitude) than the L298n driver modules.

TB67H420FTG Dual/Single Motor Driver Carrier

Pololu’s TB67H420FTG Dual/Single Motor Driver Carrier uses the Toshiba TB67H420FTG part, with the following features:

Single or dual channel operation. In dual motor mode, each channel is limited to 1.7A, which should be OK for Wall-E2’s motors.
Minimum motor drive voltage is specified as 10V. This is too high for my 2-cell LiPo setup that tops out at 8.4V. It’s still possible it will work OK down to 7V, but only experimentation will tell

Well, this is a much cheaper part ($10 vs $25) and each part can potentially handle twice the number of motors. Nominally $20 for four motors vs $100. However, the minimum motor voltage of 10V is probably a deal breaker. Besides, if I parallel two motors on each VNH5019 module, the price differential drops to 2.5:1 vs 5:1 and I don’t have to worry about the minimum motor supply voltage.

TB9051FTG Single Brushed DC Motor Driver Carrier

The Pololu TB9051FTG brushed DC motor driver is based on Toshiba’s TB9051FTG part, and has the following features:

Low price – $8.49 (single channel)
Compatible motor supply voltage range (4.5 – 28V).
Can deliver 2.6A continuously, which should be much more than I’ll ever need
1″ x 1″ form factor, so fitting four modules onto Wall-E2’s chassis shouldn’t be too much of a problem

According to the TB9051FTG’s datasheet, the Rds(ON) has a max of 0.45Ω, so very little IR drop & power loss. This could make a very nice setup, even if I have to use four modules. This will still cost much more than my current dual L298n setup, but well worth it for the much lower voltage drop.

Dual TB9051FTG Motor Driver Shield for Arduino

This board is a dual-channel version of the above single-channel part, sized and laid out as an Arduino compatible ‘shield’ module. Pertinent features:

$19.95 ea – essentially the same per-channel price as the single channel version
Same voltage (4.5 – 28V) & current (2.6A continuous) range per channel
Motor driver control pins broken out on one side so can be used without an Arduino
Size is 1.9″ x 2.02″ or about 4 times the area of the single-channel boards. This is undoubtedly due to the requirement to physically match the Arduino Uno/Mega pin layout.

This isn’t really a good option for my Wall-E2 project, as I can fit four of the single channel modules in the same footprint as one of these boards – effectively making a 4-channel version in the same footprint.

Dual MAX14870 Motor Driver for Raspberry Pi (Partial Kit)

This module uses the Maxim MAX14870 part on a board physically compatible with the later versions of the Raspberry Pi microcomputer. Pertinent parameters

Reasonable cost – $12.75 means the per-channel cost is around $6.50/channel.
Small size: 0.8″ x 1.7″, so all four channels would fit in a 1.6″ x 1.7″ space. This is significantly smaller than the 2 x 2″ space requirement for 4 ea TB9051FTG modules
Same 4.5 – 28V motor supply range, and same 1.7A continuous/channel current rating.
Low Rds(ON) – less than 0.3Ω

This unit looks very promising; it’s small size and form factor, combined with dual motor control could make it the winner in the ‘replace the L298n’ project.

Adafruit DRV8833 DC/Stepper Motor Driver Board

This is a dual H-bridge for higher current applications than the non-current-limiting Featherwing can handle. It can handle one stepper or two DC brushed motors and can provide about 1.2A per motor, and expects a motor drive input of 2.7-10.8VDC. From the documentation:

Low MOSFET ON resistance (approx 360 mΩ)
1.5A RMS output current, 2A peak per bridge
Power supply range 2.7 – 10.8 V
PWM winding current regulation and Current Limiting
Overcurrent protection, short-circuit protection, undervoltage lockout, overtemp protection
Reasonable per-channel cost; $5 per module, but each module will handle two motors – nice!

Adafruit DRV8871 Single Channel Motor Driver:

This is a single H-bridge for even higher current applications. From the documentation:

6.5V to 45V motor power voltage
Up to 5.5V logic level on IN pins
565mΩ Typical RDS(on) (high + low)
3.6A peak current
PWM control
Current limiting/regulation without an inline sense resistor
Overcurrent protection, short-circuit protection, undervoltage lockout, overtemp protection
Higher per-channel cost; $8 per module, so $32 for all 4 motors

I was thinking that I might be able to use just two of these modules and parallel the left motors on one and the right motors on the other; this would give me 4 motor drives for $16, so comparable to the DRV8833. However, even if I use one per channel, the 4 units would still occupy a smaller footprint than the current setup with two L298N driver modules (and even less if I stack them vertically)

Adafruit Featherwing Motor Driver:

The Adafruit Featherwing motor driver kit is intended to plug into Adafruit’s ‘Feather’ microcontroller product, so to integrate it into my Mega 2560 project I’ll need to make sure I interface to the proper pins, etc. The module uses I2C for communications and motor control, so the low-level drivers for this module will be quite different than the ones currently in use for my Wall-E2 robot. Looking over the Adafruit documentation, I get the following:

Motor Power and Motor outputs: these are all on 2-pin terminal blocks, so no changes
Logic Power Pins: The Featherwing requires 3.3V & GND on the 2nd & 4th pins on the ‘long’ header side, counting from the end with three terminal blocks.
I2C Data Pins: Last two pins on the ‘short’ header side
I2C Addressing: The default feather address is 0x60, so it should be OK. The Wall-E2 project currently has four devices connected to the I2C bus;
- IR Homing Teensy uC slave at addr = 0x08
- FRAM module at addr = 0x50
- DS3231 RTC at addr = 0x68 (fixed)
- MPU6050 IMU module at addr = 0x69
Smaller voltage range (4.5 – 13.5V), but OK for my 2-cell LiPo application with max V <= 8.5V
Lower max current rating – 1.2A/channel; this could be a problem, but I don’t think so; the motors draw less than 0.5A, and won’t ever need 1.2A except in stalled rotor configuration, where it doesn’t matter. However, there is no current limiting on the Featherwing, so it is entirely possible to burn out a channel if the limit is exceeded!
Reasonable cost on a per-channel basis. The board costs $20, but it will drive all four motors, for a per-motor cost of only $5 – nice!

So, I ordered several of each of the above parts, with the idea of running some simple tests of each and picking the one that best suits my application

Adafruit Featherwing Motor Driver Testing:

The first unit I tested was the Adafruit FeatherWing. I set up a spare Mega 2560 as the controller. This turned out to be quite simple, as there are only four connections; 3.3V, GND, SCL and SDA. I used my DC lab power supply to provide 8.0V, and used two spare JGA25-370 geared DC motors connected to M1 and M3 for the test. As the following short video shows, this worked great.

As a side-effect of this test, I noticed that one of the JGA25-370 210RPM gear motors seemed to be behaving a little differently than the other. After some experimentation, I discovered that one motor required a speed control input of almost half the full-speed value to even start turning, while the other one seemed to respond correctly to even low level speed drive values. Some more investigation revealed that the ‘problem’ motor was definitely stiffer than the ‘good’ one, and when the problem motor was being driven from my lab power supply, the power supply output current went up to almost 1A until the motor started moving and then dropped down to under 100mA while the motor was actually running. The ‘good’ motor current stayed under 100mA for the entire range of speeds.

I continued by connecting all four JGA25 gear motors and noticed that only one was really functioning properly, and the other three all had difficulty at low commanded speeds. To investigate further, I added an Adafruit INA219 high-side current sense module to the circuit so I could record both the current and power for each step on each channel. I ran all 4 motors in sequence, and then plotted the results in Excel as shown below

Testing all 4 JGA25-370 motors

Current and Power vs time for 4 JGA25-370 motors. Note the current/power spikes when the ‘sticky’ motors turn ON

After some posts on the Adafruit forum, I was able to troubleshoot the motor problems to some extent. I was able to free up one of the troublesome motors by exercising the gear train, but on two other motors it became obvious that it was the motors themselves, not the gear train that was sticking. A 50% (or 75% depending on one’s threshold) failure rate isn’t very good. One of the posters on the Adafruit forum suggested I take a look at the metal gear motors offered by Pololu, and I ordered some of their ’20D’ motors for evaluation.

After testing the metal gear motors, I tried some of my stock of plastic motors, as shown in the following photo and Excel plot.

two ‘red cap’ and two ‘black cap’ motors

Current and Power vs time for two ‘red cap’ and two ‘black cap’ motors

All four motors behaved reasonably well, but as shown in the above plot, the ‘red cap’ motors drew a LOT more current than the ‘black cap’ ones. This was a mystery to me until I measured the coil resistance of the two types. The ‘red cap’ motors exhibited coil resistances of about 1Ω, whereas the ‘black cap’ motors were more like 5.7Ω. I surmise that the ‘red cap’ motors are for 3V applications and the ‘black cap’ ones are for 6-12V.

After this, I decided to test the motors currently installed in my Wall-E2 robot, so I simply placed the prototype board containing the Featherwing and the Mega 2560 controller on top of the robot and rerouted the motor wires from the LN298 controllers to the Featherwing. The following photo and plot show the setup and the results.

proto board on top of Wall-E2

Current and Power vs time for the four ‘red cap’ motors currently installed in Wall-E2

Of the four installed ‘red cap’ motors currently installed in Wall-E2, only two (M1 & M4 above) exhibited reasonable performance – the other two were basically inoperative. Some closer inspection revealed that M3 exhibited essentially infinite coil resistance, i.e. an open circuit. Apparently I had managed to burn out this coil entirely, probably because the ‘red cap’ motors were intended for lower voltage applications.

Adafruit DRV8871 Single Channel Motor Driver Testing:

I removed the Featherwing module and replaced it with Adafruit’s DRV8871 Driver module. This module uses two PWM outputs to drive and direction control (vs I2C for the Featherwing) and is very simple to hook up and use. After getting it hooked up I ran a Pololu ’20D’ metal gear motor and a ‘good’ JGA25-370 over one complete up/down speed cycle, with no mechanical load. This produced the plots shown below:

Pololu 20D metal gear motor with DRV8871 Motor Driver

JGA25-370 metal gear motor with DRV8871 Motor Driver

Since I had already tested the same JGA25-370 motor with the Featherwing driver, I thought I would get similar results. However, the earlier Featherwing test produced a significantly different plot, as shown below

JGA25-370 metal gear motor with Featherwing driver

Why the differences? The coarseness of the DRV8871 plot versus Featherwing may well be because the DRV8871 uses the Arduino PWM outputs at the default frequency of around 980Hz, and I suspect the Featherwing PWM frequency is much higher. However, this doesn’t explain the dip in both power & current at the peak of the speed curve.

Frank

Back to the future with Wall-E2. Wall-following Part III

Leave a reply

Posted 24 March 2019,

In my previous post on this subject, I described some initial wall-following tests using a PID controller, and concluded that I would have to use some sort of two-stage approach/capture arrangement to make things work properly. In addition, I needed some more ‘field’ (i.e., my hallway) testing to determine the best PID values for wall-following.

I started by causing the distance input to vary in a square wave fashion with an amplitude of about 20cm around the 50cm target value. The resulting speed variations are shown in the following Excel plot. This gave me some confidence that the basic PID mechanism was working properly.

Square wave response of PID = 1,0,0

After verifying basic operation, I started field testing with the most basic values possible – PID = 1,0,0: This resulted in a very slow oscillation, as shown in the following video and Excel plot:

PID = 1,0,0, initial offset = target distance = 50cm

Then I moved on to the PID value I had obtained from previous field testing, i.e. PID = 10,0,0. This resulted in the behavior shown in the following video and Excel plot

PID = 10,0,0, initial offset = target distance = 50cm

For completeness, I also tested the PID = 10,2,0 case, but as can be seen in the following video and Excel plot, this did not appreciably change wall-tracking performance, at least not for the offset = target case.

PID = 10,2,0, initial offset = target distance = 50cm

A comparison of all three PID values is shown in the following Excel plot

Next I tried the PID = 1,0,0 case with an initial offset of 25cm and a target of 50cm, to gauge how the PID algorithm performs with an initially large error term.

PID = 1,0,0, initial offset = 25cm, target distance = 50cm

Upgraded Variance Calculation for Wall-E2 ‘Stuck’ Detection

Leave a reply

Posted 23 April 2019

A little over three years ago I developed an effective technique for detecting when Wall-E2, my autonomous wall-following robot, had gotten itself stuck and needed to back up and try again. The technique, described in that post, was to continuously calculate the mathematical variance of the last N forward distance measurements from the onboard LIDAR module. When Wall-E2 is moving, the forward distances increase or decrease, and the calculated variance is quite high (generally in the thousands). However, when it gets stuck the distances remain steady, and then the variance decreases rapidly to near zero. Setting a reasonable threshold allows Wall-E2 to figure out it is stuck on something and take appropriate action to recover.

The above arrangement has worked very well for the last three years, but recent developments and some nagging concerns prompted me to re-examine this feature.

Computational Load:

When I first added the variance calculation routine, there was very little else going on in Wall-E2’s brain; ping left, ping right, LIDAR forward, calc variance, adjust motor speeds, repeat. Since then, however, I have added a number of different sensor packages, all of which add to the computational load in one way or another. I began to be concerned that I might be about to exceed the current 100 mSec time budget.

Performance Problems:

Although the LIDAR/Variance technique has performed very well, there were still occasions where Wall-E2’s behavior indicated something was wrong; either he would think he was stuck when he obviously wasn’t, or it would take too long to detect a stuck condition, or other random glitches. This didn’t happen very often, but just enough to put me on notice that something wasn’t quite right.

Brute Force vs Incremental Variance Calculation:

I could only think of two ways to address the computational load; reduce the size of the array of LIDAR distances used, or reduce the time required for each computation. The original size selection of 50 measurements was sort of based on the idea that it would take about 5 seconds for a 50-entry array to be completely refreshed at the current 10Hz loop frequency. This means that Wall-E2 should be able to detect a stuck condition about 5 seconds after it happens. Decreasing the array size would decrease the detection time more or less linearly, but would probably also increase the chances of a false positive. The other alternative would be to find a way to speed up the variance calculation itself.

Variance is a measure of the variability of a dataset, and is defined as:

The current algorithm for computing the variance is a ‘Brute Force’ method that loops through the entire array of LIDAR distance values twice – once for computing the mean, and then again to compute the squared-difference term, before subtracting the squared mean from the squared difference term to get the final variance value, as shown below:

	//calc new 'brute force' mean
	long sum = 0;
	for (int i = 0; i < DIST_ARRAY_SIZE; i++)
	{
		sum += aDistArray[i]; //adds in rest of values
	}
	float brute_mean = (float)sum / (float)DIST_ARRAY_SIZE;

	//	Step2: calc new 'brute force' variance
	float sumsquares = 0;
	for (int i = 0; i < DIST_ARRAY_SIZE; i++)
	{
		sumsquares += (aDistArray[i] - brute_mean)*(aDistArray[i] - brute_mean);
	}

	double brute_var = sumsquares / DIST_ARRAY_SIZE;

//calc new 'brute force' mean

long sum = 0;

for (int i = 0; i < DIST_ARRAY_SIZE; i++)

{

sum += aDistArray[i]; //adds in rest of values

}

float brute_mean = (float)sum / (float)DIST_ARRAY_SIZE;

// Step2: calc new 'brute force' variance

float sumsquares = 0;

for (int i = 0; i < DIST_ARRAY_SIZE; i++)

{

sumsquares += (aDistArray[i] - brute_mean)*(aDistArray[i] - brute_mean);

}

double brute_var = sumsquares / DIST_ARRAY_SIZE;

This works fine, but is computationally clunky. With a 50-element array, this computation takes around 1.5 mSec. This is only about 1.5% of the 100 mSec time window for a 10Hz cycle time, but still…

Starting from a slightly different definition of the variance calculation

and then expanding, manipulating algebraically and then recombining, we arrive at an incremental version of the variance formula, as shown below:

Incremental version of the variance expression

And this is implemented in the code section shown below:

	double inc_mean = last_incmean - (float)oldestDistVal / DIST_ARRAY_SIZE + (float)newdistval / DIST_ARRAY_SIZE;

	unsigned long olddist_squared = oldestDistVal * oldestDistVal;
	unsigned long newdist_squared = newdistval * newdistval;

	double last_incmean_squared = last_incmean * last_incmean;
	double inc_mean_squared = inc_mean * inc_mean;

	double inc_var = last_incvar + ((float)newdist_squared / DIST_ARRAY_SIZE) - ((float)olddist_squared / DIST_ARRAY_SIZE)
		+ last_incmean_squared - inc_mean_squared;

double inc_mean = last_incmean - (float)oldestDistVal / DIST_ARRAY_SIZE + (float)newdistval / DIST_ARRAY_SIZE;

unsigned long olddist_squared = oldestDistVal * oldestDistVal;

unsigned long newdist_squared = newdistval * newdistval;

double last_incmean_squared = last_incmean * last_incmean;

double inc_mean_squared = inc_mean * inc_mean;

double inc_var = last_incvar + ((float)newdist_squared / DIST_ARRAY_SIZE) - ((float)olddist_squared / DIST_ARRAY_SIZE)

+ last_incmean_squared - inc_mean_squared;

The incremental calculation doesn’t use any loops and therefore is quite a bit faster, for no loss in accuracy. For a 50-element array as above, the incremental calculation takes only about 220 uSec, or about 7-8 times faster than the ‘brute force’ technique.

As a side-benefit of changing from the ‘brute force’ to the incremental technique, I also discovered the reason Wall-E2 was displaying occasional odd behavior. The sonar ping measurements have a maximum value of 200 cm, which fits nicely into a 8-bit ‘byte’ data type. However, the LIDAR front distance sensor goes out to 400 cm, which doesn’t. Unfortunately, I had defined the forward distance array as an array of ‘byte’ values, which meant that everything worked fine as long as the reported distance was less than 255 cm, but not so much for distances over that value. Fixing this problem turned out not to be as simple as changing the array definition from ‘byte’ to uint16_t, as then I ran into numerical overflow problems in the incremental variance calculation because of the squaring operations involved. Due to the way the compiler operates, it isn’t sufficient to cast the result of uint16_t * uint16_t, to uint32_t, as the overflow happens before the cast. To avoid this problem, the individual terms need to be uint32_t before the multiplication occurs. Once this was done, all the results settled down to what they should be, and now correct results are obtained for the full range of possible distance values. Shown below is an Excel plot of a test run performed using simulated input values from 100 to 400 (anything above 255 used to cause overrun problems)

As can be seen in the above plot, the ‘brute force’ and incremental methods both produce identical outputs, but the incremental method is 7-8 times faster.

Shown below is the same setup, but this time the input data is actual LIDAR data from the robot

03 May 2022 Update:

As part of my ongoing work to integrate charging station homing into my new Wall-E3 autonomous wall-following robot, I discovered that the ‘stuck detection’ routine wasn’t working anymore. Upon investigation I found that the result returned by the above incremental variance calculation wasn’t decreasing to near zero as expected when the robot was stuck; in fact, the calculated variance stayed pretty constant at about 10,000 – how could that be? After beating on this for a while, I realized that if the four terms to the right of the previous incremental variance calculation add to near zero, which they will if the array contents are constant, then the new calculated variance will be the same as the old calculated variance. So, if the ‘previous variance’ number starts out wrong, it will stay wrong, and the ‘stuck’ flag will never be raised – oops!

I started thinking again about why I changed from the ‘brute force’ method to the incremental method in the first place. The reason at the time was my concern that the brute force method might eat up too much of the available loop cycle time, but now that I have changed the processor from an Arduino MEGA2560 to a Teensy 3.5, that might not be applicable anymore. So I replaced the incremental algorithm with the brute force one, and instrumented the block with a hardware pin to actually measure the time required to compute the variance. As shown below, this is approximately 8μSec, insignificant compared to the 100 mSec tracking loop duration.

‘Brute Force’ variance calculation duration

Stay tuned,

Frank

Better Battery Charging for Wall-E2

Leave a reply

Posted 08 February 2019,

After recovering from my bout with #include file hell, I’m back to working on Wall-E2, my autonomous wall-following robot. In a previous post I described the integration of the TP5100 charger module into Wall-E2’s system, but I have lately discovered that the TP5100 end-of-charge (EOC) detection scheme isn’t very reliable in my application. The TP5100 uses a current threshold to determine EOC, which works fine in a normal application where the battery pack isn’t simultaneously supplying current to the load, but in my application, Wall-E2 stays active and alert while it’s docked at it’s feeding station; it has to, in order to be able to respond to the EOC signal and detach itself. So, the current going through the TP5100 never goes below the idling current for Wall-E2, which is on the order of 300mA or so. This is enough to keep the charging current above the TP5100 EOC threshold, and so Wall-E2 hangs on to the charging station forever – not what I had in mind!

Life would be good if I somehow measure Wall-E2’s idling current while on charge and the total charging current. Then I could subtract the two values to get the excess current, i.e. the current going into the battery but not coming out – the current actually going into increasing the battery charge level. When this current falls below an appropriate threshold, then charging could be terminated. This scenario is complicated by the need to measure the current on the high side of the charging circuit and of the +Vbatt supply to the rest of the system.

Well, as it turns out, Adafruit (and I’m sure others) makes a high-side current sensor just for this purpose, based on the 1NA219 and INA169 chips. The INA219 module reports current via an I2C connection, while the 1NA169 module provides a open-emitter current source proportional to the current through an onboard 0.1Ω resistor (see this data sheet for details). My plan is to use two of these modules; one at the charging circuit input, and a second one at the 8.4V +VBatt supply from the battery to the rest of the system. Since Wall-E2 stays awake during charging, it should be simple to monitor both currents and decide when charging is complete (or complete enough, anyway). As a bonus, I should be able to extend the life of Wall-E2’s battery pack by terminating the charge at less than 100% capacity. See this very informative post by François Boucher for the details.

03 March 2019 Update:

After the usual number of mistakes and setbacks, I think I have the dual current sensor feature working, and now WallE-2 charges by monitoring both the battery voltage and the actual charging current (total current measured at the charging connector minus the run current measured on WallE-2’s main power line). As a final test, I discharged the main battery pack at about 1A for about 1 hour, and then charged it again using the two-current method. As shown in the Excel plots below, Charging terminated when the actual battery charging current fell below 50mA.

Complete charge cycle, after discharging at approx 1A for approx 1 Hr

Last 20 minutes or so of charge operation, showing detail of end-of-charge behavior

two 1NA169 high-side current sensors mounted in the battery/motor compartment. Note the 3D-printed mounting plates.

Here is a showing the installation of the two 1NA169 sensor modules in WallE-2’s battery compartment. The one on the left measures running current, and the one on the right measures total current (charging + running).

The following figure shows the system schematic for WallE-2, with the two new 1NA169 sensors highlighted

System schematic with locations of new current sensors highlighted

Now that I have the current sensors and the new charge algorithm working, it’s time to go back an take another look at the charge/discharge characteristics of the Panasonic 18650B cells I’m using to see if I can extend their life with a more intelligent charge/discharge scheme. The following plot shows the charge characteristics for this cell.

Charge plot for the Panasonic 18650B LiPo cell

As noted by François Boucher, the red line above is the total energy returned to the battery during charge. As he notes, the battery acquires about 90% of its total capacity in the first 105 minutes of the charge period, when charged at 0.5C at 25C. My battery pack is a 2-cell parallel x 2-cell series stack, and currently I’m charging to a 50mA cutoff. According to Boucher, this is way too low – I’m charging to almost 100% capacity and thereby limiting the cycle life of the battery pack. Looking at the end-of-charge detail plot above (repeated below), I should probably use a charge current threshold of around 500mA charging current (250mA per cell in the parallel stack) for about 90% capacity charge.

End-of-charge detail with approximate 90% charge current highlighted

On the discharge side, Panasonic’s Discharge Characteristics plot below shows a discharge down to 2.50V/cell. WallE-2’s typical current drain is about 1A or about 0.3 – 0.5C, and the cutoff I’m using is 3.0V cell. From the plot, this gives about 3150mAH of the approximately 3300mAH available at 0.5C, or about 95%. So, it looks like I should raise the discharge cutoff voltage to about 3.2V or about 3000mAH of the 3300mAH available, or about 90%.

Conclusion:

So revisiting WallE-2’s battery management seems to have paid off; I now have much better visibility into and control over charge/discharge of the 18650B battery pack, and at least some expectation that I can use WallE-2’s new found battery super powers for good rather than evil ;-).

Stay tuned!

Frank

Back to the future with Wall-E2. Wall-following Part II

Leave a reply

Posted 09 February 2019

A long time ago in a galaxy far, far away, I set up a control algorithm for my autonomous wall-following robot Wall-E2. After a lot of tuning, I wound up with basically a bang-bang system using a motor speed step function of about 50, where the full range of motor speeds is 0-255. This works, but as you can see in the following chart & Excel diagram, it’s pretty clunky. The algorithm is shown below, along with an Excel chart of motor speeds taken during a hallway run, and a video of the run.

for left wall tracking

leftspeednum = prevleftspdnum - MOTOR_SPEED_ADJ_FACTOR * (leftdistval - prevleftdistval);
rightspeednum = prevrightspdnum + MOTOR_SPEED_ADJ_FACTOR * (leftdistval - prevleftdistval);

1 2	leftspeednum = prevleftspdnum - MOTOR_SPEED_ADJ_FACTOR * (leftdistval - prevleftdistval); rightspeednum = prevrightspdnum + MOTOR_SPEED_ADJ_FACTOR * (leftdistval - prevleftdistval);

for right wall tracking

leftspeednum = prevleftspdnum + MOTOR_SPEED_ADJ_FACTOR * (rightdistval - prevrightdistval);
rightspeednum = prevrightspdnum - MOTOR_SPEED_ADJ_FACTOR * (rightdistval - prevrightdistval);

1 2	leftspeednum = prevleftspdnum + MOTOR_SPEED_ADJ_FACTOR * (rightdistval - prevrightdistval); rightspeednum = prevrightspdnum - MOTOR_SPEED_ADJ_FACTOR * (rightdistval - prevrightdistval);

Run 1, using homebrew algorithm

Note the row of LEDs on the rear. They display (very roughly) the turn direction and rate.

Since the time I set this up, I started using a PID algorithm for the code that homes the robot in on its charging station using a modulated IR beam, and it seems to work pretty well with a PID value of (Kp,Ki,Kd) = (200,0,0). I’d like to use the knowledge gained for the IR homing subsystem to make Wall-E2 a bit more sophisticated and smooth during wall-following operations (which, after all, will be what Wall-E2 is doing most of the time).

In past work, I have not bothered to set a fixed distance from the wall being followed; I was just happy that Wall-E2 was following the wall at all, much less at a precise distance. Besides, I really didn’t know if having a preferred distance was a good idea. However, with the experience gained so far, I now believe a 20-30 cm offset would probably work very well in our home.

So, my plan is to re-purpose the PID object used for IR homing whenever it isn’t actually in the IR homing mode, but with the PID values appropriate for wall-following rather than beam-riding.

PID Parameters:

For the beam-riding application I used a setpoint of zero, meaning the algorithm adjusts the control value (motor speed adjustment value) to drive the input value (offset from IR beam center) to zero. This works very nicely as can be seen in the videos. However, for the wall-following application I am going to use a setpoint of about 20-30cm, so that the algorithm will (hopefully) drive the motors to achieve this offset. The Kp, Ki, & Kd values will be determined by experimentation.

13 February 2019 Update:

I got the PID controller working with a target offset of 25cm and Kp,Ki,Kd = 2,0,0 and ran some tests in my hallway. In the first test I started with Wall-E2 approximately 25cm away from the wall. As can be seen in the following video, this worked quite well, and I thought “I’m a genius!” Then I ran another test with Wall-E2 starting about 50cm away from the wall, and as can be seen in the second video, Wall-E2 promptly dived nose-first right into the wall, and I thought “I’m an idiot!”

The problem, of course, is the PID algorithm correctly turns Wall-E2 toward the wall to reduce the offset to the target value, but in doing so it changes the orientation of the ping sensor with respect to the wall, and the measured distance goes up instead of down. The PID response is to turn Wall-E2 more, making the problem even worse, ending with Wall-E3 colliding nose-first with the wall it’s supposed to be following – oops!

So, it appears that I’ll need some sort of two stage approach the the constant-offset wall following problem, with an ‘approach’ stage and a ‘capture’ stage. If the measured distance is outside a predefined capture window (say +/- 2cm or so), then either the PID algorithm needs to be disabled entirely in favor of a constant-angle approach, or the PID parameters need to change to something more like Kp,Ki,Kd = 0,1,1 or something. More experimentation required.

Stay tuned,

Frank

State memory for Wall-E2 – writing telemetry packets to FRAM

Leave a reply

posted 28 September 2018

In previous posts, I have described my effort to give time, memory and relative heading super-powers to Wall-E2, my autonomous wall-following robot. This posts describes a helper class I created to allow Wall-E2 to periodically write its current operating state to FRAM memory, for later readout by his human master(s), and a small test program to verify proper operation of the helper class.

My current conception of Wall-E2’s operational state consists of the current time/date, its tracking mode and submode, and the current left, right, and forward distances, and the current battery voltage. These parameters have been encapsulated in a CFramStatePacket class with methods for writing state packets to FRAM and reading them back out again. The complete code for this class is shown below. Note that all the class code is contained in just one file – FramPacket.h. There is no associated .cpp file, as I didn’t think that was necessary.

/* CCFRAMStatePacket class.
The CFRAMStatePacket class is intended to encapsulate code associated with 
writing Wall-E2's telemetry to FRAM and reading it back again. This class 
uses the Adafruit_FRAM_I2C library to actually communicate with the FRAM
via I2C.  Methods are provided to set up a pointer to the Adafruit_FRAM_I2C
object, write/read telemetry packets to/from the FRAM, and print packets to
the serial console provided by the calling program.

This class assumes the calling program calls Serial.begin() and also provides
a StreamEx object called mySerial (typically 'StreamEx mySerial = Serial;').
It also assumes that the reference to this code file is placed *after* the 
references to Wire.h, Adafruit_I2C.h, and PrintEx.h, and the instantiations
of StreamEx MySerial and Adafruit_FRAM_I2C fram.  The typical setup would be
something like:

#include <Wire.h>
#include "Adafruit_FRAM_I2C.h"
#include <RTClib.h>;
#include <time.h>;
#include <PrintEx.h>
#include <elapsedMillis/elapsedMillis.h>
#include <Time-master/time.h>

//#include <math.h>
StreamEx mySerial = Serial;
elapsedMillis mSecSinceLastPacketWrite;
Adafruit_FRAM_I2C fram = Adafruit_FRAM_I2C();

const int FIRST_PKT_STORAGE_ADDR = 2;//addr 0/1 reserved for nextFramWriteAddr
int nextFramWriteAddr = FIRST_PKT_STORAGE_ADDR; //writing starts with this address
int prevDispFramEndAddr = FIRST_PKT_STORAGE_ADDR; //optional readback starts here
const int NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION = 0; //the next free address is written to this address

//FramPacket.h holds 'inline' definition of CFRAMStatePacket class
//this has to come after #include "Adafruit_FRAM_I2C.h" and Adafruit_FRAM_I2C fram = Adafruit_FRAM_I2C();
#include "FramPacket.h"
CFRAMStatePacket packet = CFRAMStatePacket(&fram); //this object is used for all FRAM transactions

//fwd declaration required to avoid '... does not name a type' error
CFRAMStatePacket GetNextSimFRAMPacket(CFRAMStatePacket pkt);

[rest of program...]
*/

#pragma once
#ifndef FRAMSTATEPACKET_H
#define FRAMSTATEPACKET_H
#include "Adafruit_FRAM_I2C.h" //needed for pointer forward declaration

const char daysOfTheWeek[7][12] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };

class CFRAMStatePacket
{
public:
	uint32_t unixtime;
	byte mode;
	byte submode;
	byte leftdist;
	byte rightdist;
	byte fwddist;
	byte batv;
	const static int packet_size = 9;
	bool bFramReady = false; //added 09/27/18
private:
	Adafruit_FRAM_I2C* pfram;
public:
	CFRAMStatePacket(uint32_t unixtime = 0, byte mode = 0, byte submode = 0, byte leftdist = 0,
		byte rightdist = 0, byte fwddist = 0, byte batv = 0);
	CFRAMStatePacket(Adafruit_FRAM_I2C* pfram, uint32_t unixtime = 0, byte mode = 0, byte submode = 0, 
		byte leftdist = 0, byte rightdist = 0, byte fwddist = 0, byte batv = 0);
	void Print();
	int Read(int addr); //reads packet from FRAM; returns next write addr
	int Write(int addr); //writes packet to FRAM; returns next read addr
	void SetFramPointer(Adafruit_FRAM_I2C* ptr);
	int GetFramPointer();
	void PrintHumanReadable(); //displays date & time vs unixtime
	void CFRAMStatePacket::GetDateTimeStringFromUnixTime(char* str);
};

int CFRAMStatePacket::GetFramPointer()
{
	return (int)pfram;
}

void CFRAMStatePacket::SetFramPointer(Adafruit_FRAM_I2C* ptr)
{
	pfram = ptr;
}

CFRAMStatePacket::CFRAMStatePacket(uint32_t unixtime = 0, byte mode = 0, byte submode, byte leftdist = 0,
	byte rightdist = 0, byte fwddist = 0, byte batv = 0)
{
	//mySerial.printf("In CFRAMStatePacket default constructor\n");
}

CFRAMStatePacket::CFRAMStatePacket(Adafruit_FRAM_I2C* ptr, uint32_t unixtime = 0, byte mode = 0,
	byte submode, byte leftdist = 0, byte rightdist = 0, byte fwddist = 0, byte batv = 0)
{
	pfram = ptr;
}

void CFRAMStatePacket::Print()
{
	mySerial.printf("%lu\t%d\t%d\t%d\t%d\t%d\t%d\n",
		unixtime, mode, submode, leftdist, rightdist, fwddist, batv);
}

int CFRAMStatePacket::Write(int addr)
{
	//Provenance: 09/09/18 G. Frank Paynter
	//Purpose:  Write a complete state packet to the FRAM at the specified address
	//	The telemetry packet is formatted as a 9 - byte packet :
	//		Time: 4 - bytes
	//		mode / submode : 1 byte
	//		left distance : 1 byte
	//		right distance : 1 byte
	//		forward distance : 1 byte
	//		battery voltage above 5V : 1 byte
	//Inputs:
	//	addr = FRAM address to be written to
	//Outputs: 
	//	addr = address to be used for next FRAM write
	//Plan:  
	//	Step1: write each packet component to FRAM at addr, updating addr each time
	//Notes:


	//date/time - 4 bytes
	unsigned long writeval = (unsigned long)unixtime;
	int numbyteswritten = pfram->FRAM_I2C_writeAnything(addr, writeval);
	unsigned long readval;
	pfram->FRAM_I2C_readAnything(addr, readval);
	addr += numbyteswritten;

	//mode/submode - 1 bytes
	byte combomode = (byte)(10 * mode + submode);
	numbyteswritten = pfram->FRAM_I2C_writeAnything(addr, combomode);
	addr += numbyteswritten;

	//left dist - 1 bytes
	numbyteswritten = pfram->FRAM_I2C_writeAnything(addr, leftdist);
	addr += numbyteswritten;

	//right dist - 1 bytes
	numbyteswritten = pfram->FRAM_I2C_writeAnything(addr, rightdist);
	addr += numbyteswritten;

	//forward dist - 1 bytes
	numbyteswritten = pfram->FRAM_I2C_writeAnything(addr, fwddist);
	addr += numbyteswritten;

	//batV - 1 bytes
	numbyteswritten = pfram->FRAM_I2C_writeAnything(addr, batv);
	addr += numbyteswritten;

	return addr;
}

int CFRAMStatePacket::Read(int addr)
{
	//Provenance: 09/09/18 G. Frank Paynter
	//Purpose:  read a complete state packet from the FRAM at the specified address
	//	The telemetry packet is formatted as a 9 - byte packet :
	//		Time: 4 - bytes
	//		mode / submode : 1 byte
	//		left distance : 1 byte
	//		right distance : 1 byte
	//		forward distance : 1 byte
	//		battery voltage above 5V : 1 byte
	//Inputs:
	//	addr = FRAM address to be read from
	//Outputs: 
	//	addr = address to be used for next FRAM read
	//Plan:  
	//	Step1: read each packet component from FRAM at addr, updating addr each time
	//Notes:

	//mySerial.printf("In pkt.Read with address %d and Adafruit_FRAM_I2C* = %d\n", addr,pfram);

	//unixtime
	uint32_t utime;
	pfram->FRAM_I2C_readAnything(addr, unixtime);
	addr += sizeof( utime);

	//mode, submode
	byte combomode;
	pfram->FRAM_I2C_readAnything(addr, combomode);
	 mode = combomode / 10; //integer truncation OK
	 submode = combomode - 10 *  mode;
	addr++;

	//distances
	pfram->FRAM_I2C_readAnything(addr, leftdist);
	addr++;
	pfram->FRAM_I2C_readAnything(addr, rightdist);
	addr++;
	pfram->FRAM_I2C_readAnything(addr, fwddist);
	addr++;

	//batt voltage
	pfram->FRAM_I2C_readAnything(addr, batv);
	addr++;

	return addr;
}

void CFRAMStatePacket::PrintHumanReadable() //displays date & time vs unixtime
{
	//Provenance: 10/01/18 G. Frank Paynter
	//Purpose:  print a complete state packet with the uint32_t unixtime property
	//			 replaced by a human-readable date-time format.
	//Inputs: None
	//Outputs: 
	//	packet contents sent to serial port, with date/time instead of unixtime
	//Plan:  
	//	Step1: print out the human-readable date/time instead of unixtime
	//	Step2: print the rest out as normal
	//Notes:

//Step1: print out the human-readable date/time instead of unixtime
	char datestr[40];
	memset(datestr, 0, sizeof(datestr));
	GetDateTimeStringFromUnixTime(datestr);
	Serial.print(datestr); //can't use mySerial.printf() for some reason

//Step2: print the rest out as normal
	mySerial.printf("\t%d\t%d\t%d\t%d\t%d\t%d\n",
		mode, submode, leftdist, rightdist, fwddist, batv);

}

void CFRAMStatePacket::GetDateTimeStringFromUnixTime(char* datestr)
{
	time_t utime = (time_t)unixtime;
	int mydayofweek = weekday(utime) - 1;  //returns 1 for Sunday, 7 for Saturday
	mydayofweek = (mydayofweek < 0) ? 0 : mydayofweek; //guard for return of 0 from weekday()
	int myday = day(utime);
	int mymonth = month(utime);
	int myyear = year(utime);
	int myhour = hour(utime);
	int mymin = minute(utime);
	int mysec = second(utime);
	char* dayofweek = daysOfTheWeek[mydayofweek];

	sprintf(datestr, "%02d:%02d:%02d %02d/%02d/%4d", myhour, mymin, mysec, mymonth, myday, myyear );
}


#endif

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

/* CCFRAMStatePacket class.

The CFRAMStatePacket class is intended to encapsulate code associated with

writing Wall-E2's telemetry to FRAM and reading it back again. This class

uses the Adafruit_FRAM_I2C library to actually communicate with the FRAM

via I2C. Methods are provided to set up a pointer to the Adafruit_FRAM_I2C

object, write/read telemetry packets to/from the FRAM, and print packets to

the serial console provided by the calling program.

This class assumes the calling program calls Serial.begin() and also provides

a StreamEx object called mySerial (typically 'StreamEx mySerial = Serial;').

It also assumes that the reference to this code file is placed *after* the

references to Wire.h, Adafruit_I2C.h, and PrintEx.h, and the instantiations

of StreamEx MySerial and Adafruit_FRAM_I2C fram. The typical setup would be

something like:

#include <Wire.h>

#include "Adafruit_FRAM_I2C.h"

#include <RTClib.h>;

#include <time.h>;

#include <PrintEx.h>

#include <elapsedMillis/elapsedMillis.h>

#include <Time-master/time.h>

//#include <math.h>

StreamEx mySerial = Serial;

elapsedMillis mSecSinceLastPacketWrite;

Adafruit_FRAM_I2C fram = Adafruit_FRAM_I2C();

const int FIRST_PKT_STORAGE_ADDR = 2;//addr 0/1 reserved for nextFramWriteAddr

int nextFramWriteAddr = FIRST_PKT_STORAGE_ADDR; //writing starts with this address

int prevDispFramEndAddr = FIRST_PKT_STORAGE_ADDR; //optional readback starts here

const int NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION = 0; //the next free address is written to this address

//FramPacket.h holds 'inline' definition of CFRAMStatePacket class

//this has to come after #include "Adafruit_FRAM_I2C.h" and Adafruit_FRAM_I2C fram = Adafruit_FRAM_I2C();

#include "FramPacket.h"

CFRAMStatePacket packet = CFRAMStatePacket(&fram); //this object is used for all FRAM transactions

//fwd declaration required to avoid '... does not name a type' error

CFRAMStatePacket GetNextSimFRAMPacket(CFRAMStatePacket pkt);

[rest of program...]

#pragma once

#ifndef FRAMSTATEPACKET_H

#define FRAMSTATEPACKET_H

#include "Adafruit_FRAM_I2C.h" //needed for pointer forward declaration

const char daysOfTheWeek[7][12] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };

class CFRAMStatePacket

{

public:

uint32_t unixtime;

byte mode;

byte submode;

byte leftdist;

byte rightdist;

byte fwddist;

byte batv;

const static int packet_size = 9;

bool bFramReady = false; //added 09/27/18

private:

Adafruit_FRAM_I2C* pfram;

public:

CFRAMStatePacket(uint32_t unixtime = 0, byte mode = 0, byte submode = 0, byte leftdist = 0,

byte rightdist = 0, byte fwddist = 0, byte batv = 0);

CFRAMStatePacket(Adafruit_FRAM_I2C* pfram, uint32_t unixtime = 0, byte mode = 0, byte submode = 0,

byte leftdist = 0, byte rightdist = 0, byte fwddist = 0, byte batv = 0);

void Print();

int Read(int addr); //reads packet from FRAM; returns next write addr

int Write(int addr); //writes packet to FRAM; returns next read addr

void SetFramPointer(Adafruit_FRAM_I2C* ptr);

int GetFramPointer();

void PrintHumanReadable(); //displays date & time vs unixtime

void CFRAMStatePacket::GetDateTimeStringFromUnixTime(char* str);

};

int CFRAMStatePacket::GetFramPointer()

{

return (int)pfram;

}

void CFRAMStatePacket::SetFramPointer(Adafruit_FRAM_I2C* ptr)

{

pfram = ptr;

}

CFRAMStatePacket::CFRAMStatePacket(uint32_t unixtime = 0, byte mode = 0, byte submode, byte leftdist = 0,

byte rightdist = 0, byte fwddist = 0, byte batv = 0)

{

//mySerial.printf("In CFRAMStatePacket default constructor\n");

}

CFRAMStatePacket::CFRAMStatePacket(Adafruit_FRAM_I2C* ptr, uint32_t unixtime = 0, byte mode = 0,

byte submode, byte leftdist = 0, byte rightdist = 0, byte fwddist = 0, byte batv = 0)

{

pfram = ptr;

}

void CFRAMStatePacket::Print()

{

mySerial.printf("%lu\t%d\t%d\t%d\t%d\t%d\t%d\n",

unixtime, mode, submode, leftdist, rightdist, fwddist, batv);

}

int CFRAMStatePacket::Write(int addr)

{

//Provenance: 09/09/18 G. Frank Paynter

//Purpose: Write a complete state packet to the FRAM at the specified address

// The telemetry packet is formatted as a 9 - byte packet :

// Time: 4 - bytes

// mode / submode : 1 byte

// left distance : 1 byte

// right distance : 1 byte

// forward distance : 1 byte

// battery voltage above 5V : 1 byte

//Inputs:

// addr = FRAM address to be written to

//Outputs:

// addr = address to be used for next FRAM write

//Plan:

// Step1: write each packet component to FRAM at addr, updating addr each time

//Notes:

//date/time - 4 bytes

unsigned long writeval = (unsigned long)unixtime;

int numbyteswritten = pfram->FRAM_I2C_writeAnything(addr, writeval);

unsigned long readval;

pfram->FRAM_I2C_readAnything(addr, readval);

addr += numbyteswritten;

//mode/submode - 1 bytes

byte combomode = (byte)(10 * mode + submode);

numbyteswritten = pfram->FRAM_I2C_writeAnything(addr, combomode);

addr += numbyteswritten;

//left dist - 1 bytes

numbyteswritten = pfram->FRAM_I2C_writeAnything(addr, leftdist);

addr += numbyteswritten;

//right dist - 1 bytes

numbyteswritten = pfram->FRAM_I2C_writeAnything(addr, rightdist);

addr += numbyteswritten;

//forward dist - 1 bytes

numbyteswritten = pfram->FRAM_I2C_writeAnything(addr, fwddist);

addr += numbyteswritten;

//batV - 1 bytes

numbyteswritten = pfram->FRAM_I2C_writeAnything(addr, batv);

addr += numbyteswritten;

return addr;

}

int CFRAMStatePacket::Read(int addr)

{

//Provenance: 09/09/18 G. Frank Paynter

//Purpose: read a complete state packet from the FRAM at the specified address

// The telemetry packet is formatted as a 9 - byte packet :

// Time: 4 - bytes

// mode / submode : 1 byte

// left distance : 1 byte

// right distance : 1 byte

// forward distance : 1 byte

// battery voltage above 5V : 1 byte

//Inputs:

// addr = FRAM address to be read from

//Outputs:

// addr = address to be used for next FRAM read

//Plan:

// Step1: read each packet component from FRAM at addr, updating addr each time

//Notes:

//mySerial.printf("In pkt.Read with address %d and Adafruit_FRAM_I2C* = %d\n", addr,pfram);

//unixtime

uint32_t utime;

pfram->FRAM_I2C_readAnything(addr, unixtime);

addr += sizeof( utime);

//mode, submode

byte combomode;

pfram->FRAM_I2C_readAnything(addr, combomode);

mode = combomode / 10; //integer truncation OK

submode = combomode - 10 * mode;

addr++;

//distances

pfram->FRAM_I2C_readAnything(addr, leftdist);

addr++;

pfram->FRAM_I2C_readAnything(addr, rightdist);

addr++;

pfram->FRAM_I2C_readAnything(addr, fwddist);

addr++;

//batt voltage

pfram->FRAM_I2C_readAnything(addr, batv);

addr++;

return addr;

}

void CFRAMStatePacket::PrintHumanReadable() //displays date & time vs unixtime

{

//Provenance: 10/01/18 G. Frank Paynter

//Purpose: print a complete state packet with the uint32_t unixtime property

// replaced by a human-readable date-time format.

//Inputs: None

//Outputs:

// packet contents sent to serial port, with date/time instead of unixtime

//Plan:

// Step1: print out the human-readable date/time instead of unixtime

// Step2: print the rest out as normal

//Notes:

//Step1: print out the human-readable date/time instead of unixtime

char datestr[40];

memset(datestr, 0, sizeof(datestr));

GetDateTimeStringFromUnixTime(datestr);

Serial.print(datestr); //can't use mySerial.printf() for some reason

//Step2: print the rest out as normal

mySerial.printf("\t%d\t%d\t%d\t%d\t%d\t%d\n",

mode, submode, leftdist, rightdist, fwddist, batv);

}

void CFRAMStatePacket::GetDateTimeStringFromUnixTime(char* datestr)

{

time_t utime = (time_t)unixtime;

int mydayofweek = weekday(utime) - 1; //returns 1 for Sunday, 7 for Saturday

mydayofweek = (mydayofweek < 0) ? 0 : mydayofweek; //guard for return of 0 from weekday()

int myday = day(utime);

int mymonth = month(utime);

int myyear = year(utime);

int myhour = hour(utime);

int mymin = minute(utime);

int mysec = second(utime);

char* dayofweek = daysOfTheWeek[mydayofweek];

sprintf(datestr, "%02d:%02d:%02d %02d/%02d/%4d", myhour, mymin, mysec, mymonth, myday, myyear );

}

#endif

To test my new CFRAMStatePacket class, I created a small test program that periodically writes simulated state packets to FRAM using the helper class methods, and optionally (if the user creates an interrupt by grounding the appropriate pin) reads them back out again. This program is designed to run on an Arduino Mega 2560. If a Uno is used, the interrupt pin number would have to be changed.

The test code also looks for a low on the CLEAR_FRAM_PIN (Pin 3) on startup. If it finds one, it will clear NUM_FRAM_BYTES_TO_CLEAR (currently 2000) FRAM bytes and then read them back out again, byte-by-byte. Otherwise, the program will continue storing state packets where it left off the last time it was powered up. Here’s the test code:

/*
    Name:       TelemPacketsToFromFRAM.ino
    Created:	9/9/2018 9:47:30 PM
    Author:     DESKTOP-0KFED77\Frank

	The purpose of this project is to develop the code needed to write
	encoded telemetry packets to the FRAM, and optionally read them 
	back out again in decoded form.

	The telemetry packet is formatted as a 10-byte packet:
		Time: 4-bytes
		mode/submode: 1 byte
		left distance: 1 byte
		right distance: 1 byte
		forward distance: 1 byte
		battery voltage above 5V: 1 byte

	This project makes use of the CFRAMStatePacket class, which is completely defined
	in FramPacket.h (no .cpp file - just the .h).  This class contains methods to read
	and write telemetry packets from/to an Adafruit FRAM breakout board, accessible through
	the Adafruit_FRAM_I2C library

	To use the CFRAMStatePacket class, an object is instantiated using a constructor that
	takes a single parameter - the address of the Adafruit_FRAM_I2C FRAM driver object. This
	pointer is then used for all interactions with the FRAM.
*/
#include <Wire.h>
#include "Adafruit_FRAM_I2C.h"
#include <RTClib.h>;
#include <time.h>;
#include <PrintEx.h>
#include <elapsedMillis/elapsedMillis.h>
#include <Time-master/time.h>

//#include <math.h>
StreamEx mySerial = Serial;
elapsedMillis mSecSinceLastPacketWrite;
Adafruit_FRAM_I2C fram = Adafruit_FRAM_I2C();

const int FIRST_PKT_STORAGE_ADDR = 2;//addr 0/1 reserved for nextFramWriteAddr
//const int FIRST_PKT_STORAGE_ADDR = 32000;//09/29/18 for rollover debug
int nextFramWriteAddr = FIRST_PKT_STORAGE_ADDR; //writing starts with this address
int prevDispFramEndAddr = FIRST_PKT_STORAGE_ADDR; //optional readback starts here
const int NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION = 0; //the next free address is written to this address
const int LAST_AVAIL_PACKET_WRITE_ADDR = 32759; //last packet write address avail in 256kb FRAM

//FramPacket.h holds 'inline' definition of CFRAMStatePacket class 
//this has to come after #include "Adafruit_FRAM_I2C.h" and Adafruit_FRAM_I2C fram = Adafruit_FRAM_I2C();
#include "FramPacket.h" 
CFRAMStatePacket packet = CFRAMStatePacket(&fram); //this object is used for all FRAM transactions

//fwd declaration required to avoid '... does not name a type' error
CFRAMStatePacket GetNextSimFRAMPacket(CFRAMStatePacket pkt); 

RTC_DS3231 rtc;
char daysOfTheWeek[7][12] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };

const int InterruptPin = 18; //pin used to trigger a readback of previously written packet
const int CLEAR_FRAM_PIN = 3;//holding this low at startup will clear NUM_FRAM_BYTES_TO_CLEAR FRAM bytes
const int NUM_FRAM_BYTES_TO_CLEAR = 2000; //don't clear the whole thing - takes too long
const int NUM_PACKETS_TO_DISPLAY = 10; //for 1st time packet display
//const unsigned long PACKET_WRITE_INTERVAL_MSEC = 1000; //once/sec for debug
const unsigned long PACKET_WRITE_INTERVAL_MSEC = 250; //4/sec for debug
bool InSetup = true; //used to prevent interrupts during setup
bool bFirstPacketWrite = true;//used to print packet header the first time through
bool bInterrupt = false;//set true in myISR, reset in PACKET_WRITE_INTERVAL_MSEC section of loop() 


//These are the operation modes used by the Wall-E2 robot.  They are used here to
//simulate normal mode variations to verify proper encode/decode
enum OpModes
{
	MODE_NONE = 0, //04/04/17 chg from MODE_DEFAULT and moved to top (zero) position
	MODE_CHARGING,
	MODE_IRHOMING,
	MODE_WALLFOLLOW,
	MODE_DEADBATTERY //added 01/16/18 to handle dead battery case
};

//01/05/16 added for open-corner following supp
const int DIST_AVG_WINDOW_SIZE = 3;
enum WallTrackingCases
{
	TRACKING_LEFT = 1,
	TRACKING_RIGHT,
	TRACKING_NEITHER
};

enum OpModes simOpMode = MODE_NONE;
enum WallTrackingCases simTrack = TRACKING_LEFT;
byte simLeftDist = 0;
byte simRightDist = 0;
byte simForwardDist = 0;
uint32_t simTime = 0;

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

	//initialize Adafruit DS3231 Real Time Clock
	mySerial.printf("Initializing RTC...\n");
	if (!rtc.begin()) {
		Serial.println("Couldn't find RTC");
		while (1);
	}

	if (rtc.lostPower())
	{
		DateTime dt = DateTime(F(__DATE__), F(__TIME__)); //__DATE__ & __TIME__ are environment variables)
		int mydayofweek = dt.dayOfTheWeek();  //returns 0 for Sunday, 7 for Saturday
		int mymonth = dt.month();
		int myday = dt.day();
		int myyear = dt.year();
		int myhour = dt.hour();
		int mymin = dt.minute();
		int mysec = dt.second();
		long unixtime = dt.unixtime();
		char* dayofweek = daysOfTheWeek[mydayofweek];


		mySerial.printf("RTC lost power - setting to datetime of last compile %ld (%s %4d/%02d/%02d at %02d:%02d:%02d)\n",
			dt.unixtime(), daysOfTheWeek[dt.dayOfTheWeek()], dt.year(), dt.month(), dt.day(),
			dt.hour(), dt.minute(), dt.second());

		rtc.adjust(dt);
	}

	//initialize FRAM - this reads/checks FRAM device IDs to confirm valid connection
	mySerial.printf("Initializing FRAM...\n");
	if (fram.begin()) // you can stick the new i2c addr in here, e.g. begin(0x51);
	{  
		Serial.println("Found I2C FRAM");
	}
	else
	{
		Serial.println("I2C FRAM not identified ... check your connections?\r\n");
		Serial.println("Will continue in case this processor doesn't support repeated start\r\n");
	}

	// Read the stored nextFramWriteAddr value from the first two bytes
	fram.FRAM_I2C_readAnything(NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION, nextFramWriteAddr);
	mySerial.printf("read nextFramWriteAddr %d from address %d\n", nextFramWriteAddr, NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION);

	pinMode(InterruptPin, INPUT_PULLUP);
	pinMode(CLEAR_FRAM_PIN, INPUT_PULLUP);
	int intnum = digitalPinToInterrupt(InterruptPin);
	mySerial.printf("Using interrupt number %d, pin %d\n", intnum, InterruptPin);
	attachInterrupt(intnum, myISR, FALLING);
	interrupts();

	//to clear the first NUM_FRAM_BYTES_TO_CLEAR FRAM locations, hold this pin low at startup
	if (digitalRead(CLEAR_FRAM_PIN) == LOW)
	{
		Serial.print("Clearing "); Serial.print(NUM_FRAM_BYTES_TO_CLEAR); Serial.println(" FRAM addresses...");
		byte clearval = 0;
		for (size_t i = 0; i < NUM_FRAM_BYTES_TO_CLEAR; i++)
		{
			fram.FRAM_I2C_writeAnything(i, clearval);
		}

		mySerial.printf("Setting NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION (%d) to FIRST_PKT_STORAGE_ADDR (%d)\n",
			NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION, FIRST_PKT_STORAGE_ADDR);
		fram.FRAM_I2C_writeAnything(NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION, FIRST_PKT_STORAGE_ADDR);
		nextFramWriteAddr = FIRST_PKT_STORAGE_ADDR; //this is the only place it gets set - otherwise it is retrieved from the FRAM at address 1

		//now read them back
		DisplayFRAMBytes(NUM_FRAM_BYTES_TO_CLEAR);
	}
	else
	{
		int displayendaddr = NUM_PACKETS_TO_DISPLAY * CFRAMStatePacket::packet_size + FIRST_PKT_STORAGE_ADDR;
		DisplayFRAMPackets(FIRST_PKT_STORAGE_ADDR, displayendaddr);
	}

	Serial.print("Enabling ISR, Entering Loop()");
	mSecSinceLastPacketWrite = 0; //reset just before loop()
	InSetup = false; //enable power-down ISR
	bInterrupt = false;
}

void loop()
{
	if (mSecSinceLastPacketWrite >= PACKET_WRITE_INTERVAL_MSEC)
	{
		mSecSinceLastPacketWrite -= PACKET_WRITE_INTERVAL_MSEC;

		//check for interrupt.  If active, display packets written since last time
		if (bInterrupt)
		{
			//09/29/18 have to watch for prevDispFramEndAddr > nextFramWriteAddr
			if (prevDispFramEndAddr > nextFramWriteAddr)
			{
				prevDispFramEndAddr = nextFramWriteAddr;
			}
			DisplayFRAMPackets(prevDispFramEndAddr, nextFramWriteAddr);
			prevDispFramEndAddr = nextFramWriteAddr; //added 09/28/18
			bInterrupt = false;
		}

		packet = GetNextSimFRAMPacket(packet); //update packet contents
		if (bFirstPacketWrite)
		{
			mySerial.printf("addr\tunixtime\t\tmode\tsubmode\tLdist\tRdist\tFdist\tbatV\n");
			bFirstPacketWrite = false;
		}

		//check for FRAM address rollover - reset to first write address if necessary
		if (nextFramWriteAddr >= LAST_AVAIL_PACKET_WRITE_ADDR)
		{
			nextFramWriteAddr = FIRST_PKT_STORAGE_ADDR;
		}

		mySerial.printf("%d\t", nextFramWriteAddr); //puts fram addr in front of each packet readout
		packet.Print();
		nextFramWriteAddr = packet.Write(nextFramWriteAddr); //actually write the packet to FRAM
		fram.FRAM_I2C_writeAnything(NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION, nextFramWriteAddr); //update stored nextFramWriteAddr
	}
}

//not used, but left here for possible future use
void DisplayFRAMTimes(int startaddr, int endaddr)
{
	time_t utime;
	int numtimes = endaddr / sizeof(utime);
	mySerial.printf("\nDisplaying first %d stored times starting at %d\n", numtimes, startaddr);
	for (uint16_t i = 0; i < numtimes; i++)
	{
		int addr = startaddr + i * sizeof(utime);
		//int numbytes = fram.FRAM_I2C_readAnything(addr, utime);
		int mydayofweek = weekday(utime) - 1;  //returns 1 for Sunday, 7 for Saturday
		mydayofweek = (mydayofweek < 0) ? 0 : mydayofweek; //guard for return of 0 from weekday()
		int myday = day(utime);
		int mymonth = month(utime);
		int myyear = year(utime);
		int myhour = hour(utime);
		int mymin = minute(utime);
		int mysec = second(utime);
		char* dayofweek = daysOfTheWeek[mydayofweek];

		mySerial.printf("read %ld (%s %4d/%02d/%02d at %02d:%02d:%02d) from FRAM location %d\n",
			utime, dayofweek, myyear, mymonth, myday, myhour, mymin, mysec, addr);
	}
}

void DisplayFRAMBytes(int lastAddr)
{
	Serial.print("\nDisplaying memory locations 0 to "); Serial.println(lastAddr);
	uint8_t value;
	for (uint16_t a = 0; a < lastAddr; a++)
	{
		if ((a % 16) == 0)
		{
			Serial.print("\n 0x"); Serial.print(a, HEX); Serial.print(": ");
		}
		Serial.print("0x");
		if (value < 0x1)
			Serial.print('0');
		Serial.print(value, HEX); Serial.print(" ");
	}
	Serial.println();
}

void myISR()
{
	bInterrupt = true;
}

CFRAMStatePacket GetNextSimFRAMPacket(CFRAMStatePacket pkt)
{
	DateTime dt = rtc.now();
	pkt.leftdist = GetNextSimLeftDist(pkt.leftdist);
	pkt.rightdist = GetNextSimRightDist(pkt.rightdist);
	pkt.fwddist = GetNextSimFwdDist(pkt.leftdist); //uses leftdist to calc fwddist
	pkt.mode = GetNextSimMode(pkt.mode);
	pkt.submode = GetNextSimTrack(pkt.submode);
	pkt.unixtime = (uint32_t)dt.unixtime();

	return pkt;
}

int GetNextSimLeftDist(int leftdist)
{
	//zero to 200 sawtooth
	int simdist = (leftdist >= 200) ? 0 : ++leftdist;
	return simdist;
}

int GetNextSimRightDist(int rightdist)
{
	//200 to zero sawtooth
	int simdist = (rightdist <= 0) ? 200 : --rightdist;
	return simdist;
}

int GetNextSimFwdDist(int leftdist)
{
	//uses leftdist to calc new point on sine curve
	//zero to 200 sinewave
	float rads = PI*(float)leftdist/100.f;
	int simdist = 100 + (int)(100 * sin(rads));
	return simdist;
}

int GetNextSimMode(int opmode)
{
	switch (opmode)
	{
	case MODE_NONE:
		opmode = MODE_CHARGING;
		break;
	case MODE_CHARGING:
		opmode = MODE_IRHOMING;
		break;
	case MODE_IRHOMING:
		opmode = MODE_WALLFOLLOW;
		break;
	case MODE_WALLFOLLOW:
		opmode = MODE_DEADBATTERY;
		break;
	case MODE_DEADBATTERY:
		opmode = MODE_CHARGING;
		break;
	default:
		mySerial.printf("hit default case in GetNextSimMode()\n");
		opmode = MODE_NONE;
		break;
	}
	return (int)opmode;
}

int GetNextSimTrack(int trackmode)
{
	switch (trackmode)
	{
	case 0:
		trackmode = TRACKING_LEFT;
		break;
	case TRACKING_LEFT:
		trackmode = TRACKING_RIGHT;
		break;
	case TRACKING_RIGHT:
		trackmode = TRACKING_NEITHER;
		break;
	case TRACKING_NEITHER:
		trackmode = TRACKING_LEFT;
		break;
	default:
		mySerial.printf("hit default case in GetNextSimTrack()\n");
		trackmode = 0;
		break;
	}
	return (int)trackmode;
}

void DisplayFRAMPackets(int nextreadaddr, int nextwriteaddr)
{
	//Purpose:  Read complete state packets from the FRAM between the specified addresses
	//	The telemetry packet is formatted as a 10 - byte packet :
	//		Time: 4 - bytes
	//		mode / submode : 1 byte
	//		left distance : 1 byte
	//		right distance : 1 byte
	//		forward distance : 1 byte
	//		battery voltage above 5V : 1 byte
	//Inputs:
	//	nextreadaddr = 1st address to be read
	//	nextwriteaddr = next available address for writes
	//Notes:
	//	09/28/18 c/o prevDispFramEndAddr = nextwriteaddr - 1; now done in calling pgm


	int numpackets = 1 + (nextwriteaddr - nextreadaddr - 1) / CFRAMStatePacket::packet_size;
	mySerial.printf("\ndisplaying %d packets, from address %d to address %d\n", numpackets, nextreadaddr, nextwriteaddr - 1);

	mySerial.printf("addr\tunixtime\t\tmode\tsubmode\tLdist\tRdist\tFdist\tbatV\n");

	for (int i = 0; i < numpackets; i++)
	{
		mySerial.printf("%d\t", nextreadaddr); //puts fram addr in front of each packet readout
		nextreadaddr = packet.Read(nextreadaddr);
		packet.Print();
	}
	mySerial.printf("---------------- Done!-----------------\n\n");
	mySerial.printf("addr\tunixtime\t\tmode\tsubmode\tLdist\tRdist\tFdist\tbatV\n");
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

Name: TelemPacketsToFromFRAM.ino

Created: 9/9/2018 9:47:30 PM

Author: DESKTOP-0KFED77\Frank

The purpose of this project is to develop the code needed to write

encoded telemetry packets to the FRAM, and optionally read them

back out again in decoded form.

The telemetry packet is formatted as a 10-byte packet:

Time: 4-bytes

mode/submode: 1 byte

left distance: 1 byte

right distance: 1 byte

forward distance: 1 byte

battery voltage above 5V: 1 byte

This project makes use of the CFRAMStatePacket class, which is completely defined

in FramPacket.h (no .cpp file - just the .h). This class contains methods to read

and write telemetry packets from/to an Adafruit FRAM breakout board, accessible through

the Adafruit_FRAM_I2C library

To use the CFRAMStatePacket class, an object is instantiated using a constructor that

takes a single parameter - the address of the Adafruit_FRAM_I2C FRAM driver object. This

pointer is then used for all interactions with the FRAM.

#include <Wire.h>

#include "Adafruit_FRAM_I2C.h"

#include <RTClib.h>;

#include <time.h>;

#include <PrintEx.h>

#include <elapsedMillis/elapsedMillis.h>

#include <Time-master/time.h>

//#include <math.h>

StreamEx mySerial = Serial;

elapsedMillis mSecSinceLastPacketWrite;

Adafruit_FRAM_I2C fram = Adafruit_FRAM_I2C();

const int FIRST_PKT_STORAGE_ADDR = 2;//addr 0/1 reserved for nextFramWriteAddr

//const int FIRST_PKT_STORAGE_ADDR = 32000;//09/29/18 for rollover debug

int nextFramWriteAddr = FIRST_PKT_STORAGE_ADDR; //writing starts with this address

int prevDispFramEndAddr = FIRST_PKT_STORAGE_ADDR; //optional readback starts here

const int NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION = 0; //the next free address is written to this address

const int LAST_AVAIL_PACKET_WRITE_ADDR = 32759; //last packet write address avail in 256kb FRAM

//FramPacket.h holds 'inline' definition of CFRAMStatePacket class

//this has to come after #include "Adafruit_FRAM_I2C.h" and Adafruit_FRAM_I2C fram = Adafruit_FRAM_I2C();

#include "FramPacket.h"

CFRAMStatePacket packet = CFRAMStatePacket(&fram); //this object is used for all FRAM transactions

//fwd declaration required to avoid '... does not name a type' error

CFRAMStatePacket GetNextSimFRAMPacket(CFRAMStatePacket pkt);

RTC_DS3231 rtc;

char daysOfTheWeek[7][12] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };

const int InterruptPin = 18; //pin used to trigger a readback of previously written packet

const int CLEAR_FRAM_PIN = 3;//holding this low at startup will clear NUM_FRAM_BYTES_TO_CLEAR FRAM bytes

const int NUM_FRAM_BYTES_TO_CLEAR = 2000; //don't clear the whole thing - takes too long

const int NUM_PACKETS_TO_DISPLAY = 10; //for 1st time packet display

//const unsigned long PACKET_WRITE_INTERVAL_MSEC = 1000; //once/sec for debug

const unsigned long PACKET_WRITE_INTERVAL_MSEC = 250; //4/sec for debug

bool InSetup = true; //used to prevent interrupts during setup

bool bFirstPacketWrite = true;//used to print packet header the first time through

bool bInterrupt = false;//set true in myISR, reset in PACKET_WRITE_INTERVAL_MSEC section of loop()

//These are the operation modes used by the Wall-E2 robot. They are used here to

//simulate normal mode variations to verify proper encode/decode

enum OpModes

{

MODE_NONE = 0, //04/04/17 chg from MODE_DEFAULT and moved to top (zero) position

MODE_CHARGING,

MODE_IRHOMING,

MODE_WALLFOLLOW,

MODE_DEADBATTERY //added 01/16/18 to handle dead battery case

};

//01/05/16 added for open-corner following supp

const int DIST_AVG_WINDOW_SIZE = 3;

enum WallTrackingCases

{

TRACKING_LEFT = 1,

TRACKING_RIGHT,

TRACKING_NEITHER

};

enum OpModes simOpMode = MODE_NONE;

enum WallTrackingCases simTrack = TRACKING_LEFT;

byte simLeftDist = 0;

byte simRightDist = 0;

byte simForwardDist = 0;

uint32_t simTime = 0;

void setup()

{

Serial.begin(115200);

//initialize Adafruit DS3231 Real Time Clock

mySerial.printf("Initializing RTC...\n");

if (!rtc.begin()) {

Serial.println("Couldn't find RTC");

while (1);

}

if (rtc.lostPower())

{

DateTime dt = DateTime(F(__DATE__), F(__TIME__)); //__DATE__ & __TIME__ are environment variables)

int mydayofweek = dt.dayOfTheWeek(); //returns 0 for Sunday, 7 for Saturday

int mymonth = dt.month();

int myday = dt.day();

int myyear = dt.year();

int myhour = dt.hour();

int mymin = dt.minute();

int mysec = dt.second();

long unixtime = dt.unixtime();

char* dayofweek = daysOfTheWeek[mydayofweek];

mySerial.printf("RTC lost power - setting to datetime of last compile %ld (%s %4d/%02d/%02d at %02d:%02d:%02d)\n",

dt.unixtime(), daysOfTheWeek[dt.dayOfTheWeek()], dt.year(), dt.month(), dt.day(),

dt.hour(), dt.minute(), dt.second());

rtc.adjust(dt);

}

//initialize FRAM - this reads/checks FRAM device IDs to confirm valid connection

mySerial.printf("Initializing FRAM...\n");

if (fram.begin()) // you can stick the new i2c addr in here, e.g. begin(0x51);

{

Serial.println("Found I2C FRAM");

}

else

{

Serial.println("I2C FRAM not identified ... check your connections?\r\n");

Serial.println("Will continue in case this processor doesn't support repeated start\r\n");

}

// Read the stored nextFramWriteAddr value from the first two bytes

fram.FRAM_I2C_readAnything(NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION, nextFramWriteAddr);

mySerial.printf("read nextFramWriteAddr %d from address %d\n", nextFramWriteAddr, NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION);

pinMode(InterruptPin, INPUT_PULLUP);

pinMode(CLEAR_FRAM_PIN, INPUT_PULLUP);

int intnum = digitalPinToInterrupt(InterruptPin);

mySerial.printf("Using interrupt number %d, pin %d\n", intnum, InterruptPin);

attachInterrupt(intnum, myISR, FALLING);

interrupts();

//to clear the first NUM_FRAM_BYTES_TO_CLEAR FRAM locations, hold this pin low at startup

if (digitalRead(CLEAR_FRAM_PIN) == LOW)

{

Serial.print("Clearing "); Serial.print(NUM_FRAM_BYTES_TO_CLEAR); Serial.println(" FRAM addresses...");

byte clearval = 0;

for (size_t i = 0; i < NUM_FRAM_BYTES_TO_CLEAR; i++)

{

fram.FRAM_I2C_writeAnything(i, clearval);

}

mySerial.printf("Setting NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION (%d) to FIRST_PKT_STORAGE_ADDR (%d)\n",

NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION, FIRST_PKT_STORAGE_ADDR);

fram.FRAM_I2C_writeAnything(NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION, FIRST_PKT_STORAGE_ADDR);

nextFramWriteAddr = FIRST_PKT_STORAGE_ADDR; //this is the only place it gets set - otherwise it is retrieved from the FRAM at address 1

//now read them back

DisplayFRAMBytes(NUM_FRAM_BYTES_TO_CLEAR);

}

else

{

int displayendaddr = NUM_PACKETS_TO_DISPLAY * CFRAMStatePacket::packet_size + FIRST_PKT_STORAGE_ADDR;

DisplayFRAMPackets(FIRST_PKT_STORAGE_ADDR, displayendaddr);

}

Serial.print("Enabling ISR, Entering Loop()");

mSecSinceLastPacketWrite = 0; //reset just before loop()

InSetup = false; //enable power-down ISR

bInterrupt = false;

}

void loop()

{

if (mSecSinceLastPacketWrite >= PACKET_WRITE_INTERVAL_MSEC)

{

mSecSinceLastPacketWrite -= PACKET_WRITE_INTERVAL_MSEC;

//check for interrupt. If active, display packets written since last time

if (bInterrupt)

{

//09/29/18 have to watch for prevDispFramEndAddr > nextFramWriteAddr

if (prevDispFramEndAddr > nextFramWriteAddr)

{

prevDispFramEndAddr = nextFramWriteAddr;

}

DisplayFRAMPackets(prevDispFramEndAddr, nextFramWriteAddr);

prevDispFramEndAddr = nextFramWriteAddr; //added 09/28/18

bInterrupt = false;

}

packet = GetNextSimFRAMPacket(packet); //update packet contents

if (bFirstPacketWrite)

{

mySerial.printf("addr\tunixtime\t\tmode\tsubmode\tLdist\tRdist\tFdist\tbatV\n");

bFirstPacketWrite = false;

}

//check for FRAM address rollover - reset to first write address if necessary

if (nextFramWriteAddr >= LAST_AVAIL_PACKET_WRITE_ADDR)

{

nextFramWriteAddr = FIRST_PKT_STORAGE_ADDR;

}

mySerial.printf("%d\t", nextFramWriteAddr); //puts fram addr in front of each packet readout

packet.Print();

nextFramWriteAddr = packet.Write(nextFramWriteAddr); //actually write the packet to FRAM

fram.FRAM_I2C_writeAnything(NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION, nextFramWriteAddr); //update stored nextFramWriteAddr

}

//not used, but left here for possible future use

void DisplayFRAMTimes(int startaddr, int endaddr)

{

time_t utime;

int numtimes = endaddr / sizeof(utime);

mySerial.printf("\nDisplaying first %d stored times starting at %d\n", numtimes, startaddr);

for (uint16_t i = 0; i < numtimes; i++)

{

int addr = startaddr + i * sizeof(utime);

//int numbytes = fram.FRAM_I2C_readAnything(addr, utime);

int mydayofweek = weekday(utime) - 1; //returns 1 for Sunday, 7 for Saturday

mydayofweek = (mydayofweek < 0) ? 0 : mydayofweek; //guard for return of 0 from weekday()

int myday = day(utime);

int mymonth = month(utime);

int myyear = year(utime);

int myhour = hour(utime);

int mymin = minute(utime);

int mysec = second(utime);

char* dayofweek = daysOfTheWeek[mydayofweek];

mySerial.printf("read %ld (%s %4d/%02d/%02d at %02d:%02d:%02d) from FRAM location %d\n",

utime, dayofweek, myyear, mymonth, myday, myhour, mymin, mysec, addr);

}

void DisplayFRAMBytes(int lastAddr)

{

Serial.print("\nDisplaying memory locations 0 to "); Serial.println(lastAddr);

uint8_t value;

for (uint16_t a = 0; a < lastAddr; a++)

{

if ((a % 16) == 0)

{

Serial.print("\n 0x"); Serial.print(a, HEX); Serial.print(": ");

}

Serial.print("0x");

if (value < 0x1)

Serial.print('0');

Serial.print(value, HEX); Serial.print(" ");

}

Serial.println();

}

void myISR()

{

bInterrupt = true;

}

CFRAMStatePacket GetNextSimFRAMPacket(CFRAMStatePacket pkt)

{

DateTime dt = rtc.now();

pkt.leftdist = GetNextSimLeftDist(pkt.leftdist);

pkt.rightdist = GetNextSimRightDist(pkt.rightdist);

pkt.fwddist = GetNextSimFwdDist(pkt.leftdist); //uses leftdist to calc fwddist

pkt.mode = GetNextSimMode(pkt.mode);

pkt.submode = GetNextSimTrack(pkt.submode);

pkt.unixtime = (uint32_t)dt.unixtime();

return pkt;

}

int GetNextSimLeftDist(int leftdist)

{

//zero to 200 sawtooth

int simdist = (leftdist >= 200) ? 0 : ++leftdist;

return simdist;

}

int GetNextSimRightDist(int rightdist)

{

//200 to zero sawtooth

int simdist = (rightdist <= 0) ? 200 : --rightdist;

return simdist;

}

int GetNextSimFwdDist(int leftdist)

{

//uses leftdist to calc new point on sine curve

//zero to 200 sinewave

float rads = PI*(float)leftdist/100.f;

int simdist = 100 + (int)(100 * sin(rads));

return simdist;

}

int GetNextSimMode(int opmode)

{

switch (opmode)

{

case MODE_NONE:

opmode = MODE_CHARGING;

break;

case MODE_CHARGING:

opmode = MODE_IRHOMING;

break;

case MODE_IRHOMING:

opmode = MODE_WALLFOLLOW;

break;

case MODE_WALLFOLLOW:

opmode = MODE_DEADBATTERY;

break;

case MODE_DEADBATTERY:

opmode = MODE_CHARGING;

break;

default:

mySerial.printf("hit default case in GetNextSimMode()\n");

opmode = MODE_NONE;

break;

}

return (int)opmode;

}

int GetNextSimTrack(int trackmode)

{

switch (trackmode)

{

case 0:

trackmode = TRACKING_LEFT;

break;

case TRACKING_LEFT:

trackmode = TRACKING_RIGHT;

break;

case TRACKING_RIGHT:

trackmode = TRACKING_NEITHER;

break;

case TRACKING_NEITHER:

trackmode = TRACKING_LEFT;

break;

default:

mySerial.printf("hit default case in GetNextSimTrack()\n");

trackmode = 0;

break;

}

return (int)trackmode;

}

void DisplayFRAMPackets(int nextreadaddr, int nextwriteaddr)

{

//Purpose: Read complete state packets from the FRAM between the specified addresses

// The telemetry packet is formatted as a 10 - byte packet :

// Time: 4 - bytes

// mode / submode : 1 byte

// left distance : 1 byte

// right distance : 1 byte

// forward distance : 1 byte

// battery voltage above 5V : 1 byte

//Inputs:

// nextreadaddr = 1st address to be read

// nextwriteaddr = next available address for writes

//Notes:

// 09/28/18 c/o prevDispFramEndAddr = nextwriteaddr - 1; now done in calling pgm

int numpackets = 1 + (nextwriteaddr - nextreadaddr - 1) / CFRAMStatePacket::packet_size;

mySerial.printf("\ndisplaying %d packets, from address %d to address %d\n", numpackets, nextreadaddr, nextwriteaddr - 1);

mySerial.printf("addr\tunixtime\t\tmode\tsubmode\tLdist\tRdist\tFdist\tbatV\n");

for (int i = 0; i < numpackets; i++)

{

mySerial.printf("%d\t", nextreadaddr); //puts fram addr in front of each packet readout

nextreadaddr = packet.Read(nextreadaddr);

packet.Print();

}

mySerial.printf("---------------- Done!-----------------\n\n");

mySerial.printf("addr\tunixtime\t\tmode\tsubmode\tLdist\tRdist\tFdist\tbatV\n");

}

And here’s some output from a typical run:

Opening port
Port open
Initializing RTC...
Initializing FRAM...
Found I2C FRAM
read nextFramWriteAddr 8255 from address 0
Using interrupt number 5, pin 18

displaying 10 packets, from address 2 to address 91
addr	unixtime		mode	submode	Ldist	Rdist	Fdist	batV
2	1538191317	2	1	166	35	13	0
11	1538191317	3	2	167	34	14	0
20	1538191318	4	3	168	33	16	0
29	1538191318	1	1	169	32	18	0
38	1538191318	2	2	170	31	20	0
47	1538191318	3	3	171	30	21	0
56	1538191319	4	1	172	29	23	0
65	1538191319	1	2	173	28	25	0
74	1538191319	2	3	174	27	28	0
83	1538191319	3	1	175	26	30	0
---------------- Done!-----------------

addr	unixtime		mode	submode	Ldist	Rdist	Fdist	batV
Enabling ISR, Entering Loop()addr	unixtime		mode	submode	Ldist	Rdist	Fdist	batV
8255	1538191560	4	2	176	25	32	0
8264	1538191560	1	3	177	24	34	0
8273	1538191560	2	1	178	23	37	0
8282	1538191561	3	2	179	22	39	0
8291	1538191561	4	3	180	21	42	0
8300	1538191561	1	1	181	20	44	0
8309	1538191561	2	2	182	19	47	0
8318	1538191562	3	3	183	18	50	0
8327	1538191562	4	1	184	17	52	0
8336	1538191562	1	2	185	16	55	0
8345	1538191562	2	3	186	15	58	0
8354	1538191563	3	1	187	14	61	0
8363	1538191563	4	2	188	13	64	0
8372	1538191563	1	3	189	12	67	0
8381	1538191563	2	1	190	11	70	0
8390	1538191564	3	2	191	10	73	0
8399	1538191564	4	3	192	9	76	0
8408	1538191564	1	1	193	8	79	0
8417	1538191564	2	2	194	7	82	0
8426	1538191565	3	3	195	6	85	0
8435	1538191565	4	1	196	5	88	0
8444	1538191565	1	2	197	4	91	0
8453	1538191565	2	3	198	3	94	0
8462	1538191566	3	1	199	2	97	0
8471	1538191566	4	2	200	1	100	0
8480	1538191566	1	3	0	0	100	0
8489	1538191566	2	1	1	200	103	0
8498	1538191567	3	2	2	199	106	0
8507	1538191567	4	3	3	198	109	0
8516	1538191567	1	1	4	197	112	0
8525	1538191567	2	2	5	196	115	0
8534	1538191568	3	3	6	195	118	0
8543	1538191568	4	1	7	194	121	0
8552	1538191568	1	2	8	193	124	0
8561	1538191568	2	3	9	192	127	0
8570	1538191569	3	1	10	191	130	0
8579	1538191569	4	2	11	190	133	0
8588	1538191569	1	3	12	189	136	0
8597	1538191569	2	1	13	188	139	0
8606	1538191570	3	2	14	187	142	0
8615	1538191570	4	3	15	186	145	0
8624	1538191570	1	1	16	185	148	0
8633	1538191570	2	2	17	184	150	0
8642	1538191571	3	3	18	183	153	0
8651	1538191571	4	1	19	182	156	0
8660	1538191571	1	2	20	181	158	0
8669	1538191571	2	3	21	180	161	0
8678	1538191572	3	1	22	179	163	0
8687	1538191572	4	2	23	178	166	0
8696	1538191572	1	3	24	177	168	0
8705	1538191572	2	1	25	176	170	0
8714	1538191573	3	2	26	175	172	0
8723	1538191573	4	3	27	174	175	0
8732	1538191573	1	1	28	173	177	0
8741	1538191573	2	2	29	172	179	0
8750	1538191574	3	3	30	171	180	0
8759	1538191574	4	1	31	170	182	0
8768	1538191574	1	2	32	169	184	0
8777	1538191574	2	3	33	168	186	0
8786	1538191575	3	1	34	167	187	0
8795	1538191575	4	2	35	166	189	0
8804	1538191575	1	3	36	165	190	0
8813	1538191575	2	1	37	164	191	0
8822	1538191576	3	2	38	163	192	0
8831	1538191576	4	3	39	162	194	0
8840	1538191576	1	1	40	161	195	0
8849	1538191576	2	2	41	160	196	0
8858	1538191577	3	3	42	159	196	0
8867	1538191577	4	1	43	158	197	0
8876	1538191577	1	2	44	157	198	0
8885	1538191577	2	3	45	156	198	0
8894	1538191578	3	1	46	155	199	0
8903	1538191578	4	2	47	154	199	0
8912	1538191578	1	3	48	153	199	0
8921	1538191578	2	1	49	152	199	0
8930	1538191579	3	2	50	151	200	0
8939	1538191579	4	3	51	150	199	0
8948	1538191579	1	1	52	149	199	0
8957	1538191579	2	2	53	148	199	0
8966	1538191580	3	3	54	147	199	0
8975	1538191580	4	1	55	146	198	0
8984	1538191580	1	2	56	145	198	0
8993	1538191580	2	3	57	144	197	0
9002	1538191581	3	1	58	143	196	0
9011	1538191581	4	2	59	142	196	0
9020	1538191581	1	3	60	141	195	0
9029	1538191581	2	1	61	140	194	0
9038	1538191582	3	2	62	139	192	0
9047	1538191582	4	3	63	138	191	0
9056	1538191582	1	1	64	137	190	0
9065	1538191582	2	2	65	136	189	0
9074	1538191583	3	3	66	135	187	0
9083	1538191583	4	1	67	134	186	0
9092	1538191583	1	2	68	133	184	0
9101	1538191583	2	3	69	132	182	0
9110	1538191584	3	1	70	131	180	0
9119	1538191584	4	2	71	130	179	0
9128	1538191584	1	3	72	129	177	0
9137	1538191584	2	1	73	128	175	0
9146	1538191585	3	2	74	127	172	0
9155	1538191585	4	3	75	126	170	0
9164	1538191585	1	1	76	125	168	0
9173	1538191585	2	2	77	124	166	0
9182	1538191586	3	3	78	123	163	0
9191	1538191586	4	1	79	122	161	0
9200	1538191586	1	2	80	121	158	0
9209	1538191586	2	3	81	120	156	0
9218	1538191587	3	1	82	119	153	0
9227	1538191587	4	2	83	118	150	0
9236	1538191587	1	3	84	117	148	0
9245	1538191587	2	1	85	116	145	0
9254	1538191588	3	2	86	115	142	0
9263	1538191588	4	3	87	114	139	0
9272	1538191588	1	1	88	113	136	0
9281	1538191588	2	2	89	112	133	0
9290	1538191589	3	3	90	111	130	0
9299	1538191589	4	1	91	110	127	0
9308	1538191589	1	2	92	109	124	0
9317	1538191589	2	3	93	108	121	0
9326	1538191590	3	1	94	107	118	0
9335	1538191590	4	2	95	106	115	0
9344	1538191590	1	3	96	105	112	0
9353	1538191590	2	1	97	104	109	0
9362	1538191591	3	2	98	103	106	0
9371	1538191591	4	3	99	102	103	0
9380	1538191591	1	1	100	101	100	0
9389	1538191591	2	2	101	100	97	0
9398	1538191592	3	3	102	99	94	0
9407	1538191592	4	1	103	98	91	0
9416	1538191592	1	2	104	97	88	0
9425	1538191592	2	3	105	96	85	0
9434	1538191593	3	1	106	95	82	0
9443	1538191593	4	2	107	94	79	0
9452	1538191593	1	3	108	93	76	0
9461	1538191593	2	1	109	92	73	0
9470	1538191594	3	2	110	91	70	0
9479	1538191594	4	3	111	90	67	0
9488	1538191594	1	1	112	89	64	0
9497	1538191594	2	2	113	88	61	0
9506	1538191595	3	3	114	87	58	0
9515	1538191595	4	1	115	86	55	0
9524	1538191595	1	2	116	85	52	0
9533	1538191595	2	3	117	84	50	0
9542	1538191596	3	1	118	83	47	0
9551	1538191596	4	2	119	82	44	0
9560	1538191596	1	3	120	81	42	0
9569	1538191596	2	1	121	80	39	0
9578	1538191597	3	2	122	79	37	0
9587	1538191597	4	3	123	78	34	0
9596	1538191597	1	1	124	77	32	0
9605	1538191597	2	2	125	76	30	0
9614	1538191598	3	3	126	75	28	0
9623	1538191598	4	1	127	74	25	0
9632	1538191598	1	2	128	73	23	0
9641	1538191598	2	3	129	72	21	0
9650	1538191599	3	1	130	71	20	0
9659	1538191599	4	2	131	70	18	0
9668	1538191599	1	3	132	69	16	0
9677	1538191599	2	1	133	68	14	0
9686	1538191600	3	2	134	67	13	0
9695	1538191600	4	3	135	66	11	0
9704	1538191600	1	1	136	65	10	0
9713	1538191600	2	2	137	64	9	0
9722	1538191601	3	3	138	63	8	0
9731	1538191601	4	1	139	62	6	0
9740	1538191601	1	2	140	61	5	0
9749	1538191601	2	3	141	60	4	0
9758	1538191602	3	1	142	59	4	0
9767	1538191602	4	2	143	58	3	0
9776	1538191602	1	3	144	57	2	0
9785	1538191602	2	1	145	56	2	0
9794	1538191603	3	2	146	55	1	0
9803	1538191603	4	3	147	54	1	0
9812	1538191603	1	1	148	53	1	0
9821	1538191603	2	2	149	52	1	0
9830	1538191604	3	3	150	51	0	0
9839	1538191604	4	1	151	50	1	0
9848	1538191604	1	2	152	49	1	0
9857	1538191604	2	3	153	48	1	0
9866	1538191605	3	1	154	47	1	0
9875	1538191605	4	2	155	46	2	0
9884	1538191605	1	3	156	45	2	0
9893	1538191605	2	1	157	44	3	0
9902	1538191606	3	2	158	43	4	0
9911	1538191606	4	3	159	42	4	0
9920	1538191606	1	1	160	41	5	0
9929	1538191606	2	2	161	40	6	0
9938	1538191607	3	3	162	39	8	0
9947	1538191607	4	1	163	38	9	0
9956	1538191607	1	2	164	37	10	0
9965	1538191607	2	3	165	36	11	0
9974	1538191608	3	1	166	35	13	0
9983	1538191608	4	2	167	34	14	0
9992	1538191608	1	3	168	33	16	0
10001	1538191608	2	1	169	32	18	0
10010	1538191609	3	2	170	31	20	0
10019	1538191609	4	3	171	30	21	0
10028	1538191609	1	1	172	29	23	0
10037	1538191609	2	2	173	28	25	0
10046	1538191610	3	3	174	27	28	0
10055	1538191610	4	1	175	26	30	0
10064	1538191610	1	2	176	25	32	0
10073	1538191610	2	3	177	24	34	0
10082	1538191611	3	1	178	23	37	0
10091	1538191611	4	2	179	22	39	0
10100	1538191611	1	3	180	21	42	0
10109	1538191611	2	1	181	20	44	0
10118	1538191612	3	2	182	19	47	0
10127	1538191612	4	3	183	18	50	0
10136	1538191612	1	1	184	17	52	0
10145	1538191612	2	2	185	16	55	0
10154	1538191613	3	3	186	15	58	0
10163	1538191613	4	1	187	14	61	0
10172	1538191613	1	2	188	13	64	0
10181	1538191613	2	3	189	12	67	0
10190	1538191614	3	1	190	11	70	0
10199	1538191614	4	2	191	10	73	0
10208	1538191614	1	3	192	9	76	0
10217	1538191614	2	1	193	8	79	0
10226	1538191615	3	2	194	7	82	0
10235	1538191615	4	3	195	6	85	0
10244	1538191615	1	1	196	5	88	0
10253	1538191615	2	2	197	4	91	0
10262	1538191615	3	3	198	3	94	0
10271	1538191616	4	1	199	2	97	0
10280	1538191616	1	2	200	1	100	0
10289	1538191616	2	3	0	0	100	0
10298	1538191616	3	1	1	200	103	0
10307	1538191617	4	2	2	199	106	0
10316	1538191617	1	3	3	198	109	0
10325	1538191617	2	1	4	197	112	0
10334	1538191617	3	2	5	196	115	0
10343	1538191618	4	3	6	195	118	0
10352	1538191618	1	1	7	194	121	0
10361	1538191618	2	2	8	193	124	0
10370	1538191618	3	3	9	192	127	0
10379	1538191619	4	1	10	191	130	0
10388	1538191619	1	2	11	190	133	0
10397	1538191619	2	3	12	189	136	0
10406	1538191619	3	1	13	188	139	0
10415	1538191620	4	2	14	187	142	0
10424	1538191620	1	3	15	186	145	0
10433	1538191620	2	1	16	185	148	0
10442	1538191620	3	2	17	184	150	0
10451	1538191621	4	3	18	183	153	0
10460	1538191621	1	1	19	182	156	0
10469	1538191621	2	2	20	181	158	0
10478	1538191621	3	3	21	180	161	0
10487	1538191622	4	1	22	179	163	0
10496	1538191622	1	2	23	178	166	0
10505	1538191622	2	3	24	177	168	0
10514	1538191622	3	1	25	176	170	0
10523	1538191623	4	2	26	175	172	0
10532	1538191623	1	3	27	174	175	0
10541	1538191623	2	1	28	173	177	0
10550	1538191623	3	2	29	172	179	0
10559	1538191624	4	3	30	171	180	0
10568	1538191624	1	1	31	170	182	0
10577	1538191624	2	2	32	169	184	0
10586	1538191624	3	3	33	168	186	0
10595	1538191625	4	1	34	167	187	0
10604	1538191625	1	2	35	166	189	0
10613	1538191625	2	3	36	165	190	0
10622	1538191625	3	1	37	164	191	0
10631	1538191626	4	2	38	163	192	0
10640	1538191626	1	3	39	162	194	0
10649	1538191626	2	1	40	161	195	0
10658	1538191626	3	2	41	160	196	0
10667	1538191627	4	3	42	159	196	0
10676	1538191627	1	1	43	158	197	0
10685	1538191627	2	2	44	157	198	0
10694	1538191627	3	3	45	156	198	0
10703	1538191628	4	1	46	155	199	0
10712	1538191628	1	2	47	154	199	0
10721	1538191628	2	3	48	153	199	0
10730	1538191628	3	1	49	152	199	0
10739	1538191629	4	2	50	151	200	0
10748	1538191629	1	3	51	150	199	0
10757	1538191629	2	1	52	149	199	0
10766	1538191629	3	2	53	148	199	0
10775	1538191630	4	3	54	147	199	0
10784	1538191630	1	1	55	146	198	0
10793	1538191630	2	2	56	145	198	0
10802	1538191630	3	3	57	144	197	0
10811	1538191631	4	1	58	143	196	0
10820	1538191631	1	2	59	142	196	0
10829	1538191631	2	3	60	141	195	0
10838	1538191631	3	1	61	140	194	0
10847	1538191632	4	2	62	139	192	0
10856	1538191632	1	3	63	138	191	0
10865	1538191632	2	1	64	137	190	0
10874	1538191632	3	2	65	136	189	0
10883	1538191633	4	3	66	135	187	0
10892	1538191633	1	1	67	134	186	0
10901	1538191633	2	2	68	133	184	0
10910	1538191633	3	3	69	132	182	0
10919	1538191634	4	1	70	131	180	0
10928	1538191634	1	2	71	130	179	0
10937	1538191634	2	3	72	129	177	0
10946	1538191634	3	1	73	128	175	0
10955	1538191635	4	2	74	127	172	0
10964	1538191635	1	3	75	126	170	0
10973	1538191635	2	1	76	125	168	0
10982	1538191635	3	2	77	124	166	0
10991	1538191636	4	3	78	123	163	0
11000	1538191636	1	1	79	122	161	0
11009	1538191636	2	2	80	121	158	0
11018	1538191636	3	3	81	120	156	0
11027	1538191637	4	1	82	119	153	0
11036	1538191637	1	2	83	118	150	0
11045	1538191637	2	3	84	117	148	0
11054	1538191637	3	1	85	116	145	0
11063	1538191638	4	2	86	115	142	0
11072	1538191638	1	3	87	114	139	0
11081	1538191638	2	1	88	113	136	0
11090	1538191638	3	2	89	112	133	0
11099	1538191639	4	3	90	111	130	0
11108	1538191639	1	1	91	110	127	0
11117	1538191639	2	2	92	109	124	0
11126	1538191639	3	3	93	108	121	0
11135	1538191640	4	1	94	107	118	0
11144	1538191640	1	2	95	106	115	0
11153	1538191640	2	3	96	105	112	0
11162	1538191640	3	1	97	104	109	0
11171	1538191641	4	2	98	103	106	0
11180	1538191641	1	3	99	102	103	0
11189	1538191641	2	1	100	101	100	0
11198	1538191641	3	2	101	100	97	0
11207	1538191642	4	3	102	99	94	0
11216	1538191642	1	1	103	98	91	0
11225	1538191642	2	2	104	97	88	0
11234	1538191642	3	3	105	96	85	0
11243	1538191643	4	1	106	95	82	0
11252	1538191643	1	2	107	94	79	0
11261	1538191643	2	3	108	93	76	0
11270	1538191643	3	1	109	92	73	0
11279	1538191644	4	2	110	91	70	0
11288	1538191644	1	3	111	90	67	0
11297	1538191644	2	1	112	89	64	0
11306	1538191644	3	2	113	88	61	0
11315	1538191645	4	3	114	87	58	0
11324	1538191645	1	1	115	86	55	0
11333	1538191645	2	2	116	85	52	0
11342	1538191645	3	3	117	84	50	0
11351	1538191646	4	1	118	83	47	0
11360	1538191646	1	2	119	82	44	0
11369	1538191646	2	3	120	81	42	0
11378	1538191646	3	1	121	80	39	0
11387	1538191647	4	2	122	79	37	0
11396	1538191647	1	3	123	78	34	0
11405	1538191647	2	1	124	77	32	0
11414	1538191647	3	2	125	76	30	0
11423	1538191648	4	3	126	75	28	0
11432	1538191648	1	1	127	74	25	0
11441	1538191648	2	2	128	73	23	0
11450	1538191648	3	3	129	72	21	0
11459	1538191649	4	1	130	71	20	0
11468	1538191649	1	2	131	70	18	0
11477	1538191649	2	3	132	69	16	0
11486	1538191649	3	1	133	68	14	0
11495	1538191650	4	2	134	67	13	0
11504	1538191650	1	3	135	66	11	0
11513	1538191650	2	1	136	65	10	0
11522	1538191650	3	2	137	64	9	0
11531	1538191651	4	3	138	63	8	0
11540	1538191651	1	1	139	62	6	0
11549	1538191651	2	2	140	61	5	0
11558	1538191651	3	3	141	60	4	0
11567	1538191652	4	1	142	59	4	0
11576	1538191652	1	2	143	58	3	0
11585	1538191652	2	3	144	57	2	0
11594	1538191652	3	1	145	56	2	0
11603	1538191653	4	2	146	55	1	0
11612	1538191653	1	3	147	54	1	0
11621	1538191653	2	1	148	53	1	0
11630	1538191653	3	2	149	52	1	0
11639	1538191654	4	3	150	51	0	0
11648	1538191654	1	1	151	50	1	0
11657	1538191654	2	2	152	49	1	0
11666	1538191654	3	3	153	48	1	0
11675	1538191655	4	1	154	47	1	0
11684	1538191655	1	2	155	46	2	0
11693	1538191655	2	3	156	45	2	0
11702	1538191655	3	1	157	44	3	0
11711	1538191656	4	2	158	43	4	0
11720	1538191656	1	3	159	42	4	0
11729	1538191656	2	1	160	41	5	0
11738	1538191656	3	2	161	40	6	0
11747	1538191657	4	3	162	39	8	0
11756	1538191657	1	1	163	38	9	0
11765	1538191657	2	2	164	37	10	0
11774	1538191657	3	3	165	36	11	0
11783	1538191658	4	1	166	35	13	0
11792	1538191658	1	2	167	34	14	0
11801	1538191658	2	3	168	33	16	0
11810	1538191658	3	1	169	32	18	0
11819	1538191659	4	2	170	31	20	0
11828	1538191659	1	3	171	30	21	0
11837	1538191659	2	1	172	29	23	0
11846	1538191659	3	2	173	28	25	0
11855	1538191660	4	3	174	27	28	0
11864	1538191660	1	1	175	26	30	0
11873	1538191660	2	2	176	25	32	0
11882	1538191660	3	3	177	24	34	0
11891	1538191661	4	1	178	23	37	0
11900	1538191661	1	2	179	22	39	0
11909	1538191661	2	3	180	21	42	0
11918	1538191661	3	1	181	20	44	0
11927	1538191662	4	2	182	19	47	0
11936	1538191662	1	3	183	18	50	0
11945	1538191662	2	1	184	17	52	0
11954	1538191662	3	2	185	16	55	0
11963	1538191663	4	3	186	15	58	0
11972	1538191663	1	1	187	14	61	0
11981	1538191663	2	2	188	13	64	0
11990	1538191663	3	3	189	12	67	0
11999	1538191664	4	1	190	11	70	0
12008	1538191664	1	2	191	10	73	0
12017	1538191664	2	3	192	9	76	0
12026	1538191664	3	1	193	8	79	0
12035	1538191665	4	2	194	7	82	0
12044	1538191665	1	3	195	6	85	0
12053	1538191665	2	1	196	5	88	0
12062	1538191665	3	2	197	4	91	0
12071	1538191666	4	3	198	3	94	0
12080	1538191666	1	1	199	2	97	0
12089	1538191666	2	2	200	1	100	0
12098	1538191666	3	3	0	0	100	0
12107	1538191667	4	1	1	200	103	0
12116	1538191667	1	2	2	199	106	0
12125	1538191667	2	3	3	198	109	0
12134	1538191667	3	1	4	197	112	0
12143	1538191668	4	2	5	196	115	0
12152	1538191668	1	3	6	195	118	0
12161	1538191668	2	1	7	194	121	0
12170	1538191668	3	2	8	193	124	0
12179	1538191669	4	3	9	192	127	0
12188	1538191669	1	1	10	191	130	0
12197	1538191669	2	2	11	190	133	0
12206	1538191669	3	3	12	189	136	0
12215	1538191670	4	1	13	188	139	0
12224	1538191670	1	2	14	187	142	0
12233	1538191670	2	3	15	186	145	0
12242	1538191670	3	1	16	185	148	0
12251	1538191671	4	2	17	184	150	0
12260	1538191671	1	3	18	183	153	0
12269	1538191671	2	1	19	182	156	0
12278	1538191671	3	2	20	181	158	0
12287	1538191672	4	3	21	180	161	0
12296	1538191672	1	1	22	179	163	0
12305	1538191672	2	2	23	178	166	0
12314	1538191672	3	3	24	177	168	0
12323	1538191673	4	1	25	176	170	0
12332	1538191673	1	2	26	175	172	0
12341	1538191673	2	3	27	174	175	0
12350	1538191673	3	1	28	173	177	0
12359	1538191674	4	2	29	172	179	0
12368	1538191674	1	3	30	171	180	0
12377	1538191674	2	1	31	170	182	0
12386	1538191674	3	2	32	169	184	0
12395	1538191675	4	3	33	168	186	0
12404	1538191675	1	1	34	167	187	0
12413	1538191675	2	2	35	166	189	0
12422	1538191675	3	3	36	165	190	0
12431	1538191676	4	1	37	164	191	0
12440	1538191676	1	2	38	163	192	0
12449	1538191676	2	3	39	162	194	0
12458	1538191676	3	1	40	161	195	0
12467	1538191677	4	2	41	160	196	0
12476	1538191677	1	3	42	159	196	0
12485	1538191677	2	1	43	158	197	0
12494	1538191677	3	2	44	157	198	0
12503	1538191678	4	3	45	156	198	0
12512	1538191678	1	1	46	155	199	0
12521	1538191678	2	2	47	154	199	0
12530	1538191678	3	3	48	153	199	0
12539	1538191679	4	1	49	152	199	0
12548	1538191679	1	2	50	151	200	0
12557	1538191679	2	3	51	150	199	0
12566	1538191679	3	1	52	149	199	0
12575	1538191680	4	2	53	148	199	0
12584	1538191680	1	3	54	147	199	0
12593	1538191680	2	1	55	146	198	0
12602	1538191680	3	2	56	145	198	0
12611	1538191681	4	3	57	144	197	0
12620	1538191681	1	1	58	143	196	0
12629	1538191681	2	2	59	142	196	0
12638	1538191681	3	3	60	141	195	0
12647	1538191682	4	1	61	140	194	0
12656	1538191682	1	2	62	139	192	0
12665	1538191682	2	3	63	138	191	0
12674	1538191682	3	1	64	137	190	0
12683	1538191683	4	2	65	136	189	0
12692	1538191683	1	3	66	135	187	0
12701	1538191683	2	1	67	134	186	0
12710	1538191683	3	2	68	133	184	0
12719	1538191684	4	3	69	132	182	0
12728	1538191684	1	1	70	131	180	0
12737	1538191684	2	2	71	130	179	0
12746	1538191684	3	3	72	129	177	0
12755	1538191685	4	1	73	128	175	0
12764	1538191685	1	2	74	127	172	0
12773	1538191685	2	3	75	126	170	0
12782	1538191685	3	1	76	125	168	0
12791	1538191686	4	2	77	124	166	0
12800	1538191686	1	3	78	123	163	0
12809	1538191686	2	1	79	122	161	0
12818	1538191686	3	2	80	121	158	0
12827	1538191687	4	3	81	120	156	0
12836	1538191687	1	1	82	119	153	0
12845	1538191687	2	2	83	118	150	0
12854	1538191687	3	3	84	117	148	0
12863	1538191688	4	1	85	116	145	0
12872	1538191688	1	2	86	115	142	0
12881	1538191688	2	3	87	114	139	0
12890	1538191688	3	1	88	113	136	0
12899	1538191689	4	2	89	112	133	0
12908	1538191689	1	3	90	111	130	0
12917	1538191689	2	1	91	110	127	0
12926	1538191689	3	2	92	109	124	0
12935	1538191690	4	3	93	108	121	0
12944	1538191690	1	1	94	107	118	0
12953	1538191690	2	2	95	106	115	0
12962	1538191690	3	3	96	105	112	0
12971	1538191691	4	1	97	104	109	0
12980	1538191691	1	2	98	103	106	0
12989	1538191691	2	3	99	102	103	0
12998	1538191691	3	1	100	101	100	0
13007	1538191692	4	2	101	100	97	0
13016	1538191692	1	3	102	99	94	0
13025	1538191692	2	1	103	98	91	0
13034	1538191692	3	2	104	97	88	0
13043	1538191693	4	3	105	96	85	0
13052	1538191693	1	1	106	95	82	0
13061	1538191693	2	2	107	94	79	0
13070	1538191693	3	3	108	93	76	0
13079	1538191694	4	1	109	92	73	0
13088	1538191694	1	2	110	91	70	0
13097	1538191694	2	3	111	90	67	0
13106	1538191694	3	1	112	89	64	0
13115	1538191695	4	2	113	88	61	0
13124	1538191695	1	3	114	87	58	0
13133	1538191695	2	1	115	86	55	0
13142	1538191695	3	2	116	85	52	0
13151	1538191696	4	3	117	84	50	0
13160	1538191696	1	1	118	83	47	0
13169	1538191696	2	2	119	82	44	0
13178	1538191696	3	3	120	81	42	0
13187	1538191697	4	1	121	80	39	0
13196	1538191697	1	2	122	79	37	0
13205	1538191697	2	3	123	78	34	0
13214	1538191697	3	1	124	77	32	0
13223	1538191698	4	2	125	76	30	0
13232	1538191698	1	3	126	75	28	0
13241	1538191698	2	1	127	74	25	0
13250	1538191698	3	2	128	73	23	0
13259	1538191699	4	3	129	72	21	0
13268	1538191699	1	1	130	71	20	0
13277	1538191699	2	2	131	70	18	0
13286	1538191699	3	3	132	69	16	0
13295	1538191700	4	1	133	68	14	0
13304	1538191700	1	2	134	67	13	0
13313	1538191700	2	3	135	66	11	0
13322	1538191700	3	1	136	65	10	0
13331	1538191701	4	2	137	64	9	0
13340	1538191701	1	3	138	63	8	0
13349	1538191701	2	1	139	62	6	0
13358	1538191701	3	2	140	61	5	0
13367	1538191702	4	3	141	60	4	0
13376	1538191702	1	1	142	59	4	0
13385	1538191702	2	2	143	58	3	0
13394	1538191702	3	3	144	57	2	0
13403	1538191703	4	1	145	56	2	0
13412	1538191703	1	2	146	55	1	0
13421	1538191703	2	3	147	54	1	0
13430	1538191703	3	1	148	53	1	0
13439	1538191704	4	2	149	52	1	0
13448	1538191704	1	3	150	51	0	0
13457	1538191704	2	1	151	50	1	0
13466	1538191704	3	2	152	49	1	0
13475	1538191705	4	3	153	48	1	0
13484	1538191705	1	1	154	47	1	0
13493	1538191705	2	2	155	46	2	0
13502	1538191705	3	3	156	45	2	0
13511	1538191706	4	1	157	44	3	0
13520	1538191706	1	2	158	43	4	0
13529	1538191706	2	3	159	42	4	0
13538	1538191706	3	1	160	41	5	0
13547	1538191707	4	2	161	40	6	0
13556	1538191707	1	3	162	39	8	0
13565	1538191707	2	1	163	38	9	0
13574	1538191707	3	2	164	37	10	0
13583	1538191708	4	3	165	36	11	0
13592	1538191708	1	1	166	35	13	0
13601	1538191708	2	2	167	34	14	0
13610	1538191708	3	3	168	33	16	0
13619	1538191709	4	1	169	32	18	0
13628	1538191709	1	2	170	31	20	0
13637	1538191709	2	3	171	30	21	0
13646	1538191709	3	1	172	29	23	0
13655	1538191710	4	2	173	28	25	0
13664	1538191710	1	3	174	27	28	0
13673	1538191710	2	1	175	26	30	0
13682	1538191710	3	2	176	25	32	0
13691	1538191711	4	3	177	24	34	0
13700	1538191711	1	1	178	23	37	0
13709	1538191711	2	2	179	22	39	0
13718	1538191711	3	3	180	21	42	0
13727	1538191712	4	1	181	20	44	0
13736	1538191712	1	2	182	19	47	0
13745	1538191712	2	3	183	18	50	0
13754	1538191712	3	1	184	17	52	0
13763	1538191713	4	2	185	16	55	0
13772	1538191713	1	3	186	15	58	0
13781	1538191713	2	1	187	14	61	0
13790	1538191713	3	2	188	13	64	0
13799	1538191714	4	3	189	12	67	0
13808	1538191714	1	1	190	11	70	0
13817	1538191714	2	2	191	10	73	0
13826	1538191714	3	3	192	9	76	0
13835	1538191715	4	1	193	8	79	0
13844	1538191715	1	2	194	7	82	0
13853	1538191715	2	3	195	6	85	0
13862	1538191715	3	1	196	5	88	0
13871	1538191716	4	2	197	4	91	0
13880	1538191716	1	3	198	3	94	0
13889	1538191716	2	1	199	2	97	0
13898	1538191716	3	2	200	1	100	0
13907	1538191717	4	3	0	0	100	0
13916	1538191717	1	1	1	200	103	0
13925	1538191717	2	2	2	199	106	0
13934	1538191717	3	3	3	198	109	0
13943	1538191718	4	1	4	197	112	0
13952	1538191718	1	2	5	196	115	0
13961	1538191718	2	3	6	195	118	0
13970	1538191718	3	1	7	194	121	0
13979	1538191719	4	2	8	193	124	0
13988	1538191719	1	3	9	192	127	0
13997	1538191719	2	1	10	191	130	0
14006	1538191719	3	2	11	190	133	0
14015	1538191720	4	3	12	189	136	0
14024	1538191720	1	1	13	188	139	0
14033	1538191720	2	2	14	187	142	0
14042	1538191720	3	3	15	186	145	0
14051	1538191721	4	1	16	185	148	0
14060	1538191721	1	2	17	184	150	0
14069	1538191721	2	3	18	183	153	0
14078	1538191721	3	1	19	182	156	0
14087	1538191722	4	2	20	181	158	0
14096	1538191722	1	3	21	180	161	0
14105	1538191722	2	1	22	179	163	0
14114	1538191722	3	2	23	178	166	0
14123	1538191723	4	3	24	177	168	0
14132	1538191723	1	1	25	176	170	0
14141	1538191723	2	2	26	175	172	0
14150	1538191723	3	3	27	174	175	0
14159	1538191724	4	1	28	173	177	0
14168	1538191724	1	2	29	172	179	0
14177	1538191724	2	3	30	171	180	0
14186	1538191724	3	1	31	170	182	0
14195	1538191725	4	2	32	169	184	0
14204	1538191725	1	3	33	168	186	0
14213	1538191725	2	1	34	167	187	0
14222	1538191725	3	2	35	166	189	0
14231	1538191726	4	3	36	165	190	0
14240	1538191726	1	1	37	164	191	0
14249	1538191726	2	2	38	163	192	0
14258	1538191726	3	3	39	162	194	0
14267	1538191727	4	1	40	161	195	0
14276	1538191727	1	2	41	160	196	0
14285	1538191727	2	3	42	159	196	0
14294	1538191727	3	1	43	158	197	0
14303	1538191728	4	2	44	157	198	0
14312	1538191728	1	3	45	156	198	0
14321	1538191728	2	1	46	155	199	0
14330	1538191728	3	2	47	154	199	0
14339	1538191729	4	3	48	153	199	0
14348	1538191729	1	1	49	152	199	0
14357	1538191729	2	2	50	151	200	0
14366	1538191729	3	3	51	150	199	0
14375	1538191730	4	1	52	149	199	0
14384	1538191730	1	2	53	148	199	0
14393	1538191730	2	3	54	147	199	0
14402	1538191730	3	1	55	146	198	0
14411	1538191731	4	2	56	145	198	0
14420	1538191731	1	3	57	144	197	0
14429	1538191731	2	1	58	143	196	0
14438	1538191731	3	2	59	142	196	0
14447	1538191732	4	3	60	141	195	0
14456	1538191732	1	1	61	140	194	0
14465	1538191732	2	2	62	139	192	0
14474	1538191732	3	3	63	138	191	0
14483	1538191733	4	1	64	137	190	0
14492	1538191733	1	2	65	136	189	0
14501	1538191733	2	3	66	135	187	0
14510	1538191733	3	1	67	134	186	0
14519	1538191734	4	2	68	133	184	0
14528	1538191734	1	3	69	132	182	0
14537	1538191734	2	1	70	131	180	0
14546	1538191734	3	2	71	130	179	0
14555	1538191735	4	3	72	129	177	0
14564	1538191735	1	1	73	128	175	0
14573	1538191735	2	2	74	127	172	0
14582	1538191735	3	3	75	126	170	0
14591	1538191736	4	1	76	125	168	0
14600	1538191736	1	2	77	124	166	0
14609	1538191736	2	3	78	123	163	0
14618	1538191736	3	1	79	122	161	0
14627	1538191737	4	2	80	121	158	0
Port open
Initializing RTC...
Initializing FRAM...
Found I2C FRAM
read nextFramWriteAddr 14636 from address 0
Using interrupt number 5, pin 18
Clearing 2000 FRAM addresses...
Setting NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION (0) to FIRST_PKT_STORAGE_ADDR (2)

Displaying memory locations 0 to 2000

0x0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x10: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x20: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x30: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x40: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x50: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x60: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x70: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x80: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x90: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0xA0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0xB0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0xC0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0xD0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0xE0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0xF0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x100: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x110: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x120: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x130: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x140: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x150: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x160: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x170: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x180: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x190: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x1A0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x1B0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x1C0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x1D0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x1E0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x1F0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x200: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x210: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x220: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x230: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x240: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x250: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x260: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x270: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x280: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x290: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x2A0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x2B0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x2C0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x2D0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x2E0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x2F0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x300: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x310: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x320: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x330: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x340: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x350: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x360: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x370: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x380: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x390: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x3A0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x3B0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x3C0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x3D0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x3E0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x3F0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x400: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x410: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x420: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x430: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x440: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x450: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x460: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x470: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x480: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x490: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x4A0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x4B0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x4C0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x4D0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x4E0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x4F0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x500: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x510: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x520: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x530: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x540: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x550: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x560: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x570: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x580: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x590: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x5A0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x5B0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x5C0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x5D0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x5E0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x5F0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x600: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x610: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x620: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x630: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x640: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x650: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x660: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x670: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x680: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x690: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x6A0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x6B0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x6C0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x6D0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x6E0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x6F0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x700: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x710: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x720: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x730: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x740: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x750: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x760: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x770: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x780: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x790: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x7A0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x7B0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x7C0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
Enabling ISR, Entering Loop()addr	unixtime		mode	submode	Ldist	Rdist	Fdist	batV
2	1538191746	1	1	1	200	103	0
11	1538191746	2	2	2	199	106	0
20	1538191747	3	3	3	198	109	0
29	1538191747	4	1	4	197	112	0
38	1538191747	1	2	5	196	115	0

displaying 5 packets, from address 2 to address 46
addr	unixtime		mode	submode	Ldist	Rdist	Fdist	batV
2	1538191746	1	1	1	200	103	0
11	1538191746	2	2	2	199	106	0
20	1538191747	3	3	3	198	109	0
29	1538191747	4	1	4	197	112	0
38	1538191747	1	2	5	196	115	0
---------------- Done!-----------------

addr	unixtime		mode	submode	Ldist	Rdist	Fdist	batV
47	1538191747	2	3	6	195	118	0
56	1538191748	3	1	7	194	121	0
65	1538191748	4	2	8	193	124	0
74	1538191748	1	3	9	192	127	0
83	1538191748	2	1	10	191	130	0
92	1538191749	3	2	11	190	133	0
101	1538191749	4	3	12	189	136	0
110	1538191749	1	1	13	188	139	0
119	1538191749	2	2	14	187	142	0
128	1538191750	3	3	15	186	145	0
137	1538191750	4	1	16	185	148	0
146	1538191750	1	2	17	184	150	0
155	1538191750	2	3	18	183	153	0
164	1538191751	3	1	19	182	156	0
173	1538191751	4	2	20	181	158	0
182	1538191751	1	3	21	180	161	0
191	1538191751	2	1	22	179	163	0
200	1538191752	3	2	23	178	166	0
209	1538191752	4	3	24	177	168	0
218	1538191752	1	1	25	176	170	0
227	1538191752	2	2	26	175	172	0
236	1538191753	3	3	27	174	175	0
245	1538191753	4	1	28	173	177	0
254	1538191753	1	2	29	172	179	0
263	1538191753	2	3	30	171	180	0
272	1538191754	3	1	31	170	182	0

displaying 26 packets, from address 47 to address 280
addr	unixtime		mode	submode	Ldist	Rdist	Fdist	batV
47	1538191747	2	3	6	195	118	0
56	1538191748	3	1	7	194	121	0
65	1538191748	4	2	8	193	124	0
74	1538191748	1	3	9	192	127	0
83	1538191748	2	1	10	191	130	0
92	1538191749	3	2	11	190	133	0
101	1538191749	4	3	12	189	136	0
110	1538191749	1	1	13	188	139	0
119	1538191749	2	2	14	187	142	0
128	1538191750	3	3	15	186	145	0
137	1538191750	4	1	16	185	148	0
146	1538191750	1	2	17	184	150	0
155	1538191750	2	3	18	183	153	0
164	1538191751	3	1	19	182	156	0
173	1538191751	4	2	20	181	158	0
182	1538191751	1	3	21	180	161	0
191	1538191751	2	1	22	179	163	0
200	1538191752	3	2	23	178	166	0
209	1538191752	4	3	24	177	168	0
218	1538191752	1	1	25	176	170	0
227	1538191752	2	2	26	175	172	0
236	1538191753	3	3	27	174	175	0
245	1538191753	4	1	28	173	177	0
254	1538191753	1	2	29	172	179	0
263	1538191753	2	3	30	171	180	0
272	1538191754	3	1	31	170	182	0
---------------- Done!-----------------

addr	unixtime		mode	submode	Ldist	Rdist	Fdist	batV
281	1538191754	4	2	32	169	184	0
290	1538191754	1	3	33	168	186	0

displaying 2 packets, from address 281 to address 298
addr	unixtime		mode	submode	Ldist	Rdist	Fdist	batV
281	1538191754	4	2	32	169	184	0
290	1538191754	1	3	33	168	186	0
---------------- Done!-----------------

addr	unixtime		mode	submode	Ldist	Rdist	Fdist	batV
299	1538191754	2	1	34	167	187	0
308	1538191755	3	2	35	166	189	0
317	1538191755	4	3	36	165	190	0
326	1538191755	1	1	37	164	191	0
335	1538191755	2	2	38	163	192	0
344	1538191756	3	3	39	162	194	0
353	1538191756	4	1	40	161	195	0
362	1538191756	1	2	41	160	196	0
371	1538191756	2	3	42	159	196	0
380	1538191757	3	1	43	158	197	0
389	1538191757	4	2	44	157	198	0
398	1538191757	1	3	45	156	198	0
407	1538191757	2	1	46	155	199	0
416	1538191758	3	2	47	154	199	0
425	1538191758	4	3	48	153	199	0
434	1538191758	1	1	49	152	199	0
443	1538191758	2	2	50	151	200	0
452	1538191759	3	3	51	150	199	0
461	1538191759	4	1	52	149	199	0
470	1538191759	1	2	53	148	199	0
479	1538191759	2	3	54	147	199	0
488	1538191760	3	1	55	146	198	0
497	1538191760	4	2	56	145	198	0
506	1538191760	1	3	57	144	197	0
515	1538191760	2	1	58	143	196	0
524	1538191761	3	2	59	142	196	0
533	1538191761	4	3	60	141	195	0
542	1538191761	1	1	61	140	194	0
551	1538191761	2	2	62	139	192	0
560	1538191762	3	3	63	138	191	0
569	1538191762	4	1	64	137	190	0
578	1538191762	1	2	65	136	189	0
587	1538191762	2	3	66	135	187	0
596	1538191763	3	1	67	134	186	0
605	1538191763	4	2	68	133	184	0
614	1538191763	1	3	69	132	182	0
623	1538191763	2	1	70	131	180	0
632	1538191764	3	2	71	130	179	0
641	1538191764	4	3	72	129	177	0
650	1538191764	1	1	73	128	175	0
659	1538191764	2	2	74	127	172	0
668	1538191765	3	3	75	126	170	0
677	1538191765	4	1	76	125	168	0
686	1538191765	1	2	77	124	166	0
695	1538191765	2	3	78	123	163	0
704	1538191766	3	1	79	122	161	0
713	1538191766	4	2	80	121	158	0
722	1538191766	1	3	81	120	156	0
731	1538191766	2	1	82	119	153	0
740	1538191767	3	2	83	118	150	0
749	1538191767	4	3	84	117	148	0
758	1538191767	1	1	85	116	145	0
767	1538191767	2	2	86	115	142	0
776	1538191768	3	3	87	114	139	0
785	1538191768	4	1	88	113	136	0
794	1538191768	1	2	89	112	133	0
803	1538191768	2	3	90	111	130	0
812	1538191769	3	1	91	110	127	0
821	1538191769	4	2	92	109	124	0
830	1538191769	1	3	93	108	121	0
839	1538191769	2	1	94	107	118	0
848	1538191770	3	2	95	106	115	0
857	1538191770	4	3	96	105	112	0
866	1538191770	1	1	97	104	109	0

displaying 64 packets, from address 299 to address 874
addr	unixtime		mode	submode	Ldist	Rdist	Fdist	batV
299	1538191754	2	1	34	167	187	0
308	1538191755	3	2	35	166	189	0
317	1538191755	4	3	36	165	190	0
326	1538191755	1	1	37	164	191	0
335	1538191755	2	2	38	163	192	0
344	1538191756	3	3	39	162	194	0
353	1538191756	4	1	40	161	195	0
362	1538191756	1	2	41	160	196	0
371	1538191756	2	3	42	159	196	0
380	1538191757	3	1	43	158	197	0
389	1538191757	4	2	44	157	198	0
398	1538191757	1	3	45	156	198	0
407	1538191757	2	1	46	155	199	0
416	1538191758	3	2	47	154	199	0
425	1538191758	4	3	48	153	199	0
434	1538191758	1	1	49	152	199	0
443	1538191758	2	2	50	151	200	0
452	1538191759	3	3	51	150	199	0
461	1538191759	4	1	52	149	199	0
470	1538191759	1	2	53	148	199	0
479	1538191759	2	3	54	147	199	0
488	1538191760	3	1	55	146	198	0
497	1538191760	4	2	56	145	198	0
506	1538191760	1	3	57	144	197	0
515	1538191760	2	1	58	143	196	0
524	1538191761	3	2	59	142	196	0
533	1538191761	4	3	60	141	195	0
542	1538191761	1	1	61	140	194	0
551	1538191761	2	2	62	139	192	0
560	1538191762	3	3	63	138	191	0
569	1538191762	4	1	64	137	190	0
578	1538191762	1	2	65	136	189	0
587	1538191762	2	3	66	135	187	0
596	1538191763	3	1	67	134	186	0
605	1538191763	4	2	68	133	184	0
614	1538191763	1	3	69	132	182	0
623	1538191763	2	1	70	131	180	0
632	1538191764	3	2	71	130	179	0
641	1538191764	4	3	72	129	177	0
650	1538191764	1	1	73	128	175	0
659	1538191764	2	2	74	127	172	0
668	1538191765	3	3	75	126	170	0
677	1538191765	4	1	76	125	168	0
686	1538191765	1	2	77	124	166	0
695	1538191765	2	3	78	123	163	0
704	1538191766	3	1	79	122	161	0
713	1538191766	4	2	80	121	158	0
722	1538191766	1	3	81	120	156	0
731	1538191766	2	1	82	119	153	0
740	1538191767	3	2	83	118	150	0
749	1538191767	4	3	84	117	148	0
758	1538191767	1	1	85	116	145	0
767	1538191767	2	2	86	115	142	0
776	1538191768	3	3	87	114	139	0
785	1538191768	4	1	88	113	136	0
794	1538191768	1	2	89	112	133	0
803	1538191768	2	3	90	111	130	0
812	1538191769	3	1	91	110	127	0
821	1538191769	4	2	92	109	124	0
830	1538191769	1	3	93	108	121	0
839	1538191769	2	1	94	107	118	0
848	1538191770	3	2	95	106	115	0
857	1538191770	4	3	96	105	112	0
866	1538191770	1	1	97	104	109	0
---------------- Done!-----------------

addr	unixtime		mode	submode	Ldist	Rdist	Fdist	batV
875	1538191771	2	2	98	103	106	0
884	1538191771	3	3	99	102	103	0
893	1538191771	4	1	100	101	100	0
902	1538191771	1	2	101	100	97	0
911	1538191771	2	3	102	99	94	0
920	1538191772	3	1	103	98	91	0
929	1538191772	4	2	104	97	88	0
938	1538191772	1	3	105	96	85	0
947	1538191772	2	1	106	95	82	0
956	1538191773	3	2	107	94	79	0
965	1538191773	4	3	108	93	76	0
974	1538191773	1	1	109	92	73	0
983	1538191773	2	2	110	91	70	0
992	1538191774	3	3	111	90	67	0
1001	1538191774	4	1	112	89	64	0
1010	1538191774	1	2	113	88	61	0
1019	1538191774	2	3	114	87	58	0
1028	1538191775	3	1	115	86	55	0
1037	1538191775	4	2	116	85	52	0
1046	1538191775	1	3	117	84	50	0
1055	1538191775	2	1	118	83	47	0
1064	1538191776	3	2	119	82	44	0
1073	1538191776	4	3	120	81	42	0
1082	1538191776	1	1	121	80	39	0
1091	1538191776	2	2	122	79	37	0
1100	1538191777	3	3	123	78	34	0

Port closed

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

1001

1002

1003

1004

1005

1006

1007

1008

1009

1010

1011

1012

1013

1014

1015

1016

1017

1018

1019

1020

1021

1022

1023

1024

1025

1026

1027

1028

1029

1030

1031

1032

1033

1034

1035

1036

1037

1038

1039

1040

1041

1042

1043

1044

1045

1046

1047

1048

1049

1050

1051

1052

1053

1054

1055

1056

1057

1058

1059

1060

1061

1062

1063

1064

1065

1066

1067

1068

1069

1070

1071

1072

1073

1074

1075

1076

1077

1078

1079

1080

1081

1082

1083

1084

1085

1086

1087

1088

1089

1090

1091

1092

1093

1094

1095

1096

1097

1098

1099

1100

1101

1102

1103

1104

1105

1106

1107

1108

1109

1110

1111

1112

1113

1114

1115

1116

Opening port

Port open

Initializing RTC...

Initializing FRAM...

Found I2C FRAM

read nextFramWriteAddr 8255 from address 0

Using interrupt number 5, pin 18

displaying 10 packets, from address 2 to address 91

addr unixtime mode submode Ldist Rdist Fdist batV

2 1538191317 2 1 166 35 13 0

11 1538191317 3 2 167 34 14 0

20 1538191318 4 3 168 33 16 0

29 1538191318 1 1 169 32 18 0

38 1538191318 2 2 170 31 20 0

47 1538191318 3 3 171 30 21 0

56 1538191319 4 1 172 29 23 0

65 1538191319 1 2 173 28 25 0

74 1538191319 2 3 174 27 28 0

83 1538191319 3 1 175 26 30 0

---------------- Done!-----------------

addr unixtime mode submode Ldist Rdist Fdist batV

Enabling ISR, Entering Loop()addr unixtime mode submode Ldist Rdist Fdist batV

8255 1538191560 4 2 176 25 32 0

8264 1538191560 1 3 177 24 34 0

8273 1538191560 2 1 178 23 37 0

8282 1538191561 3 2 179 22 39 0

8291 1538191561 4 3 180 21 42 0

8300 1538191561 1 1 181 20 44 0

8309 1538191561 2 2 182 19 47 0

8318 1538191562 3 3 183 18 50 0

8327 1538191562 4 1 184 17 52 0

8336 1538191562 1 2 185 16 55 0

8345 1538191562 2 3 186 15 58 0

8354 1538191563 3 1 187 14 61 0

8363 1538191563 4 2 188 13 64 0

8372 1538191563 1 3 189 12 67 0

8381 1538191563 2 1 190 11 70 0

8390 1538191564 3 2 191 10 73 0

8399 1538191564 4 3 192 9 76 0

8408 1538191564 1 1 193 8 79 0

8417 1538191564 2 2 194 7 82 0

8426 1538191565 3 3 195 6 85 0

8435 1538191565 4 1 196 5 88 0

8444 1538191565 1 2 197 4 91 0

8453 1538191565 2 3 198 3 94 0

8462 1538191566 3 1 199 2 97 0

8471 1538191566 4 2 200 1 100 0

8480 1538191566 1 3 0 0 100 0

8489 1538191566 2 1 1 200 103 0

8498 1538191567 3 2 2 199 106 0

8507 1538191567 4 3 3 198 109 0

8516 1538191567 1 1 4 197 112 0

8525 1538191567 2 2 5 196 115 0

8534 1538191568 3 3 6 195 118 0

8543 1538191568 4 1 7 194 121 0

8552 1538191568 1 2 8 193 124 0

8561 1538191568 2 3 9 192 127 0

8570 1538191569 3 1 10 191 130 0

8579 1538191569 4 2 11 190 133 0

8588 1538191569 1 3 12 189 136 0

8597 1538191569 2 1 13 188 139 0

8606 1538191570 3 2 14 187 142 0

8615 1538191570 4 3 15 186 145 0

8624 1538191570 1 1 16 185 148 0

8633 1538191570 2 2 17 184 150 0

8642 1538191571 3 3 18 183 153 0

8651 1538191571 4 1 19 182 156 0

8660 1538191571 1 2 20 181 158 0

8669 1538191571 2 3 21 180 161 0

8678 1538191572 3 1 22 179 163 0

8687 1538191572 4 2 23 178 166 0

8696 1538191572 1 3 24 177 168 0

8705 1538191572 2 1 25 176 170 0

8714 1538191573 3 2 26 175 172 0

8723 1538191573 4 3 27 174 175 0

8732 1538191573 1 1 28 173 177 0

8741 1538191573 2 2 29 172 179 0

8750 1538191574 3 3 30 171 180 0

8759 1538191574 4 1 31 170 182 0

8768 1538191574 1 2 32 169 184 0

8777 1538191574 2 3 33 168 186 0

8786 1538191575 3 1 34 167 187 0

8795 1538191575 4 2 35 166 189 0

8804 1538191575 1 3 36 165 190 0

8813 1538191575 2 1 37 164 191 0

8822 1538191576 3 2 38 163 192 0

8831 1538191576 4 3 39 162 194 0

8840 1538191576 1 1 40 161 195 0

8849 1538191576 2 2 41 160 196 0

8858 1538191577 3 3 42 159 196 0

8867 1538191577 4 1 43 158 197 0

8876 1538191577 1 2 44 157 198 0

8885 1538191577 2 3 45 156 198 0

8894 1538191578 3 1 46 155 199 0

8903 1538191578 4 2 47 154 199 0

8912 1538191578 1 3 48 153 199 0

8921 1538191578 2 1 49 152 199 0

8930 1538191579 3 2 50 151 200 0

8939 1538191579 4 3 51 150 199 0

8948 1538191579 1 1 52 149 199 0

8957 1538191579 2 2 53 148 199 0

8966 1538191580 3 3 54 147 199 0

8975 1538191580 4 1 55 146 198 0

8984 1538191580 1 2 56 145 198 0

8993 1538191580 2 3 57 144 197 0

9002 1538191581 3 1 58 143 196 0

9011 1538191581 4 2 59 142 196 0

9020 1538191581 1 3 60 141 195 0

9029 1538191581 2 1 61 140 194 0

9038 1538191582 3 2 62 139 192 0

9047 1538191582 4 3 63 138 191 0

9056 1538191582 1 1 64 137 190 0

9065 1538191582 2 2 65 136 189 0

9074 1538191583 3 3 66 135 187 0

9083 1538191583 4 1 67 134 186 0

9092 1538191583 1 2 68 133 184 0

9101 1538191583 2 3 69 132 182 0

9110 1538191584 3 1 70 131 180 0

9119 1538191584 4 2 71 130 179 0

9128 1538191584 1 3 72 129 177 0

9137 1538191584 2 1 73 128 175 0

9146 1538191585 3 2 74 127 172 0

9155 1538191585 4 3 75 126 170 0

9164 1538191585 1 1 76 125 168 0

9173 1538191585 2 2 77 124 166 0

9182 1538191586 3 3 78 123 163 0

9191 1538191586 4 1 79 122 161 0

9200 1538191586 1 2 80 121 158 0

9209 1538191586 2 3 81 120 156 0

9218 1538191587 3 1 82 119 153 0

9227 1538191587 4 2 83 118 150 0

9236 1538191587 1 3 84 117 148 0

9245 1538191587 2 1 85 116 145 0

9254 1538191588 3 2 86 115 142 0

9263 1538191588 4 3 87 114 139 0

9272 1538191588 1 1 88 113 136 0

9281 1538191588 2 2 89 112 133 0

9290 1538191589 3 3 90 111 130 0

9299 1538191589 4 1 91 110 127 0

9308 1538191589 1 2 92 109 124 0

9317 1538191589 2 3 93 108 121 0

9326 1538191590 3 1 94 107 118 0

9335 1538191590 4 2 95 106 115 0

9344 1538191590 1 3 96 105 112 0

9353 1538191590 2 1 97 104 109 0

9362 1538191591 3 2 98 103 106 0

9371 1538191591 4 3 99 102 103 0

9380 1538191591 1 1 100 101 100 0

9389 1538191591 2 2 101 100 97 0

9398 1538191592 3 3 102 99 94 0

9407 1538191592 4 1 103 98 91 0

9416 1538191592 1 2 104 97 88 0

9425 1538191592 2 3 105 96 85 0

9434 1538191593 3 1 106 95 82 0

9443 1538191593 4 2 107 94 79 0

9452 1538191593 1 3 108 93 76 0

9461 1538191593 2 1 109 92 73 0

9470 1538191594 3 2 110 91 70 0

9479 1538191594 4 3 111 90 67 0

9488 1538191594 1 1 112 89 64 0

9497 1538191594 2 2 113 88 61 0

9506 1538191595 3 3 114 87 58 0

9515 1538191595 4 1 115 86 55 0

9524 1538191595 1 2 116 85 52 0

9533 1538191595 2 3 117 84 50 0

9542 1538191596 3 1 118 83 47 0

9551 1538191596 4 2 119 82 44 0

9560 1538191596 1 3 120 81 42 0

9569 1538191596 2 1 121 80 39 0

9578 1538191597 3 2 122 79 37 0

9587 1538191597 4 3 123 78 34 0

9596 1538191597 1 1 124 77 32 0

9605 1538191597 2 2 125 76 30 0

9614 1538191598 3 3 126 75 28 0

9623 1538191598 4 1 127 74 25 0

9632 1538191598 1 2 128 73 23 0

9641 1538191598 2 3 129 72 21 0

9650 1538191599 3 1 130 71 20 0

9659 1538191599 4 2 131 70 18 0

9668 1538191599 1 3 132 69 16 0

9677 1538191599 2 1 133 68 14 0

9686 1538191600 3 2 134 67 13 0

9695 1538191600 4 3 135 66 11 0

9704 1538191600 1 1 136 65 10 0

9713 1538191600 2 2 137 64 9 0

9722 1538191601 3 3 138 63 8 0

9731 1538191601 4 1 139 62 6 0

9740 1538191601 1 2 140 61 5 0

9749 1538191601 2 3 141 60 4 0

9758 1538191602 3 1 142 59 4 0

9767 1538191602 4 2 143 58 3 0

9776 1538191602 1 3 144 57 2 0

9785 1538191602 2 1 145 56 2 0

9794 1538191603 3 2 146 55 1 0

9803 1538191603 4 3 147 54 1 0

9812 1538191603 1 1 148 53 1 0

9821 1538191603 2 2 149 52 1 0

9830 1538191604 3 3 150 51 0 0

9839 1538191604 4 1 151 50 1 0

9848 1538191604 1 2 152 49 1 0

9857 1538191604 2 3 153 48 1 0

9866 1538191605 3 1 154 47 1 0

9875 1538191605 4 2 155 46 2 0

9884 1538191605 1 3 156 45 2 0

9893 1538191605 2 1 157 44 3 0

9902 1538191606 3 2 158 43 4 0

9911 1538191606 4 3 159 42 4 0

9920 1538191606 1 1 160 41 5 0

9929 1538191606 2 2 161 40 6 0

9938 1538191607 3 3 162 39 8 0

9947 1538191607 4 1 163 38 9 0

9956 1538191607 1 2 164 37 10 0

9965 1538191607 2 3 165 36 11 0

9974 1538191608 3 1 166 35 13 0

9983 1538191608 4 2 167 34 14 0

9992 1538191608 1 3 168 33 16 0

10001 1538191608 2 1 169 32 18 0

10010 1538191609 3 2 170 31 20 0

10019 1538191609 4 3 171 30 21 0

10028 1538191609 1 1 172 29 23 0

10037 1538191609 2 2 173 28 25 0

10046 1538191610 3 3 174 27 28 0

10055 1538191610 4 1 175 26 30 0

10064 1538191610 1 2 176 25 32 0

10073 1538191610 2 3 177 24 34 0

10082 1538191611 3 1 178 23 37 0

10091 1538191611 4 2 179 22 39 0

10100 1538191611 1 3 180 21 42 0

10109 1538191611 2 1 181 20 44 0

10118 1538191612 3 2 182 19 47 0

10127 1538191612 4 3 183 18 50 0

10136 1538191612 1 1 184 17 52 0

10145 1538191612 2 2 185 16 55 0

10154 1538191613 3 3 186 15 58 0

10163 1538191613 4 1 187 14 61 0

10172 1538191613 1 2 188 13 64 0

10181 1538191613 2 3 189 12 67 0

10190 1538191614 3 1 190 11 70 0

10199 1538191614 4 2 191 10 73 0

10208 1538191614 1 3 192 9 76 0

10217 1538191614 2 1 193 8 79 0

10226 1538191615 3 2 194 7 82 0

10235 1538191615 4 3 195 6 85 0

10244 1538191615 1 1 196 5 88 0

10253 1538191615 2 2 197 4 91 0

10262 1538191615 3 3 198 3 94 0

10271 1538191616 4 1 199 2 97 0

10280 1538191616 1 2 200 1 100 0

10289 1538191616 2 3 0 0 100 0

10298 1538191616 3 1 1 200 103 0

10307 1538191617 4 2 2 199 106 0

10316 1538191617 1 3 3 198 109 0

10325 1538191617 2 1 4 197 112 0

10334 1538191617 3 2 5 196 115 0

10343 1538191618 4 3 6 195 118 0

10352 1538191618 1 1 7 194 121 0

10361 1538191618 2 2 8 193 124 0

10370 1538191618 3 3 9 192 127 0

10379 1538191619 4 1 10 191 130 0

10388 1538191619 1 2 11 190 133 0

10397 1538191619 2 3 12 189 136 0

10406 1538191619 3 1 13 188 139 0

10415 1538191620 4 2 14 187 142 0

10424 1538191620 1 3 15 186 145 0

10433 1538191620 2 1 16 185 148 0

10442 1538191620 3 2 17 184 150 0

10451 1538191621 4 3 18 183 153 0

10460 1538191621 1 1 19 182 156 0

10469 1538191621 2 2 20 181 158 0

10478 1538191621 3 3 21 180 161 0

10487 1538191622 4 1 22 179 163 0

10496 1538191622 1 2 23 178 166 0

10505 1538191622 2 3 24 177 168 0

10514 1538191622 3 1 25 176 170 0

10523 1538191623 4 2 26 175 172 0

10532 1538191623 1 3 27 174 175 0

10541 1538191623 2 1 28 173 177 0

10550 1538191623 3 2 29 172 179 0

10559 1538191624 4 3 30 171 180 0

10568 1538191624 1 1 31 170 182 0

10577 1538191624 2 2 32 169 184 0

10586 1538191624 3 3 33 168 186 0

10595 1538191625 4 1 34 167 187 0

10604 1538191625 1 2 35 166 189 0

10613 1538191625 2 3 36 165 190 0

10622 1538191625 3 1 37 164 191 0

10631 1538191626 4 2 38 163 192 0

10640 1538191626 1 3 39 162 194 0

10649 1538191626 2 1 40 161 195 0

10658 1538191626 3 2 41 160 196 0

10667 1538191627 4 3 42 159 196 0

10676 1538191627 1 1 43 158 197 0

10685 1538191627 2 2 44 157 198 0

10694 1538191627 3 3 45 156 198 0

10703 1538191628 4 1 46 155 199 0

10712 1538191628 1 2 47 154 199 0

10721 1538191628 2 3 48 153 199 0

10730 1538191628 3 1 49 152 199 0

10739 1538191629 4 2 50 151 200 0

10748 1538191629 1 3 51 150 199 0

10757 1538191629 2 1 52 149 199 0

10766 1538191629 3 2 53 148 199 0

10775 1538191630 4 3 54 147 199 0

10784 1538191630 1 1 55 146 198 0

10793 1538191630 2 2 56 145 198 0

10802 1538191630 3 3 57 144 197 0

10811 1538191631 4 1 58 143 196 0

10820 1538191631 1 2 59 142 196 0

10829 1538191631 2 3 60 141 195 0

10838 1538191631 3 1 61 140 194 0

10847 1538191632 4 2 62 139 192 0

10856 1538191632 1 3 63 138 191 0

10865 1538191632 2 1 64 137 190 0

10874 1538191632 3 2 65 136 189 0

10883 1538191633 4 3 66 135 187 0

10892 1538191633 1 1 67 134 186 0

10901 1538191633 2 2 68 133 184 0

10910 1538191633 3 3 69 132 182 0

10919 1538191634 4 1 70 131 180 0

10928 1538191634 1 2 71 130 179 0

10937 1538191634 2 3 72 129 177 0

10946 1538191634 3 1 73 128 175 0

10955 1538191635 4 2 74 127 172 0

10964 1538191635 1 3 75 126 170 0

10973 1538191635 2 1 76 125 168 0

10982 1538191635 3 2 77 124 166 0

10991 1538191636 4 3 78 123 163 0

11000 1538191636 1 1 79 122 161 0

11009 1538191636 2 2 80 121 158 0

11018 1538191636 3 3 81 120 156 0

11027 1538191637 4 1 82 119 153 0

11036 1538191637 1 2 83 118 150 0

11045 1538191637 2 3 84 117 148 0

11054 1538191637 3 1 85 116 145 0

11063 1538191638 4 2 86 115 142 0

11072 1538191638 1 3 87 114 139 0

11081 1538191638 2 1 88 113 136 0

11090 1538191638 3 2 89 112 133 0

11099 1538191639 4 3 90 111 130 0

11108 1538191639 1 1 91 110 127 0

11117 1538191639 2 2 92 109 124 0

11126 1538191639 3 3 93 108 121 0

11135 1538191640 4 1 94 107 118 0

11144 1538191640 1 2 95 106 115 0

11153 1538191640 2 3 96 105 112 0

11162 1538191640 3 1 97 104 109 0

11171 1538191641 4 2 98 103 106 0

11180 1538191641 1 3 99 102 103 0

11189 1538191641 2 1 100 101 100 0

11198 1538191641 3 2 101 100 97 0

11207 1538191642 4 3 102 99 94 0

11216 1538191642 1 1 103 98 91 0

11225 1538191642 2 2 104 97 88 0

11234 1538191642 3 3 105 96 85 0

11243 1538191643 4 1 106 95 82 0

11252 1538191643 1 2 107 94 79 0

11261 1538191643 2 3 108 93 76 0

11270 1538191643 3 1 109 92 73 0

11279 1538191644 4 2 110 91 70 0

11288 1538191644 1 3 111 90 67 0

11297 1538191644 2 1 112 89 64 0

11306 1538191644 3 2 113 88 61 0

11315 1538191645 4 3 114 87 58 0

11324 1538191645 1 1 115 86 55 0

11333 1538191645 2 2 116 85 52 0

11342 1538191645 3 3 117 84 50 0

11351 1538191646 4 1 118 83 47 0

11360 1538191646 1 2 119 82 44 0

11369 1538191646 2 3 120 81 42 0

11378 1538191646 3 1 121 80 39 0

11387 1538191647 4 2 122 79 37 0

11396 1538191647 1 3 123 78 34 0

11405 1538191647 2 1 124 77 32 0

11414 1538191647 3 2 125 76 30 0

11423 1538191648 4 3 126 75 28 0

11432 1538191648 1 1 127 74 25 0

11441 1538191648 2 2 128 73 23 0

11450 1538191648 3 3 129 72 21 0

11459 1538191649 4 1 130 71 20 0

11468 1538191649 1 2 131 70 18 0

11477 1538191649 2 3 132 69 16 0

11486 1538191649 3 1 133 68 14 0

11495 1538191650 4 2 134 67 13 0

11504 1538191650 1 3 135 66 11 0

11513 1538191650 2 1 136 65 10 0

11522 1538191650 3 2 137 64 9 0

11531 1538191651 4 3 138 63 8 0

11540 1538191651 1 1 139 62 6 0

11549 1538191651 2 2 140 61 5 0

11558 1538191651 3 3 141 60 4 0

11567 1538191652 4 1 142 59 4 0

11576 1538191652 1 2 143 58 3 0

11585 1538191652 2 3 144 57 2 0

11594 1538191652 3 1 145 56 2 0

11603 1538191653 4 2 146 55 1 0

11612 1538191653 1 3 147 54 1 0

11621 1538191653 2 1 148 53 1 0

11630 1538191653 3 2 149 52 1 0

11639 1538191654 4 3 150 51 0 0

11648 1538191654 1 1 151 50 1 0

11657 1538191654 2 2 152 49 1 0

11666 1538191654 3 3 153 48 1 0

11675 1538191655 4 1 154 47 1 0

11684 1538191655 1 2 155 46 2 0

11693 1538191655 2 3 156 45 2 0

11702 1538191655 3 1 157 44 3 0

11711 1538191656 4 2 158 43 4 0

11720 1538191656 1 3 159 42 4 0

11729 1538191656 2 1 160 41 5 0

11738 1538191656 3 2 161 40 6 0

11747 1538191657 4 3 162 39 8 0

11756 1538191657 1 1 163 38 9 0

11765 1538191657 2 2 164 37 10 0

11774 1538191657 3 3 165 36 11 0

11783 1538191658 4 1 166 35 13 0

11792 1538191658 1 2 167 34 14 0

11801 1538191658 2 3 168 33 16 0

11810 1538191658 3 1 169 32 18 0

11819 1538191659 4 2 170 31 20 0

11828 1538191659 1 3 171 30 21 0

11837 1538191659 2 1 172 29 23 0

11846 1538191659 3 2 173 28 25 0

11855 1538191660 4 3 174 27 28 0

11864 1538191660 1 1 175 26 30 0

11873 1538191660 2 2 176 25 32 0

11882 1538191660 3 3 177 24 34 0

11891 1538191661 4 1 178 23 37 0

11900 1538191661 1 2 179 22 39 0

11909 1538191661 2 3 180 21 42 0

11918 1538191661 3 1 181 20 44 0

11927 1538191662 4 2 182 19 47 0

11936 1538191662 1 3 183 18 50 0

11945 1538191662 2 1 184 17 52 0

11954 1538191662 3 2 185 16 55 0

11963 1538191663 4 3 186 15 58 0

11972 1538191663 1 1 187 14 61 0

11981 1538191663 2 2 188 13 64 0

11990 1538191663 3 3 189 12 67 0

11999 1538191664 4 1 190 11 70 0

12008 1538191664 1 2 191 10 73 0

12017 1538191664 2 3 192 9 76 0

12026 1538191664 3 1 193 8 79 0

12035 1538191665 4 2 194 7 82 0

12044 1538191665 1 3 195 6 85 0

12053 1538191665 2 1 196 5 88 0

12062 1538191665 3 2 197 4 91 0

12071 1538191666 4 3 198 3 94 0

12080 1538191666 1 1 199 2 97 0

12089 1538191666 2 2 200 1 100 0

12098 1538191666 3 3 0 0 100 0

12107 1538191667 4 1 1 200 103 0

12116 1538191667 1 2 2 199 106 0

12125 1538191667 2 3 3 198 109 0

12134 1538191667 3 1 4 197 112 0

12143 1538191668 4 2 5 196 115 0

12152 1538191668 1 3 6 195 118 0

12161 1538191668 2 1 7 194 121 0

12170 1538191668 3 2 8 193 124 0

12179 1538191669 4 3 9 192 127 0

12188 1538191669 1 1 10 191 130 0

12197 1538191669 2 2 11 190 133 0

12206 1538191669 3 3 12 189 136 0

12215 1538191670 4 1 13 188 139 0

12224 1538191670 1 2 14 187 142 0

12233 1538191670 2 3 15 186 145 0

12242 1538191670 3 1 16 185 148 0

12251 1538191671 4 2 17 184 150 0

12260 1538191671 1 3 18 183 153 0

12269 1538191671 2 1 19 182 156 0

12278 1538191671 3 2 20 181 158 0

12287 1538191672 4 3 21 180 161 0

12296 1538191672 1 1 22 179 163 0

12305 1538191672 2 2 23 178 166 0

12314 1538191672 3 3 24 177 168 0

12323 1538191673 4 1 25 176 170 0

12332 1538191673 1 2 26 175 172 0

12341 1538191673 2 3 27 174 175 0

12350 1538191673 3 1 28 173 177 0

12359 1538191674 4 2 29 172 179 0

12368 1538191674 1 3 30 171 180 0

12377 1538191674 2 1 31 170 182 0

12386 1538191674 3 2 32 169 184 0

12395 1538191675 4 3 33 168 186 0

12404 1538191675 1 1 34 167 187 0

12413 1538191675 2 2 35 166 189 0

12422 1538191675 3 3 36 165 190 0

12431 1538191676 4 1 37 164 191 0

12440 1538191676 1 2 38 163 192 0

12449 1538191676 2 3 39 162 194 0

12458 1538191676 3 1 40 161 195 0

12467 1538191677 4 2 41 160 196 0

12476 1538191677 1 3 42 159 196 0

12485 1538191677 2 1 43 158 197 0

12494 1538191677 3 2 44 157 198 0

12503 1538191678 4 3 45 156 198 0

12512 1538191678 1 1 46 155 199 0

12521 1538191678 2 2 47 154 199 0

12530 1538191678 3 3 48 153 199 0

12539 1538191679 4 1 49 152 199 0

12548 1538191679 1 2 50 151 200 0

12557 1538191679 2 3 51 150 199 0

12566 1538191679 3 1 52 149 199 0

12575 1538191680 4 2 53 148 199 0

12584 1538191680 1 3 54 147 199 0

12593 1538191680 2 1 55 146 198 0

12602 1538191680 3 2 56 145 198 0

12611 1538191681 4 3 57 144 197 0

12620 1538191681 1 1 58 143 196 0

12629 1538191681 2 2 59 142 196 0

12638 1538191681 3 3 60 141 195 0

12647 1538191682 4 1 61 140 194 0

12656 1538191682 1 2 62 139 192 0

12665 1538191682 2 3 63 138 191 0

12674 1538191682 3 1 64 137 190 0

12683 1538191683 4 2 65 136 189 0

12692 1538191683 1 3 66 135 187 0

12701 1538191683 2 1 67 134 186 0

12710 1538191683 3 2 68 133 184 0

12719 1538191684 4 3 69 132 182 0

12728 1538191684 1 1 70 131 180 0

12737 1538191684 2 2 71 130 179 0

12746 1538191684 3 3 72 129 177 0

12755 1538191685 4 1 73 128 175 0

12764 1538191685 1 2 74 127 172 0

12773 1538191685 2 3 75 126 170 0

12782 1538191685 3 1 76 125 168 0

12791 1538191686 4 2 77 124 166 0

12800 1538191686 1 3 78 123 163 0

12809 1538191686 2 1 79 122 161 0

12818 1538191686 3 2 80 121 158 0

12827 1538191687 4 3 81 120 156 0

12836 1538191687 1 1 82 119 153 0

12845 1538191687 2 2 83 118 150 0

12854 1538191687 3 3 84 117 148 0

12863 1538191688 4 1 85 116 145 0

12872 1538191688 1 2 86 115 142 0

12881 1538191688 2 3 87 114 139 0

12890 1538191688 3 1 88 113 136 0

12899 1538191689 4 2 89 112 133 0

12908 1538191689 1 3 90 111 130 0

12917 1538191689 2 1 91 110 127 0

12926 1538191689 3 2 92 109 124 0

12935 1538191690 4 3 93 108 121 0

12944 1538191690 1 1 94 107 118 0

12953 1538191690 2 2 95 106 115 0

12962 1538191690 3 3 96 105 112 0

12971 1538191691 4 1 97 104 109 0

12980 1538191691 1 2 98 103 106 0

12989 1538191691 2 3 99 102 103 0

12998 1538191691 3 1 100 101 100 0

13007 1538191692 4 2 101 100 97 0

13016 1538191692 1 3 102 99 94 0

13025 1538191692 2 1 103 98 91 0

13034 1538191692 3 2 104 97 88 0

13043 1538191693 4 3 105 96 85 0

13052 1538191693 1 1 106 95 82 0

13061 1538191693 2 2 107 94 79 0

13070 1538191693 3 3 108 93 76 0

13079 1538191694 4 1 109 92 73 0

13088 1538191694 1 2 110 91 70 0

13097 1538191694 2 3 111 90 67 0

13106 1538191694 3 1 112 89 64 0

13115 1538191695 4 2 113 88 61 0

13124 1538191695 1 3 114 87 58 0

13133 1538191695 2 1 115 86 55 0

13142 1538191695 3 2 116 85 52 0

13151 1538191696 4 3 117 84 50 0

13160 1538191696 1 1 118 83 47 0

13169 1538191696 2 2 119 82 44 0

13178 1538191696 3 3 120 81 42 0

13187 1538191697 4 1 121 80 39 0

13196 1538191697 1 2 122 79 37 0

13205 1538191697 2 3 123 78 34 0

13214 1538191697 3 1 124 77 32 0

13223 1538191698 4 2 125 76 30 0

13232 1538191698 1 3 126 75 28 0

13241 1538191698 2 1 127 74 25 0

13250 1538191698 3 2 128 73 23 0

13259 1538191699 4 3 129 72 21 0

13268 1538191699 1 1 130 71 20 0

13277 1538191699 2 2 131 70 18 0

13286 1538191699 3 3 132 69 16 0

13295 1538191700 4 1 133 68 14 0

13304 1538191700 1 2 134 67 13 0

13313 1538191700 2 3 135 66 11 0

13322 1538191700 3 1 136 65 10 0

13331 1538191701 4 2 137 64 9 0

13340 1538191701 1 3 138 63 8 0

13349 1538191701 2 1 139 62 6 0

13358 1538191701 3 2 140 61 5 0

13367 1538191702 4 3 141 60 4 0

13376 1538191702 1 1 142 59 4 0

13385 1538191702 2 2 143 58 3 0

13394 1538191702 3 3 144 57 2 0

13403 1538191703 4 1 145 56 2 0

13412 1538191703 1 2 146 55 1 0

13421 1538191703 2 3 147 54 1 0

13430 1538191703 3 1 148 53 1 0

13439 1538191704 4 2 149 52 1 0

13448 1538191704 1 3 150 51 0 0

13457 1538191704 2 1 151 50 1 0

13466 1538191704 3 2 152 49 1 0

13475 1538191705 4 3 153 48 1 0

13484 1538191705 1 1 154 47 1 0

13493 1538191705 2 2 155 46 2 0

13502 1538191705 3 3 156 45 2 0

13511 1538191706 4 1 157 44 3 0

13520 1538191706 1 2 158 43 4 0

13529 1538191706 2 3 159 42 4 0

13538 1538191706 3 1 160 41 5 0

13547 1538191707 4 2 161 40 6 0

13556 1538191707 1 3 162 39 8 0

13565 1538191707 2 1 163 38 9 0

13574 1538191707 3 2 164 37 10 0

13583 1538191708 4 3 165 36 11 0

13592 1538191708 1 1 166 35 13 0

13601 1538191708 2 2 167 34 14 0

13610 1538191708 3 3 168 33 16 0

13619 1538191709 4 1 169 32 18 0

13628 1538191709 1 2 170 31 20 0

13637 1538191709 2 3 171 30 21 0

13646 1538191709 3 1 172 29 23 0

13655 1538191710 4 2 173 28 25 0

13664 1538191710 1 3 174 27 28 0

13673 1538191710 2 1 175 26 30 0

13682 1538191710 3 2 176 25 32 0

13691 1538191711 4 3 177 24 34 0

13700 1538191711 1 1 178 23 37 0

13709 1538191711 2 2 179 22 39 0

13718 1538191711 3 3 180 21 42 0

13727 1538191712 4 1 181 20 44 0

13736 1538191712 1 2 182 19 47 0

13745 1538191712 2 3 183 18 50 0

13754 1538191712 3 1 184 17 52 0

13763 1538191713 4 2 185 16 55 0

13772 1538191713 1 3 186 15 58 0

13781 1538191713 2 1 187 14 61 0

13790 1538191713 3 2 188 13 64 0

13799 1538191714 4 3 189 12 67 0

13808 1538191714 1 1 190 11 70 0

13817 1538191714 2 2 191 10 73 0

13826 1538191714 3 3 192 9 76 0

13835 1538191715 4 1 193 8 79 0

13844 1538191715 1 2 194 7 82 0

13853 1538191715 2 3 195 6 85 0

13862 1538191715 3 1 196 5 88 0

13871 1538191716 4 2 197 4 91 0

13880 1538191716 1 3 198 3 94 0

13889 1538191716 2 1 199 2 97 0

13898 1538191716 3 2 200 1 100 0

13907 1538191717 4 3 0 0 100 0

13916 1538191717 1 1 1 200 103 0

13925 1538191717 2 2 2 199 106 0

13934 1538191717 3 3 3 198 109 0

13943 1538191718 4 1 4 197 112 0

13952 1538191718 1 2 5 196 115 0

13961 1538191718 2 3 6 195 118 0

13970 1538191718 3 1 7 194 121 0

13979 1538191719 4 2 8 193 124 0

13988 1538191719 1 3 9 192 127 0

13997 1538191719 2 1 10 191 130 0

14006 1538191719 3 2 11 190 133 0

14015 1538191720 4 3 12 189 136 0

14024 1538191720 1 1 13 188 139 0

14033 1538191720 2 2 14 187 142 0

14042 1538191720 3 3 15 186 145 0

14051 1538191721 4 1 16 185 148 0

14060 1538191721 1 2 17 184 150 0

14069 1538191721 2 3 18 183 153 0

14078 1538191721 3 1 19 182 156 0

14087 1538191722 4 2 20 181 158 0

14096 1538191722 1 3 21 180 161 0

14105 1538191722 2 1 22 179 163 0

14114 1538191722 3 2 23 178 166 0

14123 1538191723 4 3 24 177 168 0

14132 1538191723 1 1 25 176 170 0

14141 1538191723 2 2 26 175 172 0

14150 1538191723 3 3 27 174 175 0

14159 1538191724 4 1 28 173 177 0

14168 1538191724 1 2 29 172 179 0

14177 1538191724 2 3 30 171 180 0

14186 1538191724 3 1 31 170 182 0

14195 1538191725 4 2 32 169 184 0

14204 1538191725 1 3 33 168 186 0

14213 1538191725 2 1 34 167 187 0

14222 1538191725 3 2 35 166 189 0

14231 1538191726 4 3 36 165 190 0

14240 1538191726 1 1 37 164 191 0

14249 1538191726 2 2 38 163 192 0

14258 1538191726 3 3 39 162 194 0

14267 1538191727 4 1 40 161 195 0

14276 1538191727 1 2 41 160 196 0

14285 1538191727 2 3 42 159 196 0

14294 1538191727 3 1 43 158 197 0

14303 1538191728 4 2 44 157 198 0

14312 1538191728 1 3 45 156 198 0

14321 1538191728 2 1 46 155 199 0

14330 1538191728 3 2 47 154 199 0

14339 1538191729 4 3 48 153 199 0

14348 1538191729 1 1 49 152 199 0

14357 1538191729 2 2 50 151 200 0

14366 1538191729 3 3 51 150 199 0

14375 1538191730 4 1 52 149 199 0

14384 1538191730 1 2 53 148 199 0

14393 1538191730 2 3 54 147 199 0

14402 1538191730 3 1 55 146 198 0

14411 1538191731 4 2 56 145 198 0

14420 1538191731 1 3 57 144 197 0

14429 1538191731 2 1 58 143 196 0

14438 1538191731 3 2 59 142 196 0

14447 1538191732 4 3 60 141 195 0

14456 1538191732 1 1 61 140 194 0

14465 1538191732 2 2 62 139 192 0

14474 1538191732 3 3 63 138 191 0

14483 1538191733 4 1 64 137 190 0

14492 1538191733 1 2 65 136 189 0

14501 1538191733 2 3 66 135 187 0

14510 1538191733 3 1 67 134 186 0

14519 1538191734 4 2 68 133 184 0

14528 1538191734 1 3 69 132 182 0

14537 1538191734 2 1 70 131 180 0

14546 1538191734 3 2 71 130 179 0

14555 1538191735 4 3 72 129 177 0

14564 1538191735 1 1 73 128 175 0

14573 1538191735 2 2 74 127 172 0

14582 1538191735 3 3 75 126 170 0

14591 1538191736 4 1 76 125 168 0

14600 1538191736 1 2 77 124 166 0

14609 1538191736 2 3 78 123 163 0

14618 1538191736 3 1 79 122 161 0

14627 1538191737 4 2 80 121 158 0

Port open

Initializing RTC...

Initializing FRAM...

Found I2C FRAM

read nextFramWriteAddr 14636 from address 0

Using interrupt number 5, pin 18

Clearing 2000 FRAM addresses...

Setting NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION (0) to FIRST_PKT_STORAGE_ADDR (2)

Displaying memory locations 0 to 2000

0x0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x10: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x20: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x30: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x40: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x50: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x60: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x70: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x80: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x90: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0xA0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0xB0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0xC0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0xD0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0xE0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0xF0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x100: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x110: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x120: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x130: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x140: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x150: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x160: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x170: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x180: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x190: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x1A0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x1B0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x1C0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x1D0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x1E0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x1F0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x200: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x210: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x220: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x230: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x240: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x250: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x260: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x270: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x280: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x290: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x2A0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x2B0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x2C0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x2D0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x2E0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x2F0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x300: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x310: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x320: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x330: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x340: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x350: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x360: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x370: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x380: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x390: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x3A0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x3B0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x3C0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x3D0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x3E0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x3F0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x400: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x410: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x420: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x430: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x440: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x450: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x460: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x470: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x480: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x490: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x4A0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x4B0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x4C0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x4D0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x4E0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x4F0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x500: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x510: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x520: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x530: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x540: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x550: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x560: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x570: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x580: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x590: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x5A0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x5B0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x5C0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x5D0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x5E0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x5F0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x600: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x610: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x620: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x630: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x640: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x650: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x660: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x670: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x680: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x690: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x6A0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x6B0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x6C0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x6D0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x6E0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x6F0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x700: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x710: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x720: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x730: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x740: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x750: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x760: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x770: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x780: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x790: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x7A0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x7B0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

0x7C0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

Enabling ISR, Entering Loop()addr unixtime mode submode Ldist Rdist Fdist batV

2 1538191746 1 1 1 200 103 0

11 1538191746 2 2 2 199 106 0

20 1538191747 3 3 3 198 109 0

29 1538191747 4 1 4 197 112 0

38 1538191747 1 2 5 196 115 0

displaying 5 packets, from address 2 to address 46

addr unixtime mode submode Ldist Rdist Fdist batV

2 1538191746 1 1 1 200 103 0

11 1538191746 2 2 2 199 106 0

20 1538191747 3 3 3 198 109 0

29 1538191747 4 1 4 197 112 0

38 1538191747 1 2 5 196 115 0

---------------- Done!-----------------

addr unixtime mode submode Ldist Rdist Fdist batV

47 1538191747 2 3 6 195 118 0

56 1538191748 3 1 7 194 121 0

65 1538191748 4 2 8 193 124 0

74 1538191748 1 3 9 192 127 0

83 1538191748 2 1 10 191 130 0

92 1538191749 3 2 11 190 133 0

101 1538191749 4 3 12 189 136 0

110 1538191749 1 1 13 188 139 0

119 1538191749 2 2 14 187 142 0

128 1538191750 3 3 15 186 145 0

137 1538191750 4 1 16 185 148 0

146 1538191750 1 2 17 184 150 0

155 1538191750 2 3 18 183 153 0

164 1538191751 3 1 19 182 156 0

173 1538191751 4 2 20 181 158 0

182 1538191751 1 3 21 180 161 0

191 1538191751 2 1 22 179 163 0

200 1538191752 3 2 23 178 166 0

209 1538191752 4 3 24 177 168 0

218 1538191752 1 1 25 176 170 0

227 1538191752 2 2 26 175 172 0

236 1538191753 3 3 27 174 175 0

245 1538191753 4 1 28 173 177 0

254 1538191753 1 2 29 172 179 0

263 1538191753 2 3 30 171 180 0

272 1538191754 3 1 31 170 182 0

displaying 26 packets, from address 47 to address 280

addr unixtime mode submode Ldist Rdist Fdist batV

47 1538191747 2 3 6 195 118 0

56 1538191748 3 1 7 194 121 0

65 1538191748 4 2 8 193 124 0

74 1538191748 1 3 9 192 127 0

83 1538191748 2 1 10 191 130 0

92 1538191749 3 2 11 190 133 0

101 1538191749 4 3 12 189 136 0

110 1538191749 1 1 13 188 139 0

119 1538191749 2 2 14 187 142 0

128 1538191750 3 3 15 186 145 0

137 1538191750 4 1 16 185 148 0

146 1538191750 1 2 17 184 150 0

155 1538191750 2 3 18 183 153 0

164 1538191751 3 1 19 182 156 0

173 1538191751 4 2 20 181 158 0

182 1538191751 1 3 21 180 161 0

191 1538191751 2 1 22 179 163 0

200 1538191752 3 2 23 178 166 0

209 1538191752 4 3 24 177 168 0

218 1538191752 1 1 25 176 170 0

227 1538191752 2 2 26 175 172 0

236 1538191753 3 3 27 174 175 0

245 1538191753 4 1 28 173 177 0

254 1538191753 1 2 29 172 179 0

263 1538191753 2 3 30 171 180 0

272 1538191754 3 1 31 170 182 0

---------------- Done!-----------------

addr unixtime mode submode Ldist Rdist Fdist batV

281 1538191754 4 2 32 169 184 0

290 1538191754 1 3 33 168 186 0

displaying 2 packets, from address 281 to address 298

addr unixtime mode submode Ldist Rdist Fdist batV

281 1538191754 4 2 32 169 184 0

290 1538191754 1 3 33 168 186 0

---------------- Done!-----------------

addr unixtime mode submode Ldist Rdist Fdist batV

299 1538191754 2 1 34 167 187 0

308 1538191755 3 2 35 166 189 0

317 1538191755 4 3 36 165 190 0

326 1538191755 1 1 37 164 191 0

335 1538191755 2 2 38 163 192 0

344 1538191756 3 3 39 162 194 0

353 1538191756 4 1 40 161 195 0

362 1538191756 1 2 41 160 196 0

371 1538191756 2 3 42 159 196 0

380 1538191757 3 1 43 158 197 0

389 1538191757 4 2 44 157 198 0

398 1538191757 1 3 45 156 198 0

407 1538191757 2 1 46 155 199 0

416 1538191758 3 2 47 154 199 0

425 1538191758 4 3 48 153 199 0

434 1538191758 1 1 49 152 199 0

443 1538191758 2 2 50 151 200 0

452 1538191759 3 3 51 150 199 0

461 1538191759 4 1 52 149 199 0

470 1538191759 1 2 53 148 199 0

479 1538191759 2 3 54 147 199 0

488 1538191760 3 1 55 146 198 0

497 1538191760 4 2 56 145 198 0

506 1538191760 1 3 57 144 197 0

515 1538191760 2 1 58 143 196 0

524 1538191761 3 2 59 142 196 0

533 1538191761 4 3 60 141 195 0

542 1538191761 1 1 61 140 194 0

551 1538191761 2 2 62 139 192 0

560 1538191762 3 3 63 138 191 0

569 1538191762 4 1 64 137 190 0

578 1538191762 1 2 65 136 189 0

587 1538191762 2 3 66 135 187 0

596 1538191763 3 1 67 134 186 0

605 1538191763 4 2 68 133 184 0

614 1538191763 1 3 69 132 182 0

623 1538191763 2 1 70 131 180 0

632 1538191764 3 2 71 130 179 0

641 1538191764 4 3 72 129 177 0

650 1538191764 1 1 73 128 175 0

659 1538191764 2 2 74 127 172 0

668 1538191765 3 3 75 126 170 0

677 1538191765 4 1 76 125 168 0

686 1538191765 1 2 77 124 166 0

695 1538191765 2 3 78 123 163 0

704 1538191766 3 1 79 122 161 0

713 1538191766 4 2 80 121 158 0

722 1538191766 1 3 81 120 156 0

731 1538191766 2 1 82 119 153 0

740 1538191767 3 2 83 118 150 0

749 1538191767 4 3 84 117 148 0

758 1538191767 1 1 85 116 145 0

767 1538191767 2 2 86 115 142 0

776 1538191768 3 3 87 114 139 0

785 1538191768 4 1 88 113 136 0

794 1538191768 1 2 89 112 133 0

803 1538191768 2 3 90 111 130 0

812 1538191769 3 1 91 110 127 0

821 1538191769 4 2 92 109 124 0

830 1538191769 1 3 93 108 121 0

839 1538191769 2 1 94 107 118 0

848 1538191770 3 2 95 106 115 0

857 1538191770 4 3 96 105 112 0

866 1538191770 1 1 97 104 109 0

displaying 64 packets, from address 299 to address 874

addr unixtime mode submode Ldist Rdist Fdist batV

299 1538191754 2 1 34 167 187 0

308 1538191755 3 2 35 166 189 0

317 1538191755 4 3 36 165 190 0

326 1538191755 1 1 37 164 191 0

335 1538191755 2 2 38 163 192 0

344 1538191756 3 3 39 162 194 0

353 1538191756 4 1 40 161 195 0

362 1538191756 1 2 41 160 196 0

371 1538191756 2 3 42 159 196 0

380 1538191757 3 1 43 158 197 0

389 1538191757 4 2 44 157 198 0

398 1538191757 1 3 45 156 198 0

407 1538191757 2 1 46 155 199 0

416 1538191758 3 2 47 154 199 0

425 1538191758 4 3 48 153 199 0

434 1538191758 1 1 49 152 199 0

443 1538191758 2 2 50 151 200 0

452 1538191759 3 3 51 150 199 0

461 1538191759 4 1 52 149 199 0

470 1538191759 1 2 53 148 199 0

479 1538191759 2 3 54 147 199 0

488 1538191760 3 1 55 146 198 0

497 1538191760 4 2 56 145 198 0

506 1538191760 1 3 57 144 197 0

515 1538191760 2 1 58 143 196 0

524 1538191761 3 2 59 142 196 0

533 1538191761 4 3 60 141 195 0

542 1538191761 1 1 61 140 194 0

551 1538191761 2 2 62 139 192 0

560 1538191762 3 3 63 138 191 0

569 1538191762 4 1 64 137 190 0

578 1538191762 1 2 65 136 189 0

587 1538191762 2 3 66 135 187 0

596 1538191763 3 1 67 134 186 0

605 1538191763 4 2 68 133 184 0

614 1538191763 1 3 69 132 182 0

623 1538191763 2 1 70 131 180 0

632 1538191764 3 2 71 130 179 0

641 1538191764 4 3 72 129 177 0

650 1538191764 1 1 73 128 175 0

659 1538191764 2 2 74 127 172 0

668 1538191765 3 3 75 126 170 0

677 1538191765 4 1 76 125 168 0

686 1538191765 1 2 77 124 166 0

695 1538191765 2 3 78 123 163 0

704 1538191766 3 1 79 122 161 0

713 1538191766 4 2 80 121 158 0

722 1538191766 1 3 81 120 156 0

731 1538191766 2 1 82 119 153 0

740 1538191767 3 2 83 118 150 0

749 1538191767 4 3 84 117 148 0

758 1538191767 1 1 85 116 145 0

767 1538191767 2 2 86 115 142 0

776 1538191768 3 3 87 114 139 0

785 1538191768 4 1 88 113 136 0

794 1538191768 1 2 89 112 133 0

803 1538191768 2 3 90 111 130 0

812 1538191769 3 1 91 110 127 0

821 1538191769 4 2 92 109 124 0

830 1538191769 1 3 93 108 121 0

839 1538191769 2 1 94 107 118 0

848 1538191770 3 2 95 106 115 0

857 1538191770 4 3 96 105 112 0

866 1538191770 1 1 97 104 109 0

---------------- Done!-----------------

addr unixtime mode submode Ldist Rdist Fdist batV

875 1538191771 2 2 98 103 106 0

884 1538191771 3 3 99 102 103 0

893 1538191771 4 1 100 101 100 0

902 1538191771 1 2 101 100 97 0

911 1538191771 2 3 102 99 94 0

920 1538191772 3 1 103 98 91 0

929 1538191772 4 2 104 97 88 0

938 1538191772 1 3 105 96 85 0

947 1538191772 2 1 106 95 82 0

956 1538191773 3 2 107 94 79 0

965 1538191773 4 3 108 93 76 0

974 1538191773 1 1 109 92 73 0

983 1538191773 2 2 110 91 70 0

992 1538191774 3 3 111 90 67 0

1001 1538191774 4 1 112 89 64 0

1010 1538191774 1 2 113 88 61 0

1019 1538191774 2 3 114 87 58 0

1028 1538191775 3 1 115 86 55 0

1037 1538191775 4 2 116 85 52 0

1046 1538191775 1 3 117 84 50 0

1055 1538191775 2 1 118 83 47 0

1064 1538191776 3 2 119 82 44 0

1073 1538191776 4 3 120 81 42 0

1082 1538191776 1 1 121 80 39 0

1091 1538191776 2 2 122 79 37 0

1100 1538191777 3 3 123 78 34 0

Port closed

And here is an Excel plot showing the simulated values

Plot of the simulated values generated by the test program

So now I have a way for Wall-E2 to write a minute-by-minute diary of its operating state to non-volatile storage, but I don’t yet have a good way to read it all back out again. That’s the next step – stay tuned!

01 October Update:

I created a small program to read back telemetry packets from FRAM. When I want to see what Wall-E2 has been up to, I will replace his normal operating firmware with this sketch, which will allow me to read out all or parts of FRAM contents. The sketch is included below:

/*
    Name:       FramPacketReadout.ino
    Created:	9/29/2018 7:01:55 PM
    Author:     DESKTOP-0KFED77\Frank

	The purpose of this project is to develop the code needed to display
	telemetry packets from Wall-E2, stored in encoded form in the onboard FRAM.
	The idea is to read out the packets with the timestamp in human-readable form,
	along with the other information.

	The stored telemetry packet is formatted as a 10-byte packet:
		Time: 4-bytes
		mode/submode: 1 byte
		left distance: 1 byte
		right distance: 1 byte
		forward distance: 1 byte
		battery voltage above 5V: 1 byte

	This project makes use of the CFRAMStatePacket class, which is completely defined
	in FramPacket.h (no .cpp file - just the .h).  This class contains methods to read
	and write telemetry packets from/to an Adafruit FRAM breakout board, accessible through
	the Adafruit_FRAM_I2C library

	To use the CFRAMStatePacket class, an object is instantiated using a constructor that
	takes a single parameter - the address of the Adafruit_FRAM_I2C FRAM driver object. This
	pointer is then used for all interactions with the FRAM.
*/

#include <Wire.h>
#include "Adafruit_FRAM_I2C.h"
#include <time.h>;
#include <PrintEx.h>
#include <elapsedMillis/elapsedMillis.h>
#include <Time-master/time.h>
#include <avr/sleep.h> //needed for sleep() functions

//#include <math.h>
StreamEx mySerial = Serial;
elapsedMillis mSecSinceLastPacketWrite;
Adafruit_FRAM_I2C fram = Adafruit_FRAM_I2C();

const int FIRST_PKT_STORAGE_ADDR = 2;//addr 0/1 reserved for nextFramWriteAddr
//const int FIRST_PKT_STORAGE_ADDR = 32000;//09/29/18 for rollover debug
const int NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION = 0; //the next free address is written to this address
const int LAST_AVAIL_PACKET_WRITE_ADDR = 32759; //last packet write address avail in 256kb FRAM
int ReadStartAddress = FIRST_PKT_STORAGE_ADDR; //writing starts with this address
int ReadStopAddress = LAST_AVAIL_PACKET_WRITE_ADDR;
//FramPacket.h holds 'inline' definition of CFRAMStatePacket class 
//this has to come after #include "Adafruit_FRAM_I2C.h" and Adafruit_FRAM_I2C fram = Adafruit_FRAM_I2C();
#include "FramPacket.h" 
CFRAMStatePacket packet = CFRAMStatePacket(&fram); //this object is used for all FRAM transactions

//fwd declaration required to avoid '... does not name a type' error
CFRAMStatePacket GetNextSimFRAMPacket(CFRAMStatePacket pkt);

//char daysOfTheWeek[7][12] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
char Instr[20];
int packetsize = CFRAMStatePacket::packet_size;


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


	//initialize FRAM - this reads/checks FRAM device IDs to confirm valid connection
	mySerial.printf("Initializing FRAM...\n");
	if (fram.begin()) // you can stick the new i2c addr in here, e.g. begin(0x51);
	{
		Serial.println("Found I2C FRAM");
	}
	else
	{
		Serial.println("I2C FRAM not identified ... check your connections?\r\n");
		Serial.println("Will continue in case this processor doesn't support repeated start\r\n");
	}


	//Display 4 undecoded packets from 2 through 29 to establish baseline
	DisplayFRAMPackets(2, 30);

	//do a test by reading just the first packet, and showing it to the user
	packet.Read(ReadStartAddress);
	packet.PrintHumanReadable();

	//get start address for readout
	mySerial.printf("In Setup()\n");
	ReadStartAddress = GetIntegerParameter("FRAM Readout Start Address (>= 2)", 2);
	ReadStopAddress = GetIntegerParameter("FRAM Readout Stop Address (<= 32759", LAST_AVAIL_PACKET_WRITE_ADDR);
	mySerial.printf("start/stop addresses are %d, %d\n", ReadStartAddress, ReadStopAddress);

	mySerial.printf("Entering print loop - send any key to terminate\n");

	mySerial.printf("addr\tdate/time\t\t\tmode\tsubmode\tLdist\tRdist\tFdist\tbatV\n");
}

void loop()
{
	int readaddr = ReadStartAddress;
	Serial.flush();
	char readbuf[80];
	int numchars = Serial.available();
	//mySerial.printf("There are %d chars available in serial channel\n", numchars);
	while (numchars > 0)
	{
		Serial.readBytes(readbuf, 80);
		//mySerial.printf("There are still %d chars available in serial channel\n", numchars);
	}

	while (readaddr <= ReadStopAddress && Serial.available() == 0)
	{
		//read, decode, and print a FRAM packet
		//mySerial.printf("Printing address %d....\n", readaddr);
		packet.Read(readaddr);
		mySerial.printf("%d\t", readaddr); //put address in 1st column
		packet.PrintHumanReadable();//prints date/time in human-readable form
		readaddr += packetsize;

		//check for  user input
		if (Serial.available() > 0)
		{
			// read the incoming byte:
			int incomingByte = Serial.read();

			// say what you got:
			Serial.print("I received: ");
			Serial.println(incomingByte, DEC);

			Serial.print("Quitting the program!");
			delay(1000);
			cli();
			sleep_enable();
			sleep_cpu();
		}
	}

	mySerial.printf("Finished printing requested FRAM addresses - have a nice day! ;-)\n");
	delay(1000);
	cli();
	sleep_enable();
	sleep_cpu();
}

int GetIntegerParameter(String prompt, int defaultval)
{
	int param = 0;
	bool bDone = false;

	while (!bDone)
	{
		Serial.print(prompt); Serial.print(" ("); Serial.print(defaultval); Serial.print("): ");
		while (Serial.available() == 0); //waits for input
		String res = Serial.readString();

		res.trim();
		int reslen = res.length();
		if (reslen == 0) //user entered CR only
		{
			bDone = true;
			param = defaultval;
		}
		else
		{
			res.toCharArray(Instr, reslen + 1);
			if (isNumeric(Instr))
			{
				param = atoi(Instr);
				bDone = true;
			}
			else
			{
				Serial.print(Instr); Serial.println(" Is invalid input - please try again");
			}
		}
	}
	Serial.println(param);
	return param;
}

// check a string to see if it is numeric and accept Decimal point
//copied from defragster's post at https://forum.pjrc.com/threads/27842-testing-if-a-string-is-numeric
bool isNumeric(char * str)
{
	byte ii = 0;
	bool RetVal = false;
	if ('-' == str[ii])
		ii++;
	while (str[ii])
	{
		if ('.' == str[ii]) {
			ii++;
			break;
		}
		if (!isdigit(str[ii])) return false;
		ii++;
		RetVal = true;
	}
	while (str[ii])
	{
		if (!isdigit(str[ii])) return false;
		ii++;
		RetVal = true;
	}
	return RetVal;
}

void DisplayFRAMPackets(int startaddr, int stopaddr)
{
	//Purpose:  Read complete state packets from the FRAM between the specified addresses
	//	The telemetry packet is formatted as a 10 - byte packet :
	//		Time: 4 - bytes
	//		mode / submode : 1 byte
	//		left distance : 1 byte
	//		right distance : 1 byte
	//		forward distance : 1 byte
	//		battery voltage above 5V : 1 byte
	//Inputs:
	//	nextreadaddr = 1st address to be read
	//	nextwriteaddr = next available address for writes
	//Notes:
	//	09/28/18 c/o prevDispFramEndAddr = nextwriteaddr - 1; now done in calling pgm


	int numpackets = 1 + (stopaddr - startaddr - 1) / CFRAMStatePacket::packet_size;
	mySerial.printf("\ndisplaying %d packets, from address %d to address %d\n", numpackets, startaddr, stopaddr - 1);

	mySerial.printf("addr\tunixtime\t\tmode\tsubmode\tLdist\tRdist\tFdist\tbatV\n");

	for (int i = 0; i < numpackets; i++)
	{
		mySerial.printf("%d\t", startaddr); //puts fram addr in front of each packet readout
		startaddr = packet.Read(startaddr);
		packet.Print();
	}
	mySerial.printf("---------------- Done!-----------------\n\n");
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

Name: FramPacketReadout.ino

Created: 9/29/2018 7:01:55 PM

Author: DESKTOP-0KFED77\Frank

The purpose of this project is to develop the code needed to display

telemetry packets from Wall-E2, stored in encoded form in the onboard FRAM.

The idea is to read out the packets with the timestamp in human-readable form,

along with the other information.

The stored telemetry packet is formatted as a 10-byte packet:

Time: 4-bytes

mode/submode: 1 byte

left distance: 1 byte

right distance: 1 byte

forward distance: 1 byte

battery voltage above 5V: 1 byte

This project makes use of the CFRAMStatePacket class, which is completely defined

in FramPacket.h (no .cpp file - just the .h). This class contains methods to read

and write telemetry packets from/to an Adafruit FRAM breakout board, accessible through

the Adafruit_FRAM_I2C library

To use the CFRAMStatePacket class, an object is instantiated using a constructor that

takes a single parameter - the address of the Adafruit_FRAM_I2C FRAM driver object. This

pointer is then used for all interactions with the FRAM.

#include <Wire.h>

#include "Adafruit_FRAM_I2C.h"

#include <time.h>;

#include <PrintEx.h>

#include <elapsedMillis/elapsedMillis.h>

#include <Time-master/time.h>

#include <avr/sleep.h> //needed for sleep() functions

//#include <math.h>

StreamEx mySerial = Serial;

elapsedMillis mSecSinceLastPacketWrite;

Adafruit_FRAM_I2C fram = Adafruit_FRAM_I2C();

const int FIRST_PKT_STORAGE_ADDR = 2;//addr 0/1 reserved for nextFramWriteAddr

//const int FIRST_PKT_STORAGE_ADDR = 32000;//09/29/18 for rollover debug

const int NEXTFRAMWRITEADDR_FRAMSTORAGELOCATION = 0; //the next free address is written to this address

const int LAST_AVAIL_PACKET_WRITE_ADDR = 32759; //last packet write address avail in 256kb FRAM

int ReadStartAddress = FIRST_PKT_STORAGE_ADDR; //writing starts with this address

int ReadStopAddress = LAST_AVAIL_PACKET_WRITE_ADDR;

//FramPacket.h holds 'inline' definition of CFRAMStatePacket class

//this has to come after #include "Adafruit_FRAM_I2C.h" and Adafruit_FRAM_I2C fram = Adafruit_FRAM_I2C();

#include "FramPacket.h"

CFRAMStatePacket packet = CFRAMStatePacket(&fram); //this object is used for all FRAM transactions

//fwd declaration required to avoid '... does not name a type' error

CFRAMStatePacket GetNextSimFRAMPacket(CFRAMStatePacket pkt);

//char daysOfTheWeek[7][12] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };

char Instr[20];

int packetsize = CFRAMStatePacket::packet_size;

void setup()

{

Serial.begin(115200);

//initialize FRAM - this reads/checks FRAM device IDs to confirm valid connection

mySerial.printf("Initializing FRAM...\n");

if (fram.begin()) // you can stick the new i2c addr in here, e.g. begin(0x51);

{

Serial.println("Found I2C FRAM");

}

else

{

Serial.println("I2C FRAM not identified ... check your connections?\r\n");

Serial.println("Will continue in case this processor doesn't support repeated start\r\n");

}

//Display 4 undecoded packets from 2 through 29 to establish baseline

DisplayFRAMPackets(2, 30);

//do a test by reading just the first packet, and showing it to the user

packet.Read(ReadStartAddress);

packet.PrintHumanReadable();

//get start address for readout

mySerial.printf("In Setup()\n");

ReadStartAddress = GetIntegerParameter("FRAM Readout Start Address (>= 2)", 2);

ReadStopAddress = GetIntegerParameter("FRAM Readout Stop Address (<= 32759", LAST_AVAIL_PACKET_WRITE_ADDR);

mySerial.printf("start/stop addresses are %d, %d\n", ReadStartAddress, ReadStopAddress);

mySerial.printf("Entering print loop - send any key to terminate\n");

mySerial.printf("addr\tdate/time\t\t\tmode\tsubmode\tLdist\tRdist\tFdist\tbatV\n");

}

void loop()

{

int readaddr = ReadStartAddress;

Serial.flush();

char readbuf[80];

int numchars = Serial.available();

//mySerial.printf("There are %d chars available in serial channel\n", numchars);

while (numchars > 0)

{

Serial.readBytes(readbuf, 80);

//mySerial.printf("There are still %d chars available in serial channel\n", numchars);

}

while (readaddr <= ReadStopAddress && Serial.available() == 0)

{

//read, decode, and print a FRAM packet

//mySerial.printf("Printing address %d....\n", readaddr);

packet.Read(readaddr);

mySerial.printf("%d\t", readaddr); //put address in 1st column

packet.PrintHumanReadable();//prints date/time in human-readable form

readaddr += packetsize;

//check for user input

if (Serial.available() > 0)

{

// read the incoming byte:

int incomingByte = Serial.read();

// say what you got:

Serial.print("I received: ");

Serial.println(incomingByte, DEC);

Serial.print("Quitting the program!");

delay(1000);

cli();

sleep_enable();

sleep_cpu();

}

mySerial.printf("Finished printing requested FRAM addresses - have a nice day! ;-)\n");

delay(1000);

cli();

sleep_enable();

sleep_cpu();

}

int GetIntegerParameter(String prompt, int defaultval)

{

int param = 0;

bool bDone = false;

while (!bDone)

{

Serial.print(prompt); Serial.print(" ("); Serial.print(defaultval); Serial.print("): ");

while (Serial.available() == 0); //waits for input

String res = Serial.readString();

res.trim();

int reslen = res.length();

if (reslen == 0) //user entered CR only

{

bDone = true;

param = defaultval;

}

else

{

res.toCharArray(Instr, reslen + 1);

if (isNumeric(Instr))

{

param = atoi(Instr);

bDone = true;

}

else

{

Serial.print(Instr); Serial.println(" Is invalid input - please try again");

}

Serial.println(param);

return param;

}

// check a string to see if it is numeric and accept Decimal point

//copied from defragster's post at https://forum.pjrc.com/threads/27842-testing-if-a-string-is-numeric

bool isNumeric(char * str)

{

byte ii = 0;

bool RetVal = false;

if ('-' == str[ii])

ii++;

while (str[ii])

{

if ('.' == str[ii]) {

ii++;

break;

}

if (!isdigit(str[ii])) return false;

ii++;

RetVal = true;

}

while (str[ii])

{

if (!isdigit(str[ii])) return false;

ii++;

RetVal = true;

}

return RetVal;

}

void DisplayFRAMPackets(int startaddr, int stopaddr)

{

//Purpose: Read complete state packets from the FRAM between the specified addresses

// The telemetry packet is formatted as a 10 - byte packet :

// Time: 4 - bytes

// mode / submode : 1 byte

// left distance : 1 byte

// right distance : 1 byte

// forward distance : 1 byte

// battery voltage above 5V : 1 byte

//Inputs:

// nextreadaddr = 1st address to be read

// nextwriteaddr = next available address for writes

//Notes:

// 09/28/18 c/o prevDispFramEndAddr = nextwriteaddr - 1; now done in calling pgm

int numpackets = 1 + (stopaddr - startaddr - 1) / CFRAMStatePacket::packet_size;

mySerial.printf("\ndisplaying %d packets, from address %d to address %d\n", numpackets, startaddr, stopaddr - 1);

mySerial.printf("addr\tunixtime\t\tmode\tsubmode\tLdist\tRdist\tFdist\tbatV\n");

for (int i = 0; i < numpackets; i++)

{

mySerial.printf("%d\t", startaddr); //puts fram addr in front of each packet readout

startaddr = packet.Read(startaddr);

packet.Print();

}

mySerial.printf("---------------- Done!-----------------\n\n");

}

and a typical output run is shown below. Note that this program decodes the stored 4-byte unix time value into human-readable date/time format. And yes, I know it’s in that funny ‘American’ mm/dd/yyyy format, but I’m an American, so … ;-).

Opening port
Port open
Initializing FRAM...
Found I2C FRAM

displaying 4 packets, from address 2 to address 29
addr	unixtime		mode	submode	Ldist	Rdist	Fdist	batV
2	1538219039	1	1	58	143	196	0
11	1538219039	2	2	59	142	196	0
20	1538219039	3	3	60	141	195	0
29	1538219040	4	1	61	140	194	0
---------------- Done!-----------------

11:03:59 09/29/2018	1	1	58	143	196	0
In Setup()
FRAM Readout Start Address (>= 2) (2): 2
FRAM Readout Stop Address (<= 32759 (32759): 100
start/stop addresses are 2, 100
Entering print loop - send any key to terminate
addr	date/time			mode	submode	Ldist	Rdist	Fdist	batV
2	11:03:59 09/29/2018	1	1	58	143	196	0
11	11:03:59 09/29/2018	2	2	59	142	196	0
20	11:03:59 09/29/2018	3	3	60	141	195	0
29	11:04:00 09/29/2018	4	1	61	140	194	0
38	11:04:00 09/29/2018	1	2	62	139	192	0
47	11:04:00 09/29/2018	2	3	63	138	191	0
56	11:04:00 09/29/2018	3	1	64	137	190	0
65	11:04:01 09/29/2018	4	2	65	136	189	0
74	11:04:01 09/29/2018	1	3	66	135	187	0
83	11:04:01 09/29/2018	2	1	67	134	186	0
92	11:04:01 09/29/2018	3	2	68	133	184	0
Finished printing requested FRAM addresses - have a nice day! ;-)

Opening port

Port open

Initializing FRAM...

Found I2C FRAM

displaying 4 packets, from address 2 to address 29

addr unixtime mode submode Ldist Rdist Fdist batV

2 1538219039 1 1 58 143 196 0

11 1538219039 2 2 59 142 196 0

20 1538219039 3 3 60 141 195 0

29 1538219040 4 1 61 140 194 0

---------------- Done!-----------------

11:03:59 09/29/2018 1 1 58 143 196 0

In Setup()

FRAM Readout Start Address (>= 2) (2): 2

FRAM Readout Stop Address (<= 32759 (32759): 100

start/stop addresses are 2, 100

Entering print loop - send any key to terminate

addr date/time mode submode Ldist Rdist Fdist batV

2 11:03:59 09/29/2018 1 1 58 143 196 0

11 11:03:59 09/29/2018 2 2 59 142 196 0

20 11:03:59 09/29/2018 3 3 60 141 195 0

29 11:04:00 09/29/2018 4 1 61 140 194 0

38 11:04:00 09/29/2018 1 2 62 139 192 0

47 11:04:00 09/29/2018 2 3 63 138 191 0

56 11:04:00 09/29/2018 3 1 64 137 190 0

65 11:04:01 09/29/2018 4 2 65 136 189 0

74 11:04:01 09/29/2018 1 3 66 135 187 0

83 11:04:01 09/29/2018 2 1 67 134 186 0

92 11:04:01 09/29/2018 3 2 68 133 184 0

Finished printing requested FRAM addresses - have a nice day! ;-)

Frank

Integrating Time, Memory, and Heading Capability, Part VIII

Leave a reply

Posted 13 September 2018

Now that I have worked out most of the problems associated with the MPU6050 6DOF IMU module, it was time to integrate the new heading-based turn algorithm into the main Wall-E2 operating system. As I have done in many past projects over the last half-century or so, I started this process by documenting the entire OS, with particular emphasis on how Wall-E2 currently navigates around his world. When I started doing this in the 1970’s, the medium I used was an MIT Engineering notebook, hand-written in ink. Over the ensuing decades the medium has changed, but not the basic idea – the process of putting coherent sentences and paragraphs onto paper (or screen) forces me to think through what is – and is not – important/true. I have solved many a seemingly intractable problem not with an oscilloscope or debugging tool, but by simply writing things down. In the current iteration of this process, I use Microsoft Word (not for any particular reason, except that it is available and familiar) initially, and then dump the results into a post like this one – see below ;-).

Description of FourWD_WallE2_V1 Navigation Algorithm

09/04/18

At the start of each pass through loop(), the software determines the current OPMODE given the current environment and the immediately previous OPMODE. The existing OPMODEs are NONE, CHARGING, IRHOMING, WALLFOLLOW, and DEADBATTERY

NONE: Default OPMODE when no other mode can be found to apply to the situation. As of this writing, the only use for this OPMODE is to initialize the PrevOpMode and CurrentOpMode loop variables in Setings()
CHARGING: set in GetOpMode() if the charger is physically connected (CHG_CONNECT_PIN goes HIGH) and the CHG_SIG_PIN is active (LOW). In the CurrentOpMode Switch the PrevOpMode is also set to CHARGING (so that both prev and current op modes are CHARGING), the motors are stopped, and MonitorChargeUntilDone() is called.
- MonitorChargeUntilDone() blocks until charging is complete, or the BATT_CHG_TIMEOUT value is reached or the charger is physically disconnected (manually pulled out for some reason).
IRHOMING: Set in GetOpMode() when the call to IRBeamAvail() (checks IR beacon signal strength) returns TRUE. In the CurrentOpMode Switch the PrevOpMode is also set to IRHOMING (so that both prev and current op modes are IRHOMING). A blocking call is made to IRHomeToChgStn() with an Avoidance Distance’ of 0 for hungry’ or 30cm (for full- no need to charge’. The idea here is that in the full’ case, the robot will continue to home until near the charging station, and then break off.
- IRHomeToChgStn(): sets up a PID and enters a loop, exited only when either the charger connects, or the robot gets stuck or it gets too close to the charging station (this can only happen in the full’ case). Is Stuck’ is determined in IsStuck() if the front distance variance gets too small (i.e. the front distance isn’t changing).
WALLFOLLOW: This is the OpMode that is assigned by GetOpMode() when none of the other mode conditions apply. IOW, this is what the robot does when it isn’t doing anything else. In the WALLFOLLOW Case section of the CurrentOpMode Switch, the wall-following operation is further broken down into a TrackingCase Switch, with TRACKING_LEFT, TRACKING_RIGHT, TRACKING_NEITHER sub-modes, with state mode variables maintained for both the current and previous tracking modes. Each time through the loop(), the various tracking cases make one adjustment to the left/right motor speeds. there are no blocking calls at all in the entire WALLFOLLOW section, with the exception of the BackupAndTurn()’ calls in the TRACKING_LEFT and TRACKING_RIGHT cases when an obstruction or the stuck’ condition is detected.
- BackupAndTurn( bool bIsLeft, int motor_speed): The idea here is for the robot to back up and do a course change to extract itself from some situation. Up until now, this has been accomplished by making a timed turn one way or the other, but this hasn’t worked well because the correct time for turning on carpet is wildly different than the correct time on hard flooring. The new heading sensor is intended to solve this problem.
- Now that Wall-E2 can make accurate turns, the question becomes “what’s the best way to do obstruction-avoidance or stuck-recovery turns?”. If Wall-E2 is following a wall when it gets stuck, maybe it should back up slightly and try to go around, or maybe it should just turn around and go back the way it came. Maybe a simple obstruction should be treated one way, but a stuck’ condition treated another? The go back the way I came’ model is simple enough but might result in an uninteresting ping-pong’ shuttle track where it stays until it runs out of battery. A more complex response might allow the robot to go around obstacles and continue its journey? Maybe it backs up slightly (wall-following in reverse, maybe?), and then makes an X degree turn away from the wall, runs straight for a second, and then starts wall following again.

09/05/18

The current BackupAndTurn()’ routine takes bIsLeft, a Boolean representing the current tracking direction (left or right) and a motor speed. All it does is call RollingTurnRev(bIsLeft, 1500), where 1500 is the time in millisecond to run the motors.

RollingTurnRev() just calls RunBothMotorsMsec() with the motor speed on one side set to MAX and on the other to OFF (we know this won’t work on Wall-E2, because the wheelbase is too wide – he just locks up.

RollingTurnRev() is called in two places; ExecDiscManeuver() and BackupAndTurn(). BackupAndTurn() is called from 4 places; TRACKING_NEITHER/RIGHT/LEFT, and IRHomeToChgStn(). In all these cases, the robot knows which (if any) wall is closer, so it can execute the proper rolling turn

From what I see so far, it appears all these cases can be handled by a turn routine that does the following:

Moves straight backward for just a second or so (or maybe even less)
Makes a 45 ° forward rolling turn away from the nearest wall. If there is no nearest wall, go opposite the way it went last time (requires a global Boolean to save this value)
Makes another 45 turn in the opposite direction to the first one. This will have the effect of a side-step maneuver, as shown in this post.

After this review, it was clear that all I had to do to integrate the new heading-based turn capability into Wall-E2’s OS was to replace the RollingTurnRev() function with a new ‘RollingTurn()’ function that takes flags for FWD/REV and for CCW/CW, and a parameter for the number of degrees to turn. Since I had already demonstrated all the code blocks in stand-alone test programs, all I had to do was copy the appropriate code pieces into the appropriate spots in Wall-E2’s OS, and then spiff things up a bit here and there. When I was done, I had a single function that could facilitate a range of maneuvers.

To test the newly integrated capability, I added some code to Wall-E2’s setup() function to perform a series of S-turns, each of which demonstrates a typical avoidance maneuver. For convenience, I told Wall-E2 to execute a ‘K-turn’ reversal and then S-turn his way back to me. As can be seen in the following short video, this worked fairly well!

Now that I have the basic heading-based turn capability integrated into Wall-E2, the next step will be to demonstrate that Wall-E2 can use its new superpowers to avoid obstacles in ‘the real world’ (as real as it gets for Wall-E2, anyway).

Stay tuned!

Frank