Monthly Archives: March 2020

I2C between an Arduino Mega and a Teensy 3.x

posted 18 March 2020

This post describes my efforts to troubleshoot an I2C communications problem between an Arduino Mega control board and a Teensy 3.2 IR beam demodulation module.

Background:

My Wall-E2 autonomous wall-following robot homes in on a modulated IR beacon to connect to a charging station. The IR beacon modulation is decoded by a dedicated Teensy 3.2 and provides left/right and combined steering values to an Arduino Mega main controller over an I2C link.

During my recent work to update the robot after some enhancements, I discovered that the main controller was no longer receiving steering information from the Teensy, even though both seemed to be operating properly. Initial efforts to troubleshoot the problem did not bear fruit, so I was forced to back up and start over from scratch.

Troubleshooting:

Initially I thought the problem was a loose connection, as the system was working before. However, I am now pretty sure that I have eliminated all the obvious culprits, so I am left with the non-obvious ones.

To start with, I resurrected an old example project to demonstrate I2C master/slave operation between two Teensy modules.

Teensy 3.2 Slave (left) and Teensy 3.5 Master (right)

Here’s the Teensy ‘Master’ code:

// -------------------------------------------------------------------------------------------
// Basic Master
// -------------------------------------------------------------------------------------------
//
// This creates a simple I2C Master device which when triggered will send/receive a text 
// string to/from a Slave device.  It is intended to pair with a Slave device running the 
// basic_slave sketch.
//
// Pull pin12 input low to send.
// Pull pin11 input low to receive.
//
// This example code is in the public domain.
//
// -------------------------------------------------------------------------------------------

#include <i2c_t3.h>
#include <T3_I2C_Anything.h>

// Memory
#define MEM_LEN 256
char databuf[MEM_LEN];
int count;
float xmtfloat = 1.2344;

void setup()
{
	pinMode(LED_BUILTIN, OUTPUT);    // LED
	digitalWrite(LED_BUILTIN, LOW);  // LED off
	pinMode(12, INPUT_PULLUP);       // Control for Send
	pinMode(11, INPUT_PULLUP);       // Control for Receive

									 // Setup for Master mode, pins 18/19, external pullups, 400kHz, 200ms default timeout
	//Wire.begin(I2C_MASTER, 0x00, I2C_PINS_18_19, I2C_PULLUP_EXT, 400000);
	Wire.begin(I2C_MASTER, 0x00, I2C_PINS_18_19, I2C_PULLUP_INT, 400000);
	Wire.setDefaultTimeout(200000); // 200ms

	// Data init
	memset(databuf, 0, sizeof(databuf));
	count = 0;

	//Serial.begin(115200);
	unsigned long now = millis();
	Serial.begin(1); //rate value ignored
	int idx = 0;
	while (!Serial && (millis() - now) < 3000)
	{
		delay(500);
		idx++;
	}
	Serial.printf("Serial available after %lu mSec\n", millis() - now);
	Serial.printf("loop idx = %d\n", idx);

	Serial.printf("I2C_Master Example\n");
	Serial.printf("\nGround Pin 12 to transmit a float value to the slave\n");
	Serial.printf("\nGround Pin 11 to request a float value from the slave\n\n");
	
}

void loop()
{
	count++;
	uint8_t target = 0x66; // target Slave address
	//size_t idx;

	// Send string to Slave
	//
	if (digitalRead(12) == LOW)
	{
		digitalWrite(LED_BUILTIN, HIGH);   // LED on

		// Transmit to Slave
		//Serial.printf("Sending to Slave: %3.3f\n", xmtfloat*count);
		float a = xmtfloat * count;
		Serial.printf("Sending to Slave: %3.6f (0x%x)\n", a , *(unsigned int*)&a);
		Wire.beginTransmission(target);   // Slave address
		I2C_writeAnything(xmtfloat*count);
		Wire.endTransmission();           // Transmit to Slave

		// Check if error occured
		if (Wire.getError())
			Serial.print("FAIL\n");
		else
			Serial.print("OK\n");

		digitalWrite(LED_BUILTIN, LOW);    // LED off
		delay(100);                       // Delay to space out tests
	}

	// Read string from Slave
	if (digitalRead(11) == LOW)
	{
		digitalWrite(LED_BUILTIN, HIGH);   // LED on
										   
		Serial.print("Reading from Slave: ");// Print message

		// Read from Slave
		Wire.requestFrom(target, (size_t)MEM_LEN); // Read from Slave (string len unknown, request full buffer)

		if (Wire.getError())
			Serial.print("FAIL\n");
		else
		{
			float slave_val = 0;
			I2C_readAnything(slave_val);
			Serial.printf("Received %f from Slave\n", slave_val);
		}

		digitalWrite(LED_BUILTIN, LOW);    // LED off
		delay(100);                       // Delay to space out tests
	}
}

100

101

102

103

104

105

106

107

108

109

110

111

// -------------------------------------------------------------------------------------------

// Basic Master

// -------------------------------------------------------------------------------------------

// This creates a simple I2C Master device which when triggered will send/receive a text

// string to/from a Slave device. It is intended to pair with a Slave device running the

// basic_slave sketch.

// Pull pin12 input low to send.

// Pull pin11 input low to receive.

// This example code is in the public domain.

// -------------------------------------------------------------------------------------------

#include <i2c_t3.h>

#include <T3_I2C_Anything.h>

// Memory

#define MEM_LEN 256

char databuf[MEM_LEN];

int count;

float xmtfloat = 1.2344;

void setup()

{

pinMode(LED_BUILTIN, OUTPUT); // LED

digitalWrite(LED_BUILTIN, LOW); // LED off

pinMode(12, INPUT_PULLUP); // Control for Send

pinMode(11, INPUT_PULLUP); // Control for Receive

// Setup for Master mode, pins 18/19, external pullups, 400kHz, 200ms default timeout

//Wire.begin(I2C_MASTER, 0x00, I2C_PINS_18_19, I2C_PULLUP_EXT, 400000);

Wire.begin(I2C_MASTER, 0x00, I2C_PINS_18_19, I2C_PULLUP_INT, 400000);

Wire.setDefaultTimeout(200000); // 200ms

// Data init

memset(databuf, 0, sizeof(databuf));

count = 0;

//Serial.begin(115200);

unsigned long now = millis();

Serial.begin(1); //rate value ignored

int idx = 0;

while (!Serial && (millis() - now) < 3000)

{

delay(500);

idx++;

}

Serial.printf("Serial available after %lu mSec\n", millis() - now);

Serial.printf("loop idx = %d\n", idx);

Serial.printf("I2C_Master Example\n");

Serial.printf("\nGround Pin 12 to transmit a float value to the slave\n");

Serial.printf("\nGround Pin 11 to request a float value from the slave\n\n");

}

void loop()

{

count++;

uint8_t target = 0x66; // target Slave address

//size_t idx;

// Send string to Slave

if (digitalRead(12) == LOW)

{

digitalWrite(LED_BUILTIN, HIGH); // LED on

// Transmit to Slave

//Serial.printf("Sending to Slave: %3.3f\n", xmtfloat*count);

float a = xmtfloat * count;

Serial.printf("Sending to Slave: %3.6f (0x%x)\n", a , *(unsigned int*)&a);

Wire.beginTransmission(target); // Slave address

I2C_writeAnything(xmtfloat*count);

Wire.endTransmission(); // Transmit to Slave

// Check if error occured

if (Wire.getError())

Serial.print("FAIL\n");

else

Serial.print("OK\n");

digitalWrite(LED_BUILTIN, LOW); // LED off

delay(100); // Delay to space out tests

}

// Read string from Slave

if (digitalRead(11) == LOW)

{

digitalWrite(LED_BUILTIN, HIGH); // LED on

Serial.print("Reading from Slave: ");// Print message

// Read from Slave

Wire.requestFrom(target, (size_t)MEM_LEN); // Read from Slave (string len unknown, request full buffer)

if (Wire.getError())

Serial.print("FAIL\n");

else

{

float slave_val = 0;

I2C_readAnything(slave_val);

Serial.printf("Received %f from Slave\n", slave_val);

}

digitalWrite(LED_BUILTIN, LOW); // LED off

delay(100); // Delay to space out tests

}

And the Teensy ‘Slave’ code:

	// -------------------------------------------------------------------------------------------
	// Basic Slave
	// -------------------------------------------------------------------------------------------
	//
	// This creates a simple I2C Slave device which will print whatever text string is sent to it.
	// It will retain the text string in memory and will send it back to a Master device if 
	// requested.  It is intended to pair with a Master device running the basic_master sketch.
	//
	// This example code is in the public domain.
	//
	// -------------------------------------------------------------------------------------------

/*
	03/07/20 Modified to be Teensy-specific, and to use 'I2C_Anything' for I2C communications
*/
#include <i2c_t3.h>
#include <T3_I2C_Anything.h>

// Function prototypes
void receiveEvent(size_t count);
void requestEvent(void);

// Memory
volatile uint8_t received;
volatile float rcvfloat = 0;

//
// Setup
//
void setup()
{
	pinMode(LED_BUILTIN, OUTPUT); // LED

	// Setup for Slave mode, address 0x66, pins 18/19, internal pullups, 400kHz
	//Wire.begin(I2C_SLAVE, 0x66, I2C_PINS_18_19, I2C_PULLUP_INT, 400000);
	//Wire.begin(I2C_SLAVE, 0x66, I2C_PINS_18_19, I2C_PULLUP_INT, 100000);
	Wire.begin(I2C_SLAVE, 0x66, I2C_PINS_18_19, I2C_PULLUP_EXT, 100000);

	// register events
	Wire.onReceive(receiveEvent);
	Wire.onRequest(requestEvent);

	//Serial.begin(115200);
	unsigned long now = millis();
	Serial.begin(1); //rate value ignored
	int idx = 0;
	while (!Serial && (millis() - now) < 3000)
	{
		delay(500);
		idx++;
	}

	Serial.printf("Serial available after %lu mSec\n", millis() - now);
	Serial.printf("I2C Slave Example\n");
}

void loop()
{
	// print received data - this is done in main loop to keep time spent in I2C ISR to minimum
	if (received)
	{
		digitalWrite(LED_BUILTIN, HIGH);
		Serial.printf("Slave received: %f\n", rcvfloat);
		received = 0;
		digitalWrite(LED_BUILTIN, LOW);
	}
}

//
// handle Rx Event (incoming I2C data)
//
void receiveEvent(size_t count)
{
	received = count; // set received flag to count, this triggers print in main loop
	I2C_readAnything(rcvfloat);
}

//
// handle Tx Event (outgoing I2C data)
//
void requestEvent(void)
{
	Serial.printf("Sending %f to Master\n", rcvfloat);

	const byte* p = (const byte*)&rcvfloat;
	unsigned int i;
	for (i = 0; i < sizeof rcvfloat; i++)
		Wire.write(*p++);
	delay(5); //experiment
	//I2C_writeAnything(rcvfloat);
}

// -------------------------------------------------------------------------------------------

// Basic Slave

// -------------------------------------------------------------------------------------------

// This creates a simple I2C Slave device which will print whatever text string is sent to it.

// It will retain the text string in memory and will send it back to a Master device if

// requested. It is intended to pair with a Master device running the basic_master sketch.

// This example code is in the public domain.

// -------------------------------------------------------------------------------------------

03/07/20 Modified to be Teensy-specific, and to use 'I2C_Anything' for I2C communications

#include <i2c_t3.h>

#include <T3_I2C_Anything.h>

// Function prototypes

void receiveEvent(size_t count);

void requestEvent(void);

// Memory

volatile uint8_t received;

volatile float rcvfloat = 0;

// Setup

void setup()

{

pinMode(LED_BUILTIN, OUTPUT); // LED

// Setup for Slave mode, address 0x66, pins 18/19, internal pullups, 400kHz

//Wire.begin(I2C_SLAVE, 0x66, I2C_PINS_18_19, I2C_PULLUP_INT, 400000);

//Wire.begin(I2C_SLAVE, 0x66, I2C_PINS_18_19, I2C_PULLUP_INT, 100000);

Wire.begin(I2C_SLAVE, 0x66, I2C_PINS_18_19, I2C_PULLUP_EXT, 100000);

// register events

Wire.onReceive(receiveEvent);

Wire.onRequest(requestEvent);

//Serial.begin(115200);

unsigned long now = millis();

Serial.begin(1); //rate value ignored

int idx = 0;

while (!Serial && (millis() - now) < 3000)

{

delay(500);

idx++;

}

Serial.printf("Serial available after %lu mSec\n", millis() - now);

Serial.printf("I2C Slave Example\n");

}

void loop()

{

// print received data - this is done in main loop to keep time spent in I2C ISR to minimum

if (received)

{

digitalWrite(LED_BUILTIN, HIGH);

Serial.printf("Slave received: %f\n", rcvfloat);

received = 0;

digitalWrite(LED_BUILTIN, LOW);

}

// handle Rx Event (incoming I2C data)

void receiveEvent(size_t count)

{

received = count; // set received flag to count, this triggers print in main loop

I2C_readAnything(rcvfloat);

}

// handle Tx Event (outgoing I2C data)

void requestEvent(void)

{

Serial.printf("Sending %f to Master\n", rcvfloat);

const byte* p = (const byte*)&rcvfloat;

unsigned int i;

for (i = 0; i < sizeof rcvfloat; i++)

Wire.write(*p++);

delay(5); //experiment

//I2C_writeAnything(rcvfloat);

}

With this configuration I got the following output:

Master:

Opening port
Port open
Sending to Slave: 812935680.000000 (0x4e41d1a8)
OK
Sending to Slave: 812935680.000000 (0x4e41d1a8)
OK
Sending to Slave: 812935680.000000 (0x4e41d1a8)
OK
Sending to Slave: 812935680.000000 (0x4e41d1a8)
OK
...
...
Reading from Slave: Received 812935744.000000 from Slave
Reading from Slave: Received 812935744.000000 from Slave
Reading from Slave: Received 812935744.000000 from Slave
Reading from Slave: Received 812935744.000000 from Slave
Reading from Slave: Received 812935744.000000 from Slave

Opening port

Port open

Sending to Slave: 812935680.000000 (0x4e41d1a8)

...

Reading from Slave: Received 812935744.000000 from Slave

Slave:

Opening port
Port open
Slave received: 812935680.000000
Slave received: 812935680.000000
Slave received: 812935680.000000
Slave received: 812935680.000000
...
...
Sending 812935744.000000 to Master
Sending 812935744.000000 to Master
Sending 812935744.000000 to Master
Sending 812935744.000000 to Master

Opening port

Port open

Slave received: 812935680.000000

...

Sending 812935744.000000 to Master

So this seems to be working OK.

Then I added in a third Teensy module (T3.5) running my newly developed I2C-Sniffer code, so that I could ‘sniff’ the I2C traffic between the two Teensy’s. This will give me a ‘known-good’ baseline for when I move back to the non-working Arduino Mega Master and Teensy Slave condition that is causing me problems.

Teensy 3.2 Slave (left), Teensy 3.5 I2C Sniffer (middle), Teensy 3.5 Master (right)

Here’s the Teensy ‘Sniffer’ code:

/*
    Name:       Teensy_I2C_Sniffer_V11.ino
    Created:	1/18/2020 10:55:55 AM
    Author:     FRANKNEWXPS15\Frank
*/
/* 'Notes:

    A typical I2C sentence when communicating with a MPU6050 IMU module goes something like:
        "I2C(68) wrote 1 byte to 75 - C0 Done."
        "I2C(68) wrote 3 bytes to 72 - C0 0C 10 Done."
        "I2C(68) read 5 bytes from 6A - C0 0C 10 14 03 Done."

    To form a sentence, we need:
        Device addr: 68 in the above examples
        Read/Write direction
        To/From register address:  75, 72 and 6A in the above examples
        Data:  C0, C0 0C 10, and C0 0C 10 14 03 in the above examples
        number of bytes written/read:  1,3 & 5 in the above examples

     Each I2C communication proceeds as follows (assuming a START from an IDLE condition):
         A START or RESTART condition, denoted by SDA & SCL HIGH, followed by SDA LOW, SCL HIGH
         A 7-bit device address, MSB first (0x8/0xC = 1, 0x0/0x4 = 0)
         A R/W bit (0x8/0xC = read, 0x0/0x4 = write)
         An ACK bit (0x8/0xC = NAK, 0x0/0x4 = ACK)
         If the bus direction is WRITE, then
             A register address for read/write
             zero or more additional data bytes
         Else (the bus direction is READ)
            One or more additional data bytes
         Endif

    This version uses a fixed-size (2048 bytes) array instead of tonton81's circular buffer library.

    To generalize for any I2C slave device rather than just the MPU6050 IMU, comment out the 
    "#define MPU6050_SPECIFIC line below. This will remove all MPU6050 specific code
*/


//#define MPU6050_SPECIFIC

#include <TimerOne.h> //needed for ISR
#ifdef MPU6050_SPECIFIC
#include "helper_3dmath.h" //Arduino\Libraries\i2cdevlib\Arduino\MPU6050\ needed to compute yaw from MPU6050 DMP packet
#endif


#define PARSE_LOOP_DEBUG

const uint16_t CAPTURE_ARRAY_SIZE = 2048;
const uint16_t VALID_DATA_ARRAY_SIZE = 2048;
const int WAITING_PRINT_INTERVAL_MSEC = 200;//interval timer for 'Waiting for data...' printout

#define MONITOR_OUT1 2 //so can monitor ISR activity with O'scope
#define MONITOR_OUT2 3 //so can monitor ISR activity with O'scope
#define MONITOR_OUT3 4 //so can monitor ISR activity with O'scope
#define SDA_PIN 18 
#define SCL_PIN 19

#pragma region PROCESSING_VARIABLES
uint8_t devAddr;
uint8_t regAddr;
uint8_t databytes[2048]; //holds multiple databytes for later output sentence construction
uint16_t numbytes = 0; //number of data bytes extracted from data stream
int ACKNAKFlag; //can be negative
uint16_t databyte_idx = 0; //index into databyte_array
uint8_t killbuff[2]; //used to consume start/stop bytes
elapsedMillis mSecSinceLastWaitingPrint;
uint8_t valid_data[2048];
uint16_t numvalidbytes = 0; //number of valid bytes in this burst
uint16_t read_idx = 0; //pointer to next byte pair to be processed

//added for bus direction labels
enum BUSDIR
{
    WRITE,
    READ,
    UNKNOWN = -1
} RWDir;
BUSDIR BusDir = BUSDIR::UNKNOWN;
#pragma endregion ProcVars


#pragma region ISR_SUPPORT
uint8_t raw_data[CAPTURE_ARRAY_SIZE]; //holds data captured from I2C bus
volatile uint16_t  write_idx = 0;
volatile uint8_t   current_portb = 0xFF;
volatile uint8_t   last_portb = 0xFF;
volatile uint16_t mult0xCCount = 0;
const uint16_t MAX_IDLE_COUNT = 2500;

volatile bool bDone = false;
volatile bool bWaitingForStart = true;
volatile bool bIsData = true;
volatile bool bIsStart = false;
volatile bool bIsStop = false;
volatile uint8_t last_current;
#pragma endregion ISR Support

#ifdef MPU6050_SPECIFIC
//01/21/20 these forward declarations are required to force the preprocessor 
//to handle #ifdef MPU6050_SPECIFIC properly
uint8_t dmpGetQuaternion(int16_t* data, const uint8_t* packet);
uint8_t dmpGetQuaternion(Quaternion* q, const uint8_t* packet);
uint8_t dmpGetYawPitchRoll(float* data, Quaternion* q, VectorFloat* gravity);
uint8_t dmpGetGravity(VectorFloat* v, Quaternion* q);

Quaternion q;           // [w, x, y, z]         quaternion container
VectorInt16 aa;         // [x, y, z]            accel sensor measurements
VectorInt16 aaReal;     // [x, y, z]            gravity-free accel sensor measurements
VectorInt16 aaWorld;    // [x, y, z]            world-frame accel sensor measurements
VectorFloat gravity;    // [x, y, z]            gravity vector
float ypr[3];           // [yaw, pitch, roll]   yaw/pitch/roll container and gravity vector
float global_yawval = 0; //updated by GetIMUHeadingDeg()
#endif // MPU6050_SPECIFIC

void setup()
{
    unsigned long now = millis();
    Serial.begin(1); //rate value ignored
    int idx = 0;
    while (!Serial && (millis() - now) < 3000)
    {
        delay(500);
        idx++;
    }
    Serial.printf("Serial available after %lu mSec\n", millis() - now);

    pinMode(MONITOR_OUT1, OUTPUT);
    digitalWrite(MONITOR_OUT1, LOW);
    pinMode(MONITOR_OUT2, OUTPUT);
    digitalWrite(MONITOR_OUT2, LOW);
    pinMode(MONITOR_OUT3, OUTPUT);
    digitalWrite(MONITOR_OUT3, LOW);

    pinMode(SCL_PIN, INPUT);
    pinMode(SDA_PIN, INPUT);

    //reset port byte vars & start timer
    last_portb = current_portb = 0;
    write_idx = 0;
    memset(raw_data, 255, CAPTURE_ARRAY_SIZE);
    //PrintNextArrayBytes(raw_data, 255, 20);
    Timer1.initialize(1); // run every mico second
    Timer1.attachInterrupt(capture_data);


    mSecSinceLastWaitingPrint = 0;
}
//-------------------------------------------------------------------------------
//--------------------------------    ISR    ------------------------------------
//-------------------------------------------------------------------------------
FASTRUN void capture_data()
//void capture_data()
{
    last_portb = current_portb;
    current_portb = GPIOB_PDIR & 12; //reads state of SDA (18) & SCL (19) at same time

    if (!bDone && last_portb != current_portb)
    {
        mult0xCCount = 0; //reset IDLE counter
        digitalWriteFast(MONITOR_OUT1, HIGH);

        //01/17/20: joepasquariello suggestion
        last_current = (last_portb << 4) | (current_portb);
        bIsStart = (last_current == 0xC4);
        bIsStop = (last_current == 0x4C);
        bIsData = (last_current == 0x04) || (last_current == 0x8C);

        if (bIsStart) //START  
        {
            digitalWriteFast(MONITOR_OUT2, HIGH);
            if (bWaitingForStart)
            {
                digitalWriteFast(MONITOR_OUT3, HIGH); //start of entire capture
                bWaitingForStart = false;
            }
        }
        else if (bIsStop) //STOP
        {
            digitalWriteFast(MONITOR_OUT2, LOW);
        }

        if (!bWaitingForStart && (bIsData || bIsStart || bIsStop))
        {
            //digitalWriteFast(MONITOR_OUT3, HIGH);
            raw_data[write_idx] = last_portb;
            write_idx++;
            raw_data[write_idx] = current_portb;
            write_idx++;
            if (write_idx >= CAPTURE_ARRAY_SIZE)
            {
                bDone = true;
                digitalWriteFast(MONITOR_OUT3, LOW);
            }
        }
        digitalWriteFast(MONITOR_OUT1, LOW);
    }
    else if (!bDone && mult0xCCount < MAX_IDLE_COUNT && last_portb == 0xc && current_portb == 0xc)
    {
        mult0xCCount++;
        if (mult0xCCount >= MAX_IDLE_COUNT)
        {
            digitalWriteFast(MONITOR_OUT3, LOW);
            bDone = true;
        }
    }
}
//-------------------------------------------------------------------------------
//-------------------------------- END ISR    ---------------------------------
//-------------------------------------------------------------------------------

void loop()
{
    if (bDone)
    { 
        if (write_idx > 14)
        {
            //OK, we have some data to process. IDLE detection must have been EOM
            Timer1.stop();

            unsigned long startMsec = millis();

            //Serial.printf("%lu\t %d\t", millis(), write_idx);
            //PrintNextArrayBytes(raw_data, 0, 50);
            //Serial.printf(" - %lu\n", millis());
            uint16_t numprocessed = DecodeAndPrintValidData(raw_data); //decode and print everything captured so far
            unsigned long endMsec = millis();
            Serial.printf("%lu: processed = %d elements in %lu mSec\n\n", startMsec, numprocessed, endMsec-startMsec);

            Timer1.start();
        }

        read_idx = 0;
        bDone = false;
        mult0xCCount = 0;
        write_idx = 0;
        bWaitingForStart = true;
    }    
    else
    {
        //no data to process, but don't blow prints out every mSec...
        if (mSecSinceLastWaitingPrint > WAITING_PRINT_INTERVAL_MSEC)
        {
            mSecSinceLastWaitingPrint -= WAITING_PRINT_INTERVAL_MSEC;
            Serial.printf("%lu: Waiting for Data...\n", millis());
        }
    }
}

void PrintNextArrayBytes(uint8_t* data, uint16_t startidx, uint16_t numbytes)
{
    Serial.printf("%d bytes starting at %d: ", numbytes, startidx);
    for (uint16_t i = 0; i < numbytes; i++)
    {
        Serial.printf("%x ", data[i + startidx]);
    }
}


uint16_t DecodeAndPrintValidData(byte* data)
{
    //Purpose:  decode and print I2C conversation held in raw_data array
    //Inputs:  
    //  cb = 2048 element FIFO
    //Outputs:
    //  returns number of bytes processed, or -1 for failure
    //  outputs structured I2C sentence to serial monitor
    //Plan:
    //  Step1: Cull out invalid bytes
    //  Step2: Determine if there is anything to do (have to have more than one transition in FIFO)
    //  Step3: Parse transitions into I2C sentence structure
    //  Step4: Output sentence to serial monitor

    memset(valid_data, 0, VALID_DATA_ARRAY_SIZE);
#ifdef PARSE_LOOP_DEBUG
    PrintNextArrayBytes(valid_data, 0, 20); //print out first 20 bytes for verification
#endif
    numvalidbytes = RemoveInvalidBytes(raw_data, valid_data);
#ifdef PARSE_LOOP_DEBUG
    Serial.printf("Removed %d invalid bytes, leaving %d remaining\n", write_idx + 1 - numvalidbytes, numvalidbytes);
    PrintNextArrayBytes(valid_data, 0, numvalidbytes); //print out first 20 bytes of valid_data array
#endif


    if (numvalidbytes < 2)
    {
        return 0;
    }

    while (read_idx < numvalidbytes)
    {
#ifdef PARSE_LOOP_DEBUG
        Serial.printf("At top of while (read_idx < numvalidbytes): read_idx = %d\n", read_idx);
        Serial.printf("Next two bytes in valid_data are %x, %x\n", valid_data[read_idx], valid_data[read_idx + 1]);
#endif
        //Find a START sequence (0xC followed by 0x4)
        while (!IsStart(valid_data, read_idx) && read_idx < numvalidbytes)
        {
            //Serial.printf("looking for start...\n");
            read_idx++;
        }
        //at this point, read_idx should point to next valid byte pair

#ifdef PARSE_LOOP_DEBUG
        Serial.printf("Start sequence found at %d\n", read_idx - 2);
        //PrintNextFIFOBytes(valid_data, 20);
#endif

        if (numvalidbytes - read_idx > 14)//14 entries required for 7-bit address
        {
            //Get 7-bit device address
            devAddr = Get7BitDeviceAddr(valid_data, read_idx);
#ifdef PARSE_LOOP_DEBUG
            Serial.printf("devAddr = %x\n", devAddr);
#endif
        }
        else
        {

#ifdef PARSE_LOOP_DEBUG
            Serial.printf("ran out of data at readidx = %d - exiting!\n", read_idx);
#endif
            break;
        }

        //get read/write flag  1 = Read, 0 = Write, -1 = error
        BusDir = (BUSDIR)GetReadWriteFlag(valid_data, read_idx);

#ifdef PARSE_LOOP_DEBUG
        Serial.printf("BusDir = %s\n", ((BusDir == BUSDIR::WRITE) ? "WRITE" : "READ"));
        //PrintNextFIFOBytes(valid_data, 20);
#endif

    //get ACK/NAK flag
        ACKNAKFlag = GetACKNAKFlag(valid_data, read_idx);
        numbytes = GetDataBytes(valid_data, read_idx, databytes); //terminates on a START, but the start bytes are not consumed
#ifdef PARSE_LOOP_DEBUG
        Serial.printf("Got %d bytes from GetDataBytes() --> ", numbytes);
        for (size_t i = 0; i < numbytes; i++)
        {
            Serial.printf(" %x ", databytes[i]);
        }
        Serial.printf("\n");

        //PrintNextFIFOBytes(cb_trans, 20);
#endif
    //If the bus direction is WRITE, then extract
    //    A register address for read / write
    //    zero or more additional data bytes
        if (BusDir == BUSDIR::WRITE)
        {
            regAddr = databytes[0];
#ifdef PARSE_LOOP_DEBUG
            Serial.printf("regAddr = %x, read_idx = %d\n", regAddr, read_idx);
#endif

            //check for additional data
            if (numbytes > 1)
            {
#ifdef PARSE_LOOP_DEBUG
                Serial.printf("Additional data found!\n");
                for (size_t i = 0; i < numbytes; i++)
                {
                    Serial.printf("data[%d] = %x\n", i, databytes[i]);
                }
#endif
                //1st byte is register addr, subsequent bytes are data
                OutputFormattedSentence(BusDir, devAddr, regAddr, numbytes, databytes, 1);
            }
        }
        else  //all bytes are data
        {
#ifdef PARSE_LOOP_DEBUG
            Serial.printf("In data block:  got %d bytes of data\n", numbytes);
            for (size_t i = 0; i < numbytes; i++)
            {
                Serial.printf("data[%d] = %x\n", i, databytes[i]);
            }
#endif
            OutputFormattedSentence(BusDir, devAddr, regAddr, numbytes, databytes, 0);
        }
#ifdef PARSE_LOOP_DEBUG
        Serial.printf("At end of while (read_idx < numvalidbytes): read_idx = %d\n", read_idx);
#endif

    }//while (read_idx < numvalidbytes)
    return numvalidbytes;
}


#pragma region Support Functions
bool IsStart(byte* data, uint16_t& readidx)
{
    bool result = false;

    //Serial.printf("IsStart[%d] = %x, IsStart[%d] = %x\n",
    //    readidx, data[readidx], readidx + 1, data[readidx + 1]);

    if (data[readidx] == 0xC && data[readidx + 1] == 0x4)
    {
        result = true;
        readidx += 2; //bump to next byte pair
    }
    return result;
}

bool IsStop(byte* data, uint16_t& readidx)
{
    bool result = false;

    //Serial.printf("IsStop[%d] = %x, IsStop[%d] = %x\n",
        //readidx, data[readidx], readidx + 1, data[readidx + 1]);

    if (data[readidx] == 0x4 && data[readidx + 1] == 0xC)
    {
        result = true;
        readidx += 2; //bump to next byte pair
    }
    return result;
}

uint8_t Get7BitDeviceAddr(byte* data, uint16_t& readidx)
{
    //Purpose: Construct a 7-bit address starting from dataidx
    //Inputs:
    //  data = pointer to valid data array
    //  readidx = starting index of 7-bit address sequence (MSB first)
    //Outputs:
    //  returns the address as an 8-bit value with the MSB = 0, or 0x0 if unsuccessful
    //  dataidx = pointer to next data entry
    //Plan:
    //  Step1: Convert a pair of data entries into a 0 or 1
    //  Step2: Add the appropriate value to an ongoing sum
    //  Step3: return the total.
    //Notes:
    //  A '0' is coded as a 0x0 followed by a 0x4
    //  A '1' is coded as a 0x8 followed by a 0xC

    uint8_t devAddr = 0x0; //failure return value

    //Serial.printf("Get7BitDeviceAddr: readidx = %d\n",readidx);

    //devAddr is exactly 7 bits long, so 8 bits with MSB = 0
    for (size_t i = 0; i < 7; i++)
    {
        if (data[readidx] == 0x0 && data[readidx + 1] == 0x4)
        {
            readidx += 2; //advance the pointer, but don't add to sum
        }

        else if (data[readidx] == 0x8 && data[readidx + 1] == 0xC)
        {
            //Serial.printf("Get7BitDeviceAddr: '1' found at i = %d, adding %x to devAddr to get %x\n",
            //    i, 1 << (7 - i), devAddr + (1 << (7-i)));

            readidx += 2; //advance the pointer
            devAddr += (1 << (7 - i)); //add 2^(7-i) to sum
        }
    }

    devAddr = devAddr >> 1; //divide result by 2 to get 7-bit addr from 8 bits
    return devAddr;
}

int Get8BitDataByte(byte* data, uint16_t& readidx)
{
    //Purpose: Construct a 8-bit data byte starting from dataidx
    //Inputs:
    //  data = pointer to valid data array
    //  readidx = starting index of 8-bit data byte (MSB first)
    //Outputs:
    //  returns the address as an 8-bit value, or 0x0 if unsuccessful
    //  dataidx = pointer to next data entry
    //Plan:
    //  Step1: Convert a pair of data entries into a 0 or 1
    //  Step2: Add the appropriate value to an ongoing sum
    //  Step3: return the total.
    //Notes:
    //  A '0' is coded as a 0x0 followed by a 0x4
    //  A '1' is coded as a 0x8 followed by a 0xC
    //  12/29/19 - changed return val to int, so can return -1 when a 'short byte' is detected

    int dataval = 0x0; //failure return value

#ifdef GET_8BIT_DATABYTE_DEBUG
    Serial.printf("Get8BitDataByte: data[%d] = %x, data[%d] = %x\n",
        readidx, data[readidx], readidx + 1, data[readidx + 1]);
#endif

    //8 bits with MSB = 0
    int numbytes = 0;
    for (size_t i = 0; i < 8; i++)
    {
        if (data[readidx] == 0x0 && data[readidx + 1] == 0x4)
        {
            readidx += 2; //advance the pointer, but don't add to sum
            numbytes++;
        }

        else if (data[readidx] == 0x8 && data[readidx + 1] == 0xC)
        {
#ifdef GET_8BIT_DATABYTE_DEBUG
            Serial.printf("Get8BitDataByte: '1' found at i = %d, adding %x to devAddr to get %x\n",
                i, 1 << (7 - i), dataval + (1 << (7 - i)));
#endif
            readidx += 2; //advance the pointer
            dataval += (1 << (7 - i)); //add 2^(8-i) to sum
            numbytes++;
        }
    }

#ifdef GET_8BIT_DATABYTE_DEBUG
    Serial.printf("Get8BitDataByte: numbytes = %d\n", numbytes);
#endif
    if (numbytes != 8)
    {
        dataval = -1; //error return value
    }

    return dataval;
}

int GetReadWriteFlag(byte* data, uint16_t& readidx)
{
    //Purpose: decode R/W byte pair
    //Inputs:
    //  data = pointer to valid data array
    //  readidx = index into data to start of R/W byte pair
    //Outputs:
    //  readidx = if successful, points to next byte pair in data
    //  returns 1 for Read (0x8/0xC), 0 for Write (0x0/0x4), -1 for failure
    //Notes:
    //  

    //Serial.printf("GetReadWriteFlag: readidx = %d, data[readidx] = %x, data[readidx+1]= %x\n",
    //    readidx, data[readidx], data[readidx + 1]);
    int result = 0;
    if (data[readidx] == 0x8 && data[readidx + 1] == 0xC)
    {
        result = 1; //read detected
        readidx += 2; //point to next byte pair
    }

    else if (data[readidx] == 0x0 && data[readidx + 1] == 0x4)
    {
        result = 0; //write detected
        readidx += 2; //point to next byte pair
    }
    else
    {
        result = -1; //failed to detect read or write
    }

    return result;
}

int GetACKNAKFlag(byte* data, uint16_t& readidx)
{
    //Purpose: decode ACK/NAK byte pair
    //Inputs:
    //  data = pointer to valid data array
    //  readidx = index into data to start of ACK/NAK byte pair
    //Outputs:
    //  readidx = if successful, points to next byte pair in data
    //  returns 1 for NAK (0x8/0xC), 0 for ACK (0x0/0x4), -1 for failure
    //Notes:
    //  

    //Serial.printf("GetACKNAKFlag: readidx = %d, data[readidx] = %x, data[readidx+1]= %x\n",
    //    readidx, data[readidx], data[readidx + 1]);
    int result = 0;
    if (data[readidx] == 0x8 && data[readidx + 1] == 0xC)
    {
        result = 1; //NAK detected
        readidx += 2; //point to next byte pair
    }

    else if (data[readidx] == 0x0 && data[readidx + 1] == 0x4)
    {
        result = 0; //ACK detected
        readidx += 2; //point to next byte pair
    }
    else
    {
        result = -1; //failed to detect ACK or NAK
    }

    return result;
}

int GetDataBytes(uint8_t* data, uint16_t& readidx, uint8_t* databytes)
{
    //Notes:
    //  01/01/2020: removed databyteidx from sig - always starts at zero

    uint16_t numbytes = 0;
    uint16_t databyte_idx = 0;

    bool StartFlag = false;
    bool StopFlag = false;

    do
    {
        int dataval = Get8BitDataByte(data, readidx);

        //watch out for 'short byte' reads
        if (dataval >= 0)
        {
            uint8_t databyte = (uint8_t)dataval;
            databytes[databyte_idx] = databyte;
            databyte_idx++;
            numbytes++;
        }

        ACKNAKFlag = GetACKNAKFlag(data, readidx);
        StartFlag = IsStart(data, readidx);
        StopFlag = IsStop(data, readidx);

#ifdef PARSE_LOOP_DEBUG
        Serial.printf("IsStart returned %d, IsStop returned %d, dataidx = %d\n",
            StartFlag, StopFlag, readidx);
#endif

    } while (!StartFlag && !StopFlag && readidx < numvalidbytes);


    readidx -= 2;//back readidx up so loop top is positioned correctly.

    return numbytes;
}

void OutputFormattedSentence(int RW, uint8_t dev, uint8_t reg, uint8_t numbytes, uint8_t* bytearray, uint16_t startidx)
{
    Serial.printf("%lu I2C(%x) %s %d bytes %s %x... ",
        millis(), dev, (RW == 0 ? "writing" : "reading"),  numbytes - startidx, (RW == 0 ? "to" : "from"), reg);
    //for (size_t i = startidx; i < numbytes; i++)
    //{
    //    Serial.printf("%x ", bytearray[i]);
    //}
    //Serial.printf(". Done\n");

#ifdef MPU6050_SPECIFIC


    //01/18/20 experiment to decode 28-byte packet into yaw value
    if (numbytes == 28)
    {
        dmpGetQuaternion(&q, bytearray);
        dmpGetGravity(&gravity, &q);
        dmpGetYawPitchRoll(ypr, &q, &gravity);

        //compute the yaw value
        global_yawval = ypr[0] * 180 / M_PI;
        Serial.printf("yawval = %3.2f\n", global_yawval);
    }
    else
    {
        Serial.printf(". Done\n");
    }
#endif // MPU6050_SPECIFIC



}

uint16_t RemoveInvalidBytes(uint8_t* rawdata, uint8_t* validdata)
{
    uint16_t numvalid = 0;
    uint16_t valididx = 0;

    //Serial.printf("raw data array contains %d bytes\n", write_idx + 1);
    //PrintNextArrayBytes(raw_data, 0, 20);

    //OK, now go back through the array, excising invalid sequences
    for (uint16_t rawidx = 0; rawidx < write_idx;/*rawidx incremented internally*/)
    {
        uint8_t firstByte = raw_data[rawidx]; //get the first byte
        uint8_t secondByte = raw_data[rawidx + 1]; //get the next byte
        bool validpair =
            (
            (firstByte == 0xC && secondByte == 0x4) //START or RESTART
                || (firstByte == 0x4 && secondByte == 0xC) //STOP
                || (firstByte == 0x0 && secondByte == 0x4) //0 OR ACK
                || (firstByte == 0x8 && secondByte == 0xC) //1 or NAK
                );

        //Serial.printf("rawidx %d: Considering %x and %x: validity = %d\n",
            //rawidx, firstByte, secondByte, validpair);
        if (validpair)
        {
            //save valid bytes to valid_bytes array
            validdata[valididx] = firstByte;
            validdata[valididx + 1] = secondByte;
            numvalid += 2;
            //Serial.printf("Added %x & %x at idx = %d & %d\n", firstByte, secondByte, valididx, valididx + 1);
            //PrintNextArrayBytes(validdata,0,numvalid);
            rawidx += 2;
            valididx += 2;
        }
        else
        {
            rawidx++; //on invalid, just go to next byte
        }
    }

    return numvalid;
}
#pragma endregion Support Functions

#ifdef MPU6050_SPECIFIC

//#pragma region YAW_COMPUTATIONS
////01/18/2020: I copied these functions from MPU6050_6Axis_MotionApps_V6_12.h and
////  modified them to be called directly instead of from an 'mpu' object
//    
uint8_t dmpGetQuaternion(int16_t* data, const uint8_t* packet) 
{
    // TODO: accommodate different arrangements of sent data (ONLY default supported now)
    if (packet != 0) 
    {
        data[0] = ((packet[0] << 8) | packet[1]);
        data[1] = ((packet[4] << 8) | packet[5]);
        data[2] = ((packet[8] << 8) | packet[9]);
        data[3] = ((packet[12] << 8) | packet[13]);
    }
    return 0;
}

uint8_t dmpGetQuaternion(Quaternion* q, const uint8_t* packet) 
{
    // TODO: accommodate different arrangements of sent data (ONLY default supported now)
    int16_t qI[4]{ 0,0,0,0 };
    uint8_t status = dmpGetQuaternion(qI, packet);
    if (status == 0) {
        q->w = (float)qI[0] / 16384.0f;
        q->x = (float)qI[1] / 16384.0f;
        q->y = (float)qI[2] / 16384.0f;
        q->z = (float)qI[3] / 16384.0f;
        return 0;
    }
    return status; // int16 return value, indicates error if this line is reached
}

uint8_t dmpGetYawPitchRoll(float* data, Quaternion* q, VectorFloat* gravity) 
{
    // yaw: (about Z axis)
    data[0] = atan2(2 * q->x * q->y - 2 * q->w * q->z, 2 * q->w * q->w + 2 * q->x * q->x - 1);
    // pitch: (nose up/down, about Y axis)
    data[1] = atan2(gravity->x, sqrt(gravity->y * gravity->y + gravity->z * gravity->z));
    // roll: (tilt left/right, about X axis)
    data[2] = atan2(gravity->y, gravity->z);
    if (gravity->z < 0) {
        if (data[1] > 0) {
            data[1] = PI - data[1];
        }
        else {
            data[1] = -PI - data[1];
        }
    }
    return 0;
}


uint8_t dmpGetGravity(VectorFloat* v, Quaternion* q) 
{
    v->x = 2 * (q->x * q->z - q->w * q->y);
    v->y = 2 * (q->w * q->x + q->y * q->z);
    v->z = q->w * q->w - q->x * q->x - q->y * q->y + q->z * q->z;
    return 0;
}
//#pragma endregion YAW_COMPUTATIONS
#endif //MPU6050_SPECIFIC

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

Name: Teensy_I2C_Sniffer_V11.ino

Created: 1/18/2020 10:55:55 AM

Author: FRANKNEWXPS15\Frank

/* 'Notes:

A typical I2C sentence when communicating with a MPU6050 IMU module goes something like:

"I2C(68) wrote 1 byte to 75 - C0 Done."

"I2C(68) wrote 3 bytes to 72 - C0 0C 10 Done."

"I2C(68) read 5 bytes from 6A - C0 0C 10 14 03 Done."

To form a sentence, we need:

Device addr: 68 in the above examples

Read/Write direction

To/From register address: 75, 72 and 6A in the above examples

Data: C0, C0 0C 10, and C0 0C 10 14 03 in the above examples

number of bytes written/read: 1,3 & 5 in the above examples

Each I2C communication proceeds as follows (assuming a START from an IDLE condition):

A START or RESTART condition, denoted by SDA & SCL HIGH, followed by SDA LOW, SCL HIGH

A 7-bit device address, MSB first (0x8/0xC = 1, 0x0/0x4 = 0)

A R/W bit (0x8/0xC = read, 0x0/0x4 = write)

An ACK bit (0x8/0xC = NAK, 0x0/0x4 = ACK)

If the bus direction is WRITE, then

A register address for read/write

zero or more additional data bytes

Else (the bus direction is READ)

One or more additional data bytes

Endif

This version uses a fixed-size (2048 bytes) array instead of tonton81's circular buffer library.

To generalize for any I2C slave device rather than just the MPU6050 IMU, comment out the

"#define MPU6050_SPECIFIC line below. This will remove all MPU6050 specific code

//#define MPU6050_SPECIFIC

#include <TimerOne.h> //needed for ISR

#ifdef MPU6050_SPECIFIC

#include "helper_3dmath.h" //Arduino\Libraries\i2cdevlib\Arduino\MPU6050\ needed to compute yaw from MPU6050 DMP packet

#endif

#define PARSE_LOOP_DEBUG

const uint16_t CAPTURE_ARRAY_SIZE = 2048;

const uint16_t VALID_DATA_ARRAY_SIZE = 2048;

const int WAITING_PRINT_INTERVAL_MSEC = 200;//interval timer for 'Waiting for data...' printout

#define MONITOR_OUT1 2 //so can monitor ISR activity with O'scope

#define MONITOR_OUT2 3 //so can monitor ISR activity with O'scope

#define MONITOR_OUT3 4 //so can monitor ISR activity with O'scope

#define SDA_PIN 18

#define SCL_PIN 19

#pragma region PROCESSING_VARIABLES

uint8_t devAddr;

uint8_t regAddr;

uint8_t databytes[2048]; //holds multiple databytes for later output sentence construction

uint16_t numbytes = 0; //number of data bytes extracted from data stream

int ACKNAKFlag; //can be negative

uint16_t databyte_idx = 0; //index into databyte_array

uint8_t killbuff[2]; //used to consume start/stop bytes

elapsedMillis mSecSinceLastWaitingPrint;

uint8_t valid_data[2048];

uint16_t numvalidbytes = 0; //number of valid bytes in this burst

uint16_t read_idx = 0; //pointer to next byte pair to be processed

//added for bus direction labels

enum BUSDIR

{

WRITE,

READ,

UNKNOWN = -1

} RWDir;

BUSDIR BusDir = BUSDIR::UNKNOWN;

#pragma endregion ProcVars

#pragma region ISR_SUPPORT

uint8_t raw_data[CAPTURE_ARRAY_SIZE]; //holds data captured from I2C bus

volatile uint16_t write_idx = 0;

volatile uint8_t current_portb = 0xFF;

volatile uint8_t last_portb = 0xFF;

volatile uint16_t mult0xCCount = 0;

const uint16_t MAX_IDLE_COUNT = 2500;

volatile bool bDone = false;

volatile bool bWaitingForStart = true;

volatile bool bIsData = true;

volatile bool bIsStart = false;

volatile bool bIsStop = false;

volatile uint8_t last_current;

#pragma endregion ISR Support

#ifdef MPU6050_SPECIFIC

//01/21/20 these forward declarations are required to force the preprocessor

//to handle #ifdef MPU6050_SPECIFIC properly

uint8_t dmpGetQuaternion(int16_t* data, const uint8_t* packet);

uint8_t dmpGetQuaternion(Quaternion* q, const uint8_t* packet);

uint8_t dmpGetYawPitchRoll(float* data, Quaternion* q, VectorFloat* gravity);

uint8_t dmpGetGravity(VectorFloat* v, Quaternion* q);

Quaternion q; // [w, x, y, z] quaternion container

VectorInt16 aa; // [x, y, z] accel sensor measurements

VectorInt16 aaReal; // [x, y, z] gravity-free accel sensor measurements

VectorInt16 aaWorld; // [x, y, z] world-frame accel sensor measurements

VectorFloat gravity; // [x, y, z] gravity vector

float ypr[3]; // [yaw, pitch, roll] yaw/pitch/roll container and gravity vector

float global_yawval = 0; //updated by GetIMUHeadingDeg()

#endif // MPU6050_SPECIFIC

void setup()

{

unsigned long now = millis();

Serial.begin(1); //rate value ignored

int idx = 0;

while (!Serial && (millis() - now) < 3000)

{

delay(500);

idx++;

}

Serial.printf("Serial available after %lu mSec\n", millis() - now);

pinMode(MONITOR_OUT1, OUTPUT);

digitalWrite(MONITOR_OUT1, LOW);

pinMode(MONITOR_OUT2, OUTPUT);

digitalWrite(MONITOR_OUT2, LOW);

pinMode(MONITOR_OUT3, OUTPUT);

digitalWrite(MONITOR_OUT3, LOW);

pinMode(SCL_PIN, INPUT);

pinMode(SDA_PIN, INPUT);

//reset port byte vars & start timer

last_portb = current_portb = 0;

write_idx = 0;

memset(raw_data, 255, CAPTURE_ARRAY_SIZE);

//PrintNextArrayBytes(raw_data, 255, 20);

Timer1.initialize(1); // run every mico second

Timer1.attachInterrupt(capture_data);

mSecSinceLastWaitingPrint = 0;

}

//-------------------------------------------------------------------------------

//-------------------------------- ISR ------------------------------------

//-------------------------------------------------------------------------------

FASTRUN void capture_data()

//void capture_data()

{

last_portb = current_portb;

current_portb = GPIOB_PDIR & 12; //reads state of SDA (18) & SCL (19) at same time

if (!bDone && last_portb != current_portb)

{

mult0xCCount = 0; //reset IDLE counter

digitalWriteFast(MONITOR_OUT1, HIGH);

//01/17/20: joepasquariello suggestion

last_current = (last_portb << 4) | (current_portb);

bIsStart = (last_current == 0xC4);

bIsStop = (last_current == 0x4C);

bIsData = (last_current == 0x04) || (last_current == 0x8C);

if (bIsStart) //START

{

digitalWriteFast(MONITOR_OUT2, HIGH);

if (bWaitingForStart)

{

digitalWriteFast(MONITOR_OUT3, HIGH); //start of entire capture

bWaitingForStart = false;

}

else if (bIsStop) //STOP

{

digitalWriteFast(MONITOR_OUT2, LOW);

}

if (!bWaitingForStart && (bIsData || bIsStart || bIsStop))

{

//digitalWriteFast(MONITOR_OUT3, HIGH);

raw_data[write_idx] = last_portb;

write_idx++;

raw_data[write_idx] = current_portb;

write_idx++;

if (write_idx >= CAPTURE_ARRAY_SIZE)

{

bDone = true;

digitalWriteFast(MONITOR_OUT3, LOW);

}

digitalWriteFast(MONITOR_OUT1, LOW);

}

else if (!bDone && mult0xCCount < MAX_IDLE_COUNT && last_portb == 0xc && current_portb == 0xc)

{

mult0xCCount++;

if (mult0xCCount >= MAX_IDLE_COUNT)

{

digitalWriteFast(MONITOR_OUT3, LOW);

bDone = true;

}

//-------------------------------------------------------------------------------

//-------------------------------- END ISR ---------------------------------

//-------------------------------------------------------------------------------

void loop()

{

if (bDone)

{

if (write_idx > 14)

{

//OK, we have some data to process. IDLE detection must have been EOM

Timer1.stop();

unsigned long startMsec = millis();

//Serial.printf("%lu\t %d\t", millis(), write_idx);

//PrintNextArrayBytes(raw_data, 0, 50);

//Serial.printf(" - %lu\n", millis());

uint16_t numprocessed = DecodeAndPrintValidData(raw_data); //decode and print everything captured so far

unsigned long endMsec = millis();

Serial.printf("%lu: processed = %d elements in %lu mSec\n\n", startMsec, numprocessed, endMsec-startMsec);

Timer1.start();

}

read_idx = 0;

bDone = false;

mult0xCCount = 0;

write_idx = 0;

bWaitingForStart = true;

}

else

{

//no data to process, but don't blow prints out every mSec...

if (mSecSinceLastWaitingPrint > WAITING_PRINT_INTERVAL_MSEC)

{

mSecSinceLastWaitingPrint -= WAITING_PRINT_INTERVAL_MSEC;

Serial.printf("%lu: Waiting for Data...\n", millis());

}

void PrintNextArrayBytes(uint8_t* data, uint16_t startidx, uint16_t numbytes)

{

Serial.printf("%d bytes starting at %d: ", numbytes, startidx);

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

{

Serial.printf("%x ", data[i + startidx]);

}

uint16_t DecodeAndPrintValidData(byte* data)

{

//Purpose: decode and print I2C conversation held in raw_data array

//Inputs:

// cb = 2048 element FIFO

//Outputs:

// returns number of bytes processed, or -1 for failure

// outputs structured I2C sentence to serial monitor

//Plan:

// Step1: Cull out invalid bytes

// Step2: Determine if there is anything to do (have to have more than one transition in FIFO)

// Step3: Parse transitions into I2C sentence structure

// Step4: Output sentence to serial monitor

memset(valid_data, 0, VALID_DATA_ARRAY_SIZE);

#ifdef PARSE_LOOP_DEBUG

PrintNextArrayBytes(valid_data, 0, 20); //print out first 20 bytes for verification

#endif

numvalidbytes = RemoveInvalidBytes(raw_data, valid_data);

#ifdef PARSE_LOOP_DEBUG

Serial.printf("Removed %d invalid bytes, leaving %d remaining\n", write_idx + 1 - numvalidbytes, numvalidbytes);

PrintNextArrayBytes(valid_data, 0, numvalidbytes); //print out first 20 bytes of valid_data array

#endif

if (numvalidbytes < 2)

{

return 0;

}

while (read_idx < numvalidbytes)

{

#ifdef PARSE_LOOP_DEBUG

Serial.printf("At top of while (read_idx < numvalidbytes): read_idx = %d\n", read_idx);

Serial.printf("Next two bytes in valid_data are %x, %x\n", valid_data[read_idx], valid_data[read_idx + 1]);

#endif

//Find a START sequence (0xC followed by 0x4)

while (!IsStart(valid_data, read_idx) && read_idx < numvalidbytes)

{

//Serial.printf("looking for start...\n");

read_idx++;

}

//at this point, read_idx should point to next valid byte pair

#ifdef PARSE_LOOP_DEBUG

Serial.printf("Start sequence found at %d\n", read_idx - 2);

//PrintNextFIFOBytes(valid_data, 20);

#endif

if (numvalidbytes - read_idx > 14)//14 entries required for 7-bit address

{

//Get 7-bit device address

devAddr = Get7BitDeviceAddr(valid_data, read_idx);

#ifdef PARSE_LOOP_DEBUG

Serial.printf("devAddr = %x\n", devAddr);

#endif

}

else

{

#ifdef PARSE_LOOP_DEBUG

Serial.printf("ran out of data at readidx = %d - exiting!\n", read_idx);

#endif

break;

}

//get read/write flag 1 = Read, 0 = Write, -1 = error

BusDir = (BUSDIR)GetReadWriteFlag(valid_data, read_idx);

#ifdef PARSE_LOOP_DEBUG

Serial.printf("BusDir = %s\n", ((BusDir == BUSDIR::WRITE) ? "WRITE" : "READ"));

//PrintNextFIFOBytes(valid_data, 20);

#endif

//get ACK/NAK flag

ACKNAKFlag = GetACKNAKFlag(valid_data, read_idx);

numbytes = GetDataBytes(valid_data, read_idx, databytes); //terminates on a START, but the start bytes are not consumed

#ifdef PARSE_LOOP_DEBUG

Serial.printf("Got %d bytes from GetDataBytes() --> ", numbytes);

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

{

Serial.printf(" %x ", databytes[i]);

}

Serial.printf("\n");

//PrintNextFIFOBytes(cb_trans, 20);

#endif

//If the bus direction is WRITE, then extract

// A register address for read / write

// zero or more additional data bytes

if (BusDir == BUSDIR::WRITE)

{

regAddr = databytes[0];

#ifdef PARSE_LOOP_DEBUG

Serial.printf("regAddr = %x, read_idx = %d\n", regAddr, read_idx);

#endif

//check for additional data

if (numbytes > 1)

{

#ifdef PARSE_LOOP_DEBUG

Serial.printf("Additional data found!\n");

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

{

Serial.printf("data[%d] = %x\n", i, databytes[i]);

}

#endif

//1st byte is register addr, subsequent bytes are data

OutputFormattedSentence(BusDir, devAddr, regAddr, numbytes, databytes, 1);

}

else //all bytes are data

{

#ifdef PARSE_LOOP_DEBUG

Serial.printf("In data block: got %d bytes of data\n", numbytes);

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

{

Serial.printf("data[%d] = %x\n", i, databytes[i]);

}

#endif

OutputFormattedSentence(BusDir, devAddr, regAddr, numbytes, databytes, 0);

}

#ifdef PARSE_LOOP_DEBUG

Serial.printf("At end of while (read_idx < numvalidbytes): read_idx = %d\n", read_idx);

#endif

}//while (read_idx < numvalidbytes)

return numvalidbytes;

}

#pragma region Support Functions

bool IsStart(byte* data, uint16_t& readidx)

{

bool result = false;

//Serial.printf("IsStart[%d] = %x, IsStart[%d] = %x\n",

// readidx, data[readidx], readidx + 1, data[readidx + 1]);

if (data[readidx] == 0xC && data[readidx + 1] == 0x4)

{

result = true;

readidx += 2; //bump to next byte pair

}

return result;

}

bool IsStop(byte* data, uint16_t& readidx)

{

bool result = false;

//Serial.printf("IsStop[%d] = %x, IsStop[%d] = %x\n",

//readidx, data[readidx], readidx + 1, data[readidx + 1]);

if (data[readidx] == 0x4 && data[readidx + 1] == 0xC)

{

result = true;

readidx += 2; //bump to next byte pair

}

return result;

}

uint8_t Get7BitDeviceAddr(byte* data, uint16_t& readidx)

{

//Purpose: Construct a 7-bit address starting from dataidx

//Inputs:

// data = pointer to valid data array

// readidx = starting index of 7-bit address sequence (MSB first)

//Outputs:

// returns the address as an 8-bit value with the MSB = 0, or 0x0 if unsuccessful

// dataidx = pointer to next data entry

//Plan:

// Step1: Convert a pair of data entries into a 0 or 1

// Step2: Add the appropriate value to an ongoing sum

// Step3: return the total.

//Notes:

// A '0' is coded as a 0x0 followed by a 0x4

// A '1' is coded as a 0x8 followed by a 0xC

uint8_t devAddr = 0x0; //failure return value

//Serial.printf("Get7BitDeviceAddr: readidx = %d\n",readidx);

//devAddr is exactly 7 bits long, so 8 bits with MSB = 0

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

{

if (data[readidx] == 0x0 && data[readidx + 1] == 0x4)

{

readidx += 2; //advance the pointer, but don't add to sum

}

else if (data[readidx] == 0x8 && data[readidx + 1] == 0xC)

{

//Serial.printf("Get7BitDeviceAddr: '1' found at i = %d, adding %x to devAddr to get %x\n",

// i, 1 << (7 - i), devAddr + (1 << (7-i)));

readidx += 2; //advance the pointer

devAddr += (1 << (7 - i)); //add 2^(7-i) to sum

}

devAddr = devAddr >> 1; //divide result by 2 to get 7-bit addr from 8 bits

return devAddr;

}

int Get8BitDataByte(byte* data, uint16_t& readidx)

{

//Purpose: Construct a 8-bit data byte starting from dataidx

//Inputs:

// data = pointer to valid data array

// readidx = starting index of 8-bit data byte (MSB first)

//Outputs:

// returns the address as an 8-bit value, or 0x0 if unsuccessful

// dataidx = pointer to next data entry

//Plan:

// Step1: Convert a pair of data entries into a 0 or 1

// Step2: Add the appropriate value to an ongoing sum

// Step3: return the total.

//Notes:

// A '0' is coded as a 0x0 followed by a 0x4

// A '1' is coded as a 0x8 followed by a 0xC

// 12/29/19 - changed return val to int, so can return -1 when a 'short byte' is detected

int dataval = 0x0; //failure return value

#ifdef GET_8BIT_DATABYTE_DEBUG

Serial.printf("Get8BitDataByte: data[%d] = %x, data[%d] = %x\n",

readidx, data[readidx], readidx + 1, data[readidx + 1]);

#endif

//8 bits with MSB = 0

int numbytes = 0;

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

{

if (data[readidx] == 0x0 && data[readidx + 1] == 0x4)

{

readidx += 2; //advance the pointer, but don't add to sum

numbytes++;

}

else if (data[readidx] == 0x8 && data[readidx + 1] == 0xC)

{

#ifdef GET_8BIT_DATABYTE_DEBUG

Serial.printf("Get8BitDataByte: '1' found at i = %d, adding %x to devAddr to get %x\n",

i, 1 << (7 - i), dataval + (1 << (7 - i)));

#endif

readidx += 2; //advance the pointer

dataval += (1 << (7 - i)); //add 2^(8-i) to sum

numbytes++;

}

#ifdef GET_8BIT_DATABYTE_DEBUG

Serial.printf("Get8BitDataByte: numbytes = %d\n", numbytes);

#endif

if (numbytes != 8)

{

dataval = -1; //error return value

}

return dataval;

}

int GetReadWriteFlag(byte* data, uint16_t& readidx)

{

//Purpose: decode R/W byte pair

//Inputs:

// data = pointer to valid data array

// readidx = index into data to start of R/W byte pair

//Outputs:

// readidx = if successful, points to next byte pair in data

// returns 1 for Read (0x8/0xC), 0 for Write (0x0/0x4), -1 for failure

//Notes:

//Serial.printf("GetReadWriteFlag: readidx = %d, data[readidx] = %x, data[readidx+1]= %x\n",

// readidx, data[readidx], data[readidx + 1]);

int result = 0;

if (data[readidx] == 0x8 && data[readidx + 1] == 0xC)

{

result = 1; //read detected

readidx += 2; //point to next byte pair

}

else if (data[readidx] == 0x0 && data[readidx + 1] == 0x4)

{

result = 0; //write detected

readidx += 2; //point to next byte pair

}

else

{

result = -1; //failed to detect read or write

}

return result;

}

int GetACKNAKFlag(byte* data, uint16_t& readidx)

{

//Purpose: decode ACK/NAK byte pair

//Inputs:

// data = pointer to valid data array

// readidx = index into data to start of ACK/NAK byte pair

//Outputs:

// readidx = if successful, points to next byte pair in data

// returns 1 for NAK (0x8/0xC), 0 for ACK (0x0/0x4), -1 for failure

//Notes:

//Serial.printf("GetACKNAKFlag: readidx = %d, data[readidx] = %x, data[readidx+1]= %x\n",

// readidx, data[readidx], data[readidx + 1]);

int result = 0;

if (data[readidx] == 0x8 && data[readidx + 1] == 0xC)

{

result = 1; //NAK detected

readidx += 2; //point to next byte pair

}

else if (data[readidx] == 0x0 && data[readidx + 1] == 0x4)

{

result = 0; //ACK detected

readidx += 2; //point to next byte pair

}

else

{

result = -1; //failed to detect ACK or NAK

}

return result;

}

int GetDataBytes(uint8_t* data, uint16_t& readidx, uint8_t* databytes)

{

//Notes:

// 01/01/2020: removed databyteidx from sig - always starts at zero

uint16_t numbytes = 0;

uint16_t databyte_idx = 0;

bool StartFlag = false;

bool StopFlag = false;

{

int dataval = Get8BitDataByte(data, readidx);

//watch out for 'short byte' reads

if (dataval >= 0)

{

uint8_t databyte = (uint8_t)dataval;

databytes[databyte_idx] = databyte;

databyte_idx++;

numbytes++;

}

ACKNAKFlag = GetACKNAKFlag(data, readidx);

StartFlag = IsStart(data, readidx);

StopFlag = IsStop(data, readidx);

#ifdef PARSE_LOOP_DEBUG

Serial.printf("IsStart returned %d, IsStop returned %d, dataidx = %d\n",

StartFlag, StopFlag, readidx);

#endif

} while (!StartFlag && !StopFlag && readidx < numvalidbytes);

readidx -= 2;//back readidx up so loop top is positioned correctly.

return numbytes;

}

void OutputFormattedSentence(int RW, uint8_t dev, uint8_t reg, uint8_t numbytes, uint8_t* bytearray, uint16_t startidx)

{

Serial.printf("%lu I2C(%x) %s %d bytes %s %x... ",

millis(), dev, (RW == 0 ? "writing" : "reading"), numbytes - startidx, (RW == 0 ? "to" : "from"), reg);

//for (size_t i = startidx; i < numbytes; i++)

//{

// Serial.printf("%x ", bytearray[i]);

//}

//Serial.printf(". Done\n");

#ifdef MPU6050_SPECIFIC

//01/18/20 experiment to decode 28-byte packet into yaw value

if (numbytes == 28)

{

dmpGetQuaternion(&q, bytearray);

dmpGetGravity(&gravity, &q);

dmpGetYawPitchRoll(ypr, &q, &gravity);

//compute the yaw value

global_yawval = ypr[0] * 180 / M_PI;

Serial.printf("yawval = %3.2f\n", global_yawval);

}

else

{

Serial.printf(". Done\n");

}

#endif // MPU6050_SPECIFIC

}

uint16_t RemoveInvalidBytes(uint8_t* rawdata, uint8_t* validdata)

{

uint16_t numvalid = 0;

uint16_t valididx = 0;

//Serial.printf("raw data array contains %d bytes\n", write_idx + 1);

//PrintNextArrayBytes(raw_data, 0, 20);

//OK, now go back through the array, excising invalid sequences

for (uint16_t rawidx = 0; rawidx < write_idx;/*rawidx incremented internally*/)

{

uint8_t firstByte = raw_data[rawidx]; //get the first byte

uint8_t secondByte = raw_data[rawidx + 1]; //get the next byte

bool validpair =

(

(firstByte == 0xC && secondByte == 0x4) //START or RESTART

|| (firstByte == 0x4 && secondByte == 0xC) //STOP

|| (firstByte == 0x0 && secondByte == 0x4) //0 OR ACK

|| (firstByte == 0x8 && secondByte == 0xC) //1 or NAK

);

//Serial.printf("rawidx %d: Considering %x and %x: validity = %d\n",

//rawidx, firstByte, secondByte, validpair);

if (validpair)

{

//save valid bytes to valid_bytes array

validdata[valididx] = firstByte;

validdata[valididx + 1] = secondByte;

numvalid += 2;

//Serial.printf("Added %x & %x at idx = %d & %d\n", firstByte, secondByte, valididx, valididx + 1);

//PrintNextArrayBytes(validdata,0,numvalid);

rawidx += 2;

valididx += 2;

}

else

{

rawidx++; //on invalid, just go to next byte

}

return numvalid;

}

#pragma endregion Support Functions

#ifdef MPU6050_SPECIFIC

//#pragma region YAW_COMPUTATIONS

////01/18/2020: I copied these functions from MPU6050_6Axis_MotionApps_V6_12.h and

//// modified them to be called directly instead of from an 'mpu' object

uint8_t dmpGetQuaternion(int16_t* data, const uint8_t* packet)

{

// TODO: accommodate different arrangements of sent data (ONLY default supported now)

if (packet != 0)

{

data[0] = ((packet[0] << 8) | packet[1]);

data[1] = ((packet[4] << 8) | packet[5]);

data[2] = ((packet[8] << 8) | packet[9]);

data[3] = ((packet[12] << 8) | packet[13]);

}

return 0;

}

uint8_t dmpGetQuaternion(Quaternion* q, const uint8_t* packet)

{

// TODO: accommodate different arrangements of sent data (ONLY default supported now)

int16_t qI[4]{ 0,0,0,0 };

uint8_t status = dmpGetQuaternion(qI, packet);

if (status == 0) {

q->w = (float)qI[0] / 16384.0f;

q->x = (float)qI[1] / 16384.0f;

q->y = (float)qI[2] / 16384.0f;

q->z = (float)qI[3] / 16384.0f;

return 0;

}

return status; // int16 return value, indicates error if this line is reached

}

uint8_t dmpGetYawPitchRoll(float* data, Quaternion* q, VectorFloat* gravity)

{

// yaw: (about Z axis)

data[0] = atan2(2 * q->x * q->y - 2 * q->w * q->z, 2 * q->w * q->w + 2 * q->x * q->x - 1);

// pitch: (nose up/down, about Y axis)

data[1] = atan2(gravity->x, sqrt(gravity->y * gravity->y + gravity->z * gravity->z));

// roll: (tilt left/right, about X axis)

data[2] = atan2(gravity->y, gravity->z);

if (gravity->z < 0) {

if (data[1] > 0) {

data[1] = PI - data[1];

}

else {

data[1] = -PI - data[1];

}

return 0;

}

uint8_t dmpGetGravity(VectorFloat* v, Quaternion* q)

{

v->x = 2 * (q->x * q->z - q->w * q->y);

v->y = 2 * (q->w * q->x + q->y * q->z);

v->z = q->w * q->w - q->x * q->x - q->y * q->y + q->z * q->z;

return 0;

}

//#pragma endregion YAW_COMPUTATIONS

#endif //MPU6050_SPECIFIC

With this setup with the master sending data to the slave, I got the following outputs:

Master

Sending to Slave: 1048.005615 (0x4483002e)
i = 0: I2C_WriteAnything() sending 2E
i = 1: I2C_WriteAnything() sending 0
i = 2: I2C_WriteAnything() sending 83
i = 3: I2C_WriteAnything() sending 44
OK
Sending to Slave: 1049.239990 (0x448327ae)
i = 0: I2C_WriteAnything() sending AE
i = 1: I2C_WriteAnything() sending 27
i = 2: I2C_WriteAnything() sending 83
i = 3: I2C_WriteAnything() sending 44
OK
Sending to Slave: 1050.474487 (0x44834f2f)
i = 0: I2C_WriteAnything() sending 2F
i = 1: I2C_WriteAnything() sending 4F
i = 2: I2C_WriteAnything() sending 83
i = 3: I2C_WriteAnything() sending 44
OK
Sending to Slave: 1051.708862 (0x448376af)
i = 0: I2C_WriteAnything() sending AF
i = 1: I2C_WriteAnything() sending 76
i = 2: I2C_WriteAnything() sending 83
i = 3: I2C_WriteAnything() sending 44
OK
Sending to Slave: 1052.943237 (0x44839e2f)
i = 0: I2C_WriteAnything() sending 2F
i = 1: I2C_WriteAnything() sending 9E
i = 2: I2C_WriteAnything() sending 83
i = 3: I2C_WriteAnything() sending 44
OK

Sending to Slave: 1048.005615 (0x4483002e)

i = 0: I2C_WriteAnything() sending 2E

i = 1: I2C_WriteAnything() sending 0

i = 2: I2C_WriteAnything() sending 83

i = 3: I2C_WriteAnything() sending 44

Sending to Slave: 1049.239990 (0x448327ae)

i = 0: I2C_WriteAnything() sending AE

i = 1: I2C_WriteAnything() sending 27

i = 2: I2C_WriteAnything() sending 83

i = 3: I2C_WriteAnything() sending 44

Sending to Slave: 1050.474487 (0x44834f2f)

i = 0: I2C_WriteAnything() sending 2F

i = 1: I2C_WriteAnything() sending 4F

i = 2: I2C_WriteAnything() sending 83

i = 3: I2C_WriteAnything() sending 44

Sending to Slave: 1051.708862 (0x448376af)

i = 0: I2C_WriteAnything() sending AF

i = 1: I2C_WriteAnything() sending 76

i = 2: I2C_WriteAnything() sending 83

i = 3: I2C_WriteAnything() sending 44

Sending to Slave: 1052.943237 (0x44839e2f)

i = 0: I2C_WriteAnything() sending 2F

i = 1: I2C_WriteAnything() sending 9E

i = 2: I2C_WriteAnything() sending 83

i = 3: I2C_WriteAnything() sending 44

Slave:

Slave received: 1048.005615
Slave received: 1049.239990
Slave received: 1050.474487
Slave received: 1051.708862
Slave received: 1052.943237

Slave received: 1048.005615

Slave received: 1049.239990

Slave received: 1050.474487

Slave received: 1051.708862

Slave received: 1052.943237

I2C Sniffer:

Start sequence found at 0
devAddr = 66
BusDir = WRITE
Got 4 bytes from GetDataBytes() -->  2e  0  83  44 
Start sequence found at 0
devAddr = 66
BusDir = WRITE
Got 4 bytes from GetDataBytes() -->  ae  27  83  44 
Start sequence found at 0
devAddr = 66
BusDir = WRITE
Got 4 bytes from GetDataBytes() -->  2f  4f  83  44 
Start sequence found at 0
devAddr = 66
BusDir = WRITE
Got 4 bytes from GetDataBytes() -->  af  76  83  44 
Start sequence found at 0
devAddr = 66
BusDir = WRITE
Got 4 bytes from GetDataBytes() -->  2f  9e  83  44

Start sequence found at 0

devAddr = 66

BusDir = WRITE

Got 4 bytes from GetDataBytes() --> 2e 0 83 44

Start sequence found at 0

devAddr = 66

BusDir = WRITE

Got 4 bytes from GetDataBytes() --> ae 27 83 44

Start sequence found at 0

devAddr = 66

BusDir = WRITE

Got 4 bytes from GetDataBytes() --> 2f 4f 83 44

Start sequence found at 0

devAddr = 66

BusDir = WRITE

Got 4 bytes from GetDataBytes() --> af 76 83 44

Start sequence found at 0

devAddr = 66

BusDir = WRITE

Got 4 bytes from GetDataBytes() --> 2f 9e 83 44

In the other direction, with the slave sending data to the master, I got the following:

Slave:

Sending 28398426.000000 to Master
Sending 28398426.000000 to Master
Sending 28398426.000000 to Master
Sending 28398426.000000 to Master

Sending 28398426.000000 to Master

Master:

Reading from Slave: Received 28398426.000000 from Slave
Reading from Slave: Received 28398426.000000 from Slave
Reading from Slave: Received 28398426.000000 from Slave

Reading from Slave: Received 28398426.000000 from Slave

I2C Sniffer:

In data block:  got 112 bytes of data
data[0] = ad
data[1] = a9
data[2] = d8
data[3] = 4b
data[4] = 0
data[5] = 0
....
In data block:  got 112 bytes of data
data[0] = ad
data[1] = a9
data[2] = d8
data[3] = 4b
data[4] = 0
data[5] = 0
.....
In data block:  got 112 bytes of data
data[0] = ad
data[1] = a9
data[2] = d8
data[3] = 4b
data[4] = 0
data[5] = 0

In data block: got 112 bytes of data

data[0] = ad

data[1] = a9

data[2] = d8

data[3] = 4b

data[4] = 0

data[5] = 0

....

In data block: got 112 bytes of data

data[0] = ad

data[1] = a9

data[2] = d8

data[3] = 4b

data[4] = 0

data[5] = 0

.....

In data block: got 112 bytes of data

data[0] = ad

data[1] = a9

data[2] = d8

data[3] = 4b

data[4] = 0

data[5] = 0

Where the HEX sequence 4B D8 A9 AD converted to a IEEE float = 2.83984e+07

So, the Teensy-to-Teensy I2C connection is clearly working in both directions, and the Teensy I2C Sniffer is successfully capturing and decoding the I2C traffic between the two modules – cool!

So, the next step is to replace the ‘Master’ Teensy with an Arduino Mega and repeat the process. Hopefully this will allow me to figure out why the slave-to-master data transfer isn’t working

21 March 2020 Update:

Based on the above results, I formed a hypothesis that the problem with sending I2C data from a Teensy slave to an Arduino Mega master might be due to the Mega not being able to properly interpret 0-3.3V transitions from the Teensy. So, I decided to construct a low-to-high level converter to make sure that SDA data from the Teensy was presented to the Mega as 0-5V transitions rather than the Teensy’s ‘raw’ 0-3.3V ones. To do this I used the circuit shown below, except with a 1K instead of 10K resistor for R2 to clean up the transitions at 100KHz.

Bidirectional 3.3-5V level shifter using 2N7000 MosFet

Here’s a scope photo of the 3.3V input to and the 5V output from the 2N7000-based level shifter. The top trace is the Teensy 0-3.3V output, and the bottom trace is the 0-5V level-shifted version. Both traces are 1V/cm, and the horizontal time scale is 20 uSec/cm.

Teensy slave, Mega master: Top: 0-3.3V input. Bottom: 0-5V output. Both traces are 1V/cm vertical, 20 uSec cm horizontally

To verify that the above circuit worked properly, I used it in the SDA line (the SCL line doesn’t require any level shifting as it is from the 5V Mega to the 3.3V Teensy) with a Teensy slave and a Teensy master. This is OK, as Teensy 3.x’s can handle 5V inputs, and it worked properly in both directions. Here’s a shot of the SDA line

Teensy slave, Teensy master: Top: 0-3.3V input. Bottom: 0-5V output. Both traces are 1V/cm vertical, 20 uSec cm horizontally

However, after replacing the Teensy master with the Mega one, I had the same problem as before – I can successfully transfer data from Mega master to Teensy slave, but not in the other direction. There is still a problem somewhere, and I no longer think it’s due to level-shifting problems. From the above scope photos, it is clear that only a few bytes are transmitted by the Teensy slave each time it services the OnRequest() interrupt, while that same function transmits MUCH more data when servicing the same request from the Teensy 3.5 master.

Stay tuned!

23 March 2020 Update:

OK, back to the basics: I downloaded the code for a very basic Arduino-Arduino I2C tutorial, and verified that it worked OK. I also took a scope shot of SDA/SCL activity during the two-way data transfers, as shown below:

Basic Arduino-Arduino tutorial layout

I2C line activity for the ‘Basic Arduino – Arduino I2C Tutorial’

So now that I have a working baseline for the Arduino-Arduino I2C case, I plan to incrementally modify it toward duplicating the non-working Arduino-Arduino I2C case until it breaks, and then I’ll know that the last incremental modification is the culprit. At the moment, I’m leaning toward the use of the I2CDev & SBWIRE libraries as they are the only significant difference between the working and non-working setups. We’ll see….

24 March 2020 Update:

I created a new Arduino project called ‘I2C_Master_Tut_Mod1’ initially identical to ‘I2C_Master_Tutorial’ and verified that it worked properly with the unmodified ‘I2C_Slave_Tutorial’ project, and then started modifying it.

Added #include <PrintEx.h> //allows printf-style printout syntax
StreamEx mySerial = Serial; //added 03/18/18 for printf-style printing, and changed all occurrences of ‘Serial’ to ‘mySerial’ and modified print statements to ‘printf’ format. All worked fine.
Added #include <I2C_Anything.h> and changed loop() to write a float value to the slave. However, this caused a compile error. When I started tracking it down I realized that I had previously modified ‘I2C_Anything.h’ to #include SBWIRE.h rather than the original #include Wire.h. So, this could be the culprit, assuming that there is something about SBWIRE that causes Arduino I2C slaves to misbehave.
Copied I2C_Anything.h/cpp from the Libraries folder to my new ‘I2C_Master_Tut_Mod1’ folder, and un-modified it to reference back Wire.h vs SBWIRE.h.

25 March 2020 Update:

As it turns out, I was never able to get the ‘I2C_Master_Tut_Mod1’ project working with #include <I2C_Anything.h> , no matter what I did, including copying the #include <I2C_Anything.h> to the local folder and including it as a resource int the VS2019 project, build cleans, removing the _vm folder created by Visual Micro, etc. To make it even stranger, I created a new Arduino project in VS2019 called ‘I2C_Master_Tut_Mod2’, copied the ‘I2C_Anything.h’ file to the local folder, and it compiles without error! So now I have two almost completely identical Arduino projects, one of which compiles fine and the other of which blows a bunch of errors about twi.c. I’m currently working with Tim Leek at VisualMicro to sort out what I did wrong.

27 March 2020 Update:

Ok, I now have the Arduino Mega master to Arduino Uno slave setup working, with I2C_Anything. I can transfer a float value in either direction with no problem. The master and slave code sets and the corresponding outputs are shown below.

Master Sketch:

/*
    Name:       I2C_Master_Tut_Mod2.ino
    Created:	3/25/2020 8:54:55 AM
    Author:     FRANKNEWXPS15\Frank
*/


/*
    Name:       I2C_Master_Tutorial.ino
    Created:	3/23/2020 1:20:08 PM
    Author:     FRANKNEWXPS15\Frank
*/
/*
  I2C Master Demo
  i2c-master-demo.ino
  Demonstrate use of I2C bus
  Master sends character and gets reply from Slave
  DroneBot Workshop 2019
  https://dronebotworkshop.com
*/

// Include Arduino Wire library for I2C
#include <Wire.h>
#include "PrintEx.h"
#include "I2C_Anything.h"
// Define Slave I2C Address
#define SLAVE_ADDR 9
StreamEx mySerial = Serial; //added 03/18/18 for printf-style printing

// Define Slave answer size
#define ANSWERSIZE 5
const float sendval = 3.14159f;
float rcvval = 0;

void setup() {

    // Initialize I2C communications as Master
    Wire.begin();

    // Setup serial monitor
    Serial.begin(115200);
    Serial.println("I2C Master Demonstration");
}

void loop() {
    delay(50);
    //Serial.println("Write data to slave");
    mySerial.printf("Sent %3.5f: ",sendval);

    // Write a charatre to the Slave
    Wire.beginTransmission(SLAVE_ADDR);
    //Wire.write(0);
    I2C_writeAnything(sendval);
    Wire.endTransmission();

    //Serial.println("Receive data");

    //// Read response from Slave
    //// Read back 5 characters
    //Wire.requestFrom(SLAVE_ADDR, ANSWERSIZE);

    //// Add characters to string
    //String response = "";
    //while (Wire.available()) {
    //    char b = Wire.read();
    //    response += b;
    //}

    //// Print to Serial Monitor
    //Serial.println(response);

    //03/26/2020 gfp rev to retrieve float value
    Wire.requestFrom(SLAVE_ADDR, sizeof(float));
    I2C_readAnything(rcvval);
    mySerial.printf("Received %4.1f\n",rcvval);


}

Name: I2C_Master_Tut_Mod2.ino

Created: 3/25/2020 8:54:55 AM

Author: FRANKNEWXPS15\Frank

Name: I2C_Master_Tutorial.ino

Created: 3/23/2020 1:20:08 PM

Author: FRANKNEWXPS15\Frank

I2C Master Demo

i2c-master-demo.ino

Demonstrate use of I2C bus

Master sends character and gets reply from Slave

DroneBot Workshop 2019

https://dronebotworkshop.com

// Include Arduino Wire library for I2C

#include <Wire.h>

#include "PrintEx.h"

#include "I2C_Anything.h"

// Define Slave I2C Address

#define SLAVE_ADDR 9

StreamEx mySerial = Serial; //added 03/18/18 for printf-style printing

// Define Slave answer size

#define ANSWERSIZE 5

const float sendval = 3.14159f;

float rcvval = 0;

void setup() {

// Initialize I2C communications as Master

Wire.begin();

// Setup serial monitor

Serial.begin(115200);

Serial.println("I2C Master Demonstration");

}

void loop() {

delay(50);

//Serial.println("Write data to slave");

mySerial.printf("Sent %3.5f: ",sendval);

// Write a charatre to the Slave

Wire.beginTransmission(SLAVE_ADDR);

//Wire.write(0);

I2C_writeAnything(sendval);

Wire.endTransmission();

//Serial.println("Receive data");

//// Read response from Slave

//// Read back 5 characters

//Wire.requestFrom(SLAVE_ADDR, ANSWERSIZE);

//// Add characters to string

//String response = "";

//while (Wire.available()) {

// char b = Wire.read();

// response += b;

//}

//// Print to Serial Monitor

//Serial.println(response);

//03/26/2020 gfp rev to retrieve float value

Wire.requestFrom(SLAVE_ADDR, sizeof(float));

I2C_readAnything(rcvval);

mySerial.printf("Received %4.1f\n",rcvval);

}

Slave Sketch:

/*
    Name:       I2C_Slave_Tutorial.ino
    Created:	3/23/2020 1:23:40 PM
    Author:     FRANKNEWXPS15\Frank
*/


/*
  I2C Slave Demo
  i2c-slave-demo.ino
  Demonstrate use of I2C bus
  Slave receives character from Master and responds
  DroneBot Workshop 2019
  https://dronebotworkshop.com
*/

// Include Arduino Wire library for I2C
#include <Wire.h>
#include "PrintEx.h"
StreamEx mySerial = Serial; //added 03/18/18 for printf-style printing

//03/26/2020 experiment with I2C_Anything
#include "I2C_Anything.h"
float rcvval = 0;
float sendval = 95141.3; //3.14159 written backwards


// Define Slave I2C Address
#define SLAVE_ADDR 9

// Define Slave answer size
#define ANSWERSIZE 5

// Define string with response to Master
String answer = "Hello";

void setup() {

    // Initialize I2C communications as Slave
    Wire.begin(SLAVE_ADDR);

    // Function to run when data requested from master
    Wire.onRequest(requestEvent);

    // Function to run when data received from master
    Wire.onReceive(receiveEvent);

    // Setup Serial Monitor 
    Serial.begin(115200);
    Serial.println("I2C Slave Demonstration");
}

void receiveEvent() {

    //Serial.println("Receive event");
    // Read while data received
    //while (0 < Wire.available()) {
    //    byte x = Wire.read();
    //}

    //03/26/2020 experiment with I2C_Anything
    I2C_readAnything(rcvval);

    // Print to Serial Monitor
    //Serial.print("Received "); Serial.print(rcvval, 6); Serial.println(" From Master");
    mySerial.printf("Received %3.6f: ", rcvval);
}

void requestEvent() {

    //// Setup byte variable in the correct size
    //byte response[ANSWERSIZE];

    //// Format answer as array
    //for (byte i = 0; i < ANSWERSIZE; i++) {
    //    response[i] = (byte)answer.charAt(i);
    //}

    //// Send response back to Master
    //Wire.write(response, sizeof(response));

    //// Print to Serial Monitor
    //Serial.println("Request event");

    //03/26/2020 experiment with I2C_Anything
    //Serial.print("Sending "); Serial.print(sendval, 6); Serial.println(" to Master");
    mySerial.printf("Sent %6.1f\n",sendval);
    I2C_writeAnything(sendval);
}

void loop() {

    // Time delay in loop
    delay(50);
}

Name: I2C_Slave_Tutorial.ino

Created: 3/23/2020 1:23:40 PM

Author: FRANKNEWXPS15\Frank

I2C Slave Demo

i2c-slave-demo.ino

Demonstrate use of I2C bus

Slave receives character from Master and responds

DroneBot Workshop 2019

https://dronebotworkshop.com

// Include Arduino Wire library for I2C

#include <Wire.h>

#include "PrintEx.h"

StreamEx mySerial = Serial; //added 03/18/18 for printf-style printing

//03/26/2020 experiment with I2C_Anything

#include "I2C_Anything.h"

float rcvval = 0;

float sendval = 95141.3; //3.14159 written backwards

// Define Slave I2C Address

#define SLAVE_ADDR 9

// Define Slave answer size

#define ANSWERSIZE 5

// Define string with response to Master

String answer = "Hello";

void setup() {

// Initialize I2C communications as Slave

Wire.begin(SLAVE_ADDR);

// Function to run when data requested from master

Wire.onRequest(requestEvent);

// Function to run when data received from master

Wire.onReceive(receiveEvent);

// Setup Serial Monitor

Serial.begin(115200);

Serial.println("I2C Slave Demonstration");

}

void receiveEvent() {

//Serial.println("Receive event");

// Read while data received

//while (0 < Wire.available()) {

// byte x = Wire.read();

//}

//03/26/2020 experiment with I2C_Anything

I2C_readAnything(rcvval);

// Print to Serial Monitor

//Serial.print("Received "); Serial.print(rcvval, 6); Serial.println(" From Master");

mySerial.printf("Received %3.6f: ", rcvval);

}

void requestEvent() {

//// Setup byte variable in the correct size

//byte response[ANSWERSIZE];

//// Format answer as array

//for (byte i = 0; i < ANSWERSIZE; i++) {

// response[i] = (byte)answer.charAt(i);

//}

//// Send response back to Master

//Wire.write(response, sizeof(response));

//// Print to Serial Monitor

//Serial.println("Request event");

//03/26/2020 experiment with I2C_Anything

//Serial.print("Sending "); Serial.print(sendval, 6); Serial.println(" to Master");

mySerial.printf("Sent %6.1f\n",sendval);

I2C_writeAnything(sendval);

}

void loop() {

// Time delay in loop

delay(50);

}

Master & Slave Output:

Opening port
Port open
I2C Master Demonstration
Sent 3.14159: Received 95141.3
Sent 3.14159: Received 95141.3
Sent 3.14159: Received 95141.3
Sent 3.14159: Received 95141.3
Sent 3.14159: Received 95141.3
Sent 3.14159: Received 95141.3


Opening port
Port open
I2C Slave Demonstration
Received 3.141590: Sent 95141.3
Received 3.141590: Sent 95141.3
Received 3.141590: Sent 95141.3
Received 3.141590: Sent 95141.3
Received 3.141590: Sent 95141.3
Received 3.141590: Sent 95141.3

Opening port

Port open

I2C Master Demonstration

Sent 3.14159: Received 95141.3

Opening port

Port open

I2C Slave Demonstration

Received 3.141590: Sent 95141.3

So now I have a working Arduino-Arduino I2C master/slave setup, using I2C_Anything.h to transfer float values back and forth, and a working Teensy-Teensy I2C master/slave setup, using I2C_Anything.h to transfer float values back and forth.

The next step was to replace the Arduino Uno I2C slave with the Teensy 3.2 I2C slave and see if I can get that combination working. This turned out to be surprisingly easy – basically plug-and-pray (oops, I meant ‘play’).

Now that I have a simple Arduiono Mega Master – Teensy 3.2 Slave setup working, I can start to explore why my 4WD robot setup doesn’t work. Some possibilities:

It could be that the SBWire version of the Wire library has some hidden bugs in the slave-related code. The SBWire library eliminates the well-known and well-hated ‘hang’ bug in the Arduino wire library.
It could be that some other library I am using, like the RTC library or the Adafruit FRAM library is interfering with the Arduino-Teensy interrupts needed for master-slave communication.
It could be that the IR demod program running on the slave Teensy is somehow interfering with master-slave communications (this is very unlikely as this same program had been working flawlessly for several months).
Something else…

To start with, I copied the current ‘I2C_Master_Tut2’ VS2019 project to a new one – ‘I2C_Master_Tut3’ before making any modifications. I plan to keep a ‘breadcrumb trail’ of incrementally modified projects so that I can go backwards in case I get lost at some point (and, in my fairly long 50+ years as a practicing engineer, I have learned that ‘getting lost’ is part and parcel of any non-trivial troubleshooting project).

Once I verified that ‘Tut3’ properly communicated with the Teensy slave, I started making modifications.

Replaced #include <Wire.h> with #include SBWire.h. This failed in compile with a linker error, but succeeded after I did a ‘Build -> Clean’. After uploading the new ‘Tut3’ version to the Mega, I found that master-slave communications still worked properly. This is actually a welcome development, as that now eliminates SBWire as the culprit for lost Mega-Teensy I2C capability on the robot.
Replaced ‘#include “SBWire” with #include “MPU6050_6Axis_MotionApps_V6_12.h” and include “I2Cdev.h” (this includes SBWire.h). These two libraries are required for interfacing to the MPU6050 IMU module.

29 March 2020 Update:

So I created a new copy of the I2C master, ‘I2C_Master_Tut4’ and started adding things from the original non-working robot program.

Added all the remaining #include’s. Still works fine with the Teensy 3.2 slave
Added all the #defines. Still works fine
Added all the IRHOMING parameters. OK
Added all ENUMs, Battery constants, distance measurement support constants & array declarations, motor parameters, wheel direction constants and variables, and heading based turn parameters. No problem
Added pin assignments. No problem.
Added all the other pre-setup stuff. No problem
Added ‘ Serial1.begin(9600); //03/04/16 bugfix’. This isn’t actually used anymore in the robot project, but it is there, so it could be the culprit. Nope – master/slave comms still OK.
Added RTC initialization and support function. Still no problem
Added FRAM initialization. No problem.
Added MPU6050 initialization. No problem
Added PID distance array and incremental variance initialization. No problem
Added I/O pin initialization. No problem
Added the rest of Setup(), and all the support functions required for the POST check to run. Compiles and runs fine. Of course, no peripherals are attached, so not much happens.

At this point I have all the pre-setup and setup code incorporated into the master/slave example, and everything is still happily plugging away. So obviously the culprit hasn’t yet been identified. However, before going any farther, I think I’ll drop ‘Tut4’ into the safe-deposit box and create a ‘Tut5’ to continue on into the loop() function.

OK, so I have a ‘Tut5’ project now, with everything up to loop() incorporated from the ‘FourWD_WallE2_V2’ robot project. Now the question is, ‘What next?’. I need to figure out what is causing I2C comms between the Mega master and the Teensy 3.2 slave to fail, so I need a way to faithfully replicate/simulate/emulate the actual robot code for this function.

The current robot algorithm as pertaining to the Teensy IR Demod module

Each time through the loop, the current operating mode is determined.
- If IsIRBeamAvail() returns TRUE, the IR HOMING mode is activated
  - IsIRBeamAvail() gets three float values from the Teensy 3.2, and returns TRUE if the total of the first two values (Fin1 & Fin2) is above a set threshold. It is this function that is failing to communicate with the Teensy. More specifically, it is this function that is not successfully acquiring the three float values, and subsequently always returns FALSE.

So, it may be that all I have to do is to call IsIRBeamAvail() by itself, and modify the slave code to send back three floats as expected. If this works, then I’ll have to start suspecting the robot’s Teensy or the I2C wiring, or something else entirely.

2 April 2020 Update:

After some additional fumbling around with I2C_Anything and the PrintEx library printf() formats, I now have a working ‘IsIRBeamAvail()’ function in ‘Tut5’, as follows:

bool IsIRBeamAvail()
{
	//Purpose: Determine whether or not an IR beam is available for homing
	//Inputs: call from loop()
	//Outputs: true if an IR beam is detected, false otherwise
	//Plan:
	//	Step1: Get analog levels from all 4 IR detectors
	//	Step2: return true if any of the 4 show detection level
	//Notes:
	//	Might need some hysteresis here to avoid toggling in and out of the TRACKING_IRBEAM mode
	//	02/21/17 read each det 3 times. If any sum is less than 3 X threshold, return true.  Otherwise return false
	//	10/15/17 rewritten to use info from IR Demod Module

	//get latest info from IR Demod Module
	long Fin1 = 0; //03/30/20 needs to be 'long int' (4 bytes) here to match Teensy int (4 bytes)
	long Fin2 = 23; //03/30/20 needs to be 'long int' (4 bytes) here to match Teensy int (4 bytes)
	float SteeringValue;

	mySerial.printf("\n<<<<<<<   In IsIRBeamAvail()  >>>>>>>>>>>>>>>>>>>>\n\n");

	Wire.requestFrom(SLAVE_ADDR, sizeof(Fin1) + sizeof(Fin2)+ sizeof(SteeringValue));
	
	I2C_readAnything(Fin1);
	I2C_readAnything(Fin2);
	I2C_readAnything(SteeringValue);

	mySerial.printf("Fin1 = %ld, Fin2 = %ld, SteeringValue = %3.2f\n", Fin1, Fin2, SteeringValue);

	return false;
}

bool IsIRBeamAvail()

{

//Purpose: Determine whether or not an IR beam is available for homing

//Inputs: call from loop()

//Outputs: true if an IR beam is detected, false otherwise

//Plan:

// Step1: Get analog levels from all 4 IR detectors

// Step2: return true if any of the 4 show detection level

//Notes:

// Might need some hysteresis here to avoid toggling in and out of the TRACKING_IRBEAM mode

// 02/21/17 read each det 3 times. If any sum is less than 3 X threshold, return true. Otherwise return false

// 10/15/17 rewritten to use info from IR Demod Module

//get latest info from IR Demod Module

long Fin1 = 0; //03/30/20 needs to be 'long int' (4 bytes) here to match Teensy int (4 bytes)

long Fin2 = 23; //03/30/20 needs to be 'long int' (4 bytes) here to match Teensy int (4 bytes)

float SteeringValue;

mySerial.printf("\n<<<<<<< In IsIRBeamAvail() >>>>>>>>>>>>>>>>>>>>\n\n");

Wire.requestFrom(SLAVE_ADDR, sizeof(Fin1) + sizeof(Fin2)+ sizeof(SteeringValue));

I2C_readAnything(Fin1);

I2C_readAnything(Fin2);

I2C_readAnything(SteeringValue);

mySerial.printf("Fin1 = %ld, Fin2 = %ld, SteeringValue = %3.2f\n", Fin1, Fin2, SteeringValue);

return false;

}

Which, when connected to my basic Teensy 3.2 I2C slave program produces the following (correct) output:

<<<<<<<   In IsIRBeamAvail()  >>>>>>>>>>>>>>>>>>>>

Fin1 = 469, Fin2 = 938, SteeringValue = 1473.41

<<<<<<<   In IsIRBeamAvail()  >>>>>>>>>>>>>>>>>>>>

Fin1 = 470, Fin2 = 940, SteeringValue = 1476.55

<<<<<<<   In IsIRBeamAvail()  >>>>>>>>>>>>>>>>>>>>

Fin1 = 471, Fin2 = 942, SteeringValue = 1479.69

<<<<<<< In IsIRBeamAvail() >>>>>>>>>>>>>>>>>>>>

Fin1 = 469, Fin2 = 938, SteeringValue = 1473.41

<<<<<<< In IsIRBeamAvail() >>>>>>>>>>>>>>>>>>>>

Fin1 = 470, Fin2 = 940, SteeringValue = 1476.55

<<<<<<< In IsIRBeamAvail() >>>>>>>>>>>>>>>>>>>>

Fin1 = 471, Fin2 = 942, SteeringValue = 1479.69

At this point we have a working robot code emulation that communicates successfully with a basic Teensy 3.2 slave. So, the available culprits have been reduced significantly to

Something about the Teensy IR demod code
The I2C Wiring
A hardware problem at either the robot’s Mega controller or the robot’s Teensy 3.2 controller
Something else.

For the next step, I modified the Teensy IR Demod code to emulate the IR detector response and loaded this code into the Teensy 3.2 slave connected to the Mega master. After some initial mis-steps, it started working nicely, with the following (correct) output from the Mega master:

<<<<<<<   In IsIRBeamAvail()  >>>>>>>>>>>>>>>>>>>>

Fin1 = 6400, Fin2 = 3200, SteeringValue = 0.33

<<<<<<<   In IsIRBeamAvail()  >>>>>>>>>>>>>>>>>>>>

Fin1 = 6400, Fin2 = 3200, SteeringValue = 0.33

<<<<<<<   In IsIRBeamAvail()  >>>>>>>>>>>>>>>>>>>>

Fin1 = 6400, Fin2 = 3200, SteeringValue = 0.33

Port closed

<<<<<<< In IsIRBeamAvail() >>>>>>>>>>>>>>>>>>>>

Fin1 = 6400, Fin2 = 3200, SteeringValue = 0.33

<<<<<<< In IsIRBeamAvail() >>>>>>>>>>>>>>>>>>>>

Fin1 = 6400, Fin2 = 3200, SteeringValue = 0.33

<<<<<<< In IsIRBeamAvail() >>>>>>>>>>>>>>>>>>>>

Fin1 = 6400, Fin2 = 3200, SteeringValue = 0.33

Port closed

So this eliminates the ‘Something about the Teensy IR demod code’ possibility from the above list.

Next, I replaced the direct SCL/SDA jumpers with the daisy-chain wiring from the robot, and miracle of miracles, I2C comms failed – YAY!!. Now hopefully I can figure out (and fix) the problem.

First, I un-replaced the daisy-chain wiring to confirm that I2C comms were still working, and they were.
Unplugged the daisy-chain from the FRAM, 6050IMU, and RTC modules – now working OK
Plugged back in to FRAM unit (now have FRAM and Teensy 3.2 in chain)- – still OK
Plugged back in to 6050 IMU (now have IMU, FRAM, and Teensy 3.2 in chain)- failed
Plugged back in to RTC (now have RTC, FRAM, and Teensy 3.2 in chain)- failed

3 April 2020 Update:

The next step in the saga was to load the ‘Tut5’ code onto the robot’s Mega 2560 controller, with the slave code still running on the original (off-robot) Teensy 3.2. Setting things up in this fashion allowed the sensors to receive power from the robot’s Mega controller as in normal operation.

In the photo above, the Teensy 3.2 slave is shown to the left of the robot. The I2C ‘daisy-chain’ cable starts at the Mega controller (just to the right of the front left wheel), and goes through three ‘hops’ to the Teensy. With this setup, the I2C comms code still ran fine, with direct I2C jumper wires or with the daisy-chain wiring setup (with no connections to the other I2C sensors) as shown above.

The next step was to connect the robot’s Mega controller to the robot’s Teensy 3.2 running the unmodified IR Demodulation code, with the I2C daisy-chain cable, but without anything else connected. This actually worked! So now I have a working robot system again, so something about the connections with the other sensors must be killing the I2C link to the Teensy. Here’s a scope photo of the SDA line showing the data activity. The vertical scale is 1V/cm, showing the HIGH value is about 3.8V, so the Mega must be comfortable with that value as a HIGH logic level

In the above photo, notice the business card for Probe Master, Inc (www.probemaster.com). These folks were kind enough to replace my ten year old scope probe with a new upgraded version at no cost – thank you Probe Master!

At this point I have the ‘Tut5’ program running on the Mega, and the unmodified IR Demod code running on the robot’s Teensy 3.2, and the Mega appears to be acquiring valid demod data from the Teensy. To further validate the data, I fired up my charging station with it’s square-wave modulated IR beam, and was pleased to see that the acquired data from the Teensy varied appropriately as I manually rotated the robot, as shown in the following Excel chart.

So, after all this work, the whole thing came down to a bad I2C ‘daisy-chain’ cable. This particular cable has been on the robot for a while, and was the soldering graduation exercise of my grandson Danny when he was here a couple of summers ago. It wasn’t the best job I’ve ever seen, but it was pretty good for a 15 year old ;-). In any case, I took the opportunity to build a new cable with smaller diameter wire so things would fit a little bit better into the Pololu pins, sockets, and 2-pin header sleeves as shown in the following photo.

New I2C ‘daisy-chain’ cable. Run starts from the Mega connector at bottom left, then to the RTC, IMU and FRAM modules in that order, then last to the Teensy 3.2 IR Demod module.

05 April 2020 Epilogue:

Well, there was one last ‘gotcha’ in all this. When I loaded the original ‘FourWD-WallE2_V2.ino’ program back onto the Mega, it still refused to acquire valid data from the Teensy IR Demod module. So, I compared the ‘Tut5’ code to the ‘_V2’ code, and noticed three significant differences:

In the ‘_V2’ code, the ‘Fin1/2’ variables had at some time been changed from ‘long’ to ‘int’. While this sounds reasonable, it isn’t – because a Teensy ‘int’ is 4 bytes – the same as a Mega ‘long’.
In the ‘_V2’ code, the Wire.requestFrom() call asks for 32 bytes, but the Teensy only sends 12.
In the ‘_V2’ code there is a loop that waits for either a timeout or receiving an entire 32-byte buffer from the Teensy. Apparently the Teensy (and/or the Mega) is slow enough so that Wire.Available() never reports a non-zero buffer size, so the loop times out.

Replacing the line

	uint8_t numbytes = Wire.requestFrom(slaveAddr, (size_t)32); //this works, with Wire.Available() reporting 32

1	uint8_t numbytes = Wire.requestFrom(slaveAddr, (size_t)32); //this works, with Wire.Available() reporting 32

with the line

	Wire.requestFrom(slaveAddr, sizeof(Fin1) + sizeof(Fin2) + sizeof(SteeringValue));

1	Wire.requestFrom(slaveAddr, sizeof(Fin1) + sizeof(Fin2) + sizeof(SteeringValue));

did the trick, but I have no idea why.

Replacing the debug printout lines

Serial.print("in IsIRBeamAvail(): got ");
Serial.print(Fin1); Serial.print(", ");
Serial.print(Fin2); Serial.print(", total =  ");
//Serial.print(SteeringValue); Serial.println(" from slave");
Serial.println(total);

Serial.print("in IsIRBeamAvail(): got ");

Serial.print(Fin1); Serial.print(", ");

Serial.print(Fin2); Serial.print(", total = ");

//Serial.print(SteeringValue); Serial.println(" from slave");

Serial.println(total);

with the line

mySerial.printf("Fin1 = %ld, Fin2 = %ld, SteeringValue = %3.2f\n", Fin1, Fin2, SteeringValue);

1	mySerial.printf("Fin1 = %ld, Fin2 = %ld, SteeringValue = %3.2f\n", Fin1, Fin2, SteeringValue);

Produced lines like this one from the ‘_V2’ program

Fin1 = 390556, Fin2 = 153386, SteeringValue = 0.44
IR Beam Detected with Battery Voltage = 7.32DateTime	Batt	FinVal1

1 2	Fin1 = 390556, Fin2 = 153386, SteeringValue = 0.44 IR Beam Detected with Battery Voltage = 7.32DateTime Batt FinVal1

Which appear to be the correct values for the given robot orientation with respect to the charging station.

With no other changed except removing power from the charging station, the output became

Fin1 = 14, Fin2 = 28, SteeringValue = -0.33
Fin1 = 66, Fin2 = 42, SteeringValue = 0.22
Fin1 = 26, Fin2 = 48, SteeringValue = -0.30
Fin1 = 54, Fin2 = 30, SteeringValue = 0.29

Fin1 = 14, Fin2 = 28, SteeringValue = -0.33

Fin1 = 66, Fin2 = 42, SteeringValue = 0.22

Fin1 = 26, Fin2 = 48, SteeringValue = -0.30

Fin1 = 54, Fin2 = 30, SteeringValue = 0.29

showing definitively that the ‘_V2’ program correctly identified and decoded the square-wave modulated IR beam.

So, after a two-week off-road trip to I2C comms hell and back, I think I finally have that particular issue put to bed. It wasn’t exactly what I wanted to do, but it was at least interesting, and more important – consumed a lot of coronavirus quarantine time ;-).

Stay tuned!

Frank

Arduino SPI Data Exchange Between Two Arduinos in a Master/Slave Configuration

2 Replies

posted 13 March 2020,

While updating my four wheel autonomous wall-following robot (aka Wall-E2), I ran into a roadblock when I couldn’t get my Teensy 3.2 IR demodulator/tracker module to communicate with the Mega 2560 main microcontroller over I2C. This worked fine when I last tested it, but now it seems to have taken a vacation. It’s been a while, and I have added some functionality since I originally installed and tested IR homing to the charging station, but it still should all work, right?

In any case, after trying (and failing) to get the I2C bus connection working, I thought I might try an alternate solution and just use SPI between the main controller (Mega 2560) and the IR homing controller (Teensy 3.2). This would have the advantage of making the Teensy independent of the I2C bus, and also give me the chance to play with a part of the Arduino ecosystem that I haven’t used before.

As usual, I started this process with a lot of Googling, and quickly ran across Australian Nick Gammon’s “SPI – Serial Peripheral Interface – for Arduino“ . This post was way more than I ever wanted to know about SPI, but it sure is complete!

Then I moved on to trying to get SPI working for myself. As noted above, my intended application is to transfer steering values from my IR detector/demodulator/homing module to the main Mega 2560 microcontroller. The Mega uses the steering data to adjust wheel speeds to home in on a charging station, so Wall-E2 can continue to roam our house autonomously.

It turns out that SPI between two Arduinos isn’t entirely straightforward, at least not at first. I went through a bunch of iterations, and even more passes through the available documentation. In the end though, I think I wrassled it into a reasonable facsimile of a working solution, as shown below. The program repeatedly transfers a fixed string (“Hello World!”) from the UNO (master) to the Mega 2560 (slave), and then transfers the string version of a float value (3.159) from the slave to the master.

The Circuit:

The circuit and layout is just about as basic as it gets. The UNO (master) connections are the default pinouts:

UNO (master) connected to Mega 2560 (slave) using default SPI pins on both ends

The Master:

/*
    Name:       SPI_EX3_Master.ino
    Created:	3/13/2020 4:19:35 PM
    Author:     FRANKNEWXPS15\Frank
*/


#include <SPI.h>
#include "pins_arduino.h"
#include <PrintEx.h> //allows printf-style printout syntax
StreamEx mySerial = Serial; //added 03/18/18 for printf-style printing

volatile byte rcvbyte = 0;
char rcvbuf[100];

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

    // Put SCK, MOSI, SS pins into output mode
    // also put SCK, MOSI into LOW state, and SS into HIGH state.
    // Then put SPI hardware into Master mode and turn SPI on
    SPI.begin();

    Serial.println("SPI Example Master");

    memset(rcvbuf, 0, sizeof(rcvbuf));

}  // end of setup

void loop(void)
{

    char c;

    // send test string
    Serial.println("Sending Test String");

    //tell slave to get ready
    digitalWrite(SS, LOW);    // SS is pin 10
    delayMicroseconds(200); //give slave some time 

    // send test string
    for (const char* p = "Hello, world!\n"; c = *p; p++)
    {
        mySerial.printf("Sending %x to Slave\n", c);
        SPI.transfer(c);
        delayMicroseconds(20); //required for arduino-arduino xfrs
    }

    //receive data from slave
    delay(500);

    //get float value from slave
    Serial.println("Receiving Data String\n");
    int pos = 0;
    memset(rcvbuf, sizeof(rcvbuf), 0);

    c = 1;
    while (c != 0x0D)
    {
        c = SPI.transfer(0);
        mySerial.printf("got %x from Slave\n", c);
        rcvbuf[pos++] = c;
        delayMicroseconds(20);
    }

    //remove any non-numeric characters
    char buf2[20];
    int buf2pos = 0;
    for (size_t i = 0; i < sizeof(rcvbuf); i++)
    {
        char p = rcvbuf[i];  // search for space
        if (p > 0x20 )
        {
            buf2[buf2pos++] = p;
        }
        buf2[buf2pos] = 0;
    }

    rcvbuf[pos] = 0; //add NULL to terminate string

    if (pos > 0)
    {
        mySerial.printf("received %s from slave\n", buf2);
    }

    // tell slave to get ready for next data transfer
    digitalWrite(SS, HIGH);

    delay(1000);  // 1 seconds delay
}  // end of loop

Name: SPI_EX3_Master.ino

Created: 3/13/2020 4:19:35 PM

Author: FRANKNEWXPS15\Frank

#include <SPI.h>

#include "pins_arduino.h"

#include <PrintEx.h> //allows printf-style printout syntax

StreamEx mySerial = Serial; //added 03/18/18 for printf-style printing

volatile byte rcvbyte = 0;

char rcvbuf[100];

void setup(void)

{

Serial.begin(115200);

// Put SCK, MOSI, SS pins into output mode

// also put SCK, MOSI into LOW state, and SS into HIGH state.

// Then put SPI hardware into Master mode and turn SPI on

SPI.begin();

Serial.println("SPI Example Master");

memset(rcvbuf, 0, sizeof(rcvbuf));

} // end of setup

void loop(void)

{

char c;

// send test string

Serial.println("Sending Test String");

//tell slave to get ready

digitalWrite(SS, LOW); // SS is pin 10

delayMicroseconds(200); //give slave some time

// send test string

for (const char* p = "Hello, world!\n"; c = *p; p++)

{

mySerial.printf("Sending %x to Slave\n", c);

SPI.transfer(c);

delayMicroseconds(20); //required for arduino-arduino xfrs

}

//receive data from slave

delay(500);

//get float value from slave

Serial.println("Receiving Data String\n");

int pos = 0;

memset(rcvbuf, sizeof(rcvbuf), 0);

c = 1;

while (c != 0x0D)

{

c = SPI.transfer(0);

mySerial.printf("got %x from Slave\n", c);

rcvbuf[pos++] = c;

delayMicroseconds(20);

}

//remove any non-numeric characters

char buf2[20];

int buf2pos = 0;

for (size_t i = 0; i < sizeof(rcvbuf); i++)

{

char p = rcvbuf[i]; // search for space

if (p > 0x20 )

{

buf2[buf2pos++] = p;

}

buf2[buf2pos] = 0;

}

rcvbuf[pos] = 0; //add NULL to terminate string

if (pos > 0)

{

mySerial.printf("received %s from slave\n", buf2);

}

// tell slave to get ready for next data transfer

digitalWrite(SS, HIGH);

delay(1000); // 1 seconds delay

} // end of loop

The Slave:

/*
 Name:		SPI_EX3_Slave.ino
 Created:	3/13/2020 4:21:43 PM
 Author:	Frank
*/


#include "pins_arduino.h"
#include <SPI.h>
#include <PrintEx.h> //allows printf-style printout syntax
StreamEx mySerial = Serial; //added 03/18/18 for printf-style printing

char buf[100];
char val[20];
volatile byte rcv_pos;
volatile byte xmt_pos;
volatile boolean process_it;
volatile boolean bReceivingString;

void setup(void)
{
    Serial.begin(115200);   // debugging
    mySerial.printf("SPI Example Slave\n");

    // have to send on master in, *slave out*
    pinMode(MISO, OUTPUT);
    pinMode(PIN_SPI_SS, INPUT_PULLUP); //SS is INPUT for slave device

    // turn on SPI in slave mode
    SPCR |= _BV(SPE);

    // turn on interrupts
    SPCR |= _BV(SPIE);

    rcv_pos = 0;
    process_it = false;

    //use dstrtof to produce string version of float value
    float x = 3.14159;
    memset(val, 0x0D, sizeof(val));
    dtostrf(x, 7, 5, val);
    mySerial.printf("string representation of %2.5f is %s\n", x, val);

    for (size_t i = 0; i < sizeof(val) - 1; i++)
    {
        mySerial.printf("%x", val[i]);
    }
    mySerial.printf("%x\n", val[sizeof(val) - 1]);

    xmt_pos = 0;

}  // end of setup


// SPI interrupt routine
ISR(SPI_STC_vect)
{
    if (bReceivingString)
    {
        byte c = SPDR;

        // add to buffer if room
        if (rcv_pos < sizeof buf)
        {
            buf[rcv_pos++] = c;

            //newline means time to process buffer
            if (c == '\n')
                process_it = true;

        }  // end of room available
    }
    else
    {
        SPDR = val[xmt_pos];
        xmt_pos++;
    }
}

// main loop - wait for flag set in interrupt routine
void loop(void)
{
    if (process_it)
    {
        mySerial.printf("In process_it with rcv_pos = %d\n",
            rcv_pos);
        buf[rcv_pos] = 0;
        mySerial.printf("Received %s from Master\n", buf);
        rcv_pos = 0;
        process_it = false;
        bReceivingString = false;
    }  // end of flag set

    if (digitalRead(PIN_SPI_SS) == HIGH)
    {
        xmt_pos = 0; //get ready for next iteration
        SPDR = 0;
        bReceivingString = true;
        process_it = false;

    }

}  // end of loop

100

101

102

103

Name: SPI_EX3_Slave.ino

Created: 3/13/2020 4:21:43 PM

Author: Frank

#include "pins_arduino.h"

#include <SPI.h>

#include <PrintEx.h> //allows printf-style printout syntax

StreamEx mySerial = Serial; //added 03/18/18 for printf-style printing

char buf[100];

char val[20];

volatile byte rcv_pos;

volatile byte xmt_pos;

volatile boolean process_it;

volatile boolean bReceivingString;

void setup(void)

{

Serial.begin(115200); // debugging

mySerial.printf("SPI Example Slave\n");

// have to send on master in, *slave out*

pinMode(MISO, OUTPUT);

pinMode(PIN_SPI_SS, INPUT_PULLUP); //SS is INPUT for slave device

// turn on SPI in slave mode

SPCR |= _BV(SPE);

// turn on interrupts

SPCR |= _BV(SPIE);

rcv_pos = 0;

process_it = false;

//use dstrtof to produce string version of float value

float x = 3.14159;

memset(val, 0x0D, sizeof(val));

dtostrf(x, 7, 5, val);

mySerial.printf("string representation of %2.5f is %s\n", x, val);

for (size_t i = 0; i < sizeof(val) - 1; i++)

{

mySerial.printf("%x", val[i]);

}

mySerial.printf("%x\n", val[sizeof(val) - 1]);

xmt_pos = 0;

} // end of setup

// SPI interrupt routine

ISR(SPI_STC_vect)

{

if (bReceivingString)

{

byte c = SPDR;

// add to buffer if room

if (rcv_pos < sizeof buf)

{

buf[rcv_pos++] = c;

//newline means time to process buffer

if (c == '\n')

process_it = true;

} // end of room available

}

else

{

SPDR = val[xmt_pos];

xmt_pos++;

}

// main loop - wait for flag set in interrupt routine

void loop(void)

{

if (process_it)

{

mySerial.printf("In process_it with rcv_pos = %d\n",

rcv_pos);

buf[rcv_pos] = 0;

mySerial.printf("Received %s from Master\n", buf);

rcv_pos = 0;

process_it = false;

bReceivingString = false;

} // end of flag set

if (digitalRead(PIN_SPI_SS) == HIGH)

{

xmt_pos = 0; //get ready for next iteration

SPDR = 0;

bReceivingString = true;

process_it = false;

}

} // end of loop

The above configuration produced the following output:

Master:

Opening port
Port open
SPI Example Master
Sending Test String
Sending 48 to Slave
Sending 65 to Slave
Sending 6C to Slave
Sending 6C to Slave
Sending 6F to Slave
Sending 2C to Slave
Sending 20 to Slave
Sending 77 to Slave
Sending 6F to Slave
Sending 72 to Slave
Sending 6C to Slave
Sending 64 to Slave
Sending 21 to Slave
Sending A to Slave
Receiving Data String

got A from Slave
got 33 from Slave
got 2E from Slave
got 31 from Slave
got 34 from Slave
got 31 from Slave
got 35 from Slave
got 39 from Slave
got 0 from Slave
got D from Slave
received 3.14159 from slave

Opening port

Port open

SPI Example Master

Sending Test String

Sending 48 to Slave

Sending 65 to Slave

Sending 6C to Slave

Sending 6F to Slave

Sending 2C to Slave

Sending 20 to Slave

Sending 77 to Slave

Sending 6F to Slave

Sending 72 to Slave

Sending 6C to Slave

Sending 64 to Slave

Sending 21 to Slave

Sending A to Slave

Receiving Data String

got A from Slave

got 33 from Slave

got 2E from Slave

got 31 from Slave

got 34 from Slave

got 31 from Slave

got 35 from Slave

got 39 from Slave

got 0 from Slave

got D from Slave

received 3.14159 from slave

Slave:

Opening port
Port open
SPI Example Slave
string representation of 3.14159 is 3.14159
332E31343135390DDDDDDDDDDDD
In process_it with rcv_pos = 14
Received Hello, world!
 from Master
In process_it with rcv_pos = 14
Received Hello, world!
 from Master
In process_it with rcv_pos = 14
Received Hello, world!
 from Master
In process_it with rcv_pos = 14
Received Hello, world!
 from Master
In process_it with rcv_pos = 14
Received Hello, world!
 from Master
In process_it with rcv_pos = 14
Received Hello, world!
 from Master

Port closed

Opening port

Port open

SPI Example Slave

string representation of 3.14159 is 3.14159

332E31343135390DDDDDDDDDDDD

In process_it with rcv_pos = 14

Received Hello, world!

from Master

In process_it with rcv_pos = 14

Received Hello, world!

from Master

In process_it with rcv_pos = 14

Received Hello, world!

from Master

In process_it with rcv_pos = 14

Received Hello, world!

from Master

In process_it with rcv_pos = 14

Received Hello, world!

from Master

In process_it with rcv_pos = 14

Received Hello, world!

from Master

Port closed

Now that I’ve had my fun and games with SPI, I’m still not at all sure I want to use it to connect the Mega to the Teensy IR Demodulator/Homing module. While it is almost certain to work (eventually), it has some drawbacks

It requires 4 additional wires
It requires that I add an ISR and other code to the Teensy module, and companion code to the Mega
More things to go wrong.

So, I think I’ll try again to get the original I2C based code working, as it worked before, so it should work again. If I can’t get it working after another good try, I’ll go with door #2 (SPI)

Stay tuned!

Frank

Updating the Four Wheel Robot

1 Reply

Posted 29 February 2020,

Happy Leap Day!

For the last several months I have been using my older 2 wheel robot to investigate improved wall following techniques using relative heading from the onboard MPU6050 IMU module. As the reader may recall (and if you can’t, look at this summarizing post) I had a heck of a time achieving reliable operation with the MPU6050 module mounted on the two wheel robot. In the process of figuring all that out, and in collaboration with Homer Creutz, we also developed a nifty polling algorithm for obtaining heading information from the MPU6050, a method that has now been incorporated into Jeff Rowberg’s fantastic I2CDev ecosystem.

After getting the MPU6050 (and the metal-geared motors on the 2 wheel robot) to behave, I was also able to significantly enhance wall-following performance (at least for the 2 wheel robot). Now it can start from any orientation relative to a nearby wall, figure out an approximate parallel heading, and then acquire and then track a specified offset distance from the wall – pretty cool, huh?

So, now it is time to integrate all this new stuff back into the 4-wheel robot, and see if it will translate to better autonomous wall-tracking, charging station acquisition, obstacle avoidance, and doing the laundry (well, maybe not the last one). The major changes are:

Update the project with the newest MPU6050 libraries:
Revise the original 4 wheel code to use polling vs interrupt for heading values
Installation of the ‘FindParallelHeading()’ function and all its support routines
Integration of the parallel heading determination step into current wall tracking routines
Verification of improved functionality
Verification that the new work hasn’t degraded any existing functionality
Incorporating heading and heading-based turn capabilities into obstacle avoidance

To implement all the above, while attempting to insulate myself from the possibility of a major screwup, I created a brand-new Arduino project called ‘FourWD_WallE2_V2’ and started integrating the original code from ‘FourWD_WallE2_V1’ and ‘TwoWheelRobot_V2’

Update the project with the newest MPU6050 libraries:

The original FourWD_WallE2_V1 project used the older MPU6050_6Axis_MotionApps20.h library, but the two wheel robot uses the newer MPU6050_6Axis_MotionApps_V6_12.h one. In addition, Homer Creutz had updated the new library even further since its incorporation into the two wheel robot. The first step in updating the 4 wheel robot was to re-synchronize the library on my PC with the newer version on GitHub. This was accomplished very easily – yay! The next step was to copy most of the #includes and program constants from the original 4 wheel project into the new one, and then get the resulting skeleton program to compile. This took a few tries and the addition of several files into the project folder as ‘local’ resource and header files, but it got done. At the conclusion of this step, the project had empty setup() and loop() functions and no auxiliary/support functions, but it did compile – yay!

Revise the original 4 wheel code to use polling vs interrupt for heading values

The original project uses a flag modified by an ISR (Interrupt Service Routine) to mediate heading value acquisition. The two wheel robot uses a polling based routine to do the same thing. However, the algorithm used by the two wheel robot isn’t exactly the same as the one provided by Homer Creutz as part of the new MPU6050_6Axis_MotionApps_V6_12.h library. In addition, the two wheel robot uses a different naming convention for the current heading value retrieved from the IMU. The 4-wheel robot uses ‘global_yawval’, and the 2-wheel one uses ‘IMUHdgValDeg’. The 4-wheel robot uses ‘bool GetIMUHeadingDeg()’ to retrieve heading values, but the 2-wheel robot uses ‘bool UpdateIMUHdgValDeg()’ to better indicate it’s function. So, all instances of ‘global_yawval’ will need to be changed to ‘IMUHdgValDeg’, and references to ‘GetIMUHeadingDeg()’ will have to instead reference ‘UpdateIMUHdgValDeg()’.

I started this step by copying the entire ‘setup()’ and ‘loop()’ function contents from the old 4-wheel robot project to the new one, and then working through the laborious process of getting everything to compile with the new variable and function names. First I just started with ‘setup()’, and kept copying over the required support functions until I’d gotten everything. For each support function I checked the corresponding function in the 2 wheel project to make sure I wasn’t missing an update or enhancement. BTW, the combination of Microsoft’s Visual Studio and Visual Micro’s wonderful Arduino extension made this much easier, as the non-compiling code is highlighted in red in the margins of the VS edit window, reducing the need for multiple compiles The affected functions were:

GetDayDateTimeStringFromDateTime(now, buffer): not in 2 wheel project
GetLeft/RightMedianDistCm(): Eliminated – these were never really used. Replaced where necessary with GetAvgLeft/RightDistCm() from the two wheel project.
GetFrontDistCm(): Not used in 2 wheel project
dmpDataReady(): ISR for MPU6050 interrupts. Replaced with polling strategy
StopLeft/RightMotors(): Not used in 2 wheel robot – copied unchanged
SetLeft/RightMotorDir(): Not used in 2 wheel robot – copied unchanged
RunBothMotors(), RunBothMotorsMsec(): Not used in 2 wheel robot – copied unchanged
IsCharging(): Not used in 2 wheel robot – copied unchanged.

At this point, the entire setup() function compiles without error, and the setup() code runs properly. The next step is to add in the loop() functionality and then modify as necessary to replace interrupt-based heading acquisition with polling-based, replace ‘global_yawval’ with ‘IMUHdgValDeg’, and to replace ‘GetIMUHeadingDeg()’ with ‘UpdateIMUHdgValDeg()’

notes:

Revise UpdateWallFollowMotorspeeds as necessary to incorporate heading-based offset tracking
Revise/Replace RollingTurn() & GetIMUHeadingDeg() as necessary – done
Global replace of global_yawval with IMUHdgValDeg showed 25 replacements
Replaced ‘GetIMUHeadingDeg()’ with ‘UpdateIMUHdgValDeg()’ from 2 wheel robot project
Added GetCurrentFIFOPacket() from 2 wheel robot project
Replaced ‘if(devStatus == 0)’ block with the one from 2 wheel project
Had to comment out PrintWallFollowTelemetry(frontvar), FillPacketFromCurrentState(CFRAMStatePacket* pkt), and DisplayHumanReadablePacket(CFRAMStatePacket* pkt) to get everything to compile.

At the conclusion of all the above, the _V2 project now compiles completely.

1 March 2020 Update:

After getting the entire program to compile, I decided to try some simple tests of heading-based turn capability, so I modified setup() to have the robot do some simple S-turns, and then a backup-and-turn procedure. As the accompanying video shows, this seemed to work quite well. This is very encouraging, as it demonstrates polling-based rather than interrupt-based MPU6050 heading value acquisition and verifies that the latest MPU6050 libraries work properly.

The next step was to incorporate the ‘command mode’ facility from the two wheel robot. This facility allows a user within range of the Wixel RF link to take over the robot and issue movement commands, like a crude RC controller. After making these changes, I was able to take control of the robot and manually command some simple maneuvers as shown in the following video.

As shown above, the left 180 degree turn as currently implemented for the 4-wheel robot takes forever! I’ll need to work on that.

04 March 2020 Update:

I lowered the value of the OFFSIDE_MOTOR_SPEED constant while leaving the DRIVESIDE_MOTOR_SPEED constant unchanged to make turns more aggressive, as shown in the following set of three video clips. In the first two, the OFFSIDE_MOTOR_SPEED is 0, while in the last one, it is 25. I think I’ll leave it set to 25 for the foreseeable future.

Stay tuned,

Frank

06 April 2020 Update:

After a two-week trip to I2C hell and back, I’m ready to continue the project to update my autonomous wall-following robot with new heading-based turn and tracking capability. The off-road trip was caused by (I now believe) the combination of a couple of software bugs and an intermittent I2C ‘daisy-chain’ cable connecting the Arduino Mega controller to four I2C peripherals. See this post for the gory details.

Installation of the ‘FindParallelHeading()’ function and all its support routines:

In the TwoWheelRobot project, the ‘FindParallelHdg()’ function is used to orient the robot parallel to the nearest wall in preparation to approaching and then tracking a specified offset distance. The algorithm first determines the parallel heading by turning the robot and monitoring the distance to the near wall. Once the parallel heading is determined, the robot turns toward or away from the wall as necessary to capture and then track the desired offset distance.

Here’s a short video and telemetry from a representative run in my ‘indoor range’.

Opening port
Port open
Two Wheel Robot
Initializing MPU6050 ...
Testing device connections...
MPU6050 connection successful
Initializing DMP...
Enabling DMP...
DMP ready! Waiting for MPU6050 drift rate to settle...

MPU6050 Ready at 1.21 Sec
mSec	Yaw	TurnDeg	PrevDeg	LeftD	RightD	Error
1347	0.04	0	0	200	200	0
turndeg = 0; Removing Entire Cut
In FindParallelHdg()
mSec	meas#	Hdg	PrevD	CurD
setting prevmindist to 49
bTrackingRight = TRUE
starting CCW turn (away from right wall)
1487	1	-0.86	49	49	1
1517	2	-1.28	49	49	2
1537	3	-1.54	49	49	3
1556	4	-1.70	49	49	4
1577	5	-1.75	49	48	2
1596	6	-1.56	48	49	3
1615	7	-1.25	48	49	4
1639	8	-0.92	48	48	5
1669	9	-0.46	48	49	6
1698	10	0.11	48	47	4
1728	11	0.77	47	48	5
1757	12	1.34	47	47	6
1789	13	1.92	47	48	7
1818	14	2.60	47	47	8
1848	15	3.38	47	47	9
1876	16	4.36	47	47	10
1909	17	5.38	47	47	11
1938	18	6.47	47	47	12
1968	19	7.50	47	47	13
1997	20	8.43	47	47	14
2026	21	9.46	47	47	15
2045	22	10.14	47	48	16
2065	23	10.82	47	48	17
2088	24	11.50	47	46	15
2118	25	12.52	46	47	16
2147	26	13.58	46	47	17
2177	27	14.64	46	48	18
2208	28	15.70	46	46	19
2238	29	16.77	46	45	17
2267	30	17.89	45	47	18
2296	31	18.96	45	48	19
2328	32	20.01	45	48	20
Tracking Case 2, Parallel Heading = 20.01
3345	26.54	20	0	200	49	19
turndeg > m_PrevHdgCutDeg; Increasing Cut
3555	15.09	20	10	200	45	15
turndeg > m_PrevHdgCutDeg; Increasing Cut
3785	3.29	20	20	200	43	13
3813	1.93	20	20	200	44	14
3843	1.16	20	20	200	44	14
not converging - increasing cut
4114	-9.10	20	30	200	43	13
Converging with turndeg 20 & PrevCut 30. Reducing Cut
4463	-0.36	10	20	200	39	9
Converging with turndeg 10 & PrevCut 20. Reducing Cut
4731	11.06	10	10	200	36	6
4761	12.67	10	10	200	36	6
4792	13.18	10	10	200	36	6
not converging - increasing cut
5123	2.97	5	20	200	34	4
Converging with turndeg 5 & PrevCut 20. Reducing Cut
5472	11.71	10	10	200	33	3
5502	13.07	5	10	200	32	2
Converging with turndeg 5 & PrevCut 10. Reducing Cut
5810	24.21	5	0	200	32	2
turndeg > m_PrevHdgCutDeg; Increasing Cut
6181	14.03	0	10	200	31	1
turndeg = 0; Removing Entire Cut
6531	23.51	0	0	200	30	0
turndeg = 0; Removing Entire Cut
6560	24.95	0	0	200	30	0
turndeg = 0; Removing Entire Cut
6590	25.04	0	0	200	30	0
turndeg = 0; Removing Entire Cut
6620	25.09	0	0	200	30	0
turndeg = 0; Removing Entire Cut
6649	25.17	0	0	200	30	0
turndeg = 0; Removing Entire Cut
6678	25.14	0	0	200	30	0
turndeg = 0; Removing Entire Cut
6711	25.05	0	0	200	30	0
turndeg = 0; Removing Entire Cut
6739	24.84	0	0	200	29	-1
turndeg = 0; Removing Entire Cut
6769	24.74	0	0	200	29	-1
turndeg = 0; Removing Entire Cut
6800	24.60	0	0	200	30	0
turndeg = 0; Removing Entire Cut
6830	24.35	0	0	200	30	0
turndeg = 0; Removing Entire Cut
6859	24.12	0	0	200	31	1
turndeg = 0; Removing Entire Cut
6888	23.96	0	0	200	31	1
turndeg = 0; Removing Entire Cut
6920	23.68	5	0	200	27	-3
turndeg > m_PrevHdgCutDeg; Increasing Cut
7249	34.05	0	10	200	31	1
turndeg = 0; Removing Entire Cut
7519	45.60	5	0	200	34	4
turndeg > m_PrevHdgCutDeg; Increasing Cut
7888	35.61	10	10	200	34	4
not converging - increasing cut
I received: 35
8138	23.63	5	20	200	33	3
Converging with turndeg 5 & PrevCut 20. Reducing Cut
I received: D
8485	33.30	10	10	200	34	4
not converging - increasing cut
I received: A
8857	24.37	5	20	200	34	4
8887	22.76	10	20	200	34	4
8916	21.88	10	20	200	34	4
8946	21.46	10	20	200	34	4
8976	21.09	10	20	200	33	3
Converging with turndeg 10 & PrevCut 20. Reducing Cut
9307	30.78	10	10	200	34	4
not converging - increasing cut
9675	21.56	5	20	200	34	4
9705	19.96	10	20	200	33	3
Converging with turndeg 10 & PrevCut 20. Reducing Cut
10055	30.10	20	10	200	36	6
turndeg > m_PrevHdgCutDeg; Increasing Cut
10343	21.16	10	20	200	26	-4
10385	18.89	20	20	200	100	70
not converging - increasing cut
I received: 63
ENTERING COMMAND MODE:
0 = 180 deg CCW Turn
1 = 180 deg CW Turn
A = Back to Auto Mode
S = Stop

       Faster
	8
Left 4	5  6 Right
	2
       Slower

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

Opening port

Port open

Two Wheel Robot

Initializing MPU6050 ...

Testing device connections...

MPU6050 connection successful

Initializing DMP...

Enabling DMP...

DMP ready! Waiting for MPU6050 drift rate to settle...

MPU6050 Ready at 1.21 Sec

mSec Yaw TurnDeg PrevDeg LeftD RightD Error

1347 0.04 0 0 200 200 0

turndeg = 0; Removing Entire Cut

In FindParallelHdg()

mSec meas# Hdg PrevD CurD

setting prevmindist to 49

bTrackingRight = TRUE

starting CCW turn (away from right wall)

1487 1 -0.86 49 49 1

1517 2 -1.28 49 49 2

1537 3 -1.54 49 49 3

1556 4 -1.70 49 49 4

1577 5 -1.75 49 48 2

1596 6 -1.56 48 49 3

1615 7 -1.25 48 49 4

1639 8 -0.92 48 48 5

1669 9 -0.46 48 49 6

1698 10 0.11 48 47 4

1728 11 0.77 47 48 5

1757 12 1.34 47 47 6

1789 13 1.92 47 48 7

1818 14 2.60 47 47 8

1848 15 3.38 47 47 9

1876 16 4.36 47 47 10

1909 17 5.38 47 47 11

1938 18 6.47 47 47 12

1968 19 7.50 47 47 13

1997 20 8.43 47 47 14

2026 21 9.46 47 47 15

2045 22 10.14 47 48 16

2065 23 10.82 47 48 17

2088 24 11.50 47 46 15

2118 25 12.52 46 47 16

2147 26 13.58 46 47 17

2177 27 14.64 46 48 18

2208 28 15.70 46 46 19

2238 29 16.77 46 45 17

2267 30 17.89 45 47 18

2296 31 18.96 45 48 19

2328 32 20.01 45 48 20

Tracking Case 2, Parallel Heading = 20.01

3345 26.54 20 0 200 49 19

turndeg > m_PrevHdgCutDeg; Increasing Cut

3555 15.09 20 10 200 45 15

turndeg > m_PrevHdgCutDeg; Increasing Cut

3785 3.29 20 20 200 43 13

3813 1.93 20 20 200 44 14

3843 1.16 20 20 200 44 14

not converging - increasing cut

4114 -9.10 20 30 200 43 13

Converging with turndeg 20 & PrevCut 30. Reducing Cut

4463 -0.36 10 20 200 39 9

Converging with turndeg 10 & PrevCut 20. Reducing Cut

4731 11.06 10 10 200 36 6

4761 12.67 10 10 200 36 6

4792 13.18 10 10 200 36 6

not converging - increasing cut

5123 2.97 5 20 200 34 4

Converging with turndeg 5 & PrevCut 20. Reducing Cut

5472 11.71 10 10 200 33 3

5502 13.07 5 10 200 32 2

Converging with turndeg 5 & PrevCut 10. Reducing Cut

5810 24.21 5 0 200 32 2

turndeg > m_PrevHdgCutDeg; Increasing Cut

6181 14.03 0 10 200 31 1

turndeg = 0; Removing Entire Cut

6531 23.51 0 0 200 30 0

turndeg = 0; Removing Entire Cut

6560 24.95 0 0 200 30 0

turndeg = 0; Removing Entire Cut

6590 25.04 0 0 200 30 0

turndeg = 0; Removing Entire Cut

6620 25.09 0 0 200 30 0

turndeg = 0; Removing Entire Cut

6649 25.17 0 0 200 30 0

turndeg = 0; Removing Entire Cut

6678 25.14 0 0 200 30 0

turndeg = 0; Removing Entire Cut

6711 25.05 0 0 200 30 0

turndeg = 0; Removing Entire Cut

6739 24.84 0 0 200 29 -1

turndeg = 0; Removing Entire Cut

6769 24.74 0 0 200 29 -1

turndeg = 0; Removing Entire Cut

6800 24.60 0 0 200 30 0

turndeg = 0; Removing Entire Cut

6830 24.35 0 0 200 30 0

turndeg = 0; Removing Entire Cut

6859 24.12 0 0 200 31 1

turndeg = 0; Removing Entire Cut

6888 23.96 0 0 200 31 1

turndeg = 0; Removing Entire Cut

6920 23.68 5 0 200 27 -3

turndeg > m_PrevHdgCutDeg; Increasing Cut

7249 34.05 0 10 200 31 1

turndeg = 0; Removing Entire Cut

7519 45.60 5 0 200 34 4

turndeg > m_PrevHdgCutDeg; Increasing Cut

7888 35.61 10 10 200 34 4

not converging - increasing cut

I received: 35

8138 23.63 5 20 200 33 3

Converging with turndeg 5 & PrevCut 20. Reducing Cut

I received: D

8485 33.30 10 10 200 34 4

not converging - increasing cut

I received: A

8857 24.37 5 20 200 34 4

8887 22.76 10 20 200 34 4

8916 21.88 10 20 200 34 4

8946 21.46 10 20 200 34 4

8976 21.09 10 20 200 33 3

Converging with turndeg 10 & PrevCut 20. Reducing Cut

9307 30.78 10 10 200 34 4

not converging - increasing cut

9675 21.56 5 20 200 34 4

9705 19.96 10 20 200 33 3

Converging with turndeg 10 & PrevCut 20. Reducing Cut

10055 30.10 20 10 200 36 6

turndeg > m_PrevHdgCutDeg; Increasing Cut

10343 21.16 10 20 200 26 -4

10385 18.89 20 20 200 100 70

not converging - increasing cut

I received: 63

ENTERING COMMAND MODE:

0 = 180 deg CCW Turn

1 = 180 deg CW Turn

A = Back to Auto Mode

S = Stop

Faster

Left 4 5 6 Right

Slower

So, now to port this capability to the FourWD_WallE_V2 project:

08 April 2020 Update:

The current operating algorithm for WallE2 is pretty simple. Every 200 mSec or so it assesses the current situation and decides on a new operating mode. This in turn allows the main code in loop() to decide what to do.

Here’s the code for GetOpMode()

int GetOpMode(float batv) //04/28/19 added batv to sig
{
	//Purpose:  Determine operating mode based on sensor inputs
	//Inputs: none
	//Outputs: Integer denoting current op mode (CHARGING = 1, IRHOMING = 2, WALLFOLLOW = 3)
	//Plan:
	//	Step1: If batt voltage too low, return MODE_DEADBATTERY (4)
	//	Step2: If Charger is connected, return MODE_CHARGING (1)
	//	Step3: Else If IR Homing beam detected, return MODE_IRHOMING (2)
	//	Step4: Else return MODE_WALLFOLLOW (3)
	//Notes:
	//	01/16/18 added MODE_DEADBATTERY
	//	03/28/18 now looking for either IsChargerConnected OR low on TP5100 Chg line
	//	09/03/18 reorganized so DEADBATTERY is on top, and added new TURNING_TO_HDG mode
	//	02/24/19 now using 1NA619 charge current sensor
	//	04/28/19 added batV to function sig

//Step1: If batt voltage too low, return MODE_DEADBATTERY (4)
	if (batv <= DEAD_BATT_THRESH_VOLTS) return MODE_DEADBATTERY;

	//Step2: If Charger is connected, return MODE_CHARGING (1)
	else if (IsChargerConnected() && IsStillCharging()) return MODE_CHARGING; //02/24/19 now using 1NA619 charge current sensor

//Step3: Else If IR Homing beam detected, return MODE_IRHOMING (2)
	else if (IsIRBeamAvail()) return MODE_IRHOMING; //this handles 'hungry/not-hungry' cases internally

//03/04/2020 added to facilitate battery discharge
#ifdef BATTERY_DISCHARGE
	while (GetBattVoltage() > DEAD_BATT_THRESH_VOLTS)
	{
		return MODE_DISCHARGE;
	}
	StopBothMotors();
	mySerial.printf("Battery Discharge Complete at %3.2f Minutes and %3.2f Volts", millis() / 60000.f, GetBattVoltage);

#else
//Step4: Else return MODE_WALLFOLLOW (3)
	else return MODE_WALLFOLLOW;
#endif // BATTERY_DISCHARGE
}

int GetOpMode(float batv) //04/28/19 added batv to sig

{

//Purpose: Determine operating mode based on sensor inputs

//Inputs: none

//Outputs: Integer denoting current op mode (CHARGING = 1, IRHOMING = 2, WALLFOLLOW = 3)

//Plan:

// Step1: If batt voltage too low, return MODE_DEADBATTERY (4)

// Step2: If Charger is connected, return MODE_CHARGING (1)

// Step3: Else If IR Homing beam detected, return MODE_IRHOMING (2)

// Step4: Else return MODE_WALLFOLLOW (3)

//Notes:

// 01/16/18 added MODE_DEADBATTERY

// 03/28/18 now looking for either IsChargerConnected OR low on TP5100 Chg line

// 09/03/18 reorganized so DEADBATTERY is on top, and added new TURNING_TO_HDG mode

// 02/24/19 now using 1NA619 charge current sensor

// 04/28/19 added batV to function sig

//Step1: If batt voltage too low, return MODE_DEADBATTERY (4)

if (batv <= DEAD_BATT_THRESH_VOLTS) return MODE_DEADBATTERY;

//Step2: If Charger is connected, return MODE_CHARGING (1)

else if (IsChargerConnected() && IsStillCharging()) return MODE_CHARGING; //02/24/19 now using 1NA619 charge current sensor

//Step3: Else If IR Homing beam detected, return MODE_IRHOMING (2)

else if (IsIRBeamAvail()) return MODE_IRHOMING; //this handles 'hungry/not-hungry' cases internally

//03/04/2020 added to facilitate battery discharge

#ifdef BATTERY_DISCHARGE

while (GetBattVoltage() > DEAD_BATT_THRESH_VOLTS)

{

return MODE_DISCHARGE;

}

StopBothMotors();

mySerial.printf("Battery Discharge Complete at %3.2f Minutes and %3.2f Volts", millis() / 60000.f, GetBattVoltage);

#else

//Step4: Else return MODE_WALLFOLLOW (3)

else return MODE_WALLFOLLOW;

#endif // BATTERY_DISCHARGE

}

In terms of the project to port heading-based specified-offset wall tracking to WallE2, the only pertinent result from GetOpMode() is the default MODE_WALLFOLLOW result.

In the main loop(), a switch(CurrentOpMode) decides what actions, if any need to occur. Here’s the relevant section of the code. In the MODE_WALLFOLLOW case, the first thing that happens is an update of the TRACKING CASE via

‘TrackingCase = (WallTrackingCases)GetTrackingDir()’

which returns one of several tracking cases; TRACKING_RIGHT, TRACKING_LEFT, or TRACKING_NEITHER. A switch(TrackingCase) handles each case separately.

		CurrentOpMode = (OpModes)GetOpMode(batVoltage); //04/28/19 bat volts added to sig

////DEBUG!!
//		//CurrentOpMode = MODE_IRHOMING; //forced to MODE_IRHOMING for testing
//		Serial.print("OpMode = ");
//		Serial.println(CurrentOpMode);
////DEBUG!!

		//Step2: Switch to appropriate operating case block
		String trackstr = "Unknown"; //used for telemetry printouts

		switch (CurrentOpMode)
		{
		case MODE_WALLFOLLOW:
			//Purpose:  Follow nearest wall, responding to obstacles as necessary
			//Provenance: G. Frank Paynter and Danny Frank 12/20/2015
			//Inputs:  Distances from left/right/front sensors
			//Outputs: updated left/right motor speeds in wall-follow case, or appropriate avoidance maneuver
			//Plan:
			//	Step 1: Update motor speeds & NAV mode based on current TRACK/NAV states and front distance
			//	Step 2: Print out telemetry info
			//Notes:
			//	03/30/14 Step1 code moved to top of loop() - compiler directives cause errors here
			//	09/11/18 revised plan to reflect reality

			// Update motor speeds & NAV mode based on current TRACK/NAV states and front distance
			// See https://fpaynter.com/2016/01/making-wall-e2-smarter-using-karnaugh-maps/ for details

////DEBUG!!
//			mySerial.printf("In MODE_WALLFOLLOW before GetTrackingDir() at time %lu\n", millis());
////DEBUG!!

			TrackingCase = (WallTrackingCases)GetTrackingDir();

			////DEBUG!!
			//			mySerial.printf("In MODE_WALLFOLLOW at time %lu with Tracking Case = %d\n", millis(), TrackingCase);
			////DEBUG!!

			if (PrevOpMode != MODE_WALLFOLLOW)
			{
				Serial.println(WallFollowTelemStr); //header for wall-follow telemetry data

				//09/09/19 maybe use a 'InApproachState' state variable here, changing to 'InTrackingState'
				//			once the proper standoff distance has been achieved?
			}

			PrevOpMode = MODE_WALLFOLLOW;

			switch (TrackingCase)
			{
			case TRACKING_LEFT:
				trackstr = "Left"; //used for telemetry printouts

				//Bkp & Rot Right = Tracking Left && (Near || Stuck)
				if (frontdistval <= MIN_OBS_DIST_CM || IsStuck(frontvar))
				{
					Serial.println("---- Backup & Turn to the Right");

					//09/19/18 bugfix - 1st param is 'nearest wall', not 'turn direction'
					BackupAndTurn(true, MOTOR_SPEED_HALF); //backup and turn 90 deg right //c/o 02/23/17 for IR Track debug

					//go back to normal tracking mode after B&T completes
					NavCase = NAV_WALLTRK;
				}

				//Step-turn Right = Tracking Left && Step && !Stuck
				//this section *starts* the step-turn.  It is terminated as soon as frontdistval exits step-turn window
				else if (frontdistval > MIN_OBS_DIST_CM && frontdistval <= STEPTURN_DIST_CM)
				{
					//if we aren't already in Step-turn mode, start it.  Otherwise, skip
					if (NavCase != NAV_STEPTURN)
					{
						Serial.println("---- Starting Stepturn to the Right");
						NavCase = NAV_STEPTURN;
						leftspeednum = MOTOR_SPEED_MAX;
						rightspeednum = MOTOR_SPEED_LOW;
						MoveAhead(leftspeednum, rightspeednum);
					}
				}

				//Wall-tracking Left = Tracking Left && Far away from obstacles
				else if (frontdistval > STEPTURN_DIST_CM)
				{
					if (NavCase == NAV_STEPTURN)
					{
						mySerial.printf("Exiting Step-turn to the right\n");
					}

					NavCase = NAV_WALLTRK;
					UpdateWallFollowMotorspeeds(leftdistval, rightdistval, leftspeednum, rightspeednum);
					MoveAhead(leftspeednum, rightspeednum);
				}

				/*				PrintWallFollowTelemetry(frontvar); *///added 04/15/19
				break;
			case TRACKING_RIGHT:
				trackstr = "Right"; //used for telemetry printouts

////DEBUG!!
//				mySerial.printf("In WALL_TRACKING_RIGHT top at %lu\n", millis());
////DEBUG!!

				if (frontdistval <= MIN_OBS_DIST_CM || IsStuck(frontvar))
				{
					Serial.println("---- Backup & Turn to the Left");
					//09/19/18 bugfix - 1st param is 'nearest wall', not 'turn direction'
					BackupAndTurn(false, MOTOR_SPEED_HALF); //backup and turn 90 deg left //c/o 02/23/17 for IR Track debug

					//go back to normal tracking mode after B&T completes
					NavCase = NAV_WALLTRK;
				}

				////02/23/19 temporarily implemented to stop robot at end of TrkPID tuning run
				//if (frontdistval <= MIN_OBS_DIST_CM)
				//{
				//	Serial.println("---- End of run - stopping motors");
				//	MoveAhead(0, 0);
				//	delay(500);
				//	cli();
				//	sleep_enable();
				//	sleep_cpu();
				//}


				//Step-turn Left = Tracking Right && Step && !Stuck
				//this section *starts* the step-turn.  It is terminated as soon as frontdistval exits step-turn window
				//02/23/19 temporarily commented out for TrkPID tuning 
				else if (frontdistval > MIN_OBS_DIST_CM && frontdistval <= STEPTURN_DIST_CM)
				{
					//if we aren't already in Step-turn mode, start it.  Otherwise, skip
					if (NavCase != NAV_STEPTURN)
					{
						Serial.println("---- Starting Stepturn to the Left");
						NavCase = NAV_STEPTURN;
						rightspeednum = MOTOR_SPEED_MAX;
						leftspeednum = MOTOR_SPEED_LOW;
						MoveAhead(leftspeednum, rightspeednum);
					}
				}

				//Wall-tracking Right = Tracking Right && Far
				else if (frontdistval > STEPTURN_DIST_CM)
				{
					if (NavCase == NAV_STEPTURN)
					{
						mySerial.printf("Exiting Step-turn to the left\n");
					}

					NavCase = NAV_WALLTRK;
					UpdateWallFollowMotorspeeds(leftdistval, rightdistval, leftspeednum, rightspeednum);
					MoveAhead(leftspeednum, rightspeednum);
				}


				////DEBUG!!
				//				mySerial.printf("In WALL_TRACKING_RIGHT just before printout at %lu\n", millis());
				////DEBUG!!


				//PrintWallFollowTelemetry(frontvar); //added 04/15/19
				break;
			case TRACKING_NEITHER:
				trackstr = "Neither"; //used for telemetry printouts
				mySerial.printf("time(ms) in TRACKNEITHER = %lu\n", millis());

				//added 01/20/16: turn direction arbitrary
				if (frontdistval <= MIN_OBS_DIST_CM || IsStuck(frontvar))
				{
					Serial.println("---- Backup & Turn to the Left");
					//09/19/18 bugfix - 1st param is 'nearest wall', not 'turn direction'
					BackupAndTurn(false, MOTOR_SPEED_HALF); //backup and turn 90 deg left //c/o 02/23/17 for IR Track debug

					//go back to normal tracking mode after B&T completes
					NavCase = NAV_WALLTRK;
				}

				//Open Corner case
				else if (frontdistval > STEPTURN_DIST_CM)
				{
					//OK, this is the Open Corner case - turn toward the last-tracked wall

#ifndef NO_MOTORS
					delay(1000); //01/20/16 - delay to give Wall-E2 time to clear the corner a bit
#endif

					if (PrevTrackingCase == TRACKING_LEFT)
					{
						//RotateCWDeg(false, NUM_DEG_FOR_90_DEG_TURN, MOTOR_SPEED_HALF);
					}
					else if (PrevTrackingCase == TRACKING_RIGHT)
					{
						//RotateCWDeg(true, NUM_DEG_FOR_90_DEG_TURN, MOTOR_SPEED_HALF);
					}
					else //oops!  not tracking either wall - out in middle of room somewhere?
					{
						//not open corner, but not tracking a wall, either - go straight
						leftspeednum = rightspeednum = MOTOR_SPEED_HALF;
						MoveAhead(leftspeednum, rightspeednum);
					}
				}
				break;
			default:
				break;
			} //switch (TrackingCase)

			digitalWrite(RED_LASER_DIODE_PIN, LOW); //disable the laser pointer
			UpdateRearLEDPanel(leftspeednum, rightspeednum); //using LEDs to visualize motor speeds
			break; //MODE_WALLFOLLOW
		}//switch (CurrentOpMode)

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

CurrentOpMode = (OpModes)GetOpMode(batVoltage); //04/28/19 bat volts added to sig

////DEBUG!!

// //CurrentOpMode = MODE_IRHOMING; //forced to MODE_IRHOMING for testing

// Serial.print("OpMode = ");

// Serial.println(CurrentOpMode);

////DEBUG!!

//Step2: Switch to appropriate operating case block

String trackstr = "Unknown"; //used for telemetry printouts

switch (CurrentOpMode)

{

case MODE_WALLFOLLOW:

//Purpose: Follow nearest wall, responding to obstacles as necessary

//Provenance: G. Frank Paynter and Danny Frank 12/20/2015

//Inputs: Distances from left/right/front sensors

//Outputs: updated left/right motor speeds in wall-follow case, or appropriate avoidance maneuver

//Plan:

// Step 1: Update motor speeds & NAV mode based on current TRACK/NAV states and front distance

// Step 2: Print out telemetry info

//Notes:

// 03/30/14 Step1 code moved to top of loop() - compiler directives cause errors here

// 09/11/18 revised plan to reflect reality

// Update motor speeds & NAV mode based on current TRACK/NAV states and front distance

// See https://fpaynter.com/2016/01/making-wall-e2-smarter-using-karnaugh-maps/ for details

////DEBUG!!

// mySerial.printf("In MODE_WALLFOLLOW before GetTrackingDir() at time %lu\n", millis());

////DEBUG!!

TrackingCase = (WallTrackingCases)GetTrackingDir();

////DEBUG!!

// mySerial.printf("In MODE_WALLFOLLOW at time %lu with Tracking Case = %d\n", millis(), TrackingCase);

////DEBUG!!

if (PrevOpMode != MODE_WALLFOLLOW)

{

Serial.println(WallFollowTelemStr); //header for wall-follow telemetry data

//09/09/19 maybe use a 'InApproachState' state variable here, changing to 'InTrackingState'

// once the proper standoff distance has been achieved?

}

PrevOpMode = MODE_WALLFOLLOW;

switch (TrackingCase)

{

case TRACKING_LEFT:

trackstr = "Left"; //used for telemetry printouts

//Bkp & Rot Right = Tracking Left && (Near || Stuck)

if (frontdistval <= MIN_OBS_DIST_CM || IsStuck(frontvar))

{

Serial.println("---- Backup & Turn to the Right");

//09/19/18 bugfix - 1st param is 'nearest wall', not 'turn direction'

BackupAndTurn(true, MOTOR_SPEED_HALF); //backup and turn 90 deg right //c/o 02/23/17 for IR Track debug

//go back to normal tracking mode after B&T completes

NavCase = NAV_WALLTRK;

}

//Step-turn Right = Tracking Left && Step && !Stuck

//this section *starts* the step-turn. It is terminated as soon as frontdistval exits step-turn window

else if (frontdistval > MIN_OBS_DIST_CM && frontdistval <= STEPTURN_DIST_CM)

{

//if we aren't already in Step-turn mode, start it. Otherwise, skip

if (NavCase != NAV_STEPTURN)

{

Serial.println("---- Starting Stepturn to the Right");

NavCase = NAV_STEPTURN;

leftspeednum = MOTOR_SPEED_MAX;

rightspeednum = MOTOR_SPEED_LOW;

MoveAhead(leftspeednum, rightspeednum);

}

//Wall-tracking Left = Tracking Left && Far away from obstacles

else if (frontdistval > STEPTURN_DIST_CM)

{

if (NavCase == NAV_STEPTURN)

{

mySerial.printf("Exiting Step-turn to the right\n");

}

NavCase = NAV_WALLTRK;

UpdateWallFollowMotorspeeds(leftdistval, rightdistval, leftspeednum, rightspeednum);

MoveAhead(leftspeednum, rightspeednum);

}

/* PrintWallFollowTelemetry(frontvar); *///added 04/15/19

break;

case TRACKING_RIGHT:

trackstr = "Right"; //used for telemetry printouts

////DEBUG!!

// mySerial.printf("In WALL_TRACKING_RIGHT top at %lu\n", millis());

////DEBUG!!

if (frontdistval <= MIN_OBS_DIST_CM || IsStuck(frontvar))

{

Serial.println("---- Backup & Turn to the Left");

//09/19/18 bugfix - 1st param is 'nearest wall', not 'turn direction'

BackupAndTurn(false, MOTOR_SPEED_HALF); //backup and turn 90 deg left //c/o 02/23/17 for IR Track debug

//go back to normal tracking mode after B&T completes

NavCase = NAV_WALLTRK;

}

////02/23/19 temporarily implemented to stop robot at end of TrkPID tuning run

//if (frontdistval <= MIN_OBS_DIST_CM)

//{

// Serial.println("---- End of run - stopping motors");

// MoveAhead(0, 0);

// delay(500);

// cli();

// sleep_enable();

// sleep_cpu();

//}

//Step-turn Left = Tracking Right && Step && !Stuck

//this section *starts* the step-turn. It is terminated as soon as frontdistval exits step-turn window

//02/23/19 temporarily commented out for TrkPID tuning

else if (frontdistval > MIN_OBS_DIST_CM && frontdistval <= STEPTURN_DIST_CM)

{

//if we aren't already in Step-turn mode, start it. Otherwise, skip

if (NavCase != NAV_STEPTURN)

{

Serial.println("---- Starting Stepturn to the Left");

NavCase = NAV_STEPTURN;

rightspeednum = MOTOR_SPEED_MAX;

leftspeednum = MOTOR_SPEED_LOW;

MoveAhead(leftspeednum, rightspeednum);

}

//Wall-tracking Right = Tracking Right && Far

else if (frontdistval > STEPTURN_DIST_CM)

{

if (NavCase == NAV_STEPTURN)

{

mySerial.printf("Exiting Step-turn to the left\n");

}

NavCase = NAV_WALLTRK;

UpdateWallFollowMotorspeeds(leftdistval, rightdistval, leftspeednum, rightspeednum);

MoveAhead(leftspeednum, rightspeednum);

}

////DEBUG!!

// mySerial.printf("In WALL_TRACKING_RIGHT just before printout at %lu\n", millis());

////DEBUG!!

//PrintWallFollowTelemetry(frontvar); //added 04/15/19

break;

case TRACKING_NEITHER:

trackstr = "Neither"; //used for telemetry printouts

mySerial.printf("time(ms) in TRACKNEITHER = %lu\n", millis());

//added 01/20/16: turn direction arbitrary

if (frontdistval <= MIN_OBS_DIST_CM || IsStuck(frontvar))

{

Serial.println("---- Backup & Turn to the Left");

//09/19/18 bugfix - 1st param is 'nearest wall', not 'turn direction'

BackupAndTurn(false, MOTOR_SPEED_HALF); //backup and turn 90 deg left //c/o 02/23/17 for IR Track debug

//go back to normal tracking mode after B&T completes

NavCase = NAV_WALLTRK;

}

//Open Corner case

else if (frontdistval > STEPTURN_DIST_CM)

{

//OK, this is the Open Corner case - turn toward the last-tracked wall

#ifndef NO_MOTORS

delay(1000); //01/20/16 - delay to give Wall-E2 time to clear the corner a bit

#endif

if (PrevTrackingCase == TRACKING_LEFT)

{

//RotateCWDeg(false, NUM_DEG_FOR_90_DEG_TURN, MOTOR_SPEED_HALF);

}

else if (PrevTrackingCase == TRACKING_RIGHT)

{

//RotateCWDeg(true, NUM_DEG_FOR_90_DEG_TURN, MOTOR_SPEED_HALF);

}

else //oops! not tracking either wall - out in middle of room somewhere?

{

//not open corner, but not tracking a wall, either - go straight

leftspeednum = rightspeednum = MOTOR_SPEED_HALF;

MoveAhead(leftspeednum, rightspeednum);

}

break;

default:

break;

} //switch (TrackingCase)

digitalWrite(RED_LASER_DIODE_PIN, LOW); //disable the laser pointer

UpdateRearLEDPanel(leftspeednum, rightspeednum); //using LEDs to visualize motor speeds

break; //MODE_WALLFOLLOW

}//switch (CurrentOpMode)

The two-wheel robot code uses a very simple left/right distance check to determine which wall to track. In the four-wheel code, the ‘GetTrackingDir()’ function uses a LR_PING_AVG_WINDOW_SIZE-point running average for left & right distances and returns TRACKING_LEFT, TRACKING_RIGHT, or TRACKING_NEITHER enum value.

09 April 2020 Update:

It looks like the two-wheel code actually checks the L/R distances twice; once in GetParallelHdg() and again in the main loop() code. Once it determines which wall to track, then it uses the same code for both tracking directions, with a ‘turndirection’ boolean to control which way the robot actually turns (CW or CCW) to effect capture and tracking.

The four-wheel code uses two LR_PING_DIST_ARRAY_SIZE buffers – aRightDist & aLeftDist – to hold ‘ping’ measurements. These arrays are updated every MIN_PING_INTERVAL_MSEC with the latest left/right distances, pushing older measurements down in the stack. The ‘GetTrackingDir()’ function computes the average of the LR_PING_AVG_WINDOW_SIZE latest measurements for tracking direction (left/right/neither) determination.

There are also two utility functions ‘GetAvgLeftDistCm()’ and ‘GetAvgRightDistCm()’ that are used in several places, but they don’t do a running average of the last LR_PING_AVG_WINDOW_SIZE measurements; instead they do an average of the first LR_PING_AVG_WINDOW_SIZE ones! Fortunately for the program right now the LR_PING_AVG_WINDOW_SIZE and LR_PING_DIST_ARRAY_SIZE values are the same — 3.

So, I think part of the port needs to involve normalizing the distance measurement situation. I think the proper way to do this is to revise the ‘GetAvgLeftDistCm()’ & ‘GetAvgRightDistCm()’ functions to compute the running average as it done currently now in GetTrackingDir(), and then call those functions there. This considerably simplifies GetTrackingDir() and increases its cohesion (in the software engineering sense) as it no longer contains any computations not directly related to its purpose. DONE in FourWD_WallE2_V3 project

The ‘GetTrackingDir()’ function is called in only one place – at the top of the ‘case MODE_WALLFOLLOW:’ block of the ‘ switch (CurrentOpMode)’ switch statement. The ‘TrackingCase’ enum value returned by ‘GetTrackingDir()’ is then used within the MODE_WALLFOLLOW:’ block in a new ‘switch (TrackingCase)’ switch statement to determine the appropriate action to be taken. Here’s the relevant code section:

			switch (TrackingCase)
			{
			case TRACKING_LEFT:
#pragma region TRACKLEFT
				trackstr = "Left"; //used for telemetry printouts

				//Bkp & Rot Right = Tracking Left && (Near || Stuck)
				if (frontdistval <= MIN_OBS_DIST_CM || IsStuck(frontvar))
				{
					Serial.println("---- Backup & Turn to the Right");

					//09/19/18 bugfix - 1st param is 'nearest wall', not 'turn direction'
					BackupAndTurn(true, MOTOR_SPEED_HALF); //backup and turn 90 deg right //c/o 02/23/17 for IR Track debug

					//go back to normal tracking mode after B&T completes
					NavCase = NAV_WALLTRK;
				}

				//Step-turn Right = Tracking Left && Step && !Stuck
				//this section *starts* the step-turn.  It is terminated as soon as frontdistval exits step-turn window
				else if (frontdistval > MIN_OBS_DIST_CM && frontdistval <= STEPTURN_DIST_CM)
				{
					//if we aren't already in Step-turn mode, start it.  Otherwise, skip
					if (NavCase != NAV_STEPTURN)
					{
						Serial.println("---- Starting Stepturn to the Right");
						NavCase = NAV_STEPTURN;
						leftspeednum = MOTOR_SPEED_MAX;
						rightspeednum = MOTOR_SPEED_LOW;
						MoveAhead(leftspeednum, rightspeednum);
					}
				}

				//Wall-tracking Left = Tracking Left && Far away from obstacles
				else if (frontdistval > STEPTURN_DIST_CM)
				{
					if (NavCase == NAV_STEPTURN)
					{
						mySerial.printf("Exiting Step-turn to the right\n");
					}

					NavCase = NAV_WALLTRK;
					UpdateWallFollowMotorspeeds(leftdistval, rightdistval, leftspeednum, rightspeednum);
					MoveAhead(leftspeednum, rightspeednum);
				}

				/*				PrintWallFollowTelemetry(frontvar); *///added 04/15/19
#pragma endregion Tracking Left Wall Case
				break;
			case TRACKING_RIGHT:
#pragma region TRACKRIGHT
				trackstr = "Right"; //used for telemetry printouts

////DEBUG!!
//				mySerial.printf("In WALL_TRACKING_RIGHT top at %lu\n", millis());
////DEBUG!!

				if (frontdistval <= MIN_OBS_DIST_CM || IsStuck(frontvar))
				{
					Serial.println("---- Backup & Turn to the Left");
					//09/19/18 bugfix - 1st param is 'nearest wall', not 'turn direction'
					BackupAndTurn(false, MOTOR_SPEED_HALF); //backup and turn 90 deg left //c/o 02/23/17 for IR Track debug

					//go back to normal tracking mode after B&T completes
					NavCase = NAV_WALLTRK;
				}

				////02/23/19 temporarily implemented to stop robot at end of TrkPID tuning run
				//if (frontdistval <= MIN_OBS_DIST_CM)
				//{
				//	Serial.println("---- End of run - stopping motors");
				//	MoveAhead(0, 0);
				//	delay(500);
				//	cli();
				//	sleep_enable();
				//	sleep_cpu();
				//}


				//Step-turn Left = Tracking Right && Step && !Stuck
				//this section *starts* the step-turn.  It is terminated as soon as frontdistval exits step-turn window
				//02/23/19 temporarily commented out for TrkPID tuning 
				else if (frontdistval > MIN_OBS_DIST_CM && frontdistval <= STEPTURN_DIST_CM)
				{
					//if we aren't already in Step-turn mode, start it.  Otherwise, skip
					if (NavCase != NAV_STEPTURN)
					{
						Serial.println("---- Starting Stepturn to the Left");
						NavCase = NAV_STEPTURN;
						rightspeednum = MOTOR_SPEED_MAX;
						leftspeednum = MOTOR_SPEED_LOW;
						MoveAhead(leftspeednum, rightspeednum);
					}
				}

				//Wall-tracking Right = Tracking Right && Far
				else if (frontdistval > STEPTURN_DIST_CM)
				{
					if (NavCase == NAV_STEPTURN)
					{
						mySerial.printf("Exiting Step-turn to the left\n");
					}

					NavCase = NAV_WALLTRK;
					UpdateWallFollowMotorspeeds(leftdistval, rightdistval, leftspeednum, rightspeednum);
					MoveAhead(leftspeednum, rightspeednum);
				}


				////DEBUG!!
				//				mySerial.printf("In WALL_TRACKING_RIGHT just before printout at %lu\n", millis());
				////DEBUG!!


				//PrintWallFollowTelemetry(frontvar); //added 04/15/19
#pragma endregion Tracking Right Wall Case
				break;
			case TRACKING_NEITHER:
#pragma region TRACKNEITHER
				trackstr = "Neither"; //used for telemetry printouts
				mySerial.printf("time(ms) in TRACKNEITHER = %lu\n", millis());

				//added 01/20/16: turn direction arbitrary
				if (frontdistval <= MIN_OBS_DIST_CM || IsStuck(frontvar))
				{
					Serial.println("---- Backup & Turn to the Left");
					//09/19/18 bugfix - 1st param is 'nearest wall', not 'turn direction'
					BackupAndTurn(false, MOTOR_SPEED_HALF); //backup and turn 90 deg left //c/o 02/23/17 for IR Track debug

					//go back to normal tracking mode after B&T completes
					NavCase = NAV_WALLTRK;
				}

				//Open Corner case
				else if (frontdistval > STEPTURN_DIST_CM)
				{
					//OK, this is the Open Corner case - turn toward the last-tracked wall

#ifndef NO_MOTORS
					delay(1000); //01/20/16 - delay to give Wall-E2 time to clear the corner a bit
#endif

					if (PrevTrackingCase == TRACKING_LEFT)
					{
						//RotateCWDeg(false, NUM_DEG_FOR_90_DEG_TURN, MOTOR_SPEED_HALF);
					}
					else if (PrevTrackingCase == TRACKING_RIGHT)
					{
						//RotateCWDeg(true, NUM_DEG_FOR_90_DEG_TURN, MOTOR_SPEED_HALF);
					}
					else //oops!  not tracking either wall - out in middle of room somewhere?
					{
						//not open corner, but not tracking a wall, either - go straight
						leftspeednum = rightspeednum = MOTOR_SPEED_HALF;
						MoveAhead(leftspeednum, rightspeednum);
					}
				}
#pragma endregion Not Tracking Either Wall
				break;
			default:
				break;
			} //switch (TrackingCase)

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

switch (TrackingCase)

{

case TRACKING_LEFT:

#pragma region TRACKLEFT

trackstr = "Left"; //used for telemetry printouts

//Bkp & Rot Right = Tracking Left && (Near || Stuck)

if (frontdistval <= MIN_OBS_DIST_CM || IsStuck(frontvar))

{

Serial.println("---- Backup & Turn to the Right");

//09/19/18 bugfix - 1st param is 'nearest wall', not 'turn direction'

BackupAndTurn(true, MOTOR_SPEED_HALF); //backup and turn 90 deg right //c/o 02/23/17 for IR Track debug

//go back to normal tracking mode after B&T completes

NavCase = NAV_WALLTRK;

}

//Step-turn Right = Tracking Left && Step && !Stuck

//this section *starts* the step-turn. It is terminated as soon as frontdistval exits step-turn window

else if (frontdistval > MIN_OBS_DIST_CM && frontdistval <= STEPTURN_DIST_CM)

{

//if we aren't already in Step-turn mode, start it. Otherwise, skip

if (NavCase != NAV_STEPTURN)

{

Serial.println("---- Starting Stepturn to the Right");

NavCase = NAV_STEPTURN;

leftspeednum = MOTOR_SPEED_MAX;

rightspeednum = MOTOR_SPEED_LOW;

MoveAhead(leftspeednum, rightspeednum);

}

//Wall-tracking Left = Tracking Left && Far away from obstacles

else if (frontdistval > STEPTURN_DIST_CM)

{

if (NavCase == NAV_STEPTURN)

{

mySerial.printf("Exiting Step-turn to the right\n");

}

NavCase = NAV_WALLTRK;

UpdateWallFollowMotorspeeds(leftdistval, rightdistval, leftspeednum, rightspeednum);

MoveAhead(leftspeednum, rightspeednum);

}

/* PrintWallFollowTelemetry(frontvar); *///added 04/15/19

#pragma endregion Tracking Left Wall Case

break;

case TRACKING_RIGHT:

#pragma region TRACKRIGHT

trackstr = "Right"; //used for telemetry printouts

////DEBUG!!

// mySerial.printf("In WALL_TRACKING_RIGHT top at %lu\n", millis());

////DEBUG!!

if (frontdistval <= MIN_OBS_DIST_CM || IsStuck(frontvar))

{

Serial.println("---- Backup & Turn to the Left");

//09/19/18 bugfix - 1st param is 'nearest wall', not 'turn direction'

BackupAndTurn(false, MOTOR_SPEED_HALF); //backup and turn 90 deg left //c/o 02/23/17 for IR Track debug

//go back to normal tracking mode after B&T completes

NavCase = NAV_WALLTRK;

}

////02/23/19 temporarily implemented to stop robot at end of TrkPID tuning run

//if (frontdistval <= MIN_OBS_DIST_CM)

//{

// Serial.println("---- End of run - stopping motors");

// MoveAhead(0, 0);

// delay(500);

// cli();

// sleep_enable();

// sleep_cpu();

//}

//Step-turn Left = Tracking Right && Step && !Stuck

//this section *starts* the step-turn. It is terminated as soon as frontdistval exits step-turn window

//02/23/19 temporarily commented out for TrkPID tuning

else if (frontdistval > MIN_OBS_DIST_CM && frontdistval <= STEPTURN_DIST_CM)

{

//if we aren't already in Step-turn mode, start it. Otherwise, skip

if (NavCase != NAV_STEPTURN)

{

Serial.println("---- Starting Stepturn to the Left");

NavCase = NAV_STEPTURN;

rightspeednum = MOTOR_SPEED_MAX;

leftspeednum = MOTOR_SPEED_LOW;

MoveAhead(leftspeednum, rightspeednum);

}

//Wall-tracking Right = Tracking Right && Far

else if (frontdistval > STEPTURN_DIST_CM)

{

if (NavCase == NAV_STEPTURN)

{

mySerial.printf("Exiting Step-turn to the left\n");

}

NavCase = NAV_WALLTRK;

UpdateWallFollowMotorspeeds(leftdistval, rightdistval, leftspeednum, rightspeednum);

MoveAhead(leftspeednum, rightspeednum);

}

////DEBUG!!

// mySerial.printf("In WALL_TRACKING_RIGHT just before printout at %lu\n", millis());

////DEBUG!!

//PrintWallFollowTelemetry(frontvar); //added 04/15/19

#pragma endregion Tracking Right Wall Case

break;

case TRACKING_NEITHER:

#pragma region TRACKNEITHER

trackstr = "Neither"; //used for telemetry printouts

mySerial.printf("time(ms) in TRACKNEITHER = %lu\n", millis());

//added 01/20/16: turn direction arbitrary

if (frontdistval <= MIN_OBS_DIST_CM || IsStuck(frontvar))

{

Serial.println("---- Backup & Turn to the Left");

//09/19/18 bugfix - 1st param is 'nearest wall', not 'turn direction'

BackupAndTurn(false, MOTOR_SPEED_HALF); //backup and turn 90 deg left //c/o 02/23/17 for IR Track debug

//go back to normal tracking mode after B&T completes

NavCase = NAV_WALLTRK;

}

//Open Corner case

else if (frontdistval > STEPTURN_DIST_CM)

{

//OK, this is the Open Corner case - turn toward the last-tracked wall

#ifndef NO_MOTORS

delay(1000); //01/20/16 - delay to give Wall-E2 time to clear the corner a bit

#endif

if (PrevTrackingCase == TRACKING_LEFT)

{

//RotateCWDeg(false, NUM_DEG_FOR_90_DEG_TURN, MOTOR_SPEED_HALF);

}

else if (PrevTrackingCase == TRACKING_RIGHT)

{

//RotateCWDeg(true, NUM_DEG_FOR_90_DEG_TURN, MOTOR_SPEED_HALF);

}

else //oops! not tracking either wall - out in middle of room somewhere?

{

//not open corner, but not tracking a wall, either - go straight

leftspeednum = rightspeednum = MOTOR_SPEED_HALF;

MoveAhead(leftspeednum, rightspeednum);

}

#pragma endregion Not Tracking Either Wall

break;

default:

break;

} //switch (TrackingCase)

looking at just the ‘TRACKING_LEFT’ section,

			case TRACKING_LEFT:
				trackstr = "Left"; //used for telemetry printouts

				//Bkp & Rot Right = Tracking Left && (Near || Stuck)
				if (frontdistval <= MIN_OBS_DIST_CM || IsStuck(frontvar))
				{
					Serial.println("---- Backup & Turn to the Right");

					//09/19/18 bugfix - 1st param is 'nearest wall', not 'turn direction'
					BackupAndTurn(true, MOTOR_SPEED_HALF); //backup and turn 90 deg right //c/o 02/23/17 for IR Track debug

					//go back to normal tracking mode after B&T completes
					NavCase = NAV_WALLTRK;
				}

				//Step-turn Right = Tracking Left && Step && !Stuck
				//this section *starts* the step-turn.  It is terminated as soon as frontdistval exits step-turn window
				else if (frontdistval > MIN_OBS_DIST_CM && frontdistval <= STEPTURN_DIST_CM)
				{
					//if we aren't already in Step-turn mode, start it.  Otherwise, skip
					if (NavCase != NAV_STEPTURN)
					{
						Serial.println("---- Starting Stepturn to the Right");
						NavCase = NAV_STEPTURN;
						leftspeednum = MOTOR_SPEED_MAX;
						rightspeednum = MOTOR_SPEED_LOW;
						MoveAhead(leftspeednum, rightspeednum);
					}
				}

				//Wall-tracking Left = Tracking Left && Far away from obstacles
				else if (frontdistval > STEPTURN_DIST_CM)
				{
					if (NavCase == NAV_STEPTURN)
					{
						mySerial.printf("Exiting Step-turn to the right\n");
					}

					NavCase = NAV_WALLTRK;
					UpdateWallFollowMotorspeeds(leftdistval, rightdistval, leftspeednum, rightspeednum);
					MoveAhead(leftspeednum, rightspeednum);
				}

				break;

case TRACKING_LEFT:

trackstr = "Left"; //used for telemetry printouts

//Bkp & Rot Right = Tracking Left && (Near || Stuck)

if (frontdistval <= MIN_OBS_DIST_CM || IsStuck(frontvar))

{

Serial.println("---- Backup & Turn to the Right");

//09/19/18 bugfix - 1st param is 'nearest wall', not 'turn direction'

BackupAndTurn(true, MOTOR_SPEED_HALF); //backup and turn 90 deg right //c/o 02/23/17 for IR Track debug

//go back to normal tracking mode after B&T completes

NavCase = NAV_WALLTRK;

}

//Step-turn Right = Tracking Left && Step && !Stuck

//this section *starts* the step-turn. It is terminated as soon as frontdistval exits step-turn window

else if (frontdistval > MIN_OBS_DIST_CM && frontdistval <= STEPTURN_DIST_CM)

{

//if we aren't already in Step-turn mode, start it. Otherwise, skip

if (NavCase != NAV_STEPTURN)

{

Serial.println("---- Starting Stepturn to the Right");

NavCase = NAV_STEPTURN;

leftspeednum = MOTOR_SPEED_MAX;

rightspeednum = MOTOR_SPEED_LOW;

MoveAhead(leftspeednum, rightspeednum);

}

//Wall-tracking Left = Tracking Left && Far away from obstacles

else if (frontdistval > STEPTURN_DIST_CM)

{

if (NavCase == NAV_STEPTURN)

{

mySerial.printf("Exiting Step-turn to the right\n");

}

NavCase = NAV_WALLTRK;

UpdateWallFollowMotorspeeds(leftdistval, rightdistval, leftspeednum, rightspeednum);

MoveAhead(leftspeednum, rightspeednum);

}

break;

There are three potential actions available in this section; a ‘back up and turn’ obstacle avoidance maneuver, a ‘step-turn to the right’ “upcoming obstacle” avoidance maneuver, and a “continue wall tracking” motor speed adjustment action.

It’s the “continue wall tracking” action that is of interest for porting the new tracking algorithm. At this point, if this is the first time for the TRACKING_LEFT mode, the robot needs to execute the FindParallelHdg() routine, then capture the offset distance, and then start tracking. If the previous mode was TRACKING_LEFT, then just continue tracking.

A potential problem with the port idea is that the ‘FindParallelHdg()’ and offset capture routines are ‘blocking’ functions, so if something else happens (like the robot runs into an obstacle), it might not ever recover. In the current four wheel code, this is handled by checking for obstacle clearance each time through the MIN_PING_INTERVAL_MSEC interval check. Maybe I can incorporate this idea into the ‘capture’ and ‘maintenance’ phases of the angle-based wall tracking algorithm. Maybe something like the following state diagram?

Possible state diagram for the TRK_RIGHT case

11 April 2020 Update:

I’m concentrating on the TRACKING_RIGHT sub-case in MODE_WALLFOLLOW, because my ‘local’ (in my office) test range is optimized for tracking the right-hand wall, and I figure I should work our the bugs on one side first.

Ported the ‘FindParallelHdg()’ code from the two wheel to the four wheel project, and in the process I changed the name to ‘RotateToParallelOrientation()’ to more accurately describe what the function does.
In porting over the actual code that decides what ‘cut’ to use to capture and maintain the desired offset, I realized this should be it’s own function so it can be called from both the left and righthand tracking algorithms. Then I discovered it already was a function in the two wheel program – but wasn’t being used that way for some unknown reason. Ported the ‘MakeTrackingTurn()’ function to FourWD_WallE_V3

26 April 2020 Update – Charging Station:

While trying (and failing so far) to work out the wall-following ‘capture/maintain’ algorithms for the four wheel robot, the battery voltage got down to the point where the ‘GetOpMode()’ function was starting to return DEAD_BATTERY. So, I decided this was a good time to complete the required software & hardware modifications to the charging station to work with the new 90 mm x 10 mm wheels I recently added to the robot. To accommodate the larger diameter wheels I raised the entire charging station electronics platform up by some 14 mm. To accommodate the much narrower wheel width, I had to completely redo the wheel guard geometry, which also required re-aligning the charging station approach guides.

When I was all done with the required physical mods, I discovered that although the robot would still home to the charging station, it wouldn’t shut off its motors when it finally connected to the charging probe. I could see from telemetry that the probe plug had successfully engaged the probe jack’s integrated switch, but the motors continued to run. However, if I lifted the robot slightly off its wheels from the back while keeping it plugged in, the motors stopped immediately, and the charging operation proceeded normally. It appeared for all the world like the plug was only partially engaged into the jack. So, I tried the same trick with the robot on its stand (this raises the robot up slightly so the motors can turn without the robot running off on me) and a second probe plug tied to the power supply but physically separate from the charging station, and this worked fine; as soon as the plug was pushed into the jack, the motors turned off and life was good.

So, back to the charging station; I thought maybe the plug wasn’t making full contact due to misalignment and after critically examining the geometry I made some adjustments. However, this did not solve the problem, even when the plug was perfectly aligned with the jack. But, with the plug alignment cone attached to the robot it is hard to see whether or not the plug is fully inserted into the jack, so I still thought that maybe I just needed to have the robot plug in with a bit more authority. To this end I modified the software to monitor the LIDAR distance measurement as the robot approached the charging station, and have the robot speed up to max wheel speed when it got within 20 cm. I also printed up a ‘target panel’ for the charging station so the LIDAR would have a consistent target to work with. This worked great, but still didn’t solve the problem; the robot clearly sped up at the end of the approach maneuver, but also still literally “spun its wheels” after hitting the charging station stops. Lifting the back slightly still caused the motors to stop and for charging to proceed normally. However, I was now convinced this phenomenon wasn’t due to plug/jack misalignment, and I had already confirmed that all electrical connections were correct. So, having eliminated the hardware, the software must be at fault

So, now I was forced to dissect the software controlling the transition from wall-following to IR homing to battery charge monitoring. In order for the robot to transition from the IR Homing mode to the charge monitoring mode, the following conditions had to exist:

The physical charging jack switch must be OPEN, causing the voltage read by the associated MEGA pin to go HIGH.
12V must be present at the charging jack +V pin
The Difference between the Total current (measured by the 1NA169 ‘high-side’ current sensor located between the charging jack and the battery charger) and the Run current (measured by the 1NA169 between the power switch and the rest of the robot) must be positive and greater than 0.5A.

Of the above conditions, I was able to directly measure the first two in both the ‘working’ (with the robot on its stand and using the auxiliary charging probe) and ‘non-working’ (when the robot engaged the charging plug automatically) conditions and verified that they were both met in both cases. That left the third condition – the I_Total – I_Run condition.

The reason for the I_Total – I_Run condition is to properly manage charge cutoff at the 80% battery capacity point. The robot has a resting (idle) current of about 0.2A, so a 0.5A difference would mean that the battery charge current has decreased to 0.3A, which is slightly above the recommended 90% capacity level (see this post for a more detailed discussion). So, this condition is included in the ‘GetOpMode()’ algorithm for determining when the battery is charging, and when the battery is fully charged. In normal operation, I_Total = 0 (nothing connected to the charger) and I_Run = Robot running current, so I_Total – I_Run < 0 and the IsCharging () function returns FALSE. When the robot is connected to a charger, I_Total is usually around 1.5A initially, and I_Total – I_Run > 0.5, causing IsCharging() to return TRUE and the robot to enter the CHARGING mode, which disables the motors. What I didn’t realize though is that the larger diameter wheels and better motors cause I_Run to be a lot higher than I had anticipated, which means that when the robot plugs into the charging station, the I_Run value goes over 2A with all four motors stalled. This in turn means that the and I_Total – I_Run > 0.5 condition is never met, IsCharging() continues to return FALSE, and the motors never turn off – OOPS!

So, how to fix this problem? It appears that I don’t want to use the I_Total – I_Run > 0.5 condition as part of the IR Homing –> CHARGING mode transition, but I do want to use it as part of the CHARGING –> CHARGE_DISCONNECT mode transition. This should work, but this exercise got me thinking about how I the charge operation relates to the rest of the robot’s behavior.

The basic idea is for the robot to autonomously seek out and connect to on of a number of charging stations whenever it is ‘hungry’, defined by a battery voltage less than some set threshold, and to avoid those same stations when it isn’t. When the robot is ‘hungry’ and a charging station signal is detected, the robot should home in on the station and connect to a charging probe, stop its motors, wait until the battery is 80% or so charged, and then back out of the station and go on its merry way.

As currently programmed, the robot operates in one of several modes as shown below.

	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
	MODE_DISCHARGE //added 03/04/20 to safely discharge the battery

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

MODE_DISCHARGE //added 03/04/20 to safely discharge the battery

The program calls a function called ‘GetOpMode’ every 400 msec to determine the proper mode based on sensor input and (to some degree) past history). The GetOpMode() function is shown below:

int GetOpMode(float batv) //04/28/19 added batv to sig
{
	//Purpose:  Determine operating mode based on sensor inputs
	//Inputs: none
	//Outputs: Integer denoting current op mode (CHARGING = 1, IRHOMING = 2, WALLFOLLOW = 3)
	//Plan:
	//	Step1: If batt voltage too low, return MODE_DEADBATTERY (4)
	//	Step2: If Charger is connected, return MODE_CHARGING (1)
	//	Step3: Else If IR Homing beam detected, return MODE_IRHOMING (2)
	//	Step4: Else return MODE_WALLFOLLOW (3)
	//Notes:
	//	01/16/18 added MODE_DEADBATTERY
	//	03/28/18 now looking for either IsChargerConnected OR low on TP5100 Chg line
	//	09/03/18 reorganized so DEADBATTERY is on top, and added new TURNING_TO_HDG mode
	//	02/24/19 now using 1NA619 charge current sensor
	//	04/28/19 added batV to function sig

//Step1: If batt voltage too low, return MODE_DEADBATTERY (4)
	if (batv <= DEAD_BATT_THRESH_VOLTS) return MODE_DEADBATTERY;

	//Step2: If Charger is connected, return MODE_CHARGING (1)
	//04/26/20 only  use IsStillCharging() if previous op mode is MODE_CHARGING
	//else if (IsChargerConnected() && IsStillCharging()) return MODE_CHARGING; //02/24/19 now using 1NA619 charge current sensor
	else if (PrevOpMode != MODE_CHARGING) //first time through with MODE_CHARGING
	{
		if (IsChargerConnected()) return MODE_CHARGING; //02/24/19 now using 1NA619 charge current sensor
		PrevOpMode = MODE_CHARGING; //this causes next 'elseif' to run until charge mode exits
		mySerial.printf("PrevOpMode = %s, IsChargerConnected() returns %s\n",
			LongModeStrArray[PrevOpMode], IsChargerConnected() ? "TRUE" : "FALSE");
	}
	else if (PrevOpMode == MODE_CHARGING) //subsequent times through with MODE_CHARGING
	{
		if (IsChargerConnected() && IsStillCharging()) return MODE_CHARGING; //02/24/19 now using 1NA619 charge current sensor
	}

	//else if (IsChargerConnected() && IsStillCharging()) return MODE_CHARGING; //02/24/19 now using 1NA619 charge current sensor

//Step3: Else If IR Homing beam detected, return MODE_IRHOMING (2)
	else if (IsIRBeamAvail()) return MODE_IRHOMING; //this handles 'hungry/not-hungry' cases internally

//03/04/2020 added to facilitate battery discharge
#ifdef BATTERY_DISCHARGE
	while (GetBattVoltage() > DEAD_BATT_THRESH_VOLTS)
	{
		return MODE_DISCHARGE;
	}
	StopBothMotors();
	mySerial.printf("Battery Discharge Complete at %3.2f Minutes and %3.2f Volts", millis() / 60000.f, GetBattVoltage);

#else
//Step4: Else return MODE_WALLFOLLOW (3)
	else return MODE_WALLFOLLOW;
#endif // BATTERY_DISCHARGE
}

int GetOpMode(float batv) //04/28/19 added batv to sig

{

//Purpose: Determine operating mode based on sensor inputs

//Inputs: none

//Outputs: Integer denoting current op mode (CHARGING = 1, IRHOMING = 2, WALLFOLLOW = 3)

//Plan:

// Step1: If batt voltage too low, return MODE_DEADBATTERY (4)

// Step2: If Charger is connected, return MODE_CHARGING (1)

// Step3: Else If IR Homing beam detected, return MODE_IRHOMING (2)

// Step4: Else return MODE_WALLFOLLOW (3)

//Notes:

// 01/16/18 added MODE_DEADBATTERY

// 03/28/18 now looking for either IsChargerConnected OR low on TP5100 Chg line

// 09/03/18 reorganized so DEADBATTERY is on top, and added new TURNING_TO_HDG mode

// 02/24/19 now using 1NA619 charge current sensor

// 04/28/19 added batV to function sig

//Step1: If batt voltage too low, return MODE_DEADBATTERY (4)

if (batv <= DEAD_BATT_THRESH_VOLTS) return MODE_DEADBATTERY;

//Step2: If Charger is connected, return MODE_CHARGING (1)

//04/26/20 only use IsStillCharging() if previous op mode is MODE_CHARGING

//else if (IsChargerConnected() && IsStillCharging()) return MODE_CHARGING; //02/24/19 now using 1NA619 charge current sensor

else if (PrevOpMode != MODE_CHARGING) //first time through with MODE_CHARGING

{

if (IsChargerConnected()) return MODE_CHARGING; //02/24/19 now using 1NA619 charge current sensor

PrevOpMode = MODE_CHARGING; //this causes next 'elseif' to run until charge mode exits

mySerial.printf("PrevOpMode = %s, IsChargerConnected() returns %s\n",

LongModeStrArray[PrevOpMode], IsChargerConnected() ? "TRUE" : "FALSE");

}

else if (PrevOpMode == MODE_CHARGING) //subsequent times through with MODE_CHARGING

{

if (IsChargerConnected() && IsStillCharging()) return MODE_CHARGING; //02/24/19 now using 1NA619 charge current sensor

}

//else if (IsChargerConnected() && IsStillCharging()) return MODE_CHARGING; //02/24/19 now using 1NA619 charge current sensor

//Step3: Else If IR Homing beam detected, return MODE_IRHOMING (2)

else if (IsIRBeamAvail()) return MODE_IRHOMING; //this handles 'hungry/not-hungry' cases internally

//03/04/2020 added to facilitate battery discharge

#ifdef BATTERY_DISCHARGE

while (GetBattVoltage() > DEAD_BATT_THRESH_VOLTS)

{

return MODE_DISCHARGE;

}

StopBothMotors();

mySerial.printf("Battery Discharge Complete at %3.2f Minutes and %3.2f Volts", millis() / 60000.f, GetBattVoltage);

#else

//Step4: Else return MODE_WALLFOLLOW (3)

else return MODE_WALLFOLLOW;

#endif // BATTERY_DISCHARGE

}

The return value from GetOpMode() is used in a SWITCH block to determine the appropriate actions to be taken, as shown below, with the MODE_WALLFOLLOW case reduced to one line for clarity:

		switch (CurrentOpMode)
		{
#pragma region MODE_CHARGING
		case MODE_CHARGING:
			digitalWrite(RED_LASER_DIODE_PIN, LOW); //disable the laser pointer
			chgStartMsec = millis(); //used for charge duration telemetry
			Serial.print("Starting Charge Mode at "); Serial.println(chgStartMsec);
			StopBothMotors(); //added 03/13/17
			PrevOpMode = MODE_CHARGING;
			//Serial.println(ChargingTelemStr); 02/28/19 moved into MonitorChargeUntilDone()
			MonitorChargeUntilDone(); //10/16/17 removed chgStartMsec from call sig
			Serial.print("Charging Complete. Executing disconnect maneuver");
			ExecDisconManeuver(); //disconnect, backup, and turn 90deg from near wall
			Serial.println("After ExexDisconManeuver");
			break;
#pragma endregion MODE_CHARGING

#pragma region MODE_IRHOMING
		case MODE_IRHOMING:
			digitalWrite(RED_LASER_DIODE_PIN, LOW); //disable the laser pointer
			mySerial.printf("IR Beam Detected with Battery Voltage = %1.2f\n", batVoltage);
			PrevOpMode = MODE_IRHOMING;

			if (batVoltage > LOW_BATT_THRESH_VOLTS) //not hungry
			{
				Serial.println("Not Hungry - Avoiding Charger");
				curMinObstacleDistance = CHG_STN_AVOIDANCE_DIST_CM; //hopefully this will cause avoidance
				IRHomeToChgStn(CHG_STN_AVOIDANCE_DIST_CM, MOTOR_SPEED_HALF, MOTOR_SPEED_HALF);
			}
			else //hungry - try to connect
			{
				Serial.println("Low battery - homing to Charger");
				IRHomeToChgStn(0, MOTOR_SPEED_HALF, MOTOR_SPEED_HALF);
			}
			break;
#pragma endregion IR Homing Case

#pragma region MODE_WALLFOLLOW
		case MODE_WALLFOLLOW:
#pragma endregion Wall Following Case

#pragma region MODE_DEADBATTERY
		case MODE_DEADBATTERY:
			Serial.println("Dead Battery Detected!");
			digitalWrite(RED_LASER_DIODE_PIN, LOW); //disable the laser pointer

			YellForHelp(); //this function never returns
			break;
#pragma endregion Dead Battery Case

#pragma region MODE_DISCHARGE
		case MODE_DISCHARGE:

			//have to explicitely set the direction, as StopBothMotors() disables everything
			SetLeftMotorDir(FWD_DIR);
			SetRightMotorDir(FWD_DIR);

			RunBothMotors(MOTOR_SPEED_FULL, MOTOR_SPEED_FULL);
			mySerial.printf("Discharge Mode %2.2f:  BattV, IRun = %2.3f, %2.3f\n",
				millis() / 60000.f, GetBattVoltage(), GetRunningAmps());
			break;
#pragma endregion MODE_DISCHARGE
		default:
			break;
		}//switch (CurrentOpMode)
#pragma endregion OP_MODE SWITCH

switch (CurrentOpMode)

{

#pragma region MODE_CHARGING

case MODE_CHARGING:

digitalWrite(RED_LASER_DIODE_PIN, LOW); //disable the laser pointer

chgStartMsec = millis(); //used for charge duration telemetry

Serial.print("Starting Charge Mode at "); Serial.println(chgStartMsec);

StopBothMotors(); //added 03/13/17

PrevOpMode = MODE_CHARGING;

//Serial.println(ChargingTelemStr); 02/28/19 moved into MonitorChargeUntilDone()

MonitorChargeUntilDone(); //10/16/17 removed chgStartMsec from call sig

Serial.print("Charging Complete. Executing disconnect maneuver");

ExecDisconManeuver(); //disconnect, backup, and turn 90deg from near wall

Serial.println("After ExexDisconManeuver");

break;

#pragma endregion MODE_CHARGING

#pragma region MODE_IRHOMING

case MODE_IRHOMING:

digitalWrite(RED_LASER_DIODE_PIN, LOW); //disable the laser pointer

mySerial.printf("IR Beam Detected with Battery Voltage = %1.2f\n", batVoltage);

PrevOpMode = MODE_IRHOMING;

if (batVoltage > LOW_BATT_THRESH_VOLTS) //not hungry

{

Serial.println("Not Hungry - Avoiding Charger");

curMinObstacleDistance = CHG_STN_AVOIDANCE_DIST_CM; //hopefully this will cause avoidance

IRHomeToChgStn(CHG_STN_AVOIDANCE_DIST_CM, MOTOR_SPEED_HALF, MOTOR_SPEED_HALF);

}

else //hungry - try to connect

{

Serial.println("Low battery - homing to Charger");

IRHomeToChgStn(0, MOTOR_SPEED_HALF, MOTOR_SPEED_HALF);

}

break;

#pragma endregion IR Homing Case

#pragma region MODE_WALLFOLLOW

case MODE_WALLFOLLOW:

#pragma endregion Wall Following Case

#pragma region MODE_DEADBATTERY

case MODE_DEADBATTERY:

Serial.println("Dead Battery Detected!");

digitalWrite(RED_LASER_DIODE_PIN, LOW); //disable the laser pointer

YellForHelp(); //this function never returns

break;

#pragma endregion Dead Battery Case

#pragma region MODE_DISCHARGE

case MODE_DISCHARGE:

//have to explicitely set the direction, as StopBothMotors() disables everything

SetLeftMotorDir(FWD_DIR);

SetRightMotorDir(FWD_DIR);

RunBothMotors(MOTOR_SPEED_FULL, MOTOR_SPEED_FULL);

mySerial.printf("Discharge Mode %2.2f: BattV, IRun = %2.3f, %2.3f\n",

millis() / 60000.f, GetBattVoltage(), GetRunningAmps());

break;

#pragma endregion MODE_DISCHARGE

default:

break;

}//switch (CurrentOpMode)

#pragma endregion OP_MODE SWITCH

In the normal sequence of events, the MODE_IRHOMING case will be executed first. If a charging station signal is detected, the robot will call IRHomeToChgStn() whether or not it is ‘hungry’. However, if it is ‘not hungry’ IRHomeToChgStn() will return FALSE with the robot oriented 90 degrees to the charging station, which should cause the program to re-enter WALL_FOLLOW mode. If the robot is ‘hungry’ and successfully connects to the charging probe, IRHomeToChgStn() returns TRUE. In either case, the program exits the SWITCH block and goes back the top of loop() to start all over again. The return value of IRHomeToChgStn() is not actually ever used.

The next time GetOpMode() runs, if the robot is indeed connected to the charging station, GetOpMode() returns MODE_CHARGING. When this section of the SWITCH statement is executed, the motors are stopped and MonitorChargeUntilDone() is called. This function is a blocking call, and doesn’t exit until the robot is fully charged or the timeout value has been reached. When MonitorChargeUntilDone() returns, the robot backs away from the charging station, turns 90 deg, and returns to wall-following.

When looking back through the above paragraphs, it becomes clear that managing the charging process is broken into two separate but interdependent parts; GetOpMode() recognizes the conditions for entering charging and returns with MODE_CHARGING. The MODE_CHARGING section of the SWITCH block in loop() actually executes the steps required to begin charging (like stopping the motors, turning off the red laser) and the steps required to disconnect at end-of-charge.

It also becomes clear that once the MODE_CHARGING section of the SWITCH statement is entered, it stays there until MonitorChargeUntilDone() returns at end-of-charge, and the robot disconnects from the charging station. I think this means the GetOpMode() code can be significantly simplified and made much more readable. Here’s the new version of GetOpMode():

int GetOpMode(float batv) //04/28/19 added batv to sig
{
	//Purpose:  Determine operating mode based on sensor inputs
	//Inputs: none
	//Outputs: Integer denoting current op mode (CHARGING = 1, IRHOMING = 2, WALLFOLLOW = 3)
	//Plan:
	//	Step1: If batt voltage too low, return MODE_DEADBATTERY (4)
	//	Step2: If Charger is connected, return MODE_CHARGING (1)
	//	Step3: Else If IR Homing beam detected, return MODE_IRHOMING (2)
	//	Step4: Else return MODE_WALLFOLLOW (3)

	int mode = MODE_NONE; //04/27/20 added so function has only one exit point

//Step1: If batt voltage too low, return MODE_DEADBATTERY (4)
	if (batv <= DEAD_BATT_THRESH_VOLTS) mode = MODE_DEADBATTERY;

	//Step2: If Charger is connected, return MODE_CHARGING (1)
	else if (IsChargerConnected())
	{
		mode = MODE_CHARGING;
		mySerial.printf("Robot has successfully connected to charger!\n");
	}

//Step3: Else If IR Homing beam detected, return MODE_IRHOMING (2)
	else if (IsIRBeamAvail()) mode = MODE_IRHOMING; //this handles 'hungry/not-hungry' cases internally

//03/04/2020 added to facilitate battery discharge
#ifdef BATTERY_DISCHARGE
	while (GetBattVoltage() > DEAD_BATT_THRESH_VOLTS)
	{
		mode = MODE_DISCHARGE;
	}
	StopBothMotors();
	mySerial.printf("Battery Discharge Complete at %3.2f Minutes and %3.2f Volts", millis() / 60000.f, GetBattVoltage);

#else
//Step4: Else return MODE_WALLFOLLOW (3)
	else mode = MODE_WALLFOLLOW;
#endif // BATTERY_DISCHARGE

	return mode;
}

int GetOpMode(float batv) //04/28/19 added batv to sig

{

//Purpose: Determine operating mode based on sensor inputs

//Inputs: none

//Outputs: Integer denoting current op mode (CHARGING = 1, IRHOMING = 2, WALLFOLLOW = 3)

//Plan:

// Step1: If batt voltage too low, return MODE_DEADBATTERY (4)

// Step2: If Charger is connected, return MODE_CHARGING (1)

// Step3: Else If IR Homing beam detected, return MODE_IRHOMING (2)

// Step4: Else return MODE_WALLFOLLOW (3)

int mode = MODE_NONE; //04/27/20 added so function has only one exit point

//Step1: If batt voltage too low, return MODE_DEADBATTERY (4)

if (batv <= DEAD_BATT_THRESH_VOLTS) mode = MODE_DEADBATTERY;

//Step2: If Charger is connected, return MODE_CHARGING (1)

else if (IsChargerConnected())

{

mode = MODE_CHARGING;

mySerial.printf("Robot has successfully connected to charger!\n");

}

//Step3: Else If IR Homing beam detected, return MODE_IRHOMING (2)

else if (IsIRBeamAvail()) mode = MODE_IRHOMING; //this handles 'hungry/not-hungry' cases internally

//03/04/2020 added to facilitate battery discharge

#ifdef BATTERY_DISCHARGE

while (GetBattVoltage() > DEAD_BATT_THRESH_VOLTS)

{

mode = MODE_DISCHARGE;

}

StopBothMotors();

mySerial.printf("Battery Discharge Complete at %3.2f Minutes and %3.2f Volts", millis() / 60000.f, GetBattVoltage);

#else

//Step4: Else return MODE_WALLFOLLOW (3)

else mode = MODE_WALLFOLLOW;

#endif // BATTERY_DISCHARGE

return mode;

}

29 April 2020 Update – Tracking (Again):

While screwing around with the charging station code, I managed to charge Wall-E2’s battery to the point where it refuses to connect to the charging station – the ‘Not Hungry’ condition. Rather than just let it run down by running the motors on its stand, I decided to continue working on the wall-following code improvements ported over from the two wheel model.

The last time I worked on the tracking code was back on 11 April when I ported the ‘RotateToParallelOrientation()’ and ‘MakeTrackingTurn()’ functions from the two wheel robot.

For reference, here’s where ended up with the TRACKING_RIGHT case from last time:

#pragma region TRACKRIGHT
				trackstr = "Right"; //used for telemetry printouts

//DEBUG!!
				//mySerial.printf("%lu: In WALL_TRACKING_RIGHT top\n", millis());
//DEBUG!!
				//04/19/20 revised to disable stepturn detection during CAPTURE
				int stepturn_dist_cm = CurrentTrackingState == TRK_RIGHT_CAPTURE ? 0 : STEPTURN_DIST_CM;

				if (frontdistval <= MIN_OBS_DIST_CM || IsStuck(frontvar))
				{
					Serial.println("---- Backup & Turn to the Left");
					//09/19/18 bugfix - 1st param is 'nearest wall', not 'turn direction'
					BackupAndTurn(false, MOTOR_SPEED_HALF); //backup and turn 90 deg left //c/o 02/23/17 for IR Track debug

					//go back to normal tracking mode after B&T completes
					NavCase = NAV_WALLTRK;
				}

				//Step-turn Left = Tracking Right && Step && !Stuck
				//04/10/20 revised to just call new 'StepTurn()' function
				//else if (frontdistval > MIN_OBS_DIST_CM && frontdistval <= STEPTURN_DIST_CM)
				else if (frontdistval > MIN_OBS_DIST_CM && frontdistval <= stepturn_dist_cm)
				{
					//if we aren't already in Step-turn mode, start it.  Otherwise, skip
					if (NavCase != NAV_STEPTURN)
					{
						Serial.println("---- Starting Stepturn to the Left");
						StepTurn(TRACKING_RIGHT);
					}
				}

				//Wall-tracking Right = Tracking Right && Far
				else if (frontdistval > STEPTURN_DIST_CM)
				{
					NavCase = NAV_WALLTRK;

					//if first time through, rotate robot to parallel
					if (CurrentTrackingState == TRK_RIGHT_NONE) //first time through
					{
						float par_hdg = RotateToParallelOrientation(TRACKING_RIGHT, DESIRED_WALL_OFFSET_DIST_CM); //this is port of two-wheel FindParallelHgd()

						mySerial.printf("%lu: parallel heading found at %2.3f deg\n", millis(), par_hdg);
//DEBUG!!
						StopBothMotors();
						delay(2000); //04/15/20 just for debugging purposes
//DEBUG!!
						CurrentTrackingState = TRK_RIGHT_CAPTURE;
					}

					else if (CurrentTrackingState == TRK_RIGHT_CAPTURE)
					{
						//OK, still in capture mode.  Adjust heading as necessary
						//right wall is closer, so CW moves twd wall, CCW moves away

						//04/19/20 have to temporarily disable obstacle detection

						loc_disterror = loc_rightdist - DESIRED_WALL_OFFSET_DIST_CM; //pos diff is 'too far away'
						turndirection = loc_disterror > 0 ? TURNDIR_CW : TURNDIR_CCW;
						turndeg = GetTrackTurnDeg(loc_disterror, m_TrkErrWinMult);
						MakeTrackingTurn(turndirection, turndeg);
						MoveAhead(MOTOR_SPEED_HALF, MOTOR_SPEED_HALF); //added 04/21/20

						////04/17/20 new experiment; use LIDAR dist to achieve capture
						//if (rightdistval > DESIRED_WALL_OFFSET_DIST_CM)
						//{
						//	//make a 90 deg right turn, then a 90 left just before desired offset
						//	RollingTurn(false, true, 45.f);
						//	StopBothMotors();
						//	delay(2000);

						//	MoveAhead(MOTOR_SPEED_HALF, MOTOR_SPEED_HALF);
						//	int turn_threshold = 1.4 * DESIRED_WALL_OFFSET_DIST_CM ;
						//	mySerial.printf("turn threshold = %d\n", turn_threshold);
						//	while (frontdistval > turn_threshold)
						//	{
						//		frontdistval = GetFrontDistCm();
						//		mySerial.printf("Front distance = %d, threshold = %d\n", frontdistval, turn_threshold);
						//		delay(10);
						//	}

						//	//now turn back to parallel
						//	RollingTurn(true, true, 45.f);
						//	StopBothMotors();
						//	while (true)
						//	{

						//	}
							
						//}
					}
				}

				////DEBUG!!
				//				mySerial.printf("In WALL_TRACKING_RIGHT just before printout at %lu\n", millis());
				////DEBUG!!


				//PrintWallFollowTelemetry(frontvar); //added 04/15/19
#pragma endregion Tracking Right Wall Case

100

#pragma region TRACKRIGHT

trackstr = "Right"; //used for telemetry printouts

//DEBUG!!

//mySerial.printf("%lu: In WALL_TRACKING_RIGHT top\n", millis());

//DEBUG!!

//04/19/20 revised to disable stepturn detection during CAPTURE

int stepturn_dist_cm = CurrentTrackingState == TRK_RIGHT_CAPTURE ? 0 : STEPTURN_DIST_CM;

if (frontdistval <= MIN_OBS_DIST_CM || IsStuck(frontvar))

{

Serial.println("---- Backup & Turn to the Left");

//09/19/18 bugfix - 1st param is 'nearest wall', not 'turn direction'

BackupAndTurn(false, MOTOR_SPEED_HALF); //backup and turn 90 deg left //c/o 02/23/17 for IR Track debug

//go back to normal tracking mode after B&T completes

NavCase = NAV_WALLTRK;

}

//Step-turn Left = Tracking Right && Step && !Stuck

//04/10/20 revised to just call new 'StepTurn()' function

//else if (frontdistval > MIN_OBS_DIST_CM && frontdistval <= STEPTURN_DIST_CM)

else if (frontdistval > MIN_OBS_DIST_CM && frontdistval <= stepturn_dist_cm)

{

//if we aren't already in Step-turn mode, start it. Otherwise, skip

if (NavCase != NAV_STEPTURN)

{

Serial.println("---- Starting Stepturn to the Left");

StepTurn(TRACKING_RIGHT);

}

//Wall-tracking Right = Tracking Right && Far

else if (frontdistval > STEPTURN_DIST_CM)

{

NavCase = NAV_WALLTRK;

//if first time through, rotate robot to parallel

if (CurrentTrackingState == TRK_RIGHT_NONE) //first time through

{

float par_hdg = RotateToParallelOrientation(TRACKING_RIGHT, DESIRED_WALL_OFFSET_DIST_CM); //this is port of two-wheel FindParallelHgd()

mySerial.printf("%lu: parallel heading found at %2.3f deg\n", millis(), par_hdg);

//DEBUG!!

StopBothMotors();

delay(2000); //04/15/20 just for debugging purposes

//DEBUG!!

CurrentTrackingState = TRK_RIGHT_CAPTURE;

}

else if (CurrentTrackingState == TRK_RIGHT_CAPTURE)

{

//OK, still in capture mode. Adjust heading as necessary

//right wall is closer, so CW moves twd wall, CCW moves away

//04/19/20 have to temporarily disable obstacle detection

loc_disterror = loc_rightdist - DESIRED_WALL_OFFSET_DIST_CM; //pos diff is 'too far away'

turndirection = loc_disterror > 0 ? TURNDIR_CW : TURNDIR_CCW;

turndeg = GetTrackTurnDeg(loc_disterror, m_TrkErrWinMult);

MakeTrackingTurn(turndirection, turndeg);

MoveAhead(MOTOR_SPEED_HALF, MOTOR_SPEED_HALF); //added 04/21/20

////04/17/20 new experiment; use LIDAR dist to achieve capture

//if (rightdistval > DESIRED_WALL_OFFSET_DIST_CM)

//{

// //make a 90 deg right turn, then a 90 left just before desired offset

// RollingTurn(false, true, 45.f);

// StopBothMotors();

// delay(2000);

// MoveAhead(MOTOR_SPEED_HALF, MOTOR_SPEED_HALF);

// int turn_threshold = 1.4 * DESIRED_WALL_OFFSET_DIST_CM ;

// mySerial.printf("turn threshold = %d\n", turn_threshold);

// while (frontdistval > turn_threshold)

// {

// frontdistval = GetFrontDistCm();

// mySerial.printf("Front distance = %d, threshold = %d\n", frontdistval, turn_threshold);

// delay(10);

// }

// //now turn back to parallel

// RollingTurn(true, true, 45.f);

// StopBothMotors();

// while (true)

// {

// }

//}

}

////DEBUG!!

// mySerial.printf("In WALL_TRACKING_RIGHT just before printout at %lu\n", millis());

////DEBUG!!

//PrintWallFollowTelemetry(frontvar); //added 04/15/19

#pragma endregion Tracking Right Wall Case

The significant changes in the code from where I started are:

Disabled ‘Far obstacle’ detection while in ‘capture’ mode to avoid obstacle avoidance step-turns in the middle of trying to capture the desired offset distance
When a ‘far obstacle’ IS detected, the StepTurn() function is now called immediately, rather than just starting the turn and letting it play out over multiple passes through the loop. This is now possible due to having accurate relative heading information, and is a huge improvement over the old timed-turn method.
Tried, and then abandoned the idea of using the front LIDAR measurement to directly acquire the desired offset distance by turning 45 deg from parallel, driving until the front distance was sqrt(2) (1.414) times the desired distance, and then turning back to parallel. This failed miserably because the robot’s turning radius is WAY too large to make this work.
ported the offset capture/maintenance code directly from the two wheel robot.

So, now the capture/maintenance code in the four whee robot looks like this

else if (CurrentTrackingState == TRK_RIGHT_CAPTURE)
{
	//OK, still in capture mode.  Adjust heading as necessary
	//right wall is closer, so CW moves twd wall, CCW moves away

	loc_disterror = loc_rightdist - DESIRED_WALL_OFFSET_DIST_CM; //pos diff is 'too far away'
	turndirection = loc_disterror > 0 ? TURNDIR_CW : TURNDIR_CCW;
	turndeg = GetTrackTurnDeg(loc_disterror, m_TrkErrWinMult);
	MakeTrackingTurn(turndirection, turndeg);
	MoveAhead(MOTOR_SPEED_HALF, MOTOR_SPEED_HALF); //added 04/21/20
}

else if (CurrentTrackingState == TRK_RIGHT_CAPTURE)

{

//OK, still in capture mode. Adjust heading as necessary

//right wall is closer, so CW moves twd wall, CCW moves away

loc_disterror = loc_rightdist - DESIRED_WALL_OFFSET_DIST_CM; //pos diff is 'too far away'

turndirection = loc_disterror > 0 ? TURNDIR_CW : TURNDIR_CCW;

turndeg = GetTrackTurnDeg(loc_disterror, m_TrkErrWinMult);

MakeTrackingTurn(turndirection, turndeg);

MoveAhead(MOTOR_SPEED_HALF, MOTOR_SPEED_HALF); //added 04/21/20

}

I ran a couple of trials in my ‘local’ (office) test range and they looked promising, so I tried a test in my ‘field’ (hallway outside my office) range, with very good results. Starting from about 75 cm out from the right wall and oriented slightly toward the wall, the robot tracked into the 30 cm desired offset and then maintained that offset to the end of the hallway. Interesting, it also attempted a ‘step-turn’ obstacle avoidance maneuver at the end, as shown in the following video:

Here is the relevant telemetry output from this run.

OpMode = Wall Following
Left/Right Avg Dist = 98/68
2585: In MODE_WALLFOLLOW  with Tracking Case = Right
3175: parallel heading found at 30.984 deg
OpMode = Wall Following
Left/Right Avg Dist = 104/72
5222: In MODE_WALLFOLLOW  with Tracking Case = Right
turndeg > m_PrevHdgCutDeg; Increasing Cut
In RollingTurn(CW, FWD,10.00)
5399: frontdistval = 354
OpMode = Wall Following
Left/Right Avg Dist = 91/71
5415: In MODE_WALLFOLLOW  with Tracking Case = Right
turndeg > m_PrevHdgCutDeg; Increasing Cut
In RollingTurn(CW, FWD,10.00)
5591: frontdistval = 354
OpMode = Wall Following
Left/Right Avg Dist = 91/70
5607: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 71/69, slope = -2	tgtdist = 30
IsConverging reports TRUE
5635: frontdistval = 354
OpMode = Wall Following
Left/Right Avg Dist = 93/69
5651: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 70/69, slope = -1	tgtdist = 30
IsConverging reports TRUE
5680: frontdistval = 353
OpMode = Wall Following
Left/Right Avg Dist = 94/68
5696: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 69/68, slope = -1	tgtdist = 30
IsConverging reports TRUE
5722: frontdistval = 353
OpMode = Wall Following
Left/Right Avg Dist = 96/68
5737: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 69/68, slope = -1	tgtdist = 30
IsConverging reports TRUE
5762: frontdistval = 349
OpMode = Wall Following
Left/Right Avg Dist = 97/68
5778: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 68/68, slope = 0	tgtdist = 30
IsConverging reports FALSE
not converging - increasing cut
In RollingTurn(CW, FWD,10.00)
6041: frontdistval = 221
OpMode = Wall Following
Left/Right Avg Dist = 131/67
6057: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 68/65, slope = -3	tgtdist = 30
IsConverging reports TRUE
Converging with turndeg 20 & PrevCut 30. Reducing Cut
In RollingTurn(CCW, FWD,10.00)
6479: frontdistval = 318
OpMode = Wall Following
Left/Right Avg Dist = 165/64
6495: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 68/59, slope = -9	tgtdist = 30
IsConverging reports TRUE
6518: frontdistval = 315
OpMode = Wall Following
Left/Right Avg Dist = 200/60
6535: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 65/58, slope = -7	tgtdist = 30
IsConverging reports TRUE
6557: frontdistval = 315
OpMode = Wall Following
Left/Right Avg Dist = 200/58
6574: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 59/58, slope = -1	tgtdist = 30
IsConverging reports TRUE
6596: frontdistval = 313
OpMode = Wall Following
Left/Right Avg Dist = 200/57
6611: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 58/57, slope = -1	tgtdist = 30
IsConverging reports TRUE
6635: frontdistval = 311
OpMode = Wall Following
Left/Right Avg Dist = 200/57
6693: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 57/57, slope = 0	tgtdist = 30
IsConverging reports FALSE
not converging - increasing cut
In RollingTurn(CW, FWD,10.00)
OpMode = Wall Following
Left/Right Avg Dist = 200/55
7017: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 57/53, slope = -4	tgtdist = 30
IsConverging reports TRUE
Converging with turndeg 20 & PrevCut 30. Reducing Cut
In RollingTurn(CCW, FWD,10.00)
OpMode = Wall Following
Left/Right Avg Dist = 200/52
7397: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 57/48, slope = -9	tgtdist = 30
IsConverging reports TRUE
7424: frontdistval = 276
OpMode = Wall Following
Left/Right Avg Dist = 200/49
7439: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 53/48, slope = -5	tgtdist = 30
IsConverging reports TRUE
OpMode = Wall Following
Left/Right Avg Dist = 200/47
7476: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 48/47, slope = -1	tgtdist = 30
IsConverging reports TRUE
7497: frontdistval = 274
OpMode = Wall Following
Left/Right Avg Dist = 200/47
7513: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 48/47, slope = -1	tgtdist = 30
IsConverging reports TRUE
7536: frontdistval = 273
OpMode = Wall Following
Left/Right Avg Dist = 200/47
7552: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 47/47, slope = 0	tgtdist = 30
IsConverging reports FALSE
not converging - increasing cut
In RollingTurn(CW, FWD,10.00)
7852: frontdistval = 160
OpMode = Wall Following
Left/Right Avg Dist = 200/46
7867: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 47/44, slope = -3	tgtdist = 30
IsConverging reports TRUE
Converging with turndeg 20 & PrevCut 30. Reducing Cut
In RollingTurn(CCW, FWD,10.00)
8290: frontdistval = 235
OpMode = Wall Following
Left/Right Avg Dist = 200/42
8304: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 47/37, slope = -10	tgtdist = 30
IsConverging reports TRUE
Converging with turndeg 10 & PrevCut 20. Reducing Cut
In RollingTurn(CCW, FWD,10.00)
8713: frontdistval = 222
OpMode = Wall Following
Left/Right Avg Dist = 200/38
8727: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 44/34, slope = -10	tgtdist = 30
IsConverging reports TRUE
Converging with turndeg 5 & PrevCut 10. Reducing Cut
In RollingTurn(CCW, FWD,10.00)
9132: frontdistval = 202
OpMode = Wall Following
Left/Right Avg Dist = 200/35
9146: In MODE_WALLFOLLOW  with Tracking Case = Right
turndeg > m_PrevHdgCutDeg; Increasing Cut
In RollingTurn(CW, FWD,10.00)
9405: frontdistval = 193
OpMode = Wall Following
Left/Right Avg Dist = 200/33
9419: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 34/33, slope = -1	tgtdist = 30
IsConverging reports TRUE
9445: frontdistval = 192
OpMode = Wall Following
Left/Right Avg Dist = 200/33
9459: In MODE_WALLFOLLOW  with Tracking Case = Right
IsConverging:  firstd/lastd = 34/34, slope = 0	tgtdist = 30
IsConverging reports FALSE
not converging - increasing cut
In RollingTurn(CW, FWD,10.00)
9764: frontdistval = 182
OpMode = Wall Following
Left/Right Avg Dist = 200/32
9779: In MODE_WALLFOLLOW  with Tracking Case = Right
turndeg = 0; Removing Entire Cut
In RollingTurn(CCW, FWD,20.00)
10454: frontdistval = 151
OpMode = Wall Following
Left/Right Avg Dist = 200/30
10468: In MODE_WALLFOLLOW  with Tracking Case = Right
turndeg > m_PrevHdgCutDeg; Increasing Cut
In RollingTurn(CCW, FWD,10.00)
10766: frontdistval = 138
OpMode = Wall Following
Left/Right Avg Dist = 200/29
10780: In MODE_WALLFOLLOW  with Tracking Case = Right
turndeg = 0; Removing Entire Cut
In RollingTurn(CW, FWD,10.00)
11036: frontdistval = 124
OpMode = Wall Following
Left/Right Avg Dist = 200/29
11051: In MODE_WALLFOLLOW  with Tracking Case = Right
turndeg = 0; Removing Entire Cut
11065: frontdistval = 124
OpMode = Wall Following
Left/Right Avg Dist = 200/30
11079: In MODE_WALLFOLLOW  with Tracking Case = Right
turndeg = 0; Removing Entire Cut
11095: frontdistval = 122
OpMode = Wall Following
Left/Right Avg Dist = 200/31
11109: In MODE_WALLFOLLOW  with Tracking Case = Right
turndeg = 0; Removing Entire Cut
11124: frontdistval = 120
OpMode = Wall Following
Left/Right Avg Dist = 200/31
11139: In MODE_WALLFOLLOW  with Tracking Case = Right
turndeg = 0; Removing Entire Cut
11154: frontdistval = 120
OpMode = Wall Following
Left/Right Avg Dist = 159/31
11168: In MODE_WALLFOLLOW  with Tracking Case = Right
turndeg = 0; Removing Entire Cut
11183: frontdistval = 118
OpMode = Wall Following
Left/Right Avg Dist = 159/31
11197: In MODE_WALLFOLLOW  with Tracking Case = Right
turndeg = 0; Removing Entire Cut
11212: frontdistval = 116
OpMode = Wall Following
Left/Right Avg Dist = 119/31
11227: In MODE_WALLFOLLOW  with Tracking Case = Right
turndeg = 0; Removing Entire Cut
11241: frontdistval = 115
OpMode = Wall Following
Left/Right Avg Dist = 118/31
11256: In MODE_WALLFOLLOW  with Tracking Case = Right
turndeg = 0; Removing Entire Cut
11271: frontdistval = 114
OpMode = Wall Following
Left/Right Avg Dist = 118/31
11285: In MODE_WALLFOLLOW  with Tracking Case = Right
turndeg = 0; Removing Entire Cut
11299: frontdistval = 111

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

OpMode = Wall Following

Left/Right Avg Dist = 98/68

2585: In MODE_WALLFOLLOW with Tracking Case = Right

3175: parallel heading found at 30.984 deg

OpMode = Wall Following

Left/Right Avg Dist = 104/72

5222: In MODE_WALLFOLLOW with Tracking Case = Right

turndeg > m_PrevHdgCutDeg; Increasing Cut

In RollingTurn(CW, FWD,10.00)

5399: frontdistval = 354

OpMode = Wall Following

Left/Right Avg Dist = 91/71

5415: In MODE_WALLFOLLOW with Tracking Case = Right

turndeg > m_PrevHdgCutDeg; Increasing Cut

In RollingTurn(CW, FWD,10.00)

5591: frontdistval = 354

OpMode = Wall Following

Left/Right Avg Dist = 91/70

5607: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 71/69, slope = -2 tgtdist = 30

IsConverging reports TRUE

5635: frontdistval = 354

OpMode = Wall Following

Left/Right Avg Dist = 93/69

5651: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 70/69, slope = -1 tgtdist = 30

IsConverging reports TRUE

5680: frontdistval = 353

OpMode = Wall Following

Left/Right Avg Dist = 94/68

5696: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 69/68, slope = -1 tgtdist = 30

IsConverging reports TRUE

5722: frontdistval = 353

OpMode = Wall Following

Left/Right Avg Dist = 96/68

5737: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 69/68, slope = -1 tgtdist = 30

IsConverging reports TRUE

5762: frontdistval = 349

OpMode = Wall Following

Left/Right Avg Dist = 97/68

5778: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 68/68, slope = 0 tgtdist = 30

IsConverging reports FALSE

not converging - increasing cut

In RollingTurn(CW, FWD,10.00)

6041: frontdistval = 221

OpMode = Wall Following

Left/Right Avg Dist = 131/67

6057: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 68/65, slope = -3 tgtdist = 30

IsConverging reports TRUE

Converging with turndeg 20 & PrevCut 30. Reducing Cut

In RollingTurn(CCW, FWD,10.00)

6479: frontdistval = 318

OpMode = Wall Following

Left/Right Avg Dist = 165/64

6495: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 68/59, slope = -9 tgtdist = 30

IsConverging reports TRUE

6518: frontdistval = 315

OpMode = Wall Following

Left/Right Avg Dist = 200/60

6535: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 65/58, slope = -7 tgtdist = 30

IsConverging reports TRUE

6557: frontdistval = 315

OpMode = Wall Following

Left/Right Avg Dist = 200/58

6574: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 59/58, slope = -1 tgtdist = 30

IsConverging reports TRUE

6596: frontdistval = 313

OpMode = Wall Following

Left/Right Avg Dist = 200/57

6611: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 58/57, slope = -1 tgtdist = 30

IsConverging reports TRUE

6635: frontdistval = 311

OpMode = Wall Following

Left/Right Avg Dist = 200/57

6693: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 57/57, slope = 0 tgtdist = 30

IsConverging reports FALSE

not converging - increasing cut

In RollingTurn(CW, FWD,10.00)

OpMode = Wall Following

Left/Right Avg Dist = 200/55

7017: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 57/53, slope = -4 tgtdist = 30

IsConverging reports TRUE

Converging with turndeg 20 & PrevCut 30. Reducing Cut

In RollingTurn(CCW, FWD,10.00)

OpMode = Wall Following

Left/Right Avg Dist = 200/52

7397: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 57/48, slope = -9 tgtdist = 30

IsConverging reports TRUE

7424: frontdistval = 276

OpMode = Wall Following

Left/Right Avg Dist = 200/49

7439: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 53/48, slope = -5 tgtdist = 30

IsConverging reports TRUE

OpMode = Wall Following

Left/Right Avg Dist = 200/47

7476: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 48/47, slope = -1 tgtdist = 30

IsConverging reports TRUE

7497: frontdistval = 274

OpMode = Wall Following

Left/Right Avg Dist = 200/47

7513: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 48/47, slope = -1 tgtdist = 30

IsConverging reports TRUE

7536: frontdistval = 273

OpMode = Wall Following

Left/Right Avg Dist = 200/47

7552: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 47/47, slope = 0 tgtdist = 30

IsConverging reports FALSE

not converging - increasing cut

In RollingTurn(CW, FWD,10.00)

7852: frontdistval = 160

OpMode = Wall Following

Left/Right Avg Dist = 200/46

7867: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 47/44, slope = -3 tgtdist = 30

IsConverging reports TRUE

Converging with turndeg 20 & PrevCut 30. Reducing Cut

In RollingTurn(CCW, FWD,10.00)

8290: frontdistval = 235

OpMode = Wall Following

Left/Right Avg Dist = 200/42

8304: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 47/37, slope = -10 tgtdist = 30

IsConverging reports TRUE

Converging with turndeg 10 & PrevCut 20. Reducing Cut

In RollingTurn(CCW, FWD,10.00)

8713: frontdistval = 222

OpMode = Wall Following

Left/Right Avg Dist = 200/38

8727: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 44/34, slope = -10 tgtdist = 30

IsConverging reports TRUE

Converging with turndeg 5 & PrevCut 10. Reducing Cut

In RollingTurn(CCW, FWD,10.00)

9132: frontdistval = 202

OpMode = Wall Following

Left/Right Avg Dist = 200/35

9146: In MODE_WALLFOLLOW with Tracking Case = Right

turndeg > m_PrevHdgCutDeg; Increasing Cut

In RollingTurn(CW, FWD,10.00)

9405: frontdistval = 193

OpMode = Wall Following

Left/Right Avg Dist = 200/33

9419: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 34/33, slope = -1 tgtdist = 30

IsConverging reports TRUE

9445: frontdistval = 192

OpMode = Wall Following

Left/Right Avg Dist = 200/33

9459: In MODE_WALLFOLLOW with Tracking Case = Right

IsConverging: firstd/lastd = 34/34, slope = 0 tgtdist = 30

IsConverging reports FALSE

not converging - increasing cut

In RollingTurn(CW, FWD,10.00)

9764: frontdistval = 182

OpMode = Wall Following

Left/Right Avg Dist = 200/32

9779: In MODE_WALLFOLLOW with Tracking Case = Right

turndeg = 0; Removing Entire Cut

In RollingTurn(CCW, FWD,20.00)

10454: frontdistval = 151

OpMode = Wall Following

Left/Right Avg Dist = 200/30

10468: In MODE_WALLFOLLOW with Tracking Case = Right

turndeg > m_PrevHdgCutDeg; Increasing Cut

In RollingTurn(CCW, FWD,10.00)

10766: frontdistval = 138

OpMode = Wall Following

Left/Right Avg Dist = 200/29

10780: In MODE_WALLFOLLOW with Tracking Case = Right

turndeg = 0; Removing Entire Cut

In RollingTurn(CW, FWD,10.00)

11036: frontdistval = 124

OpMode = Wall Following

Left/Right Avg Dist = 200/29

11051: In MODE_WALLFOLLOW with Tracking Case = Right

turndeg = 0; Removing Entire Cut

11065: frontdistval = 124

OpMode = Wall Following

Left/Right Avg Dist = 200/30

11079: In MODE_WALLFOLLOW with Tracking Case = Right

turndeg = 0; Removing Entire Cut

11095: frontdistval = 122

OpMode = Wall Following

Left/Right Avg Dist = 200/31

11109: In MODE_WALLFOLLOW with Tracking Case = Right

turndeg = 0; Removing Entire Cut

11124: frontdistval = 120

OpMode = Wall Following

Left/Right Avg Dist = 200/31

11139: In MODE_WALLFOLLOW with Tracking Case = Right

turndeg = 0; Removing Entire Cut

11154: frontdistval = 120

OpMode = Wall Following

Left/Right Avg Dist = 159/31

11168: In MODE_WALLFOLLOW with Tracking Case = Right

turndeg = 0; Removing Entire Cut

11183: frontdistval = 118

OpMode = Wall Following

Left/Right Avg Dist = 159/31

11197: In MODE_WALLFOLLOW with Tracking Case = Right

turndeg = 0; Removing Entire Cut

11212: frontdistval = 116

OpMode = Wall Following

Left/Right Avg Dist = 119/31

11227: In MODE_WALLFOLLOW with Tracking Case = Right

turndeg = 0; Removing Entire Cut

11241: frontdistval = 115

OpMode = Wall Following

Left/Right Avg Dist = 118/31

11256: In MODE_WALLFOLLOW with Tracking Case = Right

turndeg = 0; Removing Entire Cut

11271: frontdistval = 114

OpMode = Wall Following

Left/Right Avg Dist = 118/31

11285: In MODE_WALLFOLLOW with Tracking Case = Right

turndeg = 0; Removing Entire Cut

11299: frontdistval = 111

From the above telemetry and video it is clear the robot was successful in capturing and maintaining the desired wall offset. Salient points are (leading numbers denote mSec from start):

parallel heading found at 30.984 deg – very close, and very efficient
Left/Right Avg Dist = 104/72. So the robot started out with a 40 cm error
5522: In RollingTurn(CW, FWD,10.00). The capture process started with two quick 10-deg CW turns toward the right wall.
5778: After about 6 times through the loop, the ‘cut’ is increased another 10 deg toward the right wall.
6057: Cut reduced by 10 deg with distance to wall = 64 cm
6693: Cut increased by 10 deg with distance = 57 cm
7017: Cut reduced by 10 deg with distance to wall = 55 cm
7536: Cut increased by 10 deg with distance = 47 cm
7867: Cut reduced by 10 deg with distance to wall = 46 cm
8304: Cut reduced by 10 deg with distance to wall = 42 cm
8727: Cut reduced by 10 deg with distance to wall = 34 cm

So, it only took about 3 seconds after the initial ‘find parallel’ maneuver to close from 72 to 34 cm and to remove the entire initial ‘cut’ of 20 degrees. Pretty successful, I would say!

30 April 2020 Update:

After the above successful test, I tried a wall-tracking run with the robot initially oriented slightly away from the wall, and this was a dismal failure. Looking through the code, I became convinced that the algorithm as currently implemented will never work for the ‘away from wall case’, so now I’m busily rewriting the whole thing so it will work for both cases.

After a couple false starts, I think I now have a working ‘turn to parallel’ algorithm that works for both the ‘toward wall’ and ‘away from wall’ starting orientations. Here’s a couple of video clips showing the operation. For purposes of this demonstration, I added short (1 sec) pauses between each step in the ‘find parallel’ operation so they can be easily identified in the video. In actual operation each step should flow smoothly into the next one.

Here’s the code for the newly re-written ‘RotateToParallelOrientation()’:

bool RotateToParallelOrientation(int trkcase, int tgtdist)
{
	//Purpose:  Rotate robot to parallel near wall
	//Inputs: 
	//	TrackingCase = int representing current WallTrackingCases enum value
	//	tgtdist = int value representing the desired wall offset
	//Outputs:
	//	Robot orientation changed to parallel nearest wall
	//Plan:
	//Step1: Start turn away from wall.  If the distance decreases, continue the turn until it 
	//	starts going up again, and record the associated heading value.
	//Step2: Reverse the turn and wait for the distance to 
	//	go down and then back up. If the heading value associated with this inflection point and 
	//	the previous inflection point are close, return TRUE
	//Step3: If the values from Step1 & Step2 aren't close enough, reverse the turn again and 
	//	find a new inflection point.  If the resulting heading is close enough to the Step1 or
	//	Step2 values, return TRUE.  Otherwise, return FALSE
	//Notes:
	//	04/11/20 Copied from two wheel robot's FindParallelHdg() & revised
	//	04/29/20 rewritten to handle away-from-wall starting orientation

	bool bTrackingRight = true;
	bool bFirstTurnDirection = TURNDIR_CCW;
	float first_par_hdg_deg = 999; //impossible value
	float second_par_hdg_deg = 999; //impossible value
	int success_count = 0;
	bool bResult = true;


//DEBUG!!
	mySerial.printf("In RotateToParallelOrientation(Tracking %s,%d)\n", TrkStrArray[TrackingCase], tgtdist);
	mySerial.printf("mSec\tmeas#\tHdg\tPrevD\tCurD\n");
//DEBUG!!

	if ((WallTrackingCases)trkcase == TRACKING_RIGHT)
	{
		//newdist = GetRightDistCm();
		bTrackingRight = true;
		bFirstTurnDirection = TURNDIR_CCW;
	}
	else if ((WallTrackingCases)trkcase == TRACKING_LEFT)
	{
		//newdist = GetLeftDistCm();
		bTrackingRight = false;
		bFirstTurnDirection = TURNDIR_CW;
	}
	else
	{
		mySerial.printf("Error determining tracking side in RotateToParallelOrientation(Tracking %s,%d)\n",
			TrkStrArray[TrackingCase]);
	}

//Step1: Start turn away from wall.  If the distance decreases, continue the turn until it 
//	starts going up again, and record the associated heading value.

	bool bInflectionPointFound = FindInflectionPoint(bFirstTurnDirection, bTrackingRight);
	if (bInflectionPointFound)
	{
		//success - save heading for comparison with verification run
		first_par_hdg_deg = IMUHdgValDeg ; //save the latest heading from IMU
		success_count++;
		mySerial.printf("Step1: Infection point found at %3.2f deg\n", first_par_hdg_deg);
	}
	else
	{
		mySerial.printf("FindInflectionPoint(%s) failed!", bFirstTurnDirection ? "CCW" : "CW");
		first_par_hdg_deg = 999; //impossible value
	}

//DEBUG!!
	StopBothMotors();
	delay(1000);
//DEBUG!!

//Step2: Reverse the turn and wait for the distance to 
//	go down and then back up. If the heading value associated with this inflection point and 
//	the previous inflection point are close, return TRUE

	bInflectionPointFound = FindInflectionPoint(!bFirstTurnDirection, bTrackingRight);

//DEBUG!!
	StopBothMotors();
	delay(1000);
//DEBUG!!

	if (bInflectionPointFound)
	{
		//success - compare heading with one from Step1:
		success_count++;
		mySerial.printf("Step2: Inflection point found at %3.2f deg\n", IMUHdgValDeg);

		if (success_count >= 2)
		{
			//compare current inflection hdg with prev one; if close enough, we're done
			//otherwise, try again
			if (abs(first_par_hdg_deg - IMUHdgValDeg) < 10.f)
			{
				mySerial.printf("Step2: 2nd inflection point at %3.2f deg matches to within 10 deg of 1st point %3.2f\n",
					IMUHdgValDeg, first_par_hdg_deg);
				bResult = true; //sucess!
			}
			else
			{
				//Step3: If the values from Step1 & Step2 aren't close enough, reverse the turn again and 
				//	find a new inflection point.  If the resulting heading is close enough to the Step1 or
				//	Step2 values, return TRUE.  Otherwise, return FALSE
				second_par_hdg_deg = IMUHdgValDeg;
				bInflectionPointFound = FindInflectionPoint(bFirstTurnDirection, bTrackingRight);

				//DEBUG!!
				StopBothMotors();
				delay(1000);
				//DEBUG!!

				if (bInflectionPointFound)
				{
					success_count++;
					if (success_count >= 2)
					{
						//compare current inflection hdg with prev one; if close enough, we're done
						//otherwise, try again
						if (abs(first_par_hdg_deg - IMUHdgValDeg) < 10.f || abs(second_par_hdg_deg - IMUHdgValDeg) < 10.f)
						{
							mySerial.printf("Step4: 2nd inflection point at %3.2f deg matches with 1st point %3.2f or second point %3.2f\n",
								IMUHdgValDeg, first_par_hdg_deg, second_par_hdg_deg);
							bResult = true; //sucess!
						}
					}
					else
					{
						mySerial.printf("Step4: Failed to find second matching inflection point - punting\n");
						bResult = false;
					}
				}
				else
				{
					mySerial.printf("Step4: Failed to find second inflection point - punting\n");
					bResult = false;
				}
			}
		}

	}
	else
	{
		mySerial.printf("Step1: FindInflectionPoint(%s) failed!", bFirstTurnDirection ? "CCW" : "CW");
		bResult = false;
	}

	return bResult;
}

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

bool RotateToParallelOrientation(int trkcase, int tgtdist)

{

//Purpose: Rotate robot to parallel near wall

//Inputs:

// TrackingCase = int representing current WallTrackingCases enum value

// tgtdist = int value representing the desired wall offset

//Outputs:

// Robot orientation changed to parallel nearest wall

//Plan:

//Step1: Start turn away from wall. If the distance decreases, continue the turn until it

// starts going up again, and record the associated heading value.

//Step2: Reverse the turn and wait for the distance to

// go down and then back up. If the heading value associated with this inflection point and

// the previous inflection point are close, return TRUE

//Step3: If the values from Step1 & Step2 aren't close enough, reverse the turn again and

// find a new inflection point. If the resulting heading is close enough to the Step1 or

// Step2 values, return TRUE. Otherwise, return FALSE

//Notes:

// 04/11/20 Copied from two wheel robot's FindParallelHdg() & revised

// 04/29/20 rewritten to handle away-from-wall starting orientation

bool bTrackingRight = true;

bool bFirstTurnDirection = TURNDIR_CCW;

float first_par_hdg_deg = 999; //impossible value

float second_par_hdg_deg = 999; //impossible value

int success_count = 0;

bool bResult = true;

//DEBUG!!

mySerial.printf("In RotateToParallelOrientation(Tracking %s,%d)\n", TrkStrArray[TrackingCase], tgtdist);

mySerial.printf("mSec\tmeas#\tHdg\tPrevD\tCurD\n");

//DEBUG!!

if ((WallTrackingCases)trkcase == TRACKING_RIGHT)

{

//newdist = GetRightDistCm();

bTrackingRight = true;

bFirstTurnDirection = TURNDIR_CCW;

}

else if ((WallTrackingCases)trkcase == TRACKING_LEFT)

{

//newdist = GetLeftDistCm();

bTrackingRight = false;

bFirstTurnDirection = TURNDIR_CW;

}

else

{

mySerial.printf("Error determining tracking side in RotateToParallelOrientation(Tracking %s,%d)\n",

TrkStrArray[TrackingCase]);

}

//Step1: Start turn away from wall. If the distance decreases, continue the turn until it

// starts going up again, and record the associated heading value.

bool bInflectionPointFound = FindInflectionPoint(bFirstTurnDirection, bTrackingRight);

if (bInflectionPointFound)

{

//success - save heading for comparison with verification run

first_par_hdg_deg = IMUHdgValDeg ; //save the latest heading from IMU

success_count++;

mySerial.printf("Step1: Infection point found at %3.2f deg\n", first_par_hdg_deg);

}

else

{

mySerial.printf("FindInflectionPoint(%s) failed!", bFirstTurnDirection ? "CCW" : "CW");

first_par_hdg_deg = 999; //impossible value

}

//DEBUG!!

StopBothMotors();

delay(1000);

//DEBUG!!

//Step2: Reverse the turn and wait for the distance to

// go down and then back up. If the heading value associated with this inflection point and

// the previous inflection point are close, return TRUE

bInflectionPointFound = FindInflectionPoint(!bFirstTurnDirection, bTrackingRight);

//DEBUG!!

StopBothMotors();

delay(1000);

//DEBUG!!

if (bInflectionPointFound)

{

//success - compare heading with one from Step1:

success_count++;

mySerial.printf("Step2: Inflection point found at %3.2f deg\n", IMUHdgValDeg);

if (success_count >= 2)

{

//compare current inflection hdg with prev one; if close enough, we're done

//otherwise, try again

if (abs(first_par_hdg_deg - IMUHdgValDeg) < 10.f)

{

mySerial.printf("Step2: 2nd inflection point at %3.2f deg matches to within 10 deg of 1st point %3.2f\n",

IMUHdgValDeg, first_par_hdg_deg);

bResult = true; //sucess!

}

else

{

//Step3: If the values from Step1 & Step2 aren't close enough, reverse the turn again and

// find a new inflection point. If the resulting heading is close enough to the Step1 or

// Step2 values, return TRUE. Otherwise, return FALSE

second_par_hdg_deg = IMUHdgValDeg;

bInflectionPointFound = FindInflectionPoint(bFirstTurnDirection, bTrackingRight);

//DEBUG!!

StopBothMotors();

delay(1000);

//DEBUG!!

if (bInflectionPointFound)

{

success_count++;

if (success_count >= 2)

{

//compare current inflection hdg with prev one; if close enough, we're done

//otherwise, try again

if (abs(first_par_hdg_deg - IMUHdgValDeg) < 10.f || abs(second_par_hdg_deg - IMUHdgValDeg) < 10.f)

{

mySerial.printf("Step4: 2nd inflection point at %3.2f deg matches with 1st point %3.2f or second point %3.2f\n",

IMUHdgValDeg, first_par_hdg_deg, second_par_hdg_deg);

bResult = true; //sucess!

}

else

{

mySerial.printf("Step4: Failed to find second matching inflection point - punting\n");

bResult = false;

}

else

{

mySerial.printf("Step4: Failed to find second inflection point - punting\n");

bResult = false;

}

else

{

mySerial.printf("Step1: FindInflectionPoint(%s) failed!", bFirstTurnDirection ? "CCW" : "CW");

bResult = false;

}

return bResult;

}

In the above code, the actual inflection point detection routine was abstracted into its own function ‘FindInflectionPoint()’ as shown below:

bool FindInflectionPoint(bool turndir, bool bTrackingRight)
{
	int measurenum = 0;
	int hitnum = 0; //number of times inflection has been detected
	float InflectionHdgArray[3];
	int prevdist, prevmindist = 0;
	int offsidespeed, drivesidespeed = 0;
	bool bFirstTurnDirection = TURNDIR_CCW;

	bool bResult = true;

	int newdist = GetNearWallDistCm(bTrackingRight);
	prevmindist = newdist;


	if (turndir == TURNDIR_CCW)
	{
		//Start CCW turn (away from right wall)
		mySerial.printf("starting CCW turn (away from right wall)\n");
		MoveAhead(OFFSIDE_MOTOR_SPEED, DRIVESIDE_MOTOR_SPEED_HIGH);
	}
	else
	{
		//Start CW turn (away from left wall)
		mySerial.printf("starting CW turn (toward from left wall)\n");
		MoveAhead(DRIVESIDE_MOTOR_SPEED_HIGH, OFFSIDE_MOTOR_SPEED);
	}


	while (hitnum < MIN_COUNTS_PAST_INFLECTION_POINT && measurenum < MAX_INFLECTION_POINT_TRIALS)//waiting for well-defined inflection
	{
		measurenum++;
		UpdateIMUHdgValDeg();

		if (newdist < prevmindist)
		{
			prevmindist = newdist;
		}
		newdist = GetNearWallDistCm(bTrackingRight);

		if (newdist >= prevmindist)
		{
			InflectionHdgArray[hitnum] = IMUHdgValDeg;
			hitnum++;
		}
		else
		{
			//02/26/20 - rev to just decrement hit count rather than completely resetting 
			hitnum = (hitnum > INFLECTION_DETECTION_COUNT_DECREMENT) ?
				hitnum - INFLECTION_DETECTION_COUNT_DECREMENT : 0; //adj hit counter
		}

		//DEBUG!!
		mySerial.printf("%lu\t%d\t%3.2f\t%d\t%d\t%d\n", millis(),
			measurenum, IMUHdgValDeg, prevmindist, newdist, hitnum);
		//DEBUG!!
	}

	//04/29/20 at this point, we either have detected an inflection point, or something is wrong
	if (measurenum >= MAX_INFLECTION_POINT_TRIALS)
	{
		//oops - something went wrong 
		mySerial.printf("Step2: too many trials without inflection point! measurenum = %d, hitnum = %d\n", measurenum, hitnum);
		bResult = false;
	}

	return bResult;
}

bool FindInflectionPoint(bool turndir, bool bTrackingRight)

{

int measurenum = 0;

int hitnum = 0; //number of times inflection has been detected

float InflectionHdgArray[3];

int prevdist, prevmindist = 0;

int offsidespeed, drivesidespeed = 0;

bool bFirstTurnDirection = TURNDIR_CCW;

bool bResult = true;

int newdist = GetNearWallDistCm(bTrackingRight);

prevmindist = newdist;

if (turndir == TURNDIR_CCW)

{

//Start CCW turn (away from right wall)

mySerial.printf("starting CCW turn (away from right wall)\n");

MoveAhead(OFFSIDE_MOTOR_SPEED, DRIVESIDE_MOTOR_SPEED_HIGH);

}

else

{

//Start CW turn (away from left wall)

mySerial.printf("starting CW turn (toward from left wall)\n");

MoveAhead(DRIVESIDE_MOTOR_SPEED_HIGH, OFFSIDE_MOTOR_SPEED);

}

while (hitnum < MIN_COUNTS_PAST_INFLECTION_POINT && measurenum < MAX_INFLECTION_POINT_TRIALS)//waiting for well-defined inflection

{

measurenum++;

UpdateIMUHdgValDeg();

if (newdist < prevmindist)

{

prevmindist = newdist;

}

newdist = GetNearWallDistCm(bTrackingRight);

if (newdist >= prevmindist)

{

InflectionHdgArray[hitnum] = IMUHdgValDeg;

hitnum++;

}

else

{

//02/26/20 - rev to just decrement hit count rather than completely resetting

hitnum = (hitnum > INFLECTION_DETECTION_COUNT_DECREMENT) ?

hitnum - INFLECTION_DETECTION_COUNT_DECREMENT : 0; //adj hit counter

}

//DEBUG!!

mySerial.printf("%lu\t%d\t%3.2f\t%d\t%d\t%d\n", millis(),

measurenum, IMUHdgValDeg, prevmindist, newdist, hitnum);

//DEBUG!!

}

//04/29/20 at this point, we either have detected an inflection point, or something is wrong

if (measurenum >= MAX_INFLECTION_POINT_TRIALS)

{

//oops - something went wrong

mySerial.printf("Step2: too many trials without inflection point! measurenum = %d, hitnum = %d\n", measurenum, hitnum);

bResult = false;

}

return bResult;

}

At this point I think I have the wall-tracking case completely solved for the right-hand wall tracking case. Now I have to port the algorithm to the left-hand wall and ‘neither wall’ tracking cases and make sure it all works. But for now I’m pretty happy.

1 May 2020 Update: Obstacle Avoidance

Happy May Day! In Ohio USA we have now been in ‘lockdown for two entire months – All of March and all of April. According to our governor, we may be able to go out and play at least a little bit in the coming month – yay!

At the end of both the last two videos of successful ‘RotateToParallelOrientation()’ runs, the robot gets close to the end of the hallway and attempts a left/right step-turn maneuver, ending with its nose against the far wall. The maneuver occurs way too close to the obstacle to do any good as a ‘in-line obstacle’ avoidance maneuver; at this distance, a 90 degree turn to follow the new wall would be a better deal.

When I looked into the telemetry log to determine what happened, I discovered the late step-turn was a consequence of an earlier decision to significantly shorten the ‘far obstacle’ detection distance, in order to avoid step-turns in the middle of the robot’s attempt to capture and then maintain the desired wall offset distance. Unfortunately the detection distance wasn’t re-instated to its former value once the robot had captured the desired wall offset, so it didn’t detect the upcoming wall as an obstacle until too late.

And this line of thought brings up another issue; what defines the transition from the ‘approach’ state to the ‘distance hold’ state, anyway? In previous work I had sketched out a proposed state diagram for the wall-following mode, as shown below:

Possible state diagram for the TRK_RIGHT case

And I now realize it is both incomplete and poorly labelled. I now believe the ‘Capture’ state should be renamed to ‘Approach’, and the ‘Maintain’ state should be renamed ‘Offset Hold’. Moreover, there should be a third ’90-deg left turn’ state that is entered if the step-turn maneuver fails to bypass the ‘far obstacle’. Maybe something like:

02 May 2020 Update: Back to Charging Station Code

After a week of working with wall-following code, I managed to discharge Wall-E2’s battery to the point where it’s looking to be fed again, so I’m back on the charging station support code. When we last left this portion of the saga, I had discovered the problem with Wall-E2 not shutting off its motors after connecting to the charging station, and was in the process of making the changes when Wall-E2 turned up its nose at the charging station and I had to go do other stuff for a while.

Now, back on the Charging Station case, I found that I had to make some significant changes to GetOpMode; I had to move the DEAD_BATTERY condition check to after the IR Homing and Charger connected mode checks; otherwise, the robot can’t home to a charging station with a low battery because the DEAD_BATTERY mode will be detected first – oops! The new version of GetOpMode() is shown below:

int GetOpMode(float batv) //04/28/19 added batv to sig
{
	//Purpose:  Determine operating mode based on sensor inputs
	//Inputs: none
	//Outputs: Integer denoting current op mode (CHARGING = 1, IRHOMING = 2, WALLFOLLOW = 3)
	//Plan:
	//	Step1: If batt voltage too low, return MODE_DEADBATTERY (4)
	//	Step2: If Charger is connected, return MODE_CHARGING (1)
	//	Step3: Else If IR Homing beam detected, return MODE_IRHOMING (2)
	//	Step4: Else return MODE_WALLFOLLOW (3)
	//Notes:
	//	01/16/18 added MODE_DEADBATTERY
	//	03/28/18 now looking for either IsChargerConnected OR low on TP5100 Chg line
	//	09/03/18 reorganized so DEADBATTERY is on top, and added new TURNING_TO_HDG mode
	//	02/24/19 now using 1NA619 charge current sensor
	//	04/28/19 added batV to function sig
	//	04/27/20 rewrote to simplify MODE_CHARGING code and to have only one exit point
	//	05/02/20 bugfix - IsChargerConnected() block has to come before DEAD_BATTERY check

	int mode = MODE_NONE; //04/27/20 added so function has only one exit point
//Step1: If Charger is connected, return MODE_CHARGING (1)
	if (IsChargerConnected())
	{
		mode = MODE_CHARGING;
		mySerial.printf("Robot has successfully connected to charger!\n");
	}

//Step2: Else If IR Homing beam detected, return MODE_IRHOMING (2)
	else if (IsIRBeamAvail()) mode = MODE_IRHOMING; //this handles 'hungry/not-hungry' cases internally

//Step3: If batt voltage too low, return MODE_DEADBATTERY (4)
	else if (batv <= DEAD_BATT_THRESH_VOLTS) mode = MODE_DEADBATTERY;

//Step4: Else return MODE_WALLFOLLOW (3)
	else mode = MODE_WALLFOLLOW;

	return mode;
}

int GetOpMode(float batv) //04/28/19 added batv to sig

{

//Purpose: Determine operating mode based on sensor inputs

//Inputs: none

//Outputs: Integer denoting current op mode (CHARGING = 1, IRHOMING = 2, WALLFOLLOW = 3)

//Plan:

// Step1: If batt voltage too low, return MODE_DEADBATTERY (4)

// Step2: If Charger is connected, return MODE_CHARGING (1)

// Step3: Else If IR Homing beam detected, return MODE_IRHOMING (2)

// Step4: Else return MODE_WALLFOLLOW (3)

//Notes:

// 01/16/18 added MODE_DEADBATTERY

// 03/28/18 now looking for either IsChargerConnected OR low on TP5100 Chg line

// 09/03/18 reorganized so DEADBATTERY is on top, and added new TURNING_TO_HDG mode

// 02/24/19 now using 1NA619 charge current sensor

// 04/28/19 added batV to function sig

// 04/27/20 rewrote to simplify MODE_CHARGING code and to have only one exit point

// 05/02/20 bugfix - IsChargerConnected() block has to come before DEAD_BATTERY check

int mode = MODE_NONE; //04/27/20 added so function has only one exit point

//Step1: If Charger is connected, return MODE_CHARGING (1)

if (IsChargerConnected())

{

mode = MODE_CHARGING;

mySerial.printf("Robot has successfully connected to charger!\n");

}

//Step2: Else If IR Homing beam detected, return MODE_IRHOMING (2)

else if (IsIRBeamAvail()) mode = MODE_IRHOMING; //this handles 'hungry/not-hungry' cases internally

//Step3: If batt voltage too low, return MODE_DEADBATTERY (4)

else if (batv <= DEAD_BATT_THRESH_VOLTS) mode = MODE_DEADBATTERY;

//Step4: Else return MODE_WALLFOLLOW (3)

else mode = MODE_WALLFOLLOW;

return mode;

}

After these (and some other minor improvements) I was able to get Wall-E2 to successfully home to a charging station, stop its motors (yay!) and commence charging. As the following videos show, I was able to do this on my desktop ‘local’ range, and also ‘in the field’ (aka my atrium hallway).

After the robot connects to the charging station, the rear LED strip changes function to become a ‘fuel guage’, with ’empty’ on the right and ‘full’ on the left. In the videos above, note that about 6 seconds after the robot connects, the LED strip changes to show ‘almost empty’.

Stay tuned,

Frank