Author Archives: paynterf

Teensy NEMA 17 Stepper Motor Rotary Scanner Program

Posted 26 May 2020,

This post describes a small Teensy program developed to drive a NEMA 17 stepper motor to perform angular scans that can be used in conjunction with another program to obtain angle-synchronized performance data.

In a post several years ago I mentioned that I had developed a small Teensy program to drive a NEMA 17 stepper motor to perform angular scans to test Wall-E2’s IR Homing detection performance. Unfortunately, I didn’t do a very good job of documenting the setup, so when I wanted to use the same capability for my new VLX53L0X ‘Time-of-Flight’ sensor project, I was unable to easily put the pieces back together again. So, I decided to create a post dedicated to the software/hardware setup and usage, so the next time I need this capability it won’t be so hard to access.

The original rotary scanner program worked OK, but there was no way to synchronize the rotary table with the measurement program. So I decided this time around I was going to add some features to make it more usable:

It should allow the measurement program to trigger the start of the scan, and trigger each subsequent rotation to the next position, in a measure-move-measure… sequence.
It should provide notification when each scan position has been reached, and when the entire scan is complete
It should allow for repeated scans without restarting the program
It should be capable of reporting each position step number and calculated angle relative to the set zero position to the measurement program via I2C.

Here’s the wiring diagram:

Wiring diagram for Rotary Table program

And the software

/*
    Name:       Teensy_NEMA17_L298N_RotaryTable.ino
    Created:	5/27/2020 11:00:40 AM
    Author:     FRANKNEWXPS15\Frank
*/

/*
Teensy NEMA 17 L298N Rotary Table Program

This program controls a NEMA 17 stepper motor using an L298N motor driver. It
Takes user input to define the boresight (zero) position and the start and stop angles
in degrees relative to the zero position.  Then it moves to the start position and waits 
for a HIGH level on SCAN_START_PIN.  After this signal is received, the motor is 
stepped through to the stop position. At the stop position, the SCAN_COMPLETE_PIN is 
driven HIGH.

The Stepper motor is connected to an L298N motor driver with one coil on Out1/2, and the
other coil on Out3/4.  It may turn out that one coil's leads have to be reversed to match
the motor rotation direction with the program direction.  

The Teensy 3.2 is connect to In1/2/3/4 via pins 8,9,10,11 although this can be changed in the
constructor below.

The NEMA 17 motor is assumed to execute 200 steps/revolution.  Change the StepsPerRevolution
constant for other values.

05/27/20:  Performs an angular scan over user-supplied range of angles. By default a complete scan
from start position to stop position is performed, followed by a return to the start position
However, if the STEP_ENABLE_PIN (held HIGH by default) is pulled LOW, the program will wait 
until it goes HIGH before performing the next step.  In this case, a scan iteration would go
as follows

	Step 1 - Scan paramaters entered, motor moves to start position, waits for LOW on SCAN_START_PIN
	Step 2 - Measurement program pulls SCAN_START_PIN LOW for 1 sec, then back HIGH 
	Step 3 - Measurement program takes a measurement & retrieves step# & angle value via I2C request
	Step 4 - Measurement program pulls SCAN_STEP_ENABLE_PIN LOW
	Step 5 - Motor moves to first/next step, and outputs HIGH on SCAN_STEP_COMPLETE_PIN
	Step 6 - Measurement program waits for HIGH on SCAN_STEP_COMPLETE_PIN
	Step 7 - Measurement program takes a measurement & retrieves step# & angle value via I2C request
	Step 8 - Repeat Steps 4-7 until scan complete
	Step 9 - SCAN_COMPLETE_PIN goes HIGH
*/

//O5/30/20 Added I2C connection to pass step# & relative angle values to measurement program

#include <Stepper.h>
#include <Wire.h>
#include "I2C_Anything.h"


// change this to fit the number of steps per revolution for your motor
const int stepsPerRevolution = 200;

// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

//08/26/17 added for scan support
const int SCAN_START_PIN = 2;
const int SCAN_STEP_ENABLE_PIN = 3;
const int SCAN_STEP_COMPLETE_PIN = 4;
const int SCAN_COMPLETE_PIN = 5;

const float MOTOR_STEPS_PER_REV = 200;
const float MOTOR_STEPS_PER_DEG = MOTOR_STEPS_PER_REV / 360;
const float DEG_PER_MOTOR_STEP = 360/MOTOR_STEPS_PER_REV; //added 05/30/20
const int DEFAULT_MOTOR_STEPS_TO_MOVE = 10;
char Instr[20];
//const int POSITIONING_SPEED_RPM = 20;  
const int POSITIONING_SPEED_RPM = 100;

int zeroPos;
int scanStartDeg;
int scanStartSteps; //scanStartDeg converted to steps
int scanStopDeg;
int scanStopSteps; //scanStopDeg converted to steps
int scanNumberofSteps; //added 05/27/20
int stepsToMove; //steps to move to initial position
int curMotorStepVal; //keeps track of current position, in steps
float curRelPointingAngleDeg; //keeps track of current relative pointing angle, in degrees
int curAngleStepVal; //keeps track of current table step iteration value
bool bStopPosDone = false;
int scanSpeedRpm = 6;

const int SLAVE_ADDR = 8; //added 05/30/20

void setup() 
{
	//added 05/30/20 to provide step# & angle values to Angle Scan program
	Wire.begin(SLAVE_ADDR);
	Wire.setSCL(18);
	Wire.setSCL(19);
	Wire.setClock(100000);
	Wire.onRequest(requestEvent);

	Serial.begin(115200);
	unsigned long now = millis();
	while (!Serial)
	{
		delay(10);
	}

	delay(5000); //05/28/20 delay AFTER Serial object instantiation is NECESSARY!

	Serial.print("Serial available after "); Serial.print(millis() - now); Serial.print(" millisec");

	pinMode(SCAN_START_PIN, INPUT_PULLUP);
	pinMode(SCAN_STEP_ENABLE_PIN, INPUT_PULLUP);
	pinMode(SCAN_STEP_COMPLETE_PIN, OUTPUT);
	pinMode(SCAN_COMPLETE_PIN, OUTPUT);

	//init SCAN_COMPLETE_PIN, SCAN_STEP_COMPLETE to LOW (not complete) state
	digitalWrite(SCAN_COMPLETE_PIN, LOW);
	digitalWrite(SCAN_STEP_COMPLETE_PIN, LOW);

	//added 05/26/20
	Serial.printf("Serial.printf: NEMA-17 Stepper Rotary Table Program\n");

	//get motor speed to be used
	scanSpeedRpm = GetIntegerParameter("Motor speed RPM", 6);
	myStepper.setSpeed(scanSpeedRpm);


	//set zero position
	Serial.println("Set stepper zero position.  Enter +steps for CW, -steps for CCW, Q to exit");
	while (!bStopPosDone)
	{
		while (Serial.available() == 0); //waits for input
		if (toascii(Serial.peek()) == 'Q' || toascii(Serial.peek()) == 'q')
		{
			bStopPosDone = true;
			curMotorStepVal = 0;
		}
		else
		{
			stepsToMove = GetIntegerParameter("Steps to move (- = CCW, + = CW)?", DEFAULT_MOTOR_STEPS_TO_MOVE);
			Serial.print("Steps to move = "); Serial.println(stepsToMove);
			myStepper.setSpeed(POSITIONING_SPEED_RPM);
			myStepper.step(stepsToMove);
		}
	}

	Serial.readString(); //clear the input buffer - could still have chars in it
	Serial.print("curMotorStepVal = "); Serial.println(curMotorStepVal);

	//set scan start/stop positions in degrees
	scanStartDeg = GetIntegerParameter("Scan Start Pos in Degrees Relative to Zero", -90);
	scanStopDeg = GetIntegerParameter("Scan Stop Pos in Degrees Relative to Zero", 90);
	scanNumberofSteps = GetIntegerParameter("Number of Steps", 18);
	curRelPointingAngleDeg = scanStartDeg; //added 05/30/20

	Serial.println("Run Parameters:");
	Serial.print("Speed: "); Serial.print(scanSpeedRpm); Serial.println(" RPM");
	Serial.print("Scan Start: "); Serial.print(scanStartDeg); Serial.println(" Deg");
	Serial.print("Scan Stop: "); Serial.print(scanStopDeg); Serial.println(" Deg");
	Serial.print("Scan Steps: "); Serial.println(scanNumberofSteps);
	Serial.println();

	//go to scan start pos
	scanStartSteps = (int)scanStartDeg * MOTOR_STEPS_PER_DEG;
	Serial.print("steps to move = "); Serial.println(scanStartSteps);
	Serial.printf("Before move, curMotorStepVal = %d, scanStartSteps = %d\n", curMotorStepVal, scanStartSteps);
	myStepper.step(scanStartSteps);
	curMotorStepVal += scanStartSteps;
	Serial.print("Done - curMotorStepVal = "); Serial.println(curMotorStepVal);
	Serial.printf("After move, curMotorStepVal = %d, scanStartSteps = %d\n", curMotorStepVal, scanStartSteps);

	int motorStepsPerScanStep = (int)(((int)scanStopDeg * MOTOR_STEPS_PER_DEG - curMotorStepVal) / (float)scanNumberofSteps); //05/27/20
	Serial.print("Motor Steps Per Scan Step = "); Serial.println(motorStepsPerScanStep);

	while (1)  //user has opportunity to exit after each scan
	{
		//wait for trigger
		Serial.printf("waiting for LOW on SCAN_START_PIN (pin %d) ...\n", SCAN_START_PIN);
		while (digitalRead(SCAN_START_PIN) == HIGH)
		{
			delay(100);
		}

		Serial.println("Scan Triggered - starting scan, setting SCAN_COMPLETE_PIN to LOW\n");
		digitalWrite(SCAN_COMPLETE_PIN, LOW);

		//for (curAngleStepVal = 0; curAngleStepVal < scanNumberofSteps; curAngleStepVal++)
		for (curAngleStepVal = 0; curAngleStepVal <= scanNumberofSteps; curAngleStepVal++)
		{
			curRelPointingAngleDeg = curAngleStepVal * motorStepsPerScanStep * DEG_PER_MOTOR_STEP; //added 05/30/20

			//when SCAN_STEP_ENABLE_PIN goes LOW, go to first/next step.
			while (digitalRead(SCAN_STEP_ENABLE_PIN))
			{

			}

			unsigned long now = millis();
			digitalWrite(SCAN_STEP_COMPLETE_PIN, LOW);
			Serial.printf("Scan Step %d Triggered: motor steps to move = %d\n", curAngleStepVal, motorStepsPerScanStep);
			myStepper.setSpeed(scanSpeedRpm);
			myStepper.step(motorStepsPerScanStep);
			curMotorStepVal += motorStepsPerScanStep;
			Serial.printf("Done in %lu Msec - curMotorStepVal = %d\n", millis() - now, curMotorStepVal);
			//delay(200);

			//output HIGH on SCAN_STEP_COMPLETE_PIN
			Serial.printf("Outputting HIGH on SCAN_STEP_COMPLETE_PIN\n");
			digitalWrite(SCAN_STEP_COMPLETE_PIN, HIGH);
			//delay(50);  //make the HIGH period visible on scope
		}

		//quit
		Serial.printf("Outputting HIGH on SCAN_COMPLETE_PIN (pin %d)\n", SCAN_COMPLETE_PIN);
		digitalWrite(SCAN_COMPLETE_PIN, HIGH);

		//return to start position
		stepsToMove = curMotorStepVal - scanStartSteps;
		Serial.println("Resetting for next scan.");
		Serial.printf("Before move, curMotorStepVal = %d, scanStartSteps = %d, steps to move = %d\n", 
			curMotorStepVal, scanStartSteps, stepsToMove);
		myStepper.setSpeed(POSITIONING_SPEED_RPM);
		myStepper.step(-stepsToMove);
		curMotorStepVal = scanStartSteps;
		Serial.print("Done - curMotorStepVal = "); Serial.println(curMotorStepVal);
		myStepper.setSpeed(scanSpeedRpm);

		Serial.printf("Enter any key to continue\n");
		while (!Serial.available())
		{

		}

		//consume bytes until Serial buffer is empty to avoid unintended triggers
		int incomingByte;
		while (Serial.available())
		{
			incomingByte = Serial.read();
			Serial.printf("Consuming 0x%x\n", incomingByte);
		}

	}
}


void loop()
{
}

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

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

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

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

//05/30/20 added to report current angle step# & relative pointing angle to measurement program
void requestEvent()
{
	//send the current step# and current relative pointing angle
	Serial.printf("In requestEvent: curAngleStep = %d, curRelAngle = %2.2f\n", 
		curAngleStepVal, curAngleStepVal, curRelPointingAngleDeg, curRelPointingAngleDeg);

	I2C_writeAnything(curAngleStepVal);
	I2C_writeAnything(curRelPointingAngleDeg);
}

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

Name: Teensy_NEMA17_L298N_RotaryTable.ino

Created: 5/27/2020 11:00:40 AM

Author: FRANKNEWXPS15\Frank

Teensy NEMA 17 L298N Rotary Table Program

This program controls a NEMA 17 stepper motor using an L298N motor driver. It

Takes user input to define the boresight (zero) position and the start and stop angles

in degrees relative to the zero position. Then it moves to the start position and waits

for a HIGH level on SCAN_START_PIN. After this signal is received, the motor is

stepped through to the stop position. At the stop position, the SCAN_COMPLETE_PIN is

driven HIGH.

The Stepper motor is connected to an L298N motor driver with one coil on Out1/2, and the

other coil on Out3/4. It may turn out that one coil's leads have to be reversed to match

the motor rotation direction with the program direction.

The Teensy 3.2 is connect to In1/2/3/4 via pins 8,9,10,11 although this can be changed in the

constructor below.

The NEMA 17 motor is assumed to execute 200 steps/revolution. Change the StepsPerRevolution

constant for other values.

05/27/20: Performs an angular scan over user-supplied range of angles. By default a complete scan

from start position to stop position is performed, followed by a return to the start position

However, if the STEP_ENABLE_PIN (held HIGH by default) is pulled LOW, the program will wait

until it goes HIGH before performing the next step. In this case, a scan iteration would go

as follows

Step 1 - Scan paramaters entered, motor moves to start position, waits for LOW on SCAN_START_PIN

Step 2 - Measurement program pulls SCAN_START_PIN LOW for 1 sec, then back HIGH

Step 3 - Measurement program takes a measurement & retrieves step# & angle value via I2C request

Step 4 - Measurement program pulls SCAN_STEP_ENABLE_PIN LOW

Step 5 - Motor moves to first/next step, and outputs HIGH on SCAN_STEP_COMPLETE_PIN

Step 6 - Measurement program waits for HIGH on SCAN_STEP_COMPLETE_PIN

Step 7 - Measurement program takes a measurement & retrieves step# & angle value via I2C request

Step 8 - Repeat Steps 4-7 until scan complete

Step 9 - SCAN_COMPLETE_PIN goes HIGH

//O5/30/20 Added I2C connection to pass step# & relative angle values to measurement program

#include <Stepper.h>

#include <Wire.h>

#include "I2C_Anything.h"

// change this to fit the number of steps per revolution for your motor

const int stepsPerRevolution = 200;

// initialize the stepper library on pins 8 through 11:

Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

//08/26/17 added for scan support

const int SCAN_START_PIN = 2;

const int SCAN_STEP_ENABLE_PIN = 3;

const int SCAN_STEP_COMPLETE_PIN = 4;

const int SCAN_COMPLETE_PIN = 5;

const float MOTOR_STEPS_PER_REV = 200;

const float MOTOR_STEPS_PER_DEG = MOTOR_STEPS_PER_REV / 360;

const float DEG_PER_MOTOR_STEP = 360/MOTOR_STEPS_PER_REV; //added 05/30/20

const int DEFAULT_MOTOR_STEPS_TO_MOVE = 10;

char Instr[20];

//const int POSITIONING_SPEED_RPM = 20;

const int POSITIONING_SPEED_RPM = 100;

int zeroPos;

int scanStartDeg;

int scanStartSteps; //scanStartDeg converted to steps

int scanStopDeg;

int scanStopSteps; //scanStopDeg converted to steps

int scanNumberofSteps; //added 05/27/20

int stepsToMove; //steps to move to initial position

int curMotorStepVal; //keeps track of current position, in steps

float curRelPointingAngleDeg; //keeps track of current relative pointing angle, in degrees

int curAngleStepVal; //keeps track of current table step iteration value

bool bStopPosDone = false;

int scanSpeedRpm = 6;

const int SLAVE_ADDR = 8; //added 05/30/20

void setup()

{

//added 05/30/20 to provide step# & angle values to Angle Scan program

Wire.begin(SLAVE_ADDR);

Wire.setSCL(18);

Wire.setSCL(19);

Wire.setClock(100000);

Wire.onRequest(requestEvent);

Serial.begin(115200);

unsigned long now = millis();

while (!Serial)

{

delay(10);

}

delay(5000); //05/28/20 delay AFTER Serial object instantiation is NECESSARY!

Serial.print("Serial available after "); Serial.print(millis() - now); Serial.print(" millisec");

pinMode(SCAN_START_PIN, INPUT_PULLUP);

pinMode(SCAN_STEP_ENABLE_PIN, INPUT_PULLUP);

pinMode(SCAN_STEP_COMPLETE_PIN, OUTPUT);

pinMode(SCAN_COMPLETE_PIN, OUTPUT);

//init SCAN_COMPLETE_PIN, SCAN_STEP_COMPLETE to LOW (not complete) state

digitalWrite(SCAN_COMPLETE_PIN, LOW);

digitalWrite(SCAN_STEP_COMPLETE_PIN, LOW);

//added 05/26/20

Serial.printf("Serial.printf: NEMA-17 Stepper Rotary Table Program\n");

//get motor speed to be used

scanSpeedRpm = GetIntegerParameter("Motor speed RPM", 6);

myStepper.setSpeed(scanSpeedRpm);

//set zero position

Serial.println("Set stepper zero position. Enter +steps for CW, -steps for CCW, Q to exit");

while (!bStopPosDone)

{

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

if (toascii(Serial.peek()) == 'Q' || toascii(Serial.peek()) == 'q')

{

bStopPosDone = true;

curMotorStepVal = 0;

}

else

{

stepsToMove = GetIntegerParameter("Steps to move (- = CCW, + = CW)?", DEFAULT_MOTOR_STEPS_TO_MOVE);

Serial.print("Steps to move = "); Serial.println(stepsToMove);

myStepper.setSpeed(POSITIONING_SPEED_RPM);

myStepper.step(stepsToMove);

}

Serial.readString(); //clear the input buffer - could still have chars in it

Serial.print("curMotorStepVal = "); Serial.println(curMotorStepVal);

//set scan start/stop positions in degrees

scanStartDeg = GetIntegerParameter("Scan Start Pos in Degrees Relative to Zero", -90);

scanStopDeg = GetIntegerParameter("Scan Stop Pos in Degrees Relative to Zero", 90);

scanNumberofSteps = GetIntegerParameter("Number of Steps", 18);

curRelPointingAngleDeg = scanStartDeg; //added 05/30/20

Serial.println("Run Parameters:");

Serial.print("Speed: "); Serial.print(scanSpeedRpm); Serial.println(" RPM");

Serial.print("Scan Start: "); Serial.print(scanStartDeg); Serial.println(" Deg");

Serial.print("Scan Stop: "); Serial.print(scanStopDeg); Serial.println(" Deg");

Serial.print("Scan Steps: "); Serial.println(scanNumberofSteps);

Serial.println();

//go to scan start pos

scanStartSteps = (int)scanStartDeg * MOTOR_STEPS_PER_DEG;

Serial.print("steps to move = "); Serial.println(scanStartSteps);

Serial.printf("Before move, curMotorStepVal = %d, scanStartSteps = %d\n", curMotorStepVal, scanStartSteps);

myStepper.step(scanStartSteps);

curMotorStepVal += scanStartSteps;

Serial.print("Done - curMotorStepVal = "); Serial.println(curMotorStepVal);

Serial.printf("After move, curMotorStepVal = %d, scanStartSteps = %d\n", curMotorStepVal, scanStartSteps);

int motorStepsPerScanStep = (int)(((int)scanStopDeg * MOTOR_STEPS_PER_DEG - curMotorStepVal) / (float)scanNumberofSteps); //05/27/20

Serial.print("Motor Steps Per Scan Step = "); Serial.println(motorStepsPerScanStep);

while (1) //user has opportunity to exit after each scan

{

//wait for trigger

Serial.printf("waiting for LOW on SCAN_START_PIN (pin %d) ...\n", SCAN_START_PIN);

while (digitalRead(SCAN_START_PIN) == HIGH)

{

delay(100);

}

Serial.println("Scan Triggered - starting scan, setting SCAN_COMPLETE_PIN to LOW\n");

digitalWrite(SCAN_COMPLETE_PIN, LOW);

//for (curAngleStepVal = 0; curAngleStepVal < scanNumberofSteps; curAngleStepVal++)

for (curAngleStepVal = 0; curAngleStepVal <= scanNumberofSteps; curAngleStepVal++)

{

curRelPointingAngleDeg = curAngleStepVal * motorStepsPerScanStep * DEG_PER_MOTOR_STEP; //added 05/30/20

//when SCAN_STEP_ENABLE_PIN goes LOW, go to first/next step.

while (digitalRead(SCAN_STEP_ENABLE_PIN))

{

}

unsigned long now = millis();

digitalWrite(SCAN_STEP_COMPLETE_PIN, LOW);

Serial.printf("Scan Step %d Triggered: motor steps to move = %d\n", curAngleStepVal, motorStepsPerScanStep);

myStepper.setSpeed(scanSpeedRpm);

myStepper.step(motorStepsPerScanStep);

curMotorStepVal += motorStepsPerScanStep;

Serial.printf("Done in %lu Msec - curMotorStepVal = %d\n", millis() - now, curMotorStepVal);

//delay(200);

//output HIGH on SCAN_STEP_COMPLETE_PIN

Serial.printf("Outputting HIGH on SCAN_STEP_COMPLETE_PIN\n");

digitalWrite(SCAN_STEP_COMPLETE_PIN, HIGH);

//delay(50); //make the HIGH period visible on scope

}

//quit

Serial.printf("Outputting HIGH on SCAN_COMPLETE_PIN (pin %d)\n", SCAN_COMPLETE_PIN);

digitalWrite(SCAN_COMPLETE_PIN, HIGH);

//return to start position

stepsToMove = curMotorStepVal - scanStartSteps;

Serial.println("Resetting for next scan.");

Serial.printf("Before move, curMotorStepVal = %d, scanStartSteps = %d, steps to move = %d\n",

curMotorStepVal, scanStartSteps, stepsToMove);

myStepper.setSpeed(POSITIONING_SPEED_RPM);

myStepper.step(-stepsToMove);

curMotorStepVal = scanStartSteps;

Serial.print("Done - curMotorStepVal = "); Serial.println(curMotorStepVal);

myStepper.setSpeed(scanSpeedRpm);

Serial.printf("Enter any key to continue\n");

while (!Serial.available())

{

}

//consume bytes until Serial buffer is empty to avoid unintended triggers

int incomingByte;

while (Serial.available())

{

incomingByte = Serial.read();

Serial.printf("Consuming 0x%x\n", incomingByte);

}

void loop()

{

}

int GetIntegerParameter(String prompt, int defaultval)

{

int param = 0;

bool bDone = false;

while (!bDone)

{

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

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

//String res = Serial.readString().trim();

String res = Serial.readString();

res.trim();

int reslen = res.length();

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

{

bDone = true;

param = defaultval;

}

else

{

res.toCharArray(Instr, reslen + 1);

//if (isNumeric(Instr) && atoi(Instr) >= 0)

if (isNumeric(Instr))

{

param = atoi(Instr);

bDone = true;

}

else

{

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

}

Serial.println(param);

return param;

}

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

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

bool isNumeric(char* str)

{

byte ii = 0;

bool RetVal = false;

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

ii++;

while (str[ii])

{

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

ii++;

break;

}

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

ii++;

RetVal = true;

}

while (str[ii])

{

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

ii++;

RetVal = true;

}

return RetVal;

}

//05/30/20 added to report current angle step# & relative pointing angle to measurement program

void requestEvent()

{

//send the current step# and current relative pointing angle

Serial.printf("In requestEvent: curAngleStep = %d, curRelAngle = %2.2f\n",

curAngleStepVal, curAngleStepVal, curRelPointingAngleDeg, curRelPointingAngleDeg);

I2C_writeAnything(curAngleStepVal);

I2C_writeAnything(curRelPointingAngleDeg);

}

And the hardware layout:

I couldn’t find any information about winding polarity for this particular NEMA 17 stepper, so it was sort of a crapshoot as to which way the motor was going to turn for a nominal CW or CCW input to the program. As it turned out, I had to reverse one set of wires on the L298N to get the stepper to turn in the correct direction.

Companion Measurement System

For the companion measurement system, I used a Teensy 3.5 micro-controller, as I needed to connect to the VL53L0X ‘Time of Flight’ sensors and the Rotary Table program/micro-controller via I2C, and The Teensy 3.5 has provisions for up to three separate I2C busses (Wire, Wire1 & Wire2). Although it would be possible to put everything on one I2C bus, I wanted to isolate the two ‘sides’ (the rotary table control side, and the sensor control side). This dual-IC2 bus arrangement is also the way I plan to integrate the VL53L0X sensor arrays into Wall-E2, my autonomous wall-following robot, so this will give me a chance to work out the bugs on a smaller scale.

Here’s the wiring diagram:

Wiring diagram for the companion measurement system, with triple VL53L0X ToF sensors

And the software:

/*
    Name:       TeensyTripleVL53L0XAngleScanV1.ino
    Created:	5/28/2020 12:15:50 PM
    Author:     FRANKNEWXPS15\Frank
*/


/*
This program is derived from Teensy_Triple_VL53L0X_V2.ino.  It uses the 
Teensy_NEMA17_L298N_RotaryTable program to perform triple VL53L0X
measurements over a range of angles. 

Teensy_NEMA17_L298N_RotaryTable program:
Performs an angular scan over user-supplied range of angles.  By default a complete scan
from start position to stop position is performed, followed by a return to the start position
However, if the STEP_ENABLE_PIN (held HIGH by default) is pulled LOW, the program will wait
until it goes HIGH before performing the next step.  In this case, a scan iteration would go
as follows

    Step 1 - Scan paramaters entered, motor moves to start position, waits for LOW on SCAN_START_PIN
    Step 2 - Measurement program pulls SCAN_START_PIN LOW for 1 sec, then back HIGH
    Step 3 - Measurement program takes a measurement & retrieves step# & angle value via I2C request
    Step 4 - Measurement program pulls SCAN_STEP_ENABLE_PIN LOW
    Step 5 - Motor moves to first/next step, and outputs HIGH on SCAN_STEP_COMPLETE_PIN
    Step 6 - Measurement program waits for HIGH on SCAN_STEP_COMPLETE_PIN
    Step 7 - Measurement program takes a measurement & retrieves step# & angle value via I2C request
    Step 8 - Repeat Steps 4-7 until scan complete
    Step 9 - SCAN_COMPLETE_PIN goes HIGH

At present (05/28/20) the rotary table pin assignments are:
SCAN_START_PIN = 2
SCAN_STEP_ENABLE_PIN = 3
SCAN_STEP_COMPLETE_PIN = 4
SCAN_COMPLETE_PIN = 5
*/


/* This code copied from the following post on the Adafruit forum:
https://forums.adafruit.com/viewtopic.php?f=19&t=164589&p=808693&hilit=vl53l0x#p808693

And adapted to use it on the Wire1 I2C bus on a Teensy 3.5
*/


#include <Wire.h>
#include "Adafruit_VL53L0X.h"
#include "I2C_Anything.h"

Adafruit_VL53L0X lidar_RF = Adafruit_VL53L0X(); //Right-front LIDAR (angled 30 deg forward)
Adafruit_VL53L0X lidar_RC = Adafruit_VL53L0X(); //Center LIDAR
Adafruit_VL53L0X lidar_RR = Adafruit_VL53L0X(); //Right-rear LIDAR (angled 30 deg rearward)


//XSHUT required for I2C address init 
const int RF_XSHUT_PIN = 23;
const int RC_XSHUT_PIN = 22;
const int RR_XSHUT_PIN = 21;

const int RED_LASER_PIN = 0;

const int MAX_LIDAR_RANGE_MM = 1000; //make it obvious when nearest object is out of range

uint16_t RF_Dist_mm;
uint16_t RC_Dist_mm;
uint16_t RR_Dist_mm;
float SteeringVal; //mvd here 05/30/20

//Rotary Scan Table Connections:
const int SCAN_START_PIN = 2; //connect to table SCAN_START_PIN
const int SCAN_STEP_ENABLE_PIN = 3;//connect to table SCAN_STEP_ENABLE_PIN
const int SCAN_STEP_COMPLETE_PIN = 4;//connect to table SCAN_STEP_COMPLETE_PIN
const int SCAN_COMPLETE_PIN = 5;//connect to table SCAN_COMPLETE_PIN

 //added 05/30/20 to retrieve values from rotary table program
const int SLAVE_ADDR = 8;
int curStepVal = 0;
float curAngleDeg = 0;


void setup()
{

    //added 05/30/20 to retrieve step# & angle values from rotary table program
    Wire.begin();
    Wire.setClock(100000);
    Wire.setSCL(18);
    Wire.setSDA(19);

    Serial.begin(115200); //Teensy ignores rate parameter


    // wait until serial port opens for native USB devices
    while (!Serial)
    {
        delay(1);
    }

    delay(5000); //05/28/20 - this delay is necessary AFTER Serial instantiation!

    Serial.printf("Teensy Triple VL53L0X Angle Scan Program\n");

    pinMode(RF_XSHUT_PIN, OUTPUT);
    pinMode(RC_XSHUT_PIN, OUTPUT);
    pinMode(RR_XSHUT_PIN, OUTPUT);

    pinMode(RED_LASER_PIN, OUTPUT);

    //Rotary Scan Table Connections:
    pinMode(SCAN_START_PIN, OUTPUT);
    pinMode(SCAN_STEP_ENABLE_PIN, OUTPUT);
    pinMode(SCAN_STEP_COMPLETE_PIN, INPUT_PULLDOWN);
    pinMode(SCAN_COMPLETE_PIN, INPUT_PULLUP);

    //Initialize table connection states
    digitalWrite(SCAN_START_PIN, HIGH); //disables scans
    digitalWrite(SCAN_STEP_ENABLE_PIN, HIGH); //disables steps  

    //initialize 3 LIDAR sensors
    // 1. Reset all sensors by setting all of their XSHUT pins low for delay(10), then set
    //    all XSHUT high to bring out of reset
    digitalWrite(RF_XSHUT_PIN, LOW);
    delay(10);
    digitalWrite(RC_XSHUT_PIN, LOW);
    delay(10);
    digitalWrite(RR_XSHUT_PIN, LOW);
    delay(10);
    digitalWrite(RF_XSHUT_PIN, HIGH);
    digitalWrite(RC_XSHUT_PIN, HIGH);
    digitalWrite(RR_XSHUT_PIN, HIGH);

    // 2. Keep sensor #1 awake by keeping XSHUT pin high, and put all other sensors into
    //    shutdown by pulling XSHUT pins low
    digitalWrite(RC_XSHUT_PIN, LOW);
    digitalWrite(RR_XSHUT_PIN, LOW);

    // 3. Initialize sensor #1 
    if (!lidar_RF.begin(VL53L0X_I2C_ADDR + 1, false, &Wire1))
    {
        Serial.println(F("Failed to boot lidar_RF"));
        while (1);
    }

    // 4. Keep sensor #1 awake, and now bring sensor #2 out of reset by setting its XSHUT pin high.
    // 5. Initialize sensor #2 with lox.begin(new_i2c_address) Pick any number but 0x29 and whatever
    //    you set the first sensor to
    digitalWrite(RC_XSHUT_PIN, HIGH);
    if (!lidar_RC.begin(VL53L0X_I2C_ADDR + 2, false, &Wire1))
    {
        Serial.println(F("Failed to boot lidar_RC"));
        while (1);
    }

    // 6. Repeat for last sensor.
    digitalWrite(RR_XSHUT_PIN, HIGH);
    if (!lidar_RR.begin(VL53L0X_I2C_ADDR + 3, false, &Wire1))
    {
        Serial.println(F("Failed to boot lidar_RR"));
        while (1);
    }

    //turn the laser OFF
    digitalWrite(RED_LASER_PIN, LOW);

    Serial.printf("\nInit complete\n \n");

    Serial.printf("\nWhen the Rotary Table is set up and ready to go, send any key\n \n");


    while (!Serial.available())
    {
        Serial.printf("Nothing yet...\n");
        delay(1000);
    }

    //consume bytes until Serial buffer is empty to avoid unintended triggers
    int incomingByte;
    while (Serial.available())
    {
        incomingByte = Serial.read();
        Serial.printf("Consuming 0x%x\n",incomingByte);
    }

    ////05/23/20 experiment with accessing API functions
    //VL53L0X_Dev_t RightFrontDevice = lidar_RF.GetDeviceHandle();
    //VL53L0X_DeviceInfo_t RightFrontDeviceInfo = lidar_RF.GetDeviceInfo();
    //Serial.printf("Device Info for Right Front Sensor\n");
    //Serial.printf("\tName = %s\n\tType = %s\n\tProdID = %s\n\tType Number = %d\n\tMajor Rev = %d\n\tMinor Rev = %d\n \n",
    //    RightFrontDeviceInfo.Name, RightFrontDeviceInfo.Type,
    //    RightFrontDeviceInfo.ProductId, RightFrontDeviceInfo.ProductType,
    //    RightFrontDeviceInfo.ProductRevisionMajor, RightFrontDeviceInfo.ProductRevisionMinor);

    ////get measurement timing budget?
    //prog_uint32_t MeasBudgetUSec;
    //VL53L0X_Error ApiError = VL53L0X_GetMeasurementTimingBudgetMicroSeconds(&RightFrontDevice, &MeasBudgetUSec);
    //Serial.printf("Right Front Measurement Budget (uSec) = %d\n", MeasBudgetUSec);
    //delay(1000);
    //Serial.printf("Changing budget from %d to %d....\n", MeasBudgetUSec, 2 * MeasBudgetUSec);
    //delay(1000);
    //MeasBudgetUSec = 2 * MeasBudgetUSec;
    //ApiError = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(&RightFrontDevice, MeasBudgetUSec);
    //Serial.printf("Right Front Measurement Budget (uSec) Now = %d\n \n", MeasBudgetUSec);

    bool bDone = false; 
    while (!bDone)
    {
        //init controls to 'disabled' state
        digitalWrite(SCAN_STEP_ENABLE_PIN, HIGH); //init to 'steps disabled'
        digitalWrite(SCAN_START_PIN, HIGH); //init to 'scan disabled'


        Serial.printf("Starting Angle Scan...\n \n");
        Serial.printf("Msec\tStep#\tRelDeg\tFront\tCenter\tRear\tSteer\n"); //rev 5/30/20 to include step# & rel ptng angle

        //Tell the table to start the scan
        digitalWrite(SCAN_START_PIN, LOW); //trigger the scan
        delay(1000); //long enough for table to see it
        digitalWrite(SCAN_START_PIN, HIGH); //reset the trigger


        //do until the scan is complete
        while (!digitalRead(SCAN_COMPLETE_PIN))
        {
            //take measurement
            GetVL53L0XValues();

            //05/30/20 get current step# & relative pointing angle
            Wire.requestFrom(SLAVE_ADDR, sizeof(curStepVal) + sizeof(curAngleDeg));
            I2C_readAnything(curStepVal);
            I2C_readAnything(curAngleDeg);

            Serial.printf("%lu\t%d\t%3.2f\t%d\t%d\t%d\t%3.2f\n", 
                millis(),curStepVal,curAngleDeg,
                RF_Dist_mm, RC_Dist_mm, RR_Dist_mm, SteeringVal);

            digitalWrite(SCAN_STEP_ENABLE_PIN, LOW); //trigger table to step to next position
            delay(100); //give rotary table time to reset SCAN_STEP_COMPLETE_PIN state

            //wait for step to complete
            while (!digitalRead(SCAN_STEP_COMPLETE_PIN))
            {
                //Serial.printf("Waiting for SCAN_STEP_COMPLETE_PIN to go HIGH\n");
                //delay(1000);

            }

            //disable steps
            digitalWrite(SCAN_STEP_ENABLE_PIN, HIGH); //disable further steps
            delay(50); //05/31/20 give SCAN_COMPLETE_PIN a chance to go HIGH before next measurement
        }

        Serial.printf("SCAN_COMPLETE_PIN HIGH Received - Scan is Complete!\n");

        Serial.printf("Enter Q to quit, anything else for another scan\n");
        while (!Serial.available())
        {
            Serial.printf("nothing yet....\n");
            delay(1000);
        }

        incomingByte = Serial.read();
        Serial.printf("I received: 0x%0x\n",incomingByte);

        if (incomingByte == 0x51 || incomingByte == 0x71)
        {
            Serial.printf("Stopping Program - Goodbye!\n");
            while (true)
            {

            }
        }
        else
        {
            //consume any remaining bytes in buffer
            while (Serial.available() > 0)
            {
                Serial.read();
            }
            Serial.printf("Starting another scan...\n");
        }
    }
}

void loop()
{
}

void GetVL53L0XValues()
{
    //Serial.printf("In GetVL53L0XValues()\n");
    VL53L0X_RangingMeasurementData_t measure;

    //turn the laser ON
    digitalWrite(RED_LASER_PIN, HIGH);

    lidar_RF.rangingTest(&measure, false); // pass in 'true' to get debug data printout!
    if (measure.RangeStatus != 4)  // phase failures have incorrect data
    {
        RF_Dist_mm = measure.RangeMilliMeter;
        if (RF_Dist_mm > MAX_LIDAR_RANGE_MM) RF_Dist_mm = MAX_LIDAR_RANGE_MM;
    }
    else RF_Dist_mm = 0;

    lidar_RC.rangingTest(&measure, false); // pass in 'true' to get debug data printout!
    if (measure.RangeStatus != 4)  // phase failures have incorrect data
    {
        RC_Dist_mm = measure.RangeMilliMeter;
        if (RC_Dist_mm > MAX_LIDAR_RANGE_MM) RC_Dist_mm = MAX_LIDAR_RANGE_MM;
    }
    else RC_Dist_mm = 0;

    lidar_RR.rangingTest(&measure, false); // pass in 'true' to get debug data printout!
    if (measure.RangeStatus != 4)  // phase failures have incorrect data
    {
        RR_Dist_mm = measure.RangeMilliMeter;
        if (RR_Dist_mm > MAX_LIDAR_RANGE_MM) RR_Dist_mm = MAX_LIDAR_RANGE_MM;
    }
    else RR_Dist_mm = 0;

    SteeringVal = (RF_Dist_mm - RR_Dist_mm) / (float)RC_Dist_mm;

    //turn the laser OFF
    digitalWrite(RED_LASER_PIN, LOW);

    //delay(100);
}

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

Name: TeensyTripleVL53L0XAngleScanV1.ino

Created: 5/28/2020 12:15:50 PM

Author: FRANKNEWXPS15\Frank

This program is derived from Teensy_Triple_VL53L0X_V2.ino. It uses the

Teensy_NEMA17_L298N_RotaryTable program to perform triple VL53L0X

measurements over a range of angles.

Teensy_NEMA17_L298N_RotaryTable program:

Performs an angular scan over user-supplied range of angles. By default a complete scan

from start position to stop position is performed, followed by a return to the start position

However, if the STEP_ENABLE_PIN (held HIGH by default) is pulled LOW, the program will wait

until it goes HIGH before performing the next step. In this case, a scan iteration would go

as follows

Step 1 - Scan paramaters entered, motor moves to start position, waits for LOW on SCAN_START_PIN

Step 2 - Measurement program pulls SCAN_START_PIN LOW for 1 sec, then back HIGH

Step 3 - Measurement program takes a measurement & retrieves step# & angle value via I2C request

Step 4 - Measurement program pulls SCAN_STEP_ENABLE_PIN LOW

Step 5 - Motor moves to first/next step, and outputs HIGH on SCAN_STEP_COMPLETE_PIN

Step 6 - Measurement program waits for HIGH on SCAN_STEP_COMPLETE_PIN

Step 7 - Measurement program takes a measurement & retrieves step# & angle value via I2C request

Step 8 - Repeat Steps 4-7 until scan complete

Step 9 - SCAN_COMPLETE_PIN goes HIGH

At present (05/28/20) the rotary table pin assignments are:

SCAN_START_PIN = 2

SCAN_STEP_ENABLE_PIN = 3

SCAN_STEP_COMPLETE_PIN = 4

SCAN_COMPLETE_PIN = 5

/* This code copied from the following post on the Adafruit forum:

https://forums.adafruit.com/viewtopic.php?f=19&t=164589&p=808693&hilit=vl53l0x#p808693

And adapted to use it on the Wire1 I2C bus on a Teensy 3.5

#include <Wire.h>

#include "Adafruit_VL53L0X.h"

#include "I2C_Anything.h"

Adafruit_VL53L0X lidar_RF = Adafruit_VL53L0X(); //Right-front LIDAR (angled 30 deg forward)

Adafruit_VL53L0X lidar_RC = Adafruit_VL53L0X(); //Center LIDAR

Adafruit_VL53L0X lidar_RR = Adafruit_VL53L0X(); //Right-rear LIDAR (angled 30 deg rearward)

//XSHUT required for I2C address init

const int RF_XSHUT_PIN = 23;

const int RC_XSHUT_PIN = 22;

const int RR_XSHUT_PIN = 21;

const int RED_LASER_PIN = 0;

const int MAX_LIDAR_RANGE_MM = 1000; //make it obvious when nearest object is out of range

uint16_t RF_Dist_mm;

uint16_t RC_Dist_mm;

uint16_t RR_Dist_mm;

float SteeringVal; //mvd here 05/30/20

//Rotary Scan Table Connections:

const int SCAN_START_PIN = 2; //connect to table SCAN_START_PIN

const int SCAN_STEP_ENABLE_PIN = 3;//connect to table SCAN_STEP_ENABLE_PIN

const int SCAN_STEP_COMPLETE_PIN = 4;//connect to table SCAN_STEP_COMPLETE_PIN

const int SCAN_COMPLETE_PIN = 5;//connect to table SCAN_COMPLETE_PIN

//added 05/30/20 to retrieve values from rotary table program

const int SLAVE_ADDR = 8;

int curStepVal = 0;

float curAngleDeg = 0;

void setup()

{

//added 05/30/20 to retrieve step# & angle values from rotary table program

Wire.begin();

Wire.setClock(100000);

Wire.setSCL(18);

Wire.setSDA(19);

Serial.begin(115200); //Teensy ignores rate parameter

// wait until serial port opens for native USB devices

while (!Serial)

{

delay(1);

}

delay(5000); //05/28/20 - this delay is necessary AFTER Serial instantiation!

Serial.printf("Teensy Triple VL53L0X Angle Scan Program\n");

pinMode(RF_XSHUT_PIN, OUTPUT);

pinMode(RC_XSHUT_PIN, OUTPUT);

pinMode(RR_XSHUT_PIN, OUTPUT);

pinMode(RED_LASER_PIN, OUTPUT);

//Rotary Scan Table Connections:

pinMode(SCAN_START_PIN, OUTPUT);

pinMode(SCAN_STEP_ENABLE_PIN, OUTPUT);

pinMode(SCAN_STEP_COMPLETE_PIN, INPUT_PULLDOWN);

pinMode(SCAN_COMPLETE_PIN, INPUT_PULLUP);

//Initialize table connection states

digitalWrite(SCAN_START_PIN, HIGH); //disables scans

digitalWrite(SCAN_STEP_ENABLE_PIN, HIGH); //disables steps

//initialize 3 LIDAR sensors

// 1. Reset all sensors by setting all of their XSHUT pins low for delay(10), then set

// all XSHUT high to bring out of reset

digitalWrite(RF_XSHUT_PIN, LOW);

delay(10);

digitalWrite(RC_XSHUT_PIN, LOW);

delay(10);

digitalWrite(RR_XSHUT_PIN, LOW);

delay(10);

digitalWrite(RF_XSHUT_PIN, HIGH);

digitalWrite(RC_XSHUT_PIN, HIGH);

digitalWrite(RR_XSHUT_PIN, HIGH);

// 2. Keep sensor #1 awake by keeping XSHUT pin high, and put all other sensors into

// shutdown by pulling XSHUT pins low

digitalWrite(RC_XSHUT_PIN, LOW);

digitalWrite(RR_XSHUT_PIN, LOW);

// 3. Initialize sensor #1

if (!lidar_RF.begin(VL53L0X_I2C_ADDR + 1, false, &Wire1))

{

Serial.println(F("Failed to boot lidar_RF"));

while (1);

}

// 4. Keep sensor #1 awake, and now bring sensor #2 out of reset by setting its XSHUT pin high.

// 5. Initialize sensor #2 with lox.begin(new_i2c_address) Pick any number but 0x29 and whatever

// you set the first sensor to

digitalWrite(RC_XSHUT_PIN, HIGH);

if (!lidar_RC.begin(VL53L0X_I2C_ADDR + 2, false, &Wire1))

{

Serial.println(F("Failed to boot lidar_RC"));

while (1);

}

// 6. Repeat for last sensor.

digitalWrite(RR_XSHUT_PIN, HIGH);

if (!lidar_RR.begin(VL53L0X_I2C_ADDR + 3, false, &Wire1))

{

Serial.println(F("Failed to boot lidar_RR"));

while (1);

}

//turn the laser OFF

digitalWrite(RED_LASER_PIN, LOW);

Serial.printf("\nInit complete\n \n");

Serial.printf("\nWhen the Rotary Table is set up and ready to go, send any key\n \n");

while (!Serial.available())

{

Serial.printf("Nothing yet...\n");

delay(1000);

}

//consume bytes until Serial buffer is empty to avoid unintended triggers

int incomingByte;

while (Serial.available())

{

incomingByte = Serial.read();

Serial.printf("Consuming 0x%x\n",incomingByte);

}

////05/23/20 experiment with accessing API functions

//VL53L0X_Dev_t RightFrontDevice = lidar_RF.GetDeviceHandle();

//VL53L0X_DeviceInfo_t RightFrontDeviceInfo = lidar_RF.GetDeviceInfo();

//Serial.printf("Device Info for Right Front Sensor\n");

//Serial.printf("\tName = %s\n\tType = %s\n\tProdID = %s\n\tType Number = %d\n\tMajor Rev = %d\n\tMinor Rev = %d\n \n",

// RightFrontDeviceInfo.Name, RightFrontDeviceInfo.Type,

// RightFrontDeviceInfo.ProductId, RightFrontDeviceInfo.ProductType,

// RightFrontDeviceInfo.ProductRevisionMajor, RightFrontDeviceInfo.ProductRevisionMinor);

////get measurement timing budget?

//prog_uint32_t MeasBudgetUSec;

//VL53L0X_Error ApiError = VL53L0X_GetMeasurementTimingBudgetMicroSeconds(&RightFrontDevice, &MeasBudgetUSec);

//Serial.printf("Right Front Measurement Budget (uSec) = %d\n", MeasBudgetUSec);

//delay(1000);

//Serial.printf("Changing budget from %d to %d....\n", MeasBudgetUSec, 2 * MeasBudgetUSec);

//delay(1000);

//MeasBudgetUSec = 2 * MeasBudgetUSec;

//ApiError = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(&RightFrontDevice, MeasBudgetUSec);

//Serial.printf("Right Front Measurement Budget (uSec) Now = %d\n \n", MeasBudgetUSec);

bool bDone = false;

while (!bDone)

{

//init controls to 'disabled' state

digitalWrite(SCAN_STEP_ENABLE_PIN, HIGH); //init to 'steps disabled'

digitalWrite(SCAN_START_PIN, HIGH); //init to 'scan disabled'

Serial.printf("Starting Angle Scan...\n \n");

Serial.printf("Msec\tStep#\tRelDeg\tFront\tCenter\tRear\tSteer\n"); //rev 5/30/20 to include step# & rel ptng angle

//Tell the table to start the scan

digitalWrite(SCAN_START_PIN, LOW); //trigger the scan

delay(1000); //long enough for table to see it

digitalWrite(SCAN_START_PIN, HIGH); //reset the trigger

//do until the scan is complete

while (!digitalRead(SCAN_COMPLETE_PIN))

{

//take measurement

GetVL53L0XValues();

//05/30/20 get current step# & relative pointing angle

Wire.requestFrom(SLAVE_ADDR, sizeof(curStepVal) + sizeof(curAngleDeg));

I2C_readAnything(curStepVal);

I2C_readAnything(curAngleDeg);

Serial.printf("%lu\t%d\t%3.2f\t%d\t%d\t%d\t%3.2f\n",

millis(),curStepVal,curAngleDeg,

RF_Dist_mm, RC_Dist_mm, RR_Dist_mm, SteeringVal);

digitalWrite(SCAN_STEP_ENABLE_PIN, LOW); //trigger table to step to next position

delay(100); //give rotary table time to reset SCAN_STEP_COMPLETE_PIN state

//wait for step to complete

while (!digitalRead(SCAN_STEP_COMPLETE_PIN))

{

//Serial.printf("Waiting for SCAN_STEP_COMPLETE_PIN to go HIGH\n");

//delay(1000);

}

//disable steps

digitalWrite(SCAN_STEP_ENABLE_PIN, HIGH); //disable further steps

delay(50); //05/31/20 give SCAN_COMPLETE_PIN a chance to go HIGH before next measurement

}

Serial.printf("SCAN_COMPLETE_PIN HIGH Received - Scan is Complete!\n");

Serial.printf("Enter Q to quit, anything else for another scan\n");

while (!Serial.available())

{

Serial.printf("nothing yet....\n");

delay(1000);

}

incomingByte = Serial.read();

Serial.printf("I received: 0x%0x\n",incomingByte);

if (incomingByte == 0x51 || incomingByte == 0x71)

{

Serial.printf("Stopping Program - Goodbye!\n");

while (true)

{

}

else

{

//consume any remaining bytes in buffer

while (Serial.available() > 0)

{

Serial.read();

}

Serial.printf("Starting another scan...\n");

}

void loop()

{

}

void GetVL53L0XValues()

{

//Serial.printf("In GetVL53L0XValues()\n");

VL53L0X_RangingMeasurementData_t measure;

//turn the laser ON

digitalWrite(RED_LASER_PIN, HIGH);

lidar_RF.rangingTest(&measure, false); // pass in 'true' to get debug data printout!

if (measure.RangeStatus != 4) // phase failures have incorrect data

{

RF_Dist_mm = measure.RangeMilliMeter;

if (RF_Dist_mm > MAX_LIDAR_RANGE_MM) RF_Dist_mm = MAX_LIDAR_RANGE_MM;

}

else RF_Dist_mm = 0;

lidar_RC.rangingTest(&measure, false); // pass in 'true' to get debug data printout!

if (measure.RangeStatus != 4) // phase failures have incorrect data

{

RC_Dist_mm = measure.RangeMilliMeter;

if (RC_Dist_mm > MAX_LIDAR_RANGE_MM) RC_Dist_mm = MAX_LIDAR_RANGE_MM;

}

else RC_Dist_mm = 0;

lidar_RR.rangingTest(&measure, false); // pass in 'true' to get debug data printout!

if (measure.RangeStatus != 4) // phase failures have incorrect data

{

RR_Dist_mm = measure.RangeMilliMeter;

if (RR_Dist_mm > MAX_LIDAR_RANGE_MM) RR_Dist_mm = MAX_LIDAR_RANGE_MM;

}

else RR_Dist_mm = 0;

SteeringVal = (RF_Dist_mm - RR_Dist_mm) / (float)RC_Dist_mm;

//turn the laser OFF

digitalWrite(RED_LASER_PIN, LOW);

//delay(100);

}

and the hardware setup:

Rotary table Teensy 3.2 in foreground with L298N motor controller. Teensy 3.5 measurement controller in middle, with plugboard , NEMA 17 stepper motor and triple VL53L0X array in background

Here’s a short video showing a typical measurement scan:

And here’s a typical output:

Starting Angle Scan...
 
Msec	Step#	RelDeg	Front	Center	Rear	Steer
94128	0	0.00	361	416	507	-0.35
94498	1	9.00	372	418	507	-0.32
94868	2	18.00	372	413	510	-0.33
95237	3	27.00	368	418	506	-0.33
95607	4	36.00	368	420	510	-0.34
95976	5	45.00	376	420	508	-0.31
96346	6	54.00	365	418	502	-0.33
SCAN_COMPLETE_PIN HIGH Received - Scan is Complete!
Enter Q to quit, anything else for another scan

Starting Angle Scan...

Msec Step# RelDeg Front Center Rear Steer

94128 0 0.00 361 416 507 -0.35

94498 1 9.00 372 418 507 -0.32

94868 2 18.00 372 413 510 -0.33

95237 3 27.00 368 418 506 -0.33

95607 4 36.00 368 420 510 -0.34

95976 5 45.00 376 420 508 -0.31

96346 6 54.00 365 418 502 -0.33

SCAN_COMPLETE_PIN HIGH Received - Scan is Complete!

Enter Q to quit, anything else for another scan

In the above output, the ‘Step#’ and ‘RelDeg’ values were obtained from the rotary scanner program via the primary I2C bus, while the ‘Front’, ‘Center’, and ‘Rear’ distance values were obtained from the three VL53L0X ToF sensors via the secondary I2C bus. The ‘Steer’ value was calculated locally by the measurement controller.

Upgrade to Micro-step capable motor driver:

After getting everything to work properly, I was a bit puzzled why I wasn’t getting the correct relative angle values back from the rotary table subsystem. After a while I figured out that the reason was that the rotary table program calculates an integer number of steps based on the total angle change divided by the number of scan steps, and, in general, the result won’t be exact. When moving from one scan step to the next the motor moves an integer number of steps, which in general will not be the desired angle change. For a 60 degree scan arc with 6 steps, the desired angle/scan step is 10 deg, and at 1.8 deg/step this would result in 10/1.8 = 5.5555… motor steps/scan step. This value gets truncated to 5 motor steps/scan step, which results in each scan step being 1.8 deg/step * 5 steps = 9 deg/scan step. So, instead of the scan steps occurring at 0, 10, 20, 30, 40, 50, 60 deg, they are at 0, 9, 18, 27, 36, 45, and 54 deg, and the last 6 deg of scan is never covered.

The answer to this problem is to use a motor with more than 200 steps/rev, or to use a driver that can generate micro-steps, effectively increasing the angular resolution of the scan. After some Googling, and some rooting around in my parts box, I came up with the Pololu DRV8825 Stepper Motor Driver part. This driver supports up to 32 micro-steps/step and is considerably smaller than the L298N – such a deal!

Pololu Micro-stepping Driver

At 32 microsteps/step, a full motor rev would take 200*32 = 6400 microsteps or 0.05625 deg/microstep . Now the above calculation would result in 10 deg/0.05625/10 = 177.777 –> 177 microsteps per scan step. This would result in step angles of 0, 177*0.05625 = 9.95802, 19.916, 29.874, 39.83, 49.79, and 59.748. So now we lose only the last 0.252 deg of scan – much nicer!

So, I put together a quick test, using an Arduino Uno, a spare NEMA 17 stepper motor, a Pololu DRV8825 from my parts box, and the Pololu Stepper library. Here’s the program:

/*
    Name:       PololuMicroStepperDemoV2.ino
    Created:	5/31/2020 11:05:30 PM
    Author:     FRANKNEWXPS15\Frank
*/

/*
 * Microstepping demo
 *
 * This requires that microstep control pins be connected in addition to STEP,DIR
 *
 * Copyright (C)2015 Laurentiu Badea
 *
 * This file may be redistributed under the terms of the MIT license.
 * A copy of this license has been included with this distribution in the file LICENSE.
 */
#include <Arduino.h>

 // Motor steps per revolution. Most steppers are 200 steps or 1.8 degrees/step
#define MOTOR_STEPS 200
//#define RPM 120
#define RPM 12

#define DIR 8
#define STEP 9
#define SLEEP 13 // optional (just delete SLEEP from everywhere if not used)

/*
 * Choose one of the sections below that match your board
 */

//#include "DRV8834.h"
//#define M0 10
//#define M1 11
//DRV8834 stepper(MOTOR_STEPS, DIR, STEP, SLEEP, M0, M1);

// #include "A4988.h"
// #define MS1 10
// #define MS2 11
// #define MS3 12
// A4988 stepper(MOTOR_STEPS, DIR, STEP, SLEEP, MS1, MS2, MS3);

 #include "DRV8825.h"
 #define MODE0 10
 #define MODE1 11
 #define MODE2 12
 DRV8825 stepper(MOTOR_STEPS, DIR, STEP, SLEEP, MODE0, MODE1, MODE2);

// #include "DRV8880.h"
// #define M0 10
// #define M1 11
// #define TRQ0 6
// #define TRQ1 7
// DRV8880 stepper(MOTOR_STEPS, DIR, STEP, SLEEP, M0, M1, TRQ0, TRQ1);

// #include "BasicStepperDriver.h" // generic
// BasicStepperDriver stepper(DIR, STEP);

void setup() {
    /*
     * Set target motor RPM.
     */
    stepper.begin(RPM);
    // if using enable/disable on ENABLE pin (active LOW) instead of SLEEP uncomment next line
    // stepper.setEnableActiveState(LOW);
    stepper.enable();

    // set current level (for DRV8880 only). 
    // Valid percent values are 25, 50, 75 or 100.
    // stepper.setCurrent(100);
}

void loop() {
    delay(1000);

    /*
     * Moving motor in full step mode is simple:
     */
    stepper.setMicrostep(1);  // Set microstep mode to 1:1

    // One complete revolution is 360°
    stepper.rotate(360);     // forward revolution
    stepper.rotate(-360);    // reverse revolution

    // One complete revolution is also MOTOR_STEPS steps in full step mode
    stepper.move(MOTOR_STEPS);    // forward revolution
    stepper.move(-MOTOR_STEPS);   // reverse revolution

    /*
     * Microstepping mode: 1, 2, 4, 8, 16 or 32 (where supported by driver)
     * Mode 1 is full speed.
     * Mode 32 is 32 microsteps per step.
     * The motor should rotate just as fast (at the set RPM),
     * but movement precision is increased, which may become visually apparent at lower RPMs.
     */
    stepper.setMicrostep(8);   // Set microstep mode to 1:8

    // In 1:8 microstepping mode, one revolution takes 8 times as many microsteps
    stepper.move(8 * MOTOR_STEPS);    // forward revolution
    stepper.move(-8 * MOTOR_STEPS);   // reverse revolution

    // One complete revolution is still 360° regardless of microstepping mode
    // rotate() is easier to use than move() when no need to land on precise microstep position
    stepper.rotate(360);
    stepper.rotate(-360);

    delay(5000);
}

100

101

102

103

104

105

106

107

108

Name: PololuMicroStepperDemoV2.ino

Created: 5/31/2020 11:05:30 PM

Author: FRANKNEWXPS15\Frank

* Microstepping demo

* This requires that microstep control pins be connected in addition to STEP,DIR

* This file may be redistributed under the terms of the MIT license.

* A copy of this license has been included with this distribution in the file LICENSE.

#include <Arduino.h>

// Motor steps per revolution. Most steppers are 200 steps or 1.8 degrees/step

#define MOTOR_STEPS 200

//#define RPM 120

#define RPM 12

#define DIR 8

#define STEP 9

#define SLEEP 13 // optional (just delete SLEEP from everywhere if not used)

* Choose one of the sections below that match your board

//#include "DRV8834.h"

//#define M0 10

//#define M1 11

//DRV8834 stepper(MOTOR_STEPS, DIR, STEP, SLEEP, M0, M1);

// #include "A4988.h"

// #define MS1 10

// #define MS2 11

// #define MS3 12

// A4988 stepper(MOTOR_STEPS, DIR, STEP, SLEEP, MS1, MS2, MS3);

#include "DRV8825.h"

#define MODE0 10

#define MODE1 11

#define MODE2 12

DRV8825 stepper(MOTOR_STEPS, DIR, STEP, SLEEP, MODE0, MODE1, MODE2);

// #include "DRV8880.h"

// #define M0 10

// #define M1 11

// #define TRQ0 6

// #define TRQ1 7

// DRV8880 stepper(MOTOR_STEPS, DIR, STEP, SLEEP, M0, M1, TRQ0, TRQ1);

// #include "BasicStepperDriver.h" // generic

// BasicStepperDriver stepper(DIR, STEP);

void setup() {

* Set target motor RPM.

stepper.begin(RPM);

// if using enable/disable on ENABLE pin (active LOW) instead of SLEEP uncomment next line

// stepper.setEnableActiveState(LOW);

stepper.enable();

// set current level (for DRV8880 only).

// Valid percent values are 25, 50, 75 or 100.

// stepper.setCurrent(100);

}

void loop() {

delay(1000);

* Moving motor in full step mode is simple:

stepper.setMicrostep(1); // Set microstep mode to 1:1

// One complete revolution is 360°

stepper.rotate(360); // forward revolution

stepper.rotate(-360); // reverse revolution

// One complete revolution is also MOTOR_STEPS steps in full step mode

stepper.move(MOTOR_STEPS); // forward revolution

stepper.move(-MOTOR_STEPS); // reverse revolution

* Microstepping mode: 1, 2, 4, 8, 16 or 32 (where supported by driver)

* Mode 1 is full speed.

* Mode 32 is 32 microsteps per step.

* The motor should rotate just as fast (at the set RPM),

* but movement precision is increased, which may become visually apparent at lower RPMs.

stepper.setMicrostep(8); // Set microstep mode to 1:8

// In 1:8 microstepping mode, one revolution takes 8 times as many microsteps

stepper.move(8 * MOTOR_STEPS); // forward revolution

stepper.move(-8 * MOTOR_STEPS); // reverse revolution

// One complete revolution is still 360° regardless of microstepping mode

// rotate() is easier to use than move() when no need to land on precise microstep position

stepper.rotate(360);

stepper.rotate(-360);

delay(5000);

}

And the hardware test setup:

Pololu DRV8825 Microstep demo setup.

And a short video showing the stepper motor action. Note that close attention to the end of the red pointer wire shows the difference between ‘full-step’ and ‘micro-stepped’ behavior; the micro-stepped rotations are much smoother. Also, if you look very carefully, you can see the compass rose platform ‘counter-rotating’ in full-step mode, as the torque is high enough to rotate the stepper motor in the opposite direction to the shaft.

So now the idea is to incorporate micro-stepping capability into the Teensy NEMA 17 Rotary Table program, so that angle scans can be performed much more accurately than before.

02 June 2020 Update:

My original Pololu Microstep Demo program used an Arduino Uno to control the Pololu DRV8825 motor driver, but my Teensy Rotary Table setup obviously uses a Teensy and an L298N. To change the Rotary Table setup to utilize the DRV8825, I’ll need to make some adjustments to pin configurations.

The first step in the process was to change out the Arduino Uno for a Teensy (a Teensy 3.5 in this case) to verify that there were no problem with the Pololu microstep demo program running on a Teensy – done.

The next step was to change out the L298N driver on the rotary table setup with the Pololu DRV8825 driver, and modify the rotary table program to use the new driver with microstepping.

Here’s the new combined hardware layout, with both the rotary table and measurement sub-systems shown

Both measurement and rotary table sub-systems shown. Rotary table Teensy 3.2 at left foreground, followed by Teensy 3.5 measurement controller, the connection plugboard, and the triple VL53L0X sensors in the left background. The new DRV8825 is mounted on the center plugboard, and the NEMA 17 stepper motor with compass rose test platter at the right

Here’s the updated software using the Pololu DRV8825

/*
	Name:       Teensy_DRV8825_Rotary_Scan_Table.ino
	Created:	6/4/2020 12:59:57 AM
	Author:     FRANKNEWXPS15\Frank
*/

/*
Teensy DRV8825 Rotary Table Program

This program controls a NEMA 17 stepper motor using a Pololu DRV8825 motor driver. It
Takes user input to define the boresight (zero) position and the start and stop angles
in degrees relative to the zero position.  Then it moves to the start position and waits
for a HIGH level on SCAN_START_PIN.  After this signal is received, the motor is
stepped through to the stop position. At the stop position, the SCAN_COMPLETE_PIN is
driven HIGH.

The Stepper motor is connected to a DRV8825 motor driver with one coil on A1/A2, and the
other coil on B1/B2.  It may turn out that one coil's leads have to be reversed to match
the motor rotation direction with the program direction.

The NEMA 17 motor is assumed to execute 200 steps/revolution.  Change the StepsPerRevolution
constant for other values.

05/27/20:  Performs an angular scan over user-supplied range of angles. By default a complete scan
from start position to stop position is performed, followed by a return to the start position
However, if the STEP_ENABLE_PIN (held HIGH by default) is pulled LOW, the program will wait
until it goes HIGH before performing the next step.  In this case, a scan iteration would go
as follows

	Step 1 - Scan parameters entered, motor moves to start position, waits for LOW on SCAN_START_PIN
	Step 2 - Measurement program pulls SCAN_START_PIN LOW for 1 sec, then back HIGH
	Step 3 - Measurement program takes a measurement & retrieves step# & angle value via I2C request
	Step 4 - Measurement program pulls SCAN_STEP_ENABLE_PIN LOW
	Step 5 - Motor moves to first/next step, and outputs HIGH on SCAN_STEP_COMPLETE_PIN
	Step 6 - Measurement program waits for HIGH on SCAN_STEP_COMPLETE_PIN
	Step 7 - Measurement program takes a measurement & retrieves step# & angle value via I2C request
	Step 8 - Repeat Steps 4-7 until scan complete
	Step 9 - SCAN_COMPLETE_PIN goes HIGH
*/

//O5/30/20 Added I2C connection to pass step# & relative angle values to measurement program
//05/02/20 Rev to use Pololu DRV8825 & micro-stepping

#include <Wire.h>
#include "I2C_Anything.h"
#include "DRV8825.h"

const int SLAVE_ADDR = 8; //added 05/30/20

#pragma region MOTOR_CONSTANTS
 // Motor steps per revolution. Most steppers are 200 steps or 1.8 degrees/step
//06/02/20 now using Pololu DRV8825
const int MOTOR_STEPS_PER_REV = 200;
const int MICROSTEPS_PER_STEP = 32;
const int MICROSTEPS_PER_REV = MICROSTEPS_PER_STEP * MOTOR_STEPS_PER_REV;
const int DEG_PER_MICROSTEP = 360 / MICROSTEPS_PER_REV;
const int MICROSTEPS_PER_DEG = MICROSTEPS_PER_REV / 360;
const int DEFAULT_RPM = 12;
const int POSITIONING_SPEED_RPM = 100;
const int DEFAULT_MOTOR_STEPS_TO_MOVE = 10;
#pragma endregion Motor Constants

#pragma region PIN_ASSIGNMENTS
const int DIR = 8;
const int STEP = 9;
const int SLEEP = 13; // optional (just delete SLEEP from everywhere if not used)

const int MODE0 = 10;
const int MODE1 = 11;
const int MODE2 = 12;

const int SCAN_START_PIN = 2;
const int SCAN_STEP_ENABLE_PIN = 3;
const int SCAN_STEP_COMPLETE_PIN = 4;
const int SCAN_COMPLETE_PIN = 5;
#pragma endregion Pin Assignments

DRV8825 stepper(MOTOR_STEPS_PER_REV, DIR, STEP, SLEEP, MODE0, MODE1, MODE2);

char Instr[20];

//DRV8825
int zeroPos;
int scanStartDeg;
int scanStartMicroSteps; //scanStartDeg converted to steps
int scanStopDeg;
int scanStopSteps; //scanStopDeg converted to steps
int scanNumberofSteps; //added 05/27/20
int stepsToMove; //steps to move to initial position
int curMotorStepVal; //keeps track of current position, in steps
float curRelPointingAngleDeg; //keeps track of current relative pointing angle, in degrees
int curAngleStepVal; //keeps track of current table step iteration value
bool bStopPosDone = false;
int scanSpeedRpm = 6;



void setup()
{
	//added 05/30/20 to provide step# & angle values to Angle Scan program
	Wire.begin(SLAVE_ADDR);
	Wire.setSCL(18);
	Wire.setSCL(19);
	Wire.setClock(100000);
	Wire.onRequest(requestEvent);

	//06/02/20 now using Pololu DRV8825 microstepping motor driver
	stepper.begin(DEFAULT_RPM);
	// if using enable/disable on ENABLE pin (active LOW) instead of SLEEP uncomment next line
	// stepper.setEnableActiveState(LOW);
	stepper.enable();

	/*
	 * Microstepping mode: 1, 2, 4, 8, 16 or 32 (where supported by driver)
	 * Mode 1 is full speed.
	 * Mode 32 is 32 microsteps per step.
	 * The motor should rotate just as fast (at the set RPM),
	 * but movement precision is increased, which may become visually apparent at lower RPMs.
	 */
	stepper.setMicrostep(MICROSTEPS_PER_STEP);   // Set microstep mode to 1:32



	Serial.begin(115200);
	unsigned long now = millis();
	while (!Serial)
	{
		delay(10);
	}

	delay(5000); //05/28/20 delay AFTER Serial object instantiation is NECESSARY!

	Serial.print("Serial available after "); Serial.print(millis() - now); Serial.print(" millisec");

	pinMode(SCAN_START_PIN, INPUT_PULLUP);
	pinMode(SCAN_STEP_ENABLE_PIN, INPUT_PULLUP);
	pinMode(SCAN_STEP_COMPLETE_PIN, OUTPUT);
	pinMode(SCAN_COMPLETE_PIN, OUTPUT);

	//init SCAN_COMPLETE_PIN, SCAN_STEP_COMPLETE to LOW (not complete) state
	digitalWrite(SCAN_COMPLETE_PIN, LOW);
	digitalWrite(SCAN_STEP_COMPLETE_PIN, LOW);

	//added 05/26/20
	Serial.printf("Serial.printf: NEMA-17 Stepper Rotary Table Program\n");

	//get motor speed to be used
	scanSpeedRpm = GetIntegerParameter("Motor speed RPM", 6);


	//set zero position
	Serial.println("Set stepper zero position.  Enter +steps for CW, -steps for CCW, Q to exit");
	while (!bStopPosDone)
	{
		while (Serial.available() == 0); //waits for input
		if (toascii(Serial.peek()) == 'Q' || toascii(Serial.peek()) == 'q')
		{
			bStopPosDone = true;
			curMotorStepVal = 0;
		}
		else
		{
			stepsToMove = GetIntegerParameter("Steps to move (- = CCW, + = CW)?", DEFAULT_MOTOR_STEPS_TO_MOVE);
			Serial.print("Steps to move = "); Serial.println(stepsToMove);
			stepper.setRPM(POSITIONING_SPEED_RPM);
			stepper.move(stepsToMove);
		}
	}

	Serial.readString(); //clear the input buffer - could still have chars in it
	Serial.print("curMotorStepVal = "); Serial.println(curMotorStepVal);

	//set scan start/stop positions in degrees
	scanStartDeg = GetIntegerParameter("Scan Start Pos in Degrees Relative to Zero", -90);
	scanStopDeg = GetIntegerParameter("Scan Stop Pos in Degrees Relative to Zero", 90);
	scanNumberofSteps = GetIntegerParameter("Number of Steps", 18);
	curRelPointingAngleDeg = scanStartDeg; //added 05/30/20

	Serial.println("Run Parameters:");
	Serial.print("Speed: "); Serial.print(scanSpeedRpm); Serial.println(" RPM");
	Serial.print("Scan Start: "); Serial.print(scanStartDeg); Serial.println(" Deg");
	Serial.print("Scan Stop: "); Serial.print(scanStopDeg); Serial.println(" Deg");
	Serial.print("Scan Steps: "); Serial.println(scanNumberofSteps);

	//06/02/20 Now using Pololu DRV8825 driver & microstepping
	int scandeg = abs(scanStopDeg - scanStartDeg);
	double scanstepdeg = scandeg / scanNumberofSteps;

	//go to scan start pos
	stepper.setRPM(POSITIONING_SPEED_RPM);
	stepper.rotate(scanStartDeg);

	while (1)  //user has opportunity to exit after each scan
	{
		//wait for trigger
		Serial.printf("waiting for LOW on SCAN_START_PIN (pin %d) ...\n", SCAN_START_PIN);
		while (digitalRead(SCAN_START_PIN) == HIGH)
		{
			delay(100);
		}

		Serial.println("Scan Triggered - starting scan, setting SCAN_COMPLETE_PIN to LOW\n");
		digitalWrite(SCAN_COMPLETE_PIN, LOW);

		stepper.setRPM(scanSpeedRpm);

		for (curAngleStepVal = 1; curAngleStepVal <= scanNumberofSteps; curAngleStepVal++)
		{
			curRelPointingAngleDeg = scanStartDeg + (curAngleStepVal)*scanstepdeg;

			//when SCAN_STEP_ENABLE_PIN goes LOW, go to first/next step.
			while (digitalRead(SCAN_STEP_ENABLE_PIN))
			{

			}

			unsigned long now = millis();
			digitalWrite(SCAN_STEP_COMPLETE_PIN, LOW);
			Serial.printf("Scan Step %d Triggered: moving to %3.2f deg\n", curAngleStepVal, curRelPointingAngleDeg);

			//DRV8825
			stepper.rotate(scanstepdeg); //rotate to next scan angle

			//output HIGH on SCAN_STEP_COMPLETE_PIN
//DEBUG!!
			//Serial.printf("Outputting HIGH on SCAN_STEP_COMPLETE_PIN\n");
			//Serial.printf("Done in %lu Msec - Current Angle = %3.2f\n", millis() - now, curRelPointingAngleDeg);
//DEBUG!!

			digitalWrite(SCAN_STEP_COMPLETE_PIN, HIGH);
			//delay(50);  //make the HIGH period visible on scope
		}

		//quit
		Serial.printf("Outputting HIGH on SCAN_COMPLETE_PIN (pin %d)\n", SCAN_COMPLETE_PIN);

		digitalWrite(SCAN_COMPLETE_PIN, HIGH);

		//return to start position
		//DRV8825
		stepper.setRPM(POSITIONING_SPEED_RPM);
		stepper.rotate(-scandeg);

		//re-initialize step counter and current pointing angle
		curAngleStepVal = 0;
		curRelPointingAngleDeg = scanStartDeg;

		Serial.printf("Enter any key to continue\n");
		while (!Serial.available())
		{

		}

		//consume bytes until Serial buffer is empty to avoid unintended triggers
		int incomingByte;
		while (Serial.available())
		{
			incomingByte = Serial.read();
			Serial.printf("Consuming 0x%x\n", incomingByte);
		}

	}
}


void loop()
{
}

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

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

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

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

//05/30/20 added to report current angle step# & relative pointing angle to measurement program
void requestEvent()
{
	//send the current step# and current relative pointing angle
//DEBUG!!
	//Serial.printf("In requestEvent: curAngleStep = %d, curRelAngle = %2.2f\n", 
	//	curAngleStepVal, curAngleStepVal, curRelPointingAngleDeg, curRelPointingAngleDeg);
//DEBUG!!

	I2C_writeAnything(curAngleStepVal);
	I2C_writeAnything(curRelPointingAngleDeg);
}

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

Name: Teensy_DRV8825_Rotary_Scan_Table.ino

Created: 6/4/2020 12:59:57 AM

Author: FRANKNEWXPS15\Frank

Teensy DRV8825 Rotary Table Program

This program controls a NEMA 17 stepper motor using a Pololu DRV8825 motor driver. It

Takes user input to define the boresight (zero) position and the start and stop angles

in degrees relative to the zero position. Then it moves to the start position and waits

for a HIGH level on SCAN_START_PIN. After this signal is received, the motor is

stepped through to the stop position. At the stop position, the SCAN_COMPLETE_PIN is

driven HIGH.

The Stepper motor is connected to a DRV8825 motor driver with one coil on A1/A2, and the

other coil on B1/B2. It may turn out that one coil's leads have to be reversed to match

the motor rotation direction with the program direction.

The NEMA 17 motor is assumed to execute 200 steps/revolution. Change the StepsPerRevolution

constant for other values.

05/27/20: Performs an angular scan over user-supplied range of angles. By default a complete scan

from start position to stop position is performed, followed by a return to the start position

However, if the STEP_ENABLE_PIN (held HIGH by default) is pulled LOW, the program will wait

until it goes HIGH before performing the next step. In this case, a scan iteration would go

as follows

Step 1 - Scan parameters entered, motor moves to start position, waits for LOW on SCAN_START_PIN

Step 2 - Measurement program pulls SCAN_START_PIN LOW for 1 sec, then back HIGH

Step 3 - Measurement program takes a measurement & retrieves step# & angle value via I2C request

Step 4 - Measurement program pulls SCAN_STEP_ENABLE_PIN LOW

Step 5 - Motor moves to first/next step, and outputs HIGH on SCAN_STEP_COMPLETE_PIN

Step 6 - Measurement program waits for HIGH on SCAN_STEP_COMPLETE_PIN

Step 7 - Measurement program takes a measurement & retrieves step# & angle value via I2C request

Step 8 - Repeat Steps 4-7 until scan complete

Step 9 - SCAN_COMPLETE_PIN goes HIGH

//O5/30/20 Added I2C connection to pass step# & relative angle values to measurement program

//05/02/20 Rev to use Pololu DRV8825 & micro-stepping

#include <Wire.h>

#include "I2C_Anything.h"

#include "DRV8825.h"

const int SLAVE_ADDR = 8; //added 05/30/20

#pragma region MOTOR_CONSTANTS

// Motor steps per revolution. Most steppers are 200 steps or 1.8 degrees/step

//06/02/20 now using Pololu DRV8825

const int MOTOR_STEPS_PER_REV = 200;

const int MICROSTEPS_PER_STEP = 32;

const int MICROSTEPS_PER_REV = MICROSTEPS_PER_STEP * MOTOR_STEPS_PER_REV;

const int DEG_PER_MICROSTEP = 360 / MICROSTEPS_PER_REV;

const int MICROSTEPS_PER_DEG = MICROSTEPS_PER_REV / 360;

const int DEFAULT_RPM = 12;

const int POSITIONING_SPEED_RPM = 100;

const int DEFAULT_MOTOR_STEPS_TO_MOVE = 10;

#pragma endregion Motor Constants

#pragma region PIN_ASSIGNMENTS

const int DIR = 8;

const int STEP = 9;

const int SLEEP = 13; // optional (just delete SLEEP from everywhere if not used)

const int MODE0 = 10;

const int MODE1 = 11;

const int MODE2 = 12;

const int SCAN_START_PIN = 2;

const int SCAN_STEP_ENABLE_PIN = 3;

const int SCAN_STEP_COMPLETE_PIN = 4;

const int SCAN_COMPLETE_PIN = 5;

#pragma endregion Pin Assignments

DRV8825 stepper(MOTOR_STEPS_PER_REV, DIR, STEP, SLEEP, MODE0, MODE1, MODE2);

char Instr[20];

//DRV8825

int zeroPos;

int scanStartDeg;

int scanStartMicroSteps; //scanStartDeg converted to steps

int scanStopDeg;

int scanStopSteps; //scanStopDeg converted to steps

int scanNumberofSteps; //added 05/27/20

int stepsToMove; //steps to move to initial position

int curMotorStepVal; //keeps track of current position, in steps

float curRelPointingAngleDeg; //keeps track of current relative pointing angle, in degrees

int curAngleStepVal; //keeps track of current table step iteration value

bool bStopPosDone = false;

int scanSpeedRpm = 6;

void setup()

{

//added 05/30/20 to provide step# & angle values to Angle Scan program

Wire.begin(SLAVE_ADDR);

Wire.setSCL(18);

Wire.setSCL(19);

Wire.setClock(100000);

Wire.onRequest(requestEvent);

//06/02/20 now using Pololu DRV8825 microstepping motor driver

stepper.begin(DEFAULT_RPM);

// if using enable/disable on ENABLE pin (active LOW) instead of SLEEP uncomment next line

// stepper.setEnableActiveState(LOW);

stepper.enable();

* Microstepping mode: 1, 2, 4, 8, 16 or 32 (where supported by driver)

* Mode 1 is full speed.

* Mode 32 is 32 microsteps per step.

* The motor should rotate just as fast (at the set RPM),

* but movement precision is increased, which may become visually apparent at lower RPMs.

stepper.setMicrostep(MICROSTEPS_PER_STEP); // Set microstep mode to 1:32

Serial.begin(115200);

unsigned long now = millis();

while (!Serial)

{

delay(10);

}

delay(5000); //05/28/20 delay AFTER Serial object instantiation is NECESSARY!

Serial.print("Serial available after "); Serial.print(millis() - now); Serial.print(" millisec");

pinMode(SCAN_START_PIN, INPUT_PULLUP);

pinMode(SCAN_STEP_ENABLE_PIN, INPUT_PULLUP);

pinMode(SCAN_STEP_COMPLETE_PIN, OUTPUT);

pinMode(SCAN_COMPLETE_PIN, OUTPUT);

//init SCAN_COMPLETE_PIN, SCAN_STEP_COMPLETE to LOW (not complete) state

digitalWrite(SCAN_COMPLETE_PIN, LOW);

digitalWrite(SCAN_STEP_COMPLETE_PIN, LOW);

//added 05/26/20

Serial.printf("Serial.printf: NEMA-17 Stepper Rotary Table Program\n");

//get motor speed to be used

scanSpeedRpm = GetIntegerParameter("Motor speed RPM", 6);

//set zero position

Serial.println("Set stepper zero position. Enter +steps for CW, -steps for CCW, Q to exit");

while (!bStopPosDone)

{

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

if (toascii(Serial.peek()) == 'Q' || toascii(Serial.peek()) == 'q')

{

bStopPosDone = true;

curMotorStepVal = 0;

}

else

{

stepsToMove = GetIntegerParameter("Steps to move (- = CCW, + = CW)?", DEFAULT_MOTOR_STEPS_TO_MOVE);

Serial.print("Steps to move = "); Serial.println(stepsToMove);

stepper.setRPM(POSITIONING_SPEED_RPM);

stepper.move(stepsToMove);

}

Serial.readString(); //clear the input buffer - could still have chars in it

Serial.print("curMotorStepVal = "); Serial.println(curMotorStepVal);

//set scan start/stop positions in degrees

scanStartDeg = GetIntegerParameter("Scan Start Pos in Degrees Relative to Zero", -90);

scanStopDeg = GetIntegerParameter("Scan Stop Pos in Degrees Relative to Zero", 90);

scanNumberofSteps = GetIntegerParameter("Number of Steps", 18);

curRelPointingAngleDeg = scanStartDeg; //added 05/30/20

Serial.println("Run Parameters:");

Serial.print("Speed: "); Serial.print(scanSpeedRpm); Serial.println(" RPM");

Serial.print("Scan Start: "); Serial.print(scanStartDeg); Serial.println(" Deg");

Serial.print("Scan Stop: "); Serial.print(scanStopDeg); Serial.println(" Deg");

Serial.print("Scan Steps: "); Serial.println(scanNumberofSteps);

//06/02/20 Now using Pololu DRV8825 driver & microstepping

int scandeg = abs(scanStopDeg - scanStartDeg);

double scanstepdeg = scandeg / scanNumberofSteps;

//go to scan start pos

stepper.setRPM(POSITIONING_SPEED_RPM);

stepper.rotate(scanStartDeg);

while (1) //user has opportunity to exit after each scan

{

//wait for trigger

Serial.printf("waiting for LOW on SCAN_START_PIN (pin %d) ...\n", SCAN_START_PIN);

while (digitalRead(SCAN_START_PIN) == HIGH)

{

delay(100);

}

Serial.println("Scan Triggered - starting scan, setting SCAN_COMPLETE_PIN to LOW\n");

digitalWrite(SCAN_COMPLETE_PIN, LOW);

stepper.setRPM(scanSpeedRpm);

for (curAngleStepVal = 1; curAngleStepVal <= scanNumberofSteps; curAngleStepVal++)

{

curRelPointingAngleDeg = scanStartDeg + (curAngleStepVal)*scanstepdeg;

//when SCAN_STEP_ENABLE_PIN goes LOW, go to first/next step.

while (digitalRead(SCAN_STEP_ENABLE_PIN))

{

}

unsigned long now = millis();

digitalWrite(SCAN_STEP_COMPLETE_PIN, LOW);

Serial.printf("Scan Step %d Triggered: moving to %3.2f deg\n", curAngleStepVal, curRelPointingAngleDeg);

//DRV8825

stepper.rotate(scanstepdeg); //rotate to next scan angle

//output HIGH on SCAN_STEP_COMPLETE_PIN

//DEBUG!!

//Serial.printf("Outputting HIGH on SCAN_STEP_COMPLETE_PIN\n");

//Serial.printf("Done in %lu Msec - Current Angle = %3.2f\n", millis() - now, curRelPointingAngleDeg);

//DEBUG!!

digitalWrite(SCAN_STEP_COMPLETE_PIN, HIGH);

//delay(50); //make the HIGH period visible on scope

}

//quit

Serial.printf("Outputting HIGH on SCAN_COMPLETE_PIN (pin %d)\n", SCAN_COMPLETE_PIN);

digitalWrite(SCAN_COMPLETE_PIN, HIGH);

//return to start position

//DRV8825

stepper.setRPM(POSITIONING_SPEED_RPM);

stepper.rotate(-scandeg);

//re-initialize step counter and current pointing angle

curAngleStepVal = 0;

curRelPointingAngleDeg = scanStartDeg;

Serial.printf("Enter any key to continue\n");

while (!Serial.available())

{

}

//consume bytes until Serial buffer is empty to avoid unintended triggers

int incomingByte;

while (Serial.available())

{

incomingByte = Serial.read();

Serial.printf("Consuming 0x%x\n", incomingByte);

}

void loop()

{

}

int GetIntegerParameter(String prompt, int defaultval)

{

int param = 0;

bool bDone = false;

while (!bDone)

{

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

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

//String res = Serial.readString().trim();

String res = Serial.readString();

res.trim();

int reslen = res.length();

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

{

bDone = true;

param = defaultval;

}

else

{

res.toCharArray(Instr, reslen + 1);

//if (isNumeric(Instr) && atoi(Instr) >= 0)

if (isNumeric(Instr))

{

param = atoi(Instr);

bDone = true;

}

else

{

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

}

Serial.println(param);

return param;

}

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

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

bool isNumeric(char* str)

{

byte ii = 0;

bool RetVal = false;

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

ii++;

while (str[ii])

{

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

ii++;

break;

}

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

ii++;

RetVal = true;

}

while (str[ii])

{

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

ii++;

RetVal = true;

}

return RetVal;

}

//05/30/20 added to report current angle step# & relative pointing angle to measurement program

void requestEvent()

{

//send the current step# and current relative pointing angle

//DEBUG!!

//Serial.printf("In requestEvent: curAngleStep = %d, curRelAngle = %2.2f\n",

// curAngleStepVal, curAngleStepVal, curRelPointingAngleDeg, curRelPointingAngleDeg);

//DEBUG!!

I2C_writeAnything(curAngleStepVal);

I2C_writeAnything(curRelPointingAngleDeg);

}

And the updated hardware schematic:

Here’s the output from a typical 180-degree scan

The triple VL53L0X scanner program:

Starting Angle Scan...
 
Msec	Step#	RelDeg	Front	Center	Rear	Steer
23815846	0	-90.00	121	30	17	3.47
23816965	1	-80.00	120	28	19	3.61
23817408	2	-70.00	118	29	18	3.45
23817852	3	-60.00	120	30	20	3.33
23818296	4	-50.00	123	32	19	3.25
23818740	5	-40.00	120	28	20	3.57
23819183	6	-30.00	122	30	19	3.43
23819627	7	-20.00	119	29	22	3.34
23820071	8	-10.00	122	29	19	3.55
23820515	9	0.00	121	31	20	3.26
23820958	10	10.00	122	31	17	3.39
23821402	11	20.00	120	30	16	3.47
23821846	12	30.00	120	27	22	3.63
23822290	13	40.00	120	31	20	3.23
23822733	14	50.00	124	29	19	3.62
23823177	15	60.00	120	30	19	3.37
23823621	16	70.00	123	29	23	3.45
23824065	17	80.00	120	31	18	3.29
23824508	18	90.00	116	31	20	3.10
SCAN_COMPLETE_PIN HIGH Received - Scan is Complete!
Enter Q to quit, anything else for another scan

Starting Angle Scan...

Msec Step# RelDeg Front Center Rear Steer

23815846 0 -90.00 121 30 17 3.47

23816965 1 -80.00 120 28 19 3.61

23817408 2 -70.00 118 29 18 3.45

23817852 3 -60.00 120 30 20 3.33

23818296 4 -50.00 123 32 19 3.25

23818740 5 -40.00 120 28 20 3.57

23819183 6 -30.00 122 30 19 3.43

23819627 7 -20.00 119 29 22 3.34

23820071 8 -10.00 122 29 19 3.55

23820515 9 0.00 121 31 20 3.26

23820958 10 10.00 122 31 17 3.39

23821402 11 20.00 120 30 16 3.47

23821846 12 30.00 120 27 22 3.63

23822290 13 40.00 120 31 20 3.23

23822733 14 50.00 124 29 19 3.62

23823177 15 60.00 120 30 19 3.37

23823621 16 70.00 123 29 23 3.45

23824065 17 80.00 120 31 18 3.29

23824508 18 90.00 116 31 20 3.10

SCAN_COMPLETE_PIN HIGH Received - Scan is Complete!

Enter Q to quit, anything else for another scan

The DRV8825 Rotary Table program:

waiting for LOW on SCAN_START_PIN (pin 2) ...
Scan Triggered - starting scan, setting SCAN_COMPLETE_PIN to LOW

Scan Step 1 Triggered: moving to -80.00 deg
Scan Step 2 Triggered: moving to -70.00 deg
Scan Step 3 Triggered: moving to -60.00 deg
Scan Step 4 Triggered: moving to -50.00 deg
Scan Step 5 Triggered: moving to -40.00 deg
Scan Step 6 Triggered: moving to -30.00 deg
Scan Step 7 Triggered: moving to -20.00 deg
Scan Step 8 Triggered: moving to -10.00 deg
Scan Step 9 Triggered: moving to 0.00 deg
Scan Step 10 Triggered: moving to 10.00 deg
Scan Step 11 Triggered: moving to 20.00 deg
Scan Step 12 Triggered: moving to 30.00 deg
Scan Step 13 Triggered: moving to 40.00 deg
Scan Step 14 Triggered: moving to 50.00 deg
Scan Step 15 Triggered: moving to 60.00 deg
Scan Step 16 Triggered: moving to 70.00 deg
Scan Step 17 Triggered: moving to 80.00 deg
Scan Step 18 Triggered: moving to 90.00 deg
Outputting HIGH on SCAN_COMPLETE_PIN (pin 5)
Enter any key to continue

waiting for LOW on SCAN_START_PIN (pin 2) ...

Scan Triggered - starting scan, setting SCAN_COMPLETE_PIN to LOW

Scan Step 1 Triggered: moving to -80.00 deg

Scan Step 2 Triggered: moving to -70.00 deg

Scan Step 3 Triggered: moving to -60.00 deg

Scan Step 4 Triggered: moving to -50.00 deg

Scan Step 5 Triggered: moving to -40.00 deg

Scan Step 6 Triggered: moving to -30.00 deg

Scan Step 7 Triggered: moving to -20.00 deg

Scan Step 8 Triggered: moving to -10.00 deg

Scan Step 9 Triggered: moving to 0.00 deg

Scan Step 10 Triggered: moving to 10.00 deg

Scan Step 11 Triggered: moving to 20.00 deg

Scan Step 12 Triggered: moving to 30.00 deg

Scan Step 13 Triggered: moving to 40.00 deg

Scan Step 14 Triggered: moving to 50.00 deg

Scan Step 15 Triggered: moving to 60.00 deg

Scan Step 16 Triggered: moving to 70.00 deg

Scan Step 17 Triggered: moving to 80.00 deg

Scan Step 18 Triggered: moving to 90.00 deg

Outputting HIGH on SCAN_COMPLETE_PIN (pin 5)

Enter any key to continue

For anyone interested in using this program, it is available on my GitHub site at https://github.com/paynterf/Teensy-DRV8825-Rotary-Scan-Table

Off-perpendicular measurement problems with HC-SRO4 Ping Measurements

1 Reply

Posted 14 May 2020,

For the last couple of months I have been working lately on updating my four-wheel autonomous wall-following robot. Unfortunately, I have been unable to really nail down an effective algorithm for capturing and then holding a specified offset distance from the nearest wall. If the robot starts with its body oriented parallel to the wall, it can successfully capture and then hold the desired distance. Unfortunately, it has turned out to more difficult than I thought to consistently obtain the required parallel orientation starting position.

So, came up with an idea that was sure to work; instead of making a sweeping turn looking for an inflection point in the distance reported by the HC-SR04 ‘ping’ sensor, I would instead make a series of N-degree turns. I wouldn’t know the absolute orientation of the robot with respect to the wall, but I would know the total angle subtended by the robot, and (I thought) it should be much easier to determine the inflection point from the resulting Angle/Distance table.

Unfortunately, when I tested this idea, it failed because the distances reported by the ping sensor didn’t vary significantly, even though I could plainly see that the actual distance between the robot’s ping sensor and where the sensor was pointing was changing significantly – what the heck? The following short video clip and Excel plot show the situation.

If you were to believe the Excel plot, the inflection point denoting parallel orientation would actually be at about 63 degrees off the perpendicular – clearly not right.

To further investigate the issue, I ran some simple manual ping vs tape measure and LIDAR vs tape measure tests. The following photo shows the setup, and the Excel plots show the results.

Setup for LIDAR vs tape vs angle measurements. The ‘Ping’ vs tape measurements were set up the same way

As the above plots show, the ping sensor measurements are basically useless for anything more than a few degrees off perpendicular; as the ‘ping diff’ plot in the upper chart shows, the inflection point could be anywhere. In contrast, the manual tape measurements show a distinct curve, and the point-point differential changes sign at very close to 0 deg off perpendicular.

The lower plot shows the same measurements but using LIDAR rather than the ultrasonic ping sensors. As the plot shows, the LIDAR measurements would actually be reasonably accurate; the inflection point for both the LIDAR measurement (the ‘LIDAR diff’ line above) and the tape measurement (‘Tape Diff’ line above) is at approximately 0 degrees off perpendicular. Unfortunately, the Pulsed Light ‘LIDAR-lite’ units are much more expensive than the ubiquitous HC-SRO4 ‘ping’ sensor.

After noodling around on the web for a while, I found some references to a GY-530/VL53L0X ‘Time of Flight’ (ToF) sensor that looks like it might do the job. From the Adafruit description of this neat device:

3 to 120 cm in ‘default’ mode
As far as 1.5 to 2 meters on a nice white reflective surface in ‘long range’ mode
3-5V compatible
Control via I2C (default addr = 0x29, but can be configured during setup)
Less than 40mA current draw

The big question, of course, is whether or not this device will be any better at off-perpendicular measurements than the ‘ping’ sensors. I have some on order so hopefully I’ll be able to answer this question shortly.

18 May 2020 Update:

I got my GL530/VLX53L0X sensor in yesterday and I’ve now had a chance to play with it a bit. It’s super small and pretty responsive. Here’s a photo of the setup with an Arduino UNO.

GL530/VL53L0X ToF sensor test setup. Note the sensor could fit on a U.S. dime with room to spare

I got it to play and produce basic distance data, but haven’t done much else with it yet. However, while noodling around looking at data sheets, I ran across this demo video by an ST engineer, and it really started me thinking about different ways to use this device as one of an array of sensors; maybe this would make the ‘RotateToParallelOrientation()’ function easier – or even unnecessary!

19 May Update:

I was able to make some reasonably precise measurements today with the GY530/VL53L0X Time-of-Flight sensor. Here’s the setup:

Testing setup for GY530/VL53LOX ToF Sensor. Note wood board test surface in background

And here’s a plot of the measured distance vs off-perpendicular angle, along with actual tape measure value for accuracy comparisons

While the measuring tape values and sensor distance values track very well over the -50 to +40 deg range, they aren’t the same. The sensor measurements are consistently lower, by 10 mm or so. That’s not a big deal, and there may be some calibration techniques available to zero out any constant error term.

I also noticed that the sensor value returned were occasionally dead wrong, reporting a value of 20 mm when the real value was more like 300-350. Again, this might be addressable by averaging, but…

And lastly, as shown by the above plot, above about 40 degrees off-perpendicular, the sensor measurements become unreliable, probably due to low SNR return signal.

The good news is that the off-perpendicular plot does seem to behave fairly well in the -30 to +30 degree range, and has the expected quadratic bowl shape, so it should be usable for finding the parallel point, and maybe even for providing a steering value to a PID engine for offset hold operations once the proper offset has been captured.

To explore the ‘steering value’ idea, I simulated a 3-sensor setup by picking values out of the above plots 3 at a time. For instance assuming the -40, -10, and +20 degree values were taken at the same time by 3 different sensors. The following plot shows the results of the following calculation:

(M_l – M_r)/M_c

where, ‘l’, ‘r’ and ‘c’ subscripts refer to the left, right, and center sensors in a 3-sensor array angled at -30, 0 and +30 degrees respectively. Here’s the plot

simulation of a 3-sensor array created by picking values from single-sensor sweep

This plot is quite exciting, as it shows a clear linear relationship between off-perpendicular orientation and steering values that could be used as the input to a PID engine.

Stay tuned,

Frank

I2C between an Arduino Mega and a Teensy 3.x

3 Replies

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

Wall tracking: finding the heading parallel to the nearest wall

Background:

For some time now I have been working on ways to enhance Wall-E2’s autonomous wall-tracking ability. Wall-E2 can track walls fairly well, but lacks the ability to track a wall at a specified stand-off distance. Currently, tracking occurs at whatever distance Wall-E2 first detects the nearest wall. While this isn’t terrible, I wanted to do better.

Unfortunately, the way in which the measured ‘ping’ distance to the nearest wall interacts with the relative orientation of the robot with respect to that wall makes it almost impossible to determine the actual offset distance, and therefore how to determine what to do to maintain a constant offset distance. As shown in the following diagram, when the robot makes a turn, the measured distance to the wall will change just due to the orientation change, without the robot’s actual offset distance changing at all.

Without having some idea of the angle theta in the above diagram, making a judgement of where the robot is relative to the target offset distance is difficult, if not impossible. This situation was the impetus for adding the MPU6050 Inertial Measurement Unit (IMU) to Wall-E2’s list of super powers. The general idea was that knowledge of relative headings would allow Wall-E2 to make accurate heading-controlled turns without relying solely on timing. After a lot of work to eliminate RFI/EMI problems associated with the Pololu metal-geared motors on Wall-E2, I’m happy to say that the MPU6050 is now quite stable, and making turns of just a few degrees is quite possible.

However, acquiring and then maintaining a particular offset distance from the nearest wall is still not straightforward. Back in early December last year I demonstrated the ability to acquire and then maintain a constant offset distance, but only if the robot started out reasonably parallel to the wall. If the robot was oriented toward or away from the wall by more than a few degrees, it would not work. So I needed to find a way to first orient the robot parallel to the nearest wall at any distance, so that my current acquisition & tracking algorithm would work successfully.

The basic idea behind finding the parallel heading is that when the robot is turned through a forward arc and the measured ‘ping’ distance decreases and then starts increasing, the robot’s relative heading at this inflection point is the desired parallel heading. If the distance instead starts increasing, then the robot started out either parallel to or facing away from the wall. In either case, reversing the turn back toward the wall will cause the measured distance to decrease to a minimum and then increase again. As in the first case the heading at the point at which the measured distance starts to increase is the desired parallel heading.

Although the basic idea as described above is very straightforward, as usual there are some ‘gotchas’ in the actual implementation:

In order to minimize heading overshoot due to the robot’s mass and angular momentum, the parallel heading search turns must be performed at lower-than-normal speeds. After some experimentation I settled on a turn rate of about 60 deg/sec. With the robot starting with an angle-in orientation of about 30 deg, this means that it takes about 1 second to sweep through to an angle-out orientation of about 30 deg. With the Arduino UNO setup I’m using for the tests, I was getting distance measurements about every 30-50 mSec, so about 33 to 20 measurements/sec, or around 2-3 measurements/degree.

The lower turn rate significantly reduces the rate at which the ‘ping’ distance changes per unit time, making it much harder to detect the distance inflection point. In effect, the lower turn rate flattens the ‘distance/degree’ slope, making inflection point detection more difficult. At 20-30 measurements/degree and only a few cm change from max on one side to max on the other, there are a lot of identical measurements returned.

My initial cut at addressing the the above issue was to space the ping measurements further apart in time, thereby increasing the ‘distance/degree’ slope. After trying this (using a ‘elapsedMillisec’ variable) I realized that an equivalent method would be to simply increase the size of the inflection detection window (the number of times the ping measurement must be on the ‘other side’ of the inflection point in order to qualify as a valid inflection). After some experimentation, I arrived at a value of 20.

For some reason, it was much easier to find a good parallel heading value if the robot started out pointed toward the near wall. If it started out pointed away from the wall, the robot often stopped well short of or well after the actual parallel heading. Eventually I developed a 4-turn process for this case to really nail down the parallel heading. Here are some short videos demonstrating the algorithm.

Now that I can reliably determine the relative heading that orients the robot parallel to the nearest wall, I should be able to marry this capability with my already-developed algorithm for acquiring and maintaining a specific offset distance.

20 February 2020 Update:

So I combined the ‘find parallel heading’ feature with my already-existing angle-based tracking algorithm, and this worked fairly well. Here’s a short video demonstrating the technique:

In the above video, the blue painter’s tape strips are marked every 10 cm, with a double-width mark at 30 cm (the desired offset distance). As the video shows, the robot first determines an approximate parallel heading, and from there starts the normal angle-based tracking algorithm.

Next, I tried an ‘enhancement’ to the above by having the robot move toward the wall on a 30-45 deg ‘cut’ from the parallel heading, and then turning back to parallel at the desired offset distance. As the following video shows, this didn’t turn out so well. If the robot doesn’t start out exactly parallel, then the ‘cut’ is either too steep or too shallow, resulting in a too-early or too-late turn back to the parallel heading.

So it looks like the ‘find parallel then start tracking’ approach works pretty well, but the ‘find parallel then drive to offset on a cut then back to parallel’ approach hasn’t been very successful.

27 February 2020 Update

After thinking about the difficulties I was encountering with my ‘FindParallel’ algorithm, I realized that the reason the robot was often overshooting the parallel orientation was due to small aberrations in ‘ping’ distance measurements that caused the ‘hit counter’ to reset to zero in the middle of an otherwise perfect arc of distance values. The ‘hit counter’ is incremented each time the newest ‘ping’ distance measurement trends along the same line, and is reset to zero whenever the newest ping measurement breaks the trend. When the hit counter exceeds a preset level, the parallel condition is considered to be detected. I thought I might be able to improve performance by making the algorithm a little more tolerant of such aberrations. So, rather than having the ‘hit counter’ reset to zero, I changed the algorithm to decrement by a set amount rather than reset it to zero. This markedly improved performance, as shown in the following videos.

There are four sections in the above video. In the first clip, the robot starts out pointed away from the wall and outside the desired 30 cm offset. The ‘FindParallel’ algorithm executes, and then approaches and then tracks the wall at the desired 30 cm offset. The next three clips show the same situation, except starting outside the 30 cm offset and pointed toward the wall, and then from inside the 30 cm offset, pointed away from and toward the wall. In each case, the robot successfully acquires a reasonably parallel heading and then acquires and tracks the 30 cm offset distance.

Stay tuned!

Frank

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

1 Reply

Posted 25 January 2020

About 6 weeks ago I posted that I had finally killed the “intermittent MPU6050 failure” dragon, by belatedly following Pololu’s recommendations for installing bypass capacitors on their metal-geared motors. Unfortunately it turned out that my celebration was cut short by more annoying intermittent MPU6050 failures, so I was once again forced back to the drawing board.

This time I decided that the only way to figure out what was going on was to actively examine the I2C traffic in real time, to determine who exactly was doing what to whom. So, over the course of the six week period between my last declaration of victory to this one, I created a Teensy based I2C bus ‘sniffer’ and used it to figure out what was going on. I was able to determine that the ‘master’ micro-controller continued to operate normally through a failure, but the MPU6050 didn’t. I was also able to determine that just resetting the IMU would not allow the system to recover, but resetting the micro-controller often did. Moreover, I was able to definitively show that the problem was caused by ‘contact bounce’ on one or more of the four 6″ male-male jumper wires connecting the micro-controller to the IMU. Eliminating these jumpers also (I hope) eliminated the last piece of the “I2C Intermittent failure” puzzle.

Looking back over the entire I2C failure saga, I now realize that this was the classic case of multiple failure modes complicating the troubleshooting effort. The RFI/EMI problem caused by the Pololu metal-geared motors completely overshadowed the issue of non-secure jumper connections. Then, after finally coming to my senses and installing the recommended bypass capacitors on the motors, the ‘contact bounce’ problem was unmasked. I do love interesting problems, but this one went past ‘interesting’ and was well into ‘agonizing’ by the time I got it solved ;-).

After getting everything set up, I ran some wall tracking tests in my entry hall ‘test range’ with pretty good results, as shown in the short video clip below.

Stay tuned,

Frank

30 January 2020 Update:

Still having trouble with the initial approach to a wall from outside the target distance. The robot still has a tendency to dive into the wall, unable to cope with the problem of the measured distance increasing instead of decreasing when the robot turns into the wall. This inverse relationship makes it almost impossible to use a simple ‘turn toward the wall and wait for the distance to count down’ technique.

After thinking about this for while, I realized that this would all be so much simpler if I cheated and started with the robot placed parallel to the target wall. Then the robot could simply turn 45 deg toward the wall and proceed until the measured wall distance was appropriate (Dtgt / 0.707), and then turn parallel again. Then I realized that I could easily determine the parallel condition by turning the robot toward and/or away from the wall while continuously measuring the distance; when the measurement goes through a minimum, then the robot is parallel to the wall. Simple in concept, and not all that hard to program, either.

IMU Motor Noise Troubleshooting, Part III

1 Reply

Posted 19 January 2020

In Part II of this saga, I described my continuing efforts to track down and fix the problem of intermittent failures associated with the MPU6050 IMU on my robot. The MPU6050 IMU is required for the ability to make precise heading-based turns, which is in turn required to track walls at a designated stand-off distance.

This post summarizes the work to date and suggests new avenues of investigation for fully addressing the motor noise issue.

Summary of work to date:

July 2019: First started working with heading-based turns, and first noticed the motor noise problem. Basically the problem presented itself as frequent, abrupt, and wildly divergent heading readings when the motors were running, but perfectly stable readings when the motors are not running. See this post for the details.
October 2019: Successfully demonstrated polling-based (vs interrupt-based) MPU6050 IMU management. This development meant that I could acquire yaw (heading) values on an as-needed basis rather than at a 20 or 200Hz rate, throwing away 99% of the results. This was demonstrated in this post.
November 2019: Made another run at solving the motor noise problem using a home-brew optical isolator and a 2-stage power filter. After a LOT of work, I wound up discovering that most (but not all!) of the problem could be addressed with proper RF bypassing at the terminals of the metal-geared Pololu motors I was using. See this post for the details.
Early December 2019: Demonstrated heading-based wall offset tracking using my 2-motor robot, with RF bypassing installed on both Pololu metal gear motors. No IMU failures were noticed during these runs. See this post for details.
Early December 2019: Reprised some of the motor driver testing performed back in May of 2019 (see this post), and again noticed MPU6050 IMU communication failures when the motors were running, but none when the motors weren’t running. This test was performed on the 2-motor robot using the Pololu motors with the RF bypassing in place. So clearly just the bypassing was not of and by itself sufficient to solve the problem; something else had to be going on. See this post for the details.
Late December 2019 to mid-January 2020: I decided I needed a tool to monitor the I2C bus traffic between the robot’s controller and the MPU6050 IMU – an I2C ‘sniffer’. After some research, I found that the cheapest commercial sniffer cost about $330, and DIY sniffers were few and far between. I did, however, find a Teensy-based sniffer program by Kito, so I had a starting place. After three major development stages, I had a Teensy 3.2 program that would reliably monitor I2C communications between an Arduino (Mega or Uno) master and a MPU6050 slave, using the polling approach developed earlier. See this post, this post, and this post for the development details.

Current Effort:

With the above history in mind, I applied my new I2C sniffer tool to the Motor Noise Problem. As usual, I started this using the simplest possible setup; an Arduino Mega acting as the I2C master running my polling based ‘MPU6050_MotorNoiseTest1’ program, and a Teensy 3.2 and a MPU6050 IMU module both mounted on a small plugboard, as shown below.

Arduino Mega I2C master, with Teensy I2C sniffer and MPU6050 module on a separate plugboard

I played around with this setup for a while, and captured at least one IMU communications failure with the sniffer active. The failure occurred when I was moving the plugboard around a bit to verify that the MPU6050 IMU heading values changed appropriately. At some point I noticed the I2C monitor output had changed its character significantly, so I quickly stopped the sniffer program and opened the log file (see attached file below).

From the log I can see that things proceeded normally until 6012443 mSec ( 1.67 hours) and then changed to report that nothing was being received from register 0x72 (the FIFO count register). This continued until 6022224 mSec (9.8 seconds later) where it returned to what looks like normal operation.

So, my preliminary guess at what happened is the connection from the Mega to the Teensy/MPU6050 got dropped momentarily, and it took the Teensy a while to find another START sequence in the I2C data stream from the Mega, as the ‘2048’ number in “6017280: processed = 2048 elements in 3 mSec” means that the capture buffer overflowed before a START sequence was detected. “At 6022240: processed = 1224 elements in 2 mSec” means that a normal Mega ‘burst’ was captured and operation returned to normal.

Since the Teensy I2C monitor is on the MPU6050 end of the male-male jumpers, It begins to look like the Mega was still doing fine, but the jumper connection burped on one end or the other. More testing to follow.

Taking too long?

Reload document

Open in new tab

Download

Next, I moved the plugboard containing the Teensy I2C Sniffer and the MPU6050 module to my 2-motor robot, and used the existing Arduino Uno on the robot as the master, as shown below.

I loaded my MotorNoiseTest1 program on the Uno, and allowed it to run both motors at a steady rate, while monitoring the I2C traffic with the Teensy, and also monitoring the heading values being printed out by the Uno. I started the program just before 1PM, and it was still running fine with no IMU errors at 10pm, more than 9 hours later! The I2C sniffer log shows regular communication with the MPU6050, and the calculated yaw value based on the packet bytes received by the sniffer program matches the yaw value calculated in the Uno program. This is clear verification that the sniffer program will run ‘forever’, and that at least in this case, the two motor robot will also run ‘forever’ with no yaw errors.

Based on my earlier experience with the captured I2C communications failure, I’m more inclined now to believe that motor vibration or other mechanical perturbation is causing a momentary I2C bus or power/ground lead disconnect. More tests to follow:

21 January 2020 Update:

After the 10-hour run described above, I tried to induce some failures by fiddling with the I2C and power/ground jumper wires, and found that I could easily and reliably cause a failure by ‘flicking’ the wires with my finger or a pen. After each failure, the built-in recovery routine of clearing the FIFO and resetting the DMP failed to restore communications. However, manually resetting the UNO did allow the system to recover.

From the above, I believe it’s safe to say that the current male-male jumper connections between the UNO and the Teensy/IMU are unreliable, and are hopefully the only remaining failure mode. I haven’t quite figured out how to replace the connections with something more reliable, but I’m working on it. I moved the IMU module from the plugboard and plugged its I2C pins directly into the I2C sockets on the UNO. Then I replaced the power & ground leads with a permanent twisted pair connection to the Wixel shield, as shown in the following photo.

MPU6050 plugged directly into Uno board, with pwr/gnd jumpers replaced with permanent twisted pair

Then I fired up the system and ran it for a while but was unable to make it fail. This is encouraging news to say the least.

Stay tuned,

Frank

Teensy I2C Sniffer for MPU6050 Part II

1 Reply

Posted 13 January 2020,

In my last post on this subject, I described my efforts to build an I2C bus sniffer using a Teensy 3.2 micro-controller. This post describes my efforts to move from a fixed array containing a 928-byte snapshot of an I2C bus conversation between an Arduino Mega 2560 and a MPU6050 IMU to a live, repeated-burst setup.

As the source for I2C traffic for the MPU6050 IMU I am using my MPU6050_MotorNoiseTest1 Arduino project with no motors or sensors connected. All the code does is ask the MPU6050 for a yaw value every 200 mSec (the value of NAV_UPDATE_INTERVAL_MSEC), as shown below:

void loop()
{
	if (bFirstTime)
	{
		bFirstTime = false;
		mySerial.printf("Min\tYaw\tLDist\tRDist\n");
	}

	if (sinceLastNavUpdateMsec >=  NAV_UPDATE_INTERVAL_MSEC)
	{
		sinceLastNavUpdateMsec -= NAV_UPDATE_INTERVAL_MSEC;

		bool getYawResult = GetIMUHeadingDeg(); //updates global_yawval if successful

		if (getYawResult == 0)
		{
			if (mpu.testConnection())
			{
				mySerial.printf("resetting IMU\n");
				mpu.reset();
				delay(50);
			}
		}

		int leftdist = GetLeftDistCm();
		int rightdist = GetRightDistCm();

		mySerial.printf("%3.2f\t%3.2f\t%d\t%d\n", millis()/60000.0, global_yawval, leftdist, rightdist);
	}
}

void loop()

{

if (bFirstTime)

{

bFirstTime = false;

mySerial.printf("Min\tYaw\tLDist\tRDist\n");

}

if (sinceLastNavUpdateMsec >= NAV_UPDATE_INTERVAL_MSEC)

{

sinceLastNavUpdateMsec -= NAV_UPDATE_INTERVAL_MSEC;

bool getYawResult = GetIMUHeadingDeg(); //updates global_yawval if successful

if (getYawResult == 0)

{

if (mpu.testConnection())

{

mySerial.printf("resetting IMU\n");

mpu.reset();

delay(50);

}

int leftdist = GetLeftDistCm();

int rightdist = GetRightDistCm();

mySerial.printf("%3.2f\t%3.2f\t%d\t%d\n", millis()/60000.0, global_yawval, leftdist, rightdist);

}

The Teensy code to monitor the I2C bus traffic is shown below. When I first started working with this project, I copied Kito’s I2C sniffer code, which used Teensy’s Timer1 interval timer set to produce interrupts every 1 uSec, and an ISR to capture the data. This turned out to be hard to deal with, as I couldn’t add instrumentation code to the ISR without overrunning the 1 uSec interrupt period, leading to confusing results. So, for this part of the project I disabled the Timer1 interrupt, and called the ISR directly from the loop() function. As others have pointed out, the Arduino loop() function does a lot of housekeeping in the background, so for top performance it is best to never let loop() execute, by placing another infinite loop inside loop() or inside setup(). This is what I did with the code designed to investigate whether or not the Teensy could keep up with an I2C bus running at 100Kbs.

/*
    Name:       Teensy_I2C_Sniffer_V9.ino
    Created:	1/10/2020 4:15:25 PM
    Author:     FRANKNEWXPS15\Frank
*/


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

const uint16_t CAPTURE_ARRAY_SIZE = 2048;
const uint16_t VALID_DATA_ARRAY_SIZE = 2048;

uint8_t raw_data[CAPTURE_ARRAY_SIZE]; //holds data captured from I2C bus
uint8_t valid_data[VALID_DATA_ARRAY_SIZE]; //invalid bytes removed
//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


//#define PARSE_LOOP_DEBUG
//#define GET_8BIT_DATABYTE_DEBUG

#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;
uint16_t numvalidbytes = 0; //number of valid bytes in this burst
uint16_t read_idx = 0; //pointer to next byte pair to be processed
unsigned long curMsec;
unsigned long lastMsec;

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

//added for bus direction labels
enum BUS_STATES
{
    IDLE, //repeated 0xC/0xC
    ACTIVE,//0xC/0x4 transition
    COUNTING, //0x4/0xC transition, but 0XC count < MAC_0XC_COUNT
    PROCESSING //0XC count >= MAC_0XC_COUNT 
};

enum BUS_STATES last_State = IDLE;
enum BUS_STATES BusState = IDLE;


#pragma region ISR_SUPPORT
volatile uint16_t  write_idx = 0;
volatile uint16_t  BurstLength = 0;
uint16_t  read_index = 0;
uint8_t   current_portb = 0xFF;
uint8_t   last_portb = 0xFF;
bool bBufferFull = false;
uint16_t idlecount = 0; //used to detect EOM (end-of-message)
//const uint16_t MAX_IDLE_COUNT = 10000; //how many idle cycles before EOM detection
//const uint16_t MAX_IDLE_COUNT = 5000; //how many idle cycles before EOM detection
const uint16_t MAX_IDLE_COUNT = 2500; //how many idle cycles before EOM detection
//const uint16_t MAX_IDLE_COUNT = 1000; //how many idle cycles before EOM detection
//const uint16_t MAX_IDLE_COUNT = 20000; //how many idle cycles before EOM detection
//const uint16_t MAX_IDLE_COUNT = 30000; //how many idle cycles before EOM detection

volatile bool bStartCapture = false;
volatile uint16_t mult0xCCount = 0;
#pragma endregion ISR Support

volatile bool bDone = false;
unsigned long timevals[100];
uint8_t timevalidx = 0;
//-------------------------------------------------------------------------------
//--------------------------------    ISR    ------------------------------------
//-------------------------------------------------------------------------------
//01/06/2020 modified back to capture data from SDA/SCL lines
//01/09/20 modified to just capture between START & STOP
void capture_data(void)
{
    last_portb = current_portb;
    current_portb = GPIOB_PDIR & 12; //reads state of SDA (18) & SCL (19) at same time

    if (last_portb == 0xC && current_portb == 0x4) //START  
    {
        digitalWriteFast(MONITOR_OUT2, HIGH);
        digitalWriteFast(MONITOR_OUT3, HIGH);
        bDone = false;
        mult0xCCount = 0;
    }
    else if (last_portb == 0x4 && current_portb == 0xc) //STOP
    {
        digitalWriteFast(MONITOR_OUT2, LOW);
        mult0xCCount = 0;
    }
    else if (mult0xCCount < MAX_IDLE_COUNT && last_portb == 0xc && current_portb == 0xc)
    {
        mult0xCCount++;
        if (mult0xCCount >= MAX_IDLE_COUNT)
        {
            digitalWriteFast(MONITOR_OUT3, LOW);
            //mult0xCCount = 0;
            //Serial.printf("%lu: wrote %d bytes\n", millis(),write_idx);
            Serial.printf("%lu\t%d\n", millis(),write_idx);
            bDone = true;
        }
    }
    if (!bDone)
    {
        digitalWriteFast(MONITOR_OUT1, HIGH);
        raw_data[write_idx++] = last_portb;
        raw_data[write_idx++] = current_portb;
        if (write_idx >= CAPTURE_ARRAY_SIZE)
        {
            //BurstLength = write_idx;
            write_idx = 0;
        }
        digitalWriteFast(MONITOR_OUT1, LOW);
    }
}


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


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);
    pinMode(MONITOR_OUT2, OUTPUT);
    pinMode(MONITOR_OUT3, OUTPUT);
    pinMode(LED_BUILTIN, OUTPUT);

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

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

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

    Serial.printf("mSec\tlast\tnew\tmult\tburst\n");


    mSecSinceLastWaitingPrint = 0;
    last_State = BusState = BUS_STATES::IDLE;  
    curMsec = millis();
    lastMsec = curMsec;
}

void loop()
{
    while (true)
    {
        capture_data();
    }
}

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 - 1; i++)
    {
        if (i % 40 != 0)
        {
            Serial.printf("0x%x,", data[i + startidx]);
        }
        else Serial.printf("\n");
    }
    Serial.printf("0x%x\n", data[numbytes + startidx - 1]);
}

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

Name: Teensy_I2C_Sniffer_V9.ino

Created: 1/10/2020 4:15:25 PM

Author: FRANKNEWXPS15\Frank

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

const uint16_t CAPTURE_ARRAY_SIZE = 2048;

const uint16_t VALID_DATA_ARRAY_SIZE = 2048;

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

uint8_t valid_data[VALID_DATA_ARRAY_SIZE]; //invalid bytes removed

//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

//#define PARSE_LOOP_DEBUG

//#define GET_8BIT_DATABYTE_DEBUG

#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;

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

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

unsigned long curMsec;

unsigned long lastMsec;

//added for bus direction labels

enum BUSDIR

{

WRITE,

READ,

UNKNOWN = -1

} RWDir;

BUSDIR BusDir = BUSDIR::UNKNOWN;

//added for bus direction labels

enum BUS_STATES

{

IDLE, //repeated 0xC/0xC

ACTIVE,//0xC/0x4 transition

COUNTING, //0x4/0xC transition, but 0XC count < MAC_0XC_COUNT

PROCESSING //0XC count >= MAC_0XC_COUNT

};

enum BUS_STATES last_State = IDLE;

enum BUS_STATES BusState = IDLE;

#pragma region ISR_SUPPORT

volatile uint16_t write_idx = 0;

volatile uint16_t BurstLength = 0;

uint16_t read_index = 0;

uint8_t current_portb = 0xFF;

uint8_t last_portb = 0xFF;

bool bBufferFull = false;

uint16_t idlecount = 0; //used to detect EOM (end-of-message)

//const uint16_t MAX_IDLE_COUNT = 10000; //how many idle cycles before EOM detection

//const uint16_t MAX_IDLE_COUNT = 5000; //how many idle cycles before EOM detection

const uint16_t MAX_IDLE_COUNT = 2500; //how many idle cycles before EOM detection

//const uint16_t MAX_IDLE_COUNT = 1000; //how many idle cycles before EOM detection

//const uint16_t MAX_IDLE_COUNT = 20000; //how many idle cycles before EOM detection

//const uint16_t MAX_IDLE_COUNT = 30000; //how many idle cycles before EOM detection

volatile bool bStartCapture = false;

volatile uint16_t mult0xCCount = 0;

#pragma endregion ISR Support

volatile bool bDone = false;

unsigned long timevals[100];

uint8_t timevalidx = 0;

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

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

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

//01/06/2020 modified back to capture data from SDA/SCL lines

//01/09/20 modified to just capture between START & STOP

void capture_data(void)

{

last_portb = current_portb;

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

if (last_portb == 0xC && current_portb == 0x4) //START

{

digitalWriteFast(MONITOR_OUT2, HIGH);

digitalWriteFast(MONITOR_OUT3, HIGH);

bDone = false;

mult0xCCount = 0;

}

else if (last_portb == 0x4 && current_portb == 0xc) //STOP

{

digitalWriteFast(MONITOR_OUT2, LOW);

mult0xCCount = 0;

}

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

{

mult0xCCount++;

if (mult0xCCount >= MAX_IDLE_COUNT)

{

digitalWriteFast(MONITOR_OUT3, LOW);

//mult0xCCount = 0;

//Serial.printf("%lu: wrote %d bytes\n", millis(),write_idx);

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

bDone = true;

}

if (!bDone)

{

digitalWriteFast(MONITOR_OUT1, HIGH);

raw_data[write_idx++] = last_portb;

raw_data[write_idx++] = current_portb;

if (write_idx >= CAPTURE_ARRAY_SIZE)

{

//BurstLength = write_idx;

write_idx = 0;

}

digitalWriteFast(MONITOR_OUT1, LOW);

}

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

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

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

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);

pinMode(MONITOR_OUT2, OUTPUT);

pinMode(MONITOR_OUT3, OUTPUT);

pinMode(LED_BUILTIN, OUTPUT);

digitalWrite(MONITOR_OUT1, LOW);

digitalWrite(MONITOR_OUT2, LOW);

digitalWrite(MONITOR_OUT3, LOW);

pinMode(SDA_PIN, INPUT);

pinMode(SCL_PIN, INPUT);

//reset port byte vars & start timer

last_portb = current_portb = 0;

write_idx = 0;

memset(raw_data, 0, CAPTURE_ARRAY_SIZE);

PrintNextArrayBytes(raw_data, 0, 20);

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

//Timer1.attachInterrupt(capture_data);

Serial.printf("mSec\tlast\tnew\tmult\tburst\n");

mSecSinceLastWaitingPrint = 0;

last_State = BusState = BUS_STATES::IDLE;

curMsec = millis();

lastMsec = curMsec;

}

void loop()

{

while (true)

{

capture_data();

}

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 - 1; i++)

{

if (i % 40 != 0)

{

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

}

else Serial.printf("\n");

}

Serial.printf("0x%x\n", data[numbytes + startidx - 1]);

}

The ‘capture_data()’ function (no longer used as an ISR) captures SCL & SDA states with a single port operation as shown

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

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

and then everything from a START pair (0xC followed by 0x4) to a STOP pair (0X4 followed by 0xC) inclusive is captured in the raw_data array.

Any I2C Sniffer project like this one assumes that I2C activity occurs in short bursts with fairly long pauses in between. This is certainly the case with my robot project, as yaw data is only acquired every 200 mSec. However, there is still the problem of determining when a I2C ‘burst’ has finished so the sniffer program can decode and print the results from the last burst. In my investigation, it became clear that at the end of the burst both the SDA line goes HIGH and stays that way until the next START condition (a 0XC followed by a 0X4). So then the question becomes “how many 0XC/0XC pairs do I have to wait before determining that the last burst is over?”

In order to answer this question I decided to use my trusty Tektronix 2236 O’Scope and Teeny’s ‘digitalReadFast’ and ‘digitalWriteFast’ functions to implement a hardware-based timing capability using Teensy pins 0,1, and 2 (MONITOR_OUT1, 2 & 3 respectively). Among other things, this allowed me to definitively determine that a ‘idle’ (0XC/0XC) count of 1000 was too small, but an idle count of 2500 was plenty, without consuming too much of the available processing time. It also turned out that ‘idle’ counts all the way up to 30,000 work too, but leave less time for processing.

O’Scope shot showing I2C traffic on the bottom trace, and the point at which 2500 0xC/0xC (Idle) pairs is reached on the top trace (the high-to-low transition)

As can be seen in the above photo, the I2C ‘sentence’ lasts about 15 mSec, and the ‘idle’ condition is detected about 5 mSec later for a total of about 20 mSec out of the nominal 200 mSec cycle time for my robot application. This leaves about 190 mSec for I2C sentence processing and display.

18 January 2020 Update:

Success!! I now have a working Teensy 3.2 I2C Sniffer program that can continuously monitor the I2C traffic between my Arduino Mega test program acting as a I2C master and a MPU6050 IMU I2C slave. The Teensy code is available on my GitHub account here.

A major challenge in creating the sniffer program was the requirement to sample the I2C SCL & SDA lines quickly enough to accurately detect the line transitions denoting all the different I2C signals. With the I2C bus running at 100Kbs, SCL (clock) transitions occur every 5 uSec. Good sampling requires at least 2 and preferably more samples per SCL state. As noted above, I started off by copying the ISR routine from Kito’s I2C sniffer, but discovered I needed to add some logic to zero in on the desired I2C bus states (IDLE, START, DATA & STOP), and the additional code made the ISR take more than the desired 1 uSec window. After posting about this problem to Paul Stoffregen’s Teensy forum, I got some good pointers for speedup, incuding a post that mentioned the Teensy FASTRUN macro that runs functions from RAM rather than FLASH. As it turned out, adding this macro to the program allowed me to reduce the ISR cycle time from about 1.4 uSec to about .89 uSec – yay! The final ISR routine is shown below:

//-------------------------------------------------------------------------------
//--------------------------------    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    ---------------------------------
//-------------------------------------------------------------------------------

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

//-------------------------------- 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 ---------------------------------

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

Note the use of digitalWriteFast() calls to output timing pulses on Teensy hardware pins so I could use my trusty Tek 2236 100 MHz O’scope to verify proper timing.

Once I got the ISR running properly, then I focused on getting the data parsing algorithm integrated into the program. I had previously shown that I could correctly parse simulated I2C traffic, so all the current challenge was to integrate the algorithm in a way that allowed continuous capture-decode-print cycles at at rate that could keep up with the desired 5 measurements/sec rate. So, I instrumented the sniffer program to display the decoded IMU traffic, along with the calculated yaw value and the time required to perform the decode.

Here’s a short section of the printout from the test program, showing the time (in minutes), the yaw (relative heading ) value retrieved from the IMU, and left/right ping distances (unused in this application).

Min	Yaw	LDist	RDist
0.72	4.15	200	200
0.72	4.15	200	200
0.73	4.14	200	200
0.73	4.14	200	200
0.73	4.14	200	200
0.74	4.14	200	200
0.74	4.14	200	200
0.74	4.14	200	200
0.75	4.14	200	200
0.75	4.14	200	200
0.75	4.13	200	200
0.76	4.13	200	200
0.76	4.13	200	200
0.76	4.13	200	200
0.77	4.13	200	200
0.77	4.13	200	200
0.77	4.13	200	200
0.78	4.13	200	200
0.78	4.13	200	200

Min Yaw LDist RDist

0.72 4.15 200 200

0.73 4.14 200 200

0.74 4.14 200 200

0.75 4.14 200 200

0.75 4.13 200 200

0.76 4.13 200 200

0.77 4.13 200 200

0.78 4.13 200 200

And here is the corresponding output from the I2C sniffer program

Opening port
Port open
Serial available after 500 mSec
4922 I2C(69) reading 2 bytes from 72... 2 14 . Done
4922 I2C(69) reading 1 bytes from 6a... c0 . Done
4922 I2C(69) writing 1 bytes to 6a... c4 . Done
4922 I2C(69) reading 2 bytes from 72... 0 0 . Done
4923 I2C(69) reading 2 bytes from 72... 0 0 . Done
4923 I2C(69) reading 2 bytes from 72... 0 0 . Done
4923 I2C(69) reading 2 bytes from 72... 0 0 . Done
4923 I2C(69) reading 2 bytes from 72... 0 1c . Done
4923 I2C(69) reading 28 bytes from 74... 3f ce 5d a1 fb b4 7e 27 0 db 6e 91 fd a2 4a 16 fe e4 f7 76 3f f0 ff ff ff fe ff fd yawval = 4.13
4922: processed = 1326 elements in 2 mSec

5103: Waiting for Data...
5122 I2C(69) reading 2 bytes from 72... 2 14 . Done
5122 I2C(69) reading 1 bytes from 6a... c0 . Done
5122 I2C(69) writing 1 bytes to 6a... c4 . Done
5122 I2C(69) reading 2 bytes from 72... 0 0 . Done
5122 I2C(69) reading 2 bytes from 72... 0 0 . Done
5123 I2C(69) reading 2 bytes from 72... 0 0 . Done
5123 I2C(69) reading 2 bytes from 72... 0 0 . Done
5123 I2C(69) reading 2 bytes from 72... 0 1c . Done
5123 I2C(69) reading 28 bytes from 74... 3f ce 5b d2 fb b4 5c 1b 0 da e8 1b fd a2 26 70 fe 86 f7 20 3f 3e 0 0 0 0 0 0 yawval = 4.13
5122: processed = 1326 elements in 2 mSec

5303: Waiting for Data...
5322 I2C(69) reading 2 bytes from 72... 2 14 . Done
5322 I2C(69) reading 1 bytes from 6a... c0 . Done
5322 I2C(69) writing 1 bytes to 6a... c4 . Done
5322 I2C(69) reading 2 bytes from 72... 0 0 . Done
5322 I2C(69) reading 2 bytes from 72... 0 0 . Done
5322 I2C(69) reading 2 bytes from 72... 0 0 . Done
5323 I2C(69) reading 2 bytes from 72... 0 0 . Done
5323 I2C(69) reading 2 bytes from 72... 0 1c . Done
5323 I2C(69) reading 28 bytes from 74... 3f ce 54 aa fb b4 42 d4 0 db 4d a7 fd a1 b8 30 fe 7e f7 72 3f 74 0 0 0 0 ff fe yawval = 4.14
5322: processed = 1326 elements in 2 mSec

5504: Waiting for Data...
5520 I2C(69) reading 2 bytes from 72... 2 14 . Done
5520 I2C(69) reading 1 bytes from 6a... c0 . Done
5520 I2C(69) writing 1 bytes to 6a... c4 . Done
5520 I2C(69) reading 2 bytes from 72... 0 0 . Done
5521 I2C(69) reading 2 bytes from 72... 0 0 . Done
5521 I2C(69) reading 2 bytes from 72... 0 0 . Done
5521 I2C(69) reading 2 bytes from 72... 0 1c . Done
5521 I2C(69) reading 28 bytes from 74... 3f ce 4e 97 fb b3 f9 2c 0 db 4f 8f fd a1 9a d9 fe 90 f7 22 3f 3c ff ff ff ff ff fd yawval = 4.14
5520: processed = 1224 elements in 2 mSec

5704: Waiting for Data...
5720 I2C(69) reading 2 bytes from 72... 2 14 . Done
5720 I2C(69) reading 1 bytes from 6a... c0 . Done
5720 I2C(69) writing 1 bytes to 6a... c4 . Done
5720 I2C(69) reading 2 bytes from 72... 0 0 . Done
5720 I2C(69) reading 2 bytes from 72... 0 0 . Done
5720 I2C(69) reading 2 bytes from 72... 0 0 . Done
5721 I2C(69) reading 2 bytes from 72... 0 1c . Done
5721 I2C(69) reading 28 bytes from 74... 3f ce 3b 8f fb b2 cf a3 0 db bd 9a fd a1 de 18 fe 84 f7 3a 3f 6e 0 0 0 1 ff ff yawval = 4.14
5720: processed = 1224 elements in 1 mSec

5903: Waiting for Data...
5920 I2C(69) reading 2 bytes from 72... 2 14 . Done
5920 I2C(69) reading 1 bytes from 6a... c0 . Done
5920 I2C(69) writing 1 bytes to 6a... c4 . Done
5920 I2C(69) reading 2 bytes from 72... 0 0 . Done
5920 I2C(69) reading 2 bytes from 72... 0 0 . Done
5920 I2C(69) reading 2 bytes from 72... 0 0 . Done
5920 I2C(69) reading 2 bytes from 72... 0 1c . Done
5921 I2C(69) reading 28 bytes from 74... 3f ce 3f 14 fb b3 1f ee 0 dc 35 23 fd a1 d6 7e fe a6 f7 7c 3f 2c ff fe ff fd 0 0 yawval = 4.13
5919: processed = 1224 elements in 2 mSec

6104: Waiting for Data...
6120 I2C(69) reading 2 bytes from 72... 2 14 . Done
6121 I2C(69) reading 1 bytes from 6a... c0 . Done
6121 I2C(69) writing 1 bytes to 6a... c4 . Done
6121 I2C(69) reading 2 bytes from 72... 0 0 . Done
6121 I2C(69) reading 2 bytes from 72... 0 0 . Done
6121 I2C(69) reading 2 bytes from 72... 0 0 . Done
6121 I2C(69) reading 2 bytes from 72... 0 1c . Done
6121 I2C(69) reading 28 bytes from 74... 3f ce 36 df fb b2 93 7 0 db 6c 5b fd a1 b0 7a fe 72 f7 54 3f a2 0 0 0 0 0 0 yawval = 4.14
6120: processed = 1224 elements in 2 mSec

6304: Waiting for Data...
6320 I2C(69) reading 2 bytes from 72... 2 14 . Done
6320 I2C(69) reading 1 bytes from 6a... c0 . Done
6320 I2C(69) writing 1 bytes to 6a... c4 . Done
6321 I2C(69) reading 2 bytes from 72... 0 0 . Done
6321 I2C(69) reading 2 bytes from 72... 0 0 . Done
6321 I2C(69) reading 2 bytes from 72... 0 0 . Done
6321 I2C(69) reading 2 bytes from 72... 0 1c . Done
6321 I2C(69) reading 28 bytes from 74... 3f ce 40 75 fb b2 dc d1 0 db 56 f8 fd a2 24 ff fe be f7 64 3f 4c 0 1 0 1 0 1 yawval = 4.13
6320: processed = 1224 elements in 2 mSec

Opening port

Port open

Serial available after 500 mSec

4922 I2C(69) reading 2 bytes from 72... 2 14 . Done

4922 I2C(69) reading 1 bytes from 6a... c0 . Done

4922 I2C(69) writing 1 bytes to 6a... c4 . Done

4922 I2C(69) reading 2 bytes from 72... 0 0 . Done

4923 I2C(69) reading 2 bytes from 72... 0 0 . Done

4923 I2C(69) reading 2 bytes from 72... 0 1c . Done

4923 I2C(69) reading 28 bytes from 74... 3f ce 5d a1 fb b4 7e 27 0 db 6e 91 fd a2 4a 16 fe e4 f7 76 3f f0 ff ff ff fe ff fd yawval = 4.13

4922: processed = 1326 elements in 2 mSec

5103: Waiting for Data...

5122 I2C(69) reading 2 bytes from 72... 2 14 . Done

5122 I2C(69) reading 1 bytes from 6a... c0 . Done

5122 I2C(69) writing 1 bytes to 6a... c4 . Done

5122 I2C(69) reading 2 bytes from 72... 0 0 . Done

5123 I2C(69) reading 2 bytes from 72... 0 0 . Done

5123 I2C(69) reading 2 bytes from 72... 0 1c . Done

5123 I2C(69) reading 28 bytes from 74... 3f ce 5b d2 fb b4 5c 1b 0 da e8 1b fd a2 26 70 fe 86 f7 20 3f 3e 0 0 0 0 0 0 yawval = 4.13

5122: processed = 1326 elements in 2 mSec

5303: Waiting for Data...

5322 I2C(69) reading 2 bytes from 72... 2 14 . Done

5322 I2C(69) reading 1 bytes from 6a... c0 . Done

5322 I2C(69) writing 1 bytes to 6a... c4 . Done

5322 I2C(69) reading 2 bytes from 72... 0 0 . Done

5323 I2C(69) reading 2 bytes from 72... 0 0 . Done

5323 I2C(69) reading 2 bytes from 72... 0 1c . Done

5323 I2C(69) reading 28 bytes from 74... 3f ce 54 aa fb b4 42 d4 0 db 4d a7 fd a1 b8 30 fe 7e f7 72 3f 74 0 0 0 0 ff fe yawval = 4.14

5322: processed = 1326 elements in 2 mSec

5504: Waiting for Data...

5520 I2C(69) reading 2 bytes from 72... 2 14 . Done

5520 I2C(69) reading 1 bytes from 6a... c0 . Done

5520 I2C(69) writing 1 bytes to 6a... c4 . Done

5520 I2C(69) reading 2 bytes from 72... 0 0 . Done

5521 I2C(69) reading 2 bytes from 72... 0 0 . Done

5521 I2C(69) reading 2 bytes from 72... 0 1c . Done

5521 I2C(69) reading 28 bytes from 74... 3f ce 4e 97 fb b3 f9 2c 0 db 4f 8f fd a1 9a d9 fe 90 f7 22 3f 3c ff ff ff ff ff fd yawval = 4.14

5520: processed = 1224 elements in 2 mSec

5704: Waiting for Data...

5720 I2C(69) reading 2 bytes from 72... 2 14 . Done

5720 I2C(69) reading 1 bytes from 6a... c0 . Done

5720 I2C(69) writing 1 bytes to 6a... c4 . Done

5720 I2C(69) reading 2 bytes from 72... 0 0 . Done

5721 I2C(69) reading 2 bytes from 72... 0 1c . Done

5721 I2C(69) reading 28 bytes from 74... 3f ce 3b 8f fb b2 cf a3 0 db bd 9a fd a1 de 18 fe 84 f7 3a 3f 6e 0 0 0 1 ff ff yawval = 4.14

5720: processed = 1224 elements in 1 mSec

5903: Waiting for Data...

5920 I2C(69) reading 2 bytes from 72... 2 14 . Done

5920 I2C(69) reading 1 bytes from 6a... c0 . Done

5920 I2C(69) writing 1 bytes to 6a... c4 . Done

5920 I2C(69) reading 2 bytes from 72... 0 0 . Done

5920 I2C(69) reading 2 bytes from 72... 0 1c . Done

5921 I2C(69) reading 28 bytes from 74... 3f ce 3f 14 fb b3 1f ee 0 dc 35 23 fd a1 d6 7e fe a6 f7 7c 3f 2c ff fe ff fd 0 0 yawval = 4.13

5919: processed = 1224 elements in 2 mSec

6104: Waiting for Data...

6120 I2C(69) reading 2 bytes from 72... 2 14 . Done

6121 I2C(69) reading 1 bytes from 6a... c0 . Done

6121 I2C(69) writing 1 bytes to 6a... c4 . Done

6121 I2C(69) reading 2 bytes from 72... 0 0 . Done

6121 I2C(69) reading 2 bytes from 72... 0 1c . Done

6121 I2C(69) reading 28 bytes from 74... 3f ce 36 df fb b2 93 7 0 db 6c 5b fd a1 b0 7a fe 72 f7 54 3f a2 0 0 0 0 0 0 yawval = 4.14

6120: processed = 1224 elements in 2 mSec

6304: Waiting for Data...

6320 I2C(69) reading 2 bytes from 72... 2 14 . Done

6320 I2C(69) reading 1 bytes from 6a... c0 . Done

6320 I2C(69) writing 1 bytes to 6a... c4 . Done

6321 I2C(69) reading 2 bytes from 72... 0 0 . Done

6321 I2C(69) reading 2 bytes from 72... 0 1c . Done

6321 I2C(69) reading 28 bytes from 74... 3f ce 40 75 fb b2 dc d1 0 db 56 f8 fd a2 24 ff fe be f7 64 3f 4c 0 1 0 1 0 1 yawval = 4.13

6320: processed = 1224 elements in 2 mSec

In the above printout, each printout shows the individual transmit & receive ‘sentences’ to/from the IMU, and the 28-byte packet received from the IMU containing, among other things, the values required to calculate a yaw (relative heading value). As can be seen, the yaw value calculated from the received bytes, closely matches the yaw values retrieved using the test program. In addition the last line of each section of the readout shows the time tag for the start of the decode process, and the total time taken to decode all the bytes in that particular burst. From the data, it is clear that only 1-2 mSec is required to decode and display a full burst.

The complete I2C Sniffer program is available on my GitHub site here. The complete test program that obtains a yaw value from the IMU every 200 mSec is shown below:

/*
    Name:       MPU6050_MotorNoiseTest1.ino
    Created:	11/10/2019 9:17:51 AM
    Author:     FRANKWIN10\Frank
*/


#pragma region INCLUDES
//#include <Adafruit_INA219.h>
#include <elapsedMillis.h>
#include <PrintEx.h> //allows printf-style printout syntax
#include "MPU6050_6Axis_MotionApps_V6_12.h"  //changed to this version 10/05/19
#include "I2Cdev.h" //02/19/19: this includes SBWire.h
#include <NewPing.h> //added 01/15/15
#pragma endregion INCLUDES

StreamEx mySerial = Serial; //added 03/18/18 for printf-style printing
elapsedMillis 	sinceLastNavUpdateMsec; //added 10/15/18 to replace lastmillisec

MPU6050 mpu(0x69); //06/23/18 chg to AD0 high addr on 2-motor robot


#pragma region MOTOR_PARAMETERS
//drive wheel speed parameters
const int MOTOR_SPEED_FULL = 200; //range is 0-255
const int MOTOR_SPEED_MAX = 255; //range is 0-255
const int MOTOR_SPEED_HALF = 127; //range is 0-255
const int MOTOR_SPEED_LOW = 50; //added 01/22/15
const int MOTOR_SPEED_OFF = 0; //range is 0-255
const int MOTOR_SPEED_ADJ_FACTOR = 0; //chg to 40 at 5:55pm
const int LEFT_SPEED_COMP_VAL_FWD = 0; //left speed compensation value
const int RIGHT_SPEED_COMP_VAL_FWD = 5; //right speed compensation value
const int LEFT_SPEED_COMP_VAL_REV = 0; //left speed compensation value
const int RIGHT_SPEED_COMP_VAL_REV = 0; //right speed compensation value

//drive wheel direction constants
const boolean FWD_DIR = true;
const boolean REV_DIR = !FWD_DIR;

//Motor direction variables
boolean bLeftMotorDirIsFwd = true;
boolean bRightMotorDirIsFwd = true;
int leftspeednum = MOTOR_SPEED_HALF;
int rightspeednum = MOTOR_SPEED_HALF;
#pragma endregion Motor Parameters


#define LED_PIN 13 // (Arduino is 13, Teensy is 11, Teensy++ is 6)


#pragma region DIST_HDG_MEASUREMENT_SUPPORT
//misc LIDAR and Ping sensor parameters
const int MIN_OBS_DIST_CM = 20; //rev 04/28/17 for better obstacle handling
const int MAX_LR_DISTANCE_CM = 200;  //04/19/15 now using sep parameters for front and side sensors

//distance and heading running average
const int LR_PING_DIST_ARRAY_SIZE = 3; //04/28/19 added to reinstate l/r dist running avg
const int LR_PING_AVG_WINDOW_SIZE = 3; //added 04/28/19 so front & lr averages can differ
const int HDG_RUNNING_AVG_ARRAY_SIZE = 20; //1 second

byte aLeftDist[LR_PING_DIST_ARRAY_SIZE];
byte aRightDist[LR_PING_DIST_ARRAY_SIZE];
#pragma endregion Distance Measurement Support


#pragma region SENSOR_PINS
const int RightSensorTrigPin = 2;
const int LeftSensorTrigPin = 3;
const int LeftSensorEchoPin = LeftSensorTrigPin;
const int RightSensorEchoPin = RightSensorTrigPin;


//added 01/16/15 for NewPing support
NewPing LeftPing(LeftSensorTrigPin, LeftSensorEchoPin, MAX_LR_DISTANCE_CM / 2);
NewPing RightPing(RightSensorTrigPin, RightSensorEchoPin, MAX_LR_DISTANCE_CM / 2);

//const int TOT_CURR_PIN = A8;
#pragma endregion Sensor Pins

#pragma region MOTOR_PINS
//testing with a power-blocked UNO
const int EnA_Pin = 11;
const int In1_Pin = 10;
const int In2_Pin = 9;

//Right Motor
const int In3_Pin = 8;
const int In4_Pin = 7;
const int EnB_Pin = 6;

const int MOTOR_SPEED_STEP_VAL = 20;
const int MAX_MOTOR_SPEED = 255;
const int MIN_MOTOR_SPEED = 0;
bool bMotorIsFwd = true;
bool bMotorSpeedingUp = true;
int MotorSpeed = 0;

#pragma endregion Motor Pin Assignments


#pragma region MPU6050_SUPPORT
uint8_t mpuIntStatus;   // holds actual interrupt status byte from MPU. Used in Homer's Overflow routine
uint8_t devStatus;      // return status after each device operation (0 = success, !0 = error)
uint16_t packetSize;    // expected DMP packet size (default is 42 bytes)
uint16_t fifoCount;     // count of all bytes currently in FIFO
uint8_t fifoBuffer[64]; // FIFO storage buffer

						// orientation/motion vars
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 euler[3];         // [psi, theta, phi]    Euler angle container
float ypr[3];           // [yaw, pitch, roll]   yaw/pitch/roll container and gravity vector
int GetPacketLoopCount = 0;
int OuterGetPacketLoopCount = 0;

//RTC/FRAM/MPU6050 status flags
bool bMPU6050Ready = true;
bool dmpReady = false;  // set true if DMP init was successful
volatile float global_yawval = 0; //updated by GetIMUHeadingDeg()
const uint16_t MAX_GETPACKET_LOOPS = 100; //10/30/19 added for backup loop exit condition in GetCurrentFIFOPacket()
uint8_t GetCurrentFIFOPacket(uint8_t* data, uint8_t length, uint16_t max_loops = MAX_GETPACKET_LOOPS); //prototype here so can define a default param
bool bFirstTime = true;
#pragma endregion MPU6050 Support

const int NAV_UPDATE_INTERVAL_MSEC = 200;

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

	Serial.println("Two Wheel Robot");

	// join I2C bus (I2Cdev library doesn't do this automatically)
	Wire.begin();
	Wire.setTwiMaxLoops(15000); //08/23 needed for SBWire library
	Wire.setClock(100000); //07/25/19 slow down I2C clock for better noise immunity

	//motor control PWM pins
	Serial.println("...Setting up Motor Control Pins...");
	pinMode(EnA_Pin, OUTPUT);//set up left motor pins as outputs
	pinMode(In1_Pin, OUTPUT);
	pinMode(In2_Pin, OUTPUT);


	pinMode(In3_Pin, OUTPUT);//set up right motor pins as outputs
	pinMode(In4_Pin, OUTPUT);
	pinMode(EnB_Pin, OUTPUT);
	pinMode(LED_PIN, OUTPUT);


	// initialize MPU6050 added 09/03/18
	Serial.println(F("Initializing MPU6050 ..."));
	mpu.initialize();

	// verify connection
	Serial.println(F("Testing device connections..."));
	Serial.println(mpu.testConnection() ? F("MPU6050 connection successful") : F("MPU6050 connection failed"));

	Serial.println(F("Initializing DMP..."));
	devStatus = mpu.dmpInitialize();

	// supply your own gyro offsets here, scaled for min sensitivity
	//mpu.setXGyroOffset(51);
	//mpu.setYGyroOffset(8);
	//mpu.setZGyroOffset(21);
	//mpu.setXAccelOffset(1150);
	//mpu.setYAccelOffset(-50);
	//mpu.setZAccelOffset(1060);

	//12/03/19 settings from calibration routines
	mpu.setXGyroOffset(58);
	mpu.setYGyroOffset(20);
	mpu.setZGyroOffset(12);
	mpu.setXAccelOffset(1618);
	mpu.setYAccelOffset(3046);
	mpu.setZAccelOffset(4554);

	// make sure it worked (returns 0 if successful)
	if (devStatus == 0)
	{
		//12/06/19 no longer needed; cal vals already acquired
		//// Calibration Time: generate offsets and calibrate our MPU6050
		//mpu.CalibrateAccel(6); 
		//mpu.CalibrateGyro(6);
		//Serial.println();
		//mpu.PrintActiveOffsets();

		// turn on the DMP, now that it's ready
		Serial.println(F("Enabling DMP..."));
		mpu.setDMPEnabled(true);

		// set our DMP Ready flag so the main loop() function knows it's okay to use it
		Serial.println(F("DMP ready! Waiting for MPU6050 drift rate to settle..."));
		dmpReady = true;

		// get expected DMP packet size for later comparison
		packetSize = mpu.dmpGetFIFOPacketSize();
		bMPU6050Ready = true;
		mySerial.printf("\nMPU6050 Ready at %2.2f Sec\n", millis() / 1000.f);
	}
	else
	{
		// ERROR!
		// 1 = initial memory load failed
		// 2 = DMP configuration updates failed
		// (if it's going to break, usually the code will be 1)
		Serial.print(F("DMP Initialization failed (code "));
		Serial.print(devStatus);
		Serial.println(F(")"));

		bMPU6050Ready = false;
	}

	//mySerial.printf("Starting Motors...");
	//MoveAhead(MOTOR_SPEED_FULL, MOTOR_SPEED_FULL);

	Serial.println("Set motor speed full & FWD direction ...");
	analogWrite(EnA_Pin, 255);
	digitalWrite(In1_Pin, LOW);
	digitalWrite(In2_Pin, HIGH);
	analogWrite(EnB_Pin, 255);
	digitalWrite(In3_Pin, LOW);
	digitalWrite(In4_Pin, HIGH);

	sinceLastNavUpdateMsec = 0;
}

void loop()
{
	if (bFirstTime)
	{
		bFirstTime = false;
		mySerial.printf("Min\tYaw\tLDist\tRDist\n");
	}

	if (sinceLastNavUpdateMsec >=  NAV_UPDATE_INTERVAL_MSEC)
	{
		sinceLastNavUpdateMsec -= NAV_UPDATE_INTERVAL_MSEC;

		bool getYawResult = GetIMUHeadingDeg(); //updates global_yawval if successful

		if (getYawResult == 0)
		{
			if (mpu.testConnection())
			{
				mySerial.printf("resetting IMU\n");
				mpu.reset();
				delay(50);
			}
		}

		int leftdist = GetLeftDistCm();
		int rightdist = GetRightDistCm();

		//mySerial.printf("%3.2f\t%3.2f\t%d\t%d\t%d\t%d\n", millis()/60000.0, global_yawval, getYawResult, fifoCount, GetPacketLoopCount, OuterGetPacketLoopCount);
		mySerial.printf("%3.2f\t%3.2f\t%d\t%d\n", millis()/60000.0, global_yawval, leftdist, rightdist);

		//12/06/19 commented out for now - just want constant motor speed
		////change the motor speed (and maybe the direction)
		//if (bMotorSpeedingUp)
		//{
		//	MotorSpeed += MOTOR_SPEED_STEP_VAL;
		//}
		//else
		//{
		//	MotorSpeed -= MOTOR_SPEED_STEP_VAL;
		//}

		//if (MotorSpeed >= MAX_MOTOR_SPEED)
		//{
		//	bMotorSpeedingUp = false;
		//}
		//if (MotorSpeed <= MIN_MOTOR_SPEED)
		//{
		//	//Serial.println("Reversing Motor Direction...");
		//	bMotorSpeedingUp = true;
		//	bMotorIsFwd = !bMotorIsFwd;
		//}

		////now actually set the motor speed and direction
		//analogWrite(EnA_Pin, MotorSpeed);
		//digitalWrite(In1_Pin, bMotorIsFwd ? LOW : HIGH);
		//digitalWrite(In2_Pin, bMotorIsFwd ? HIGH : LOW);

		////now actually set the motor speed and direction
		//analogWrite(EnB_Pin, MotorSpeed);
		//digitalWrite(In3_Pin, bMotorIsFwd ? LOW : HIGH);
		//digitalWrite(In4_Pin, bMotorIsFwd ? HIGH : LOW);

	}

}

#pragma region MOTOR_SUPPORT_ROUTINES
void RunBothMotors(int leftspeednum, int rightspeednum)
{
	//Purpose: Run both Motors at left/rightspeednum speeds
	//Inputs:
	//    speednum = speed value (0 = OFF, 255 = full speed)
	//Outputs: Both Motors run for timesec seconds at speednum speed
	//Plan:
	//Notes:
	//    01/14/15 - added left/right speed offset for straightness compensation
	//    01/22/15 - added code to restrict fast/slow values
	//    01/24/15 - revised for continuous run - no timing
	//  01/26/15 - speednum modifications moved to UpdateWallFollowmyMotorspeeds()
	//	12/07/15 - chg args from &int to int

////DEBUG!!
//	mySerial.printf("In RunBothMotors(%d,%d\n", leftspeednum, rightspeednum);
////DEBUG!!
	SetLeftMotorSpeed(leftspeednum);
	SetRightMotorSpeed(rightspeednum);
}

//01/24/15 removed time from MoveAhead sig, added MoveAheadMsec
void MoveAhead(int leftspeednum, int rightspeednum)
{
	//Purpose:  Move ahead continuously
	//Provenance: G. Frank Paynter and Danny Frank 01/24/2014
	//Inputs:  
	//    leftspeednum = integer denoting speed (0=stop, 255 = full speed)
	//    rightspeednum = integer denoting speed (0=stop, 255 = full speed)
	//Outputs: both drive Motors energized with the specified speed
	//Plan:
	//    Step 1: Set forward direction for both wheels
	//    Step 2: Run both Motors at specified speeds

	//Step 1: Set forward direction for both wheels
	SetLeftMotorDir(true);
	SetRightMotorDir(true);

	//Step 2: Run both myMotors for timsec seconds
	RunBothMotors(leftspeednum, rightspeednum);
}
void SetLeftMotorSpeed(int speed)
{
	if (bLeftMotorDirIsFwd)
	{
		speed = speed + LEFT_SPEED_COMP_VAL_FWD;

		//check limits
		speed = (speed <= MOTOR_SPEED_MAX) ? speed : MOTOR_SPEED_MAX;
		speed = (speed >= MOTOR_SPEED_OFF) ? speed : MOTOR_SPEED_OFF;

	}
	else //must be REV
	{
		speed = speed + LEFT_SPEED_COMP_VAL_REV;

		//check limits
		speed = (speed <= MOTOR_SPEED_MAX) ? speed : MOTOR_SPEED_MAX;
		speed = (speed >= MOTOR_SPEED_OFF) ? speed : MOTOR_SPEED_OFF;
	}


#ifndef NO_MOTORS
	Serial.print("Left Speed = "); Serial.println(speed);
	analogWrite(EnA_Pin, speed);
#endif

}

//11/25/15 added to utilize new private member variable bRightMotorDirIsFwd
void SetRightMotorSpeed(int speed)
{
	if (bRightMotorDirIsFwd)
	{
		speed = speed + LEFT_SPEED_COMP_VAL_FWD;

		//check limits
		speed = (speed <= MOTOR_SPEED_MAX) ? speed : MOTOR_SPEED_MAX;
		speed = (speed >= MOTOR_SPEED_OFF) ? speed : MOTOR_SPEED_OFF;

	}
	else //must be REV
	{
		speed = speed + LEFT_SPEED_COMP_VAL_REV;

		//check limits
		speed = (speed <= MOTOR_SPEED_MAX) ? speed : MOTOR_SPEED_MAX;
		speed = (speed >= MOTOR_SPEED_OFF) ? speed : MOTOR_SPEED_OFF;

	}

#ifndef NO_MOTORS
	Serial.print("Right Speed = "); Serial.println(speed);
	analogWrite(EnB_Pin, speed);
#endif

}

void SetLeftMotorDir(boolean bIsFwdDir)
{
	if (bIsFwdDir)
	{
		digitalWrite(In1_Pin, LOW);
		digitalWrite(In2_Pin, HIGH);
	}
	else //must be REV
	{
		digitalWrite(In1_Pin, HIGH);
		digitalWrite(In2_Pin, LOW);
	}

	bLeftMotorDirIsFwd = bIsFwdDir;
}

void SetRightMotorDir(boolean bIsFwdDir)
{
	if (bIsFwdDir)
	{
		digitalWrite(In3_Pin, LOW);
		digitalWrite(In4_Pin, HIGH);
	}
	else //must be REV
	{
		digitalWrite(In3_Pin, HIGH);
		digitalWrite(In4_Pin, LOW);
	}

	bRightMotorDirIsFwd = bIsFwdDir;
}
#pragma endregion Motor Support Routines


bool GetIMUHeadingDeg()
{
	//Purpose: Get latest yaw (heading) value from IMU
	//Inputs: None.  This function should only be called after mpu.dmpPacketAvailable() returns TRUE
	//Outputs: 
	//	returns true if successful, otherwise false
	//	global_yawval updated on success
	//Plan:
	//Step1: check for overflow and reset the FIFO if it occurs. In this case, wait for new packet
	//Step2: read all available packets to get to latest data
	//Step3: update global_yawval with latest value
	//Notes:
	//	10/08/19 changed return type to boolean
	//	10/08/19 no longer need mpuIntStatus
	//	10/21/19 completely rewritten to use Homer's algorithm

	bool retval = false;

	int flag = GetCurrentFIFOPacket(fifoBuffer, packetSize, MAX_GETPACKET_LOOPS); //get the latest mpu packet

	if (flag != 0) //0 = error exit, 1 = normal exit, 2 = recovered from an overflow
	{
		// display Euler angles in degrees
		mpu.dmpGetQuaternion(&q, fifoBuffer);
		mpu.dmpGetGravity(&gravity, &q);
		mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);

		//compute the yaw value
		global_yawval = ypr[0] * 180 / M_PI;
		retval = true;
	}

	return retval;
}

uint8_t GetCurrentFIFOPacket(uint8_t *data, uint8_t length, uint16_t max_loops)
{
	max_loops = max(10, max_loops); //added 12/04/19 to ensure we loop at least 10 times. This really IS a hard-coded number!
	fifoCount = mpu.getFIFOCount();
	GetPacketLoopCount = 0;

	//11/10/19 I have seen this fail with fifoC > 28 on occasion, so now I loop max three times
	OuterGetPacketLoopCount = 0;
	while (fifoCount != packetSize && OuterGetPacketLoopCount <= 3)
	{
		mpu.resetFIFO();
		delay(1);

		fifoCount = mpu.getFIFOCount();
		GetPacketLoopCount = 0;

		while (fifoCount < packetSize && GetPacketLoopCount < max_loops)
		{
			GetPacketLoopCount++;
			fifoCount = mpu.getFIFOCount();
			delay(2);
		}

		//if we get to here, there should be exactly one packet in the FIFO
		OuterGetPacketLoopCount++;
	}

	if (OuterGetPacketLoopCount < 3)
	{
		mpu.getFIFOBytes(data, packetSize);
		return 1;
	}

	return 0; //failed to get a good packet
}


int GetLeftDistCm()
{
	//Serial.print("LeftPing\t"); Serial.println(millis());
	//Notes:
	//	04/30/17 added limit detection/correction

	int timeUsec = LeftPing.ping();
	//Serial.print("Left Ping Usec = "); Serial.println(timeUsec);
	int distCm = LeftPing.convert_cm(timeUsec);

	//04/30/17 added limit detection/correction
	distCm = (distCm > 0) ? distCm : MAX_LR_DISTANCE_CM;

	return distCm;
}

//01/10/18 reverted to regular ping().  median distance function takes too long
int GetRightDistCm()
{
	//Serial.print("RightPing\t"); Serial.println(millis());
	//Notes:
	//	04/30/17 added limit detection/correction

	int timeUsec = RightPing.ping();
	//Serial.print("Right Ping Usec = "); Serial.println(timeUsec);
	int distCm = RightPing.convert_cm(timeUsec);

	//04/30/17 added limit detection/correction
	distCm = (distCm > 0) ? distCm : MAX_LR_DISTANCE_CM;

	return distCm;
}

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

Name: MPU6050_MotorNoiseTest1.ino

Created: 11/10/2019 9:17:51 AM

Author: FRANKWIN10\Frank

#pragma region INCLUDES

//#include <Adafruit_INA219.h>

#include <elapsedMillis.h>

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

#include "MPU6050_6Axis_MotionApps_V6_12.h" //changed to this version 10/05/19

#include "I2Cdev.h" //02/19/19: this includes SBWire.h

#include <NewPing.h> //added 01/15/15

#pragma endregion INCLUDES

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

elapsedMillis sinceLastNavUpdateMsec; //added 10/15/18 to replace lastmillisec

MPU6050 mpu(0x69); //06/23/18 chg to AD0 high addr on 2-motor robot

#pragma region MOTOR_PARAMETERS

//drive wheel speed parameters

const int MOTOR_SPEED_FULL = 200; //range is 0-255

const int MOTOR_SPEED_MAX = 255; //range is 0-255

const int MOTOR_SPEED_HALF = 127; //range is 0-255

const int MOTOR_SPEED_LOW = 50; //added 01/22/15

const int MOTOR_SPEED_OFF = 0; //range is 0-255

const int MOTOR_SPEED_ADJ_FACTOR = 0; //chg to 40 at 5:55pm

const int LEFT_SPEED_COMP_VAL_FWD = 0; //left speed compensation value

const int RIGHT_SPEED_COMP_VAL_FWD = 5; //right speed compensation value

const int LEFT_SPEED_COMP_VAL_REV = 0; //left speed compensation value

const int RIGHT_SPEED_COMP_VAL_REV = 0; //right speed compensation value

//drive wheel direction constants

const boolean FWD_DIR = true;

const boolean REV_DIR = !FWD_DIR;

//Motor direction variables

boolean bLeftMotorDirIsFwd = true;

boolean bRightMotorDirIsFwd = true;

int leftspeednum = MOTOR_SPEED_HALF;

int rightspeednum = MOTOR_SPEED_HALF;

#pragma endregion Motor Parameters

#define LED_PIN 13 // (Arduino is 13, Teensy is 11, Teensy++ is 6)

#pragma region DIST_HDG_MEASUREMENT_SUPPORT

//misc LIDAR and Ping sensor parameters

const int MIN_OBS_DIST_CM = 20; //rev 04/28/17 for better obstacle handling

const int MAX_LR_DISTANCE_CM = 200; //04/19/15 now using sep parameters for front and side sensors

//distance and heading running average

const int LR_PING_DIST_ARRAY_SIZE = 3; //04/28/19 added to reinstate l/r dist running avg

const int LR_PING_AVG_WINDOW_SIZE = 3; //added 04/28/19 so front & lr averages can differ

const int HDG_RUNNING_AVG_ARRAY_SIZE = 20; //1 second

byte aLeftDist[LR_PING_DIST_ARRAY_SIZE];

byte aRightDist[LR_PING_DIST_ARRAY_SIZE];

#pragma endregion Distance Measurement Support

#pragma region SENSOR_PINS

const int RightSensorTrigPin = 2;

const int LeftSensorTrigPin = 3;

const int LeftSensorEchoPin = LeftSensorTrigPin;

const int RightSensorEchoPin = RightSensorTrigPin;

//added 01/16/15 for NewPing support

NewPing LeftPing(LeftSensorTrigPin, LeftSensorEchoPin, MAX_LR_DISTANCE_CM / 2);

NewPing RightPing(RightSensorTrigPin, RightSensorEchoPin, MAX_LR_DISTANCE_CM / 2);

//const int TOT_CURR_PIN = A8;

#pragma endregion Sensor Pins

#pragma region MOTOR_PINS

//testing with a power-blocked UNO

const int EnA_Pin = 11;

const int In1_Pin = 10;

const int In2_Pin = 9;

//Right Motor

const int In3_Pin = 8;

const int In4_Pin = 7;

const int EnB_Pin = 6;

const int MOTOR_SPEED_STEP_VAL = 20;

const int MAX_MOTOR_SPEED = 255;

const int MIN_MOTOR_SPEED = 0;

bool bMotorIsFwd = true;

bool bMotorSpeedingUp = true;

int MotorSpeed = 0;

#pragma endregion Motor Pin Assignments

#pragma region MPU6050_SUPPORT

uint8_t mpuIntStatus; // holds actual interrupt status byte from MPU. Used in Homer's Overflow routine

uint8_t devStatus; // return status after each device operation (0 = success, !0 = error)

uint16_t packetSize; // expected DMP packet size (default is 42 bytes)

uint16_t fifoCount; // count of all bytes currently in FIFO

uint8_t fifoBuffer[64]; // FIFO storage buffer

// orientation/motion vars

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 euler[3]; // [psi, theta, phi] Euler angle container

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

int GetPacketLoopCount = 0;

int OuterGetPacketLoopCount = 0;

//RTC/FRAM/MPU6050 status flags

bool bMPU6050Ready = true;

bool dmpReady = false; // set true if DMP init was successful

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

const uint16_t MAX_GETPACKET_LOOPS = 100; //10/30/19 added for backup loop exit condition in GetCurrentFIFOPacket()

uint8_t GetCurrentFIFOPacket(uint8_t* data, uint8_t length, uint16_t max_loops = MAX_GETPACKET_LOOPS); //prototype here so can define a default param

bool bFirstTime = true;

#pragma endregion MPU6050 Support

const int NAV_UPDATE_INTERVAL_MSEC = 200;

void setup()

{

Serial.begin(115200);

Serial.println("Two Wheel Robot");

// join I2C bus (I2Cdev library doesn't do this automatically)

Wire.begin();

Wire.setTwiMaxLoops(15000); //08/23 needed for SBWire library

Wire.setClock(100000); //07/25/19 slow down I2C clock for better noise immunity

//motor control PWM pins

Serial.println("...Setting up Motor Control Pins...");

pinMode(EnA_Pin, OUTPUT);//set up left motor pins as outputs

pinMode(In1_Pin, OUTPUT);

pinMode(In2_Pin, OUTPUT);

pinMode(In3_Pin, OUTPUT);//set up right motor pins as outputs

pinMode(In4_Pin, OUTPUT);

pinMode(EnB_Pin, OUTPUT);

pinMode(LED_PIN, OUTPUT);

// initialize MPU6050 added 09/03/18

Serial.println(F("Initializing MPU6050 ..."));

mpu.initialize();

// verify connection

Serial.println(F("Testing device connections..."));

Serial.println(mpu.testConnection() ? F("MPU6050 connection successful") : F("MPU6050 connection failed"));

Serial.println(F("Initializing DMP..."));

devStatus = mpu.dmpInitialize();

// supply your own gyro offsets here, scaled for min sensitivity

//mpu.setXGyroOffset(51);

//mpu.setYGyroOffset(8);

//mpu.setZGyroOffset(21);

//mpu.setXAccelOffset(1150);

//mpu.setYAccelOffset(-50);

//mpu.setZAccelOffset(1060);

//12/03/19 settings from calibration routines

mpu.setXGyroOffset(58);

mpu.setYGyroOffset(20);

mpu.setZGyroOffset(12);

mpu.setXAccelOffset(1618);

mpu.setYAccelOffset(3046);

mpu.setZAccelOffset(4554);

// make sure it worked (returns 0 if successful)

if (devStatus == 0)

{

//12/06/19 no longer needed; cal vals already acquired

//// Calibration Time: generate offsets and calibrate our MPU6050

//mpu.CalibrateAccel(6);

//mpu.CalibrateGyro(6);

//Serial.println();

//mpu.PrintActiveOffsets();

// turn on the DMP, now that it's ready

Serial.println(F("Enabling DMP..."));

mpu.setDMPEnabled(true);

// set our DMP Ready flag so the main loop() function knows it's okay to use it

Serial.println(F("DMP ready! Waiting for MPU6050 drift rate to settle..."));

dmpReady = true;

// get expected DMP packet size for later comparison

packetSize = mpu.dmpGetFIFOPacketSize();

bMPU6050Ready = true;

mySerial.printf("\nMPU6050 Ready at %2.2f Sec\n", millis() / 1000.f);

}

else

{

// ERROR!

// 1 = initial memory load failed

// 2 = DMP configuration updates failed

// (if it's going to break, usually the code will be 1)

Serial.print(F("DMP Initialization failed (code "));

Serial.print(devStatus);

Serial.println(F(")"));

bMPU6050Ready = false;

}

//mySerial.printf("Starting Motors...");

//MoveAhead(MOTOR_SPEED_FULL, MOTOR_SPEED_FULL);

Serial.println("Set motor speed full & FWD direction ...");

analogWrite(EnA_Pin, 255);

digitalWrite(In1_Pin, LOW);

digitalWrite(In2_Pin, HIGH);

analogWrite(EnB_Pin, 255);

digitalWrite(In3_Pin, LOW);

digitalWrite(In4_Pin, HIGH);

sinceLastNavUpdateMsec = 0;

}

void loop()

{

if (bFirstTime)

{

bFirstTime = false;

mySerial.printf("Min\tYaw\tLDist\tRDist\n");

}

if (sinceLastNavUpdateMsec >= NAV_UPDATE_INTERVAL_MSEC)

{

sinceLastNavUpdateMsec -= NAV_UPDATE_INTERVAL_MSEC;

bool getYawResult = GetIMUHeadingDeg(); //updates global_yawval if successful

if (getYawResult == 0)

{

if (mpu.testConnection())

{

mySerial.printf("resetting IMU\n");

mpu.reset();

delay(50);

}

int leftdist = GetLeftDistCm();

int rightdist = GetRightDistCm();

//mySerial.printf("%3.2f\t%3.2f\t%d\t%d\t%d\t%d\n", millis()/60000.0, global_yawval, getYawResult, fifoCount, GetPacketLoopCount, OuterGetPacketLoopCount);

mySerial.printf("%3.2f\t%3.2f\t%d\t%d\n", millis()/60000.0, global_yawval, leftdist, rightdist);

//12/06/19 commented out for now - just want constant motor speed

////change the motor speed (and maybe the direction)

//if (bMotorSpeedingUp)

//{

// MotorSpeed += MOTOR_SPEED_STEP_VAL;

//}

//else

//{

// MotorSpeed -= MOTOR_SPEED_STEP_VAL;

//}

//if (MotorSpeed >= MAX_MOTOR_SPEED)

//{

// bMotorSpeedingUp = false;

//}

//if (MotorSpeed <= MIN_MOTOR_SPEED)

//{

// //Serial.println("Reversing Motor Direction...");

// bMotorSpeedingUp = true;

// bMotorIsFwd = !bMotorIsFwd;

//}

////now actually set the motor speed and direction

//analogWrite(EnA_Pin, MotorSpeed);

//digitalWrite(In1_Pin, bMotorIsFwd ? LOW : HIGH);

//digitalWrite(In2_Pin, bMotorIsFwd ? HIGH : LOW);

////now actually set the motor speed and direction

//analogWrite(EnB_Pin, MotorSpeed);

//digitalWrite(In3_Pin, bMotorIsFwd ? LOW : HIGH);

//digitalWrite(In4_Pin, bMotorIsFwd ? HIGH : LOW);

}

#pragma region MOTOR_SUPPORT_ROUTINES

void RunBothMotors(int leftspeednum, int rightspeednum)

{

//Purpose: Run both Motors at left/rightspeednum speeds

//Inputs:

// speednum = speed value (0 = OFF, 255 = full speed)

//Outputs: Both Motors run for timesec seconds at speednum speed

//Plan:

//Notes:

// 01/14/15 - added left/right speed offset for straightness compensation

// 01/22/15 - added code to restrict fast/slow values

// 01/24/15 - revised for continuous run - no timing

// 01/26/15 - speednum modifications moved to UpdateWallFollowmyMotorspeeds()

// 12/07/15 - chg args from &int to int

////DEBUG!!

// mySerial.printf("In RunBothMotors(%d,%d\n", leftspeednum, rightspeednum);

////DEBUG!!

SetLeftMotorSpeed(leftspeednum);

SetRightMotorSpeed(rightspeednum);

}

//01/24/15 removed time from MoveAhead sig, added MoveAheadMsec

void MoveAhead(int leftspeednum, int rightspeednum)

{

//Purpose: Move ahead continuously

//Provenance: G. Frank Paynter and Danny Frank 01/24/2014

//Inputs:

// leftspeednum = integer denoting speed (0=stop, 255 = full speed)

// rightspeednum = integer denoting speed (0=stop, 255 = full speed)

//Outputs: both drive Motors energized with the specified speed

//Plan:

// Step 1: Set forward direction for both wheels

// Step 2: Run both Motors at specified speeds

//Step 1: Set forward direction for both wheels

SetLeftMotorDir(true);

SetRightMotorDir(true);

//Step 2: Run both myMotors for timsec seconds

RunBothMotors(leftspeednum, rightspeednum);

}

void SetLeftMotorSpeed(int speed)

{

if (bLeftMotorDirIsFwd)

{

speed = speed + LEFT_SPEED_COMP_VAL_FWD;

//check limits

speed = (speed <= MOTOR_SPEED_MAX) ? speed : MOTOR_SPEED_MAX;

speed = (speed >= MOTOR_SPEED_OFF) ? speed : MOTOR_SPEED_OFF;

}

else //must be REV

{

speed = speed + LEFT_SPEED_COMP_VAL_REV;

//check limits

speed = (speed <= MOTOR_SPEED_MAX) ? speed : MOTOR_SPEED_MAX;

speed = (speed >= MOTOR_SPEED_OFF) ? speed : MOTOR_SPEED_OFF;

}

#ifndef NO_MOTORS

Serial.print("Left Speed = "); Serial.println(speed);

analogWrite(EnA_Pin, speed);

#endif

}

//11/25/15 added to utilize new private member variable bRightMotorDirIsFwd

void SetRightMotorSpeed(int speed)

{

if (bRightMotorDirIsFwd)

{

speed = speed + LEFT_SPEED_COMP_VAL_FWD;

//check limits

speed = (speed <= MOTOR_SPEED_MAX) ? speed : MOTOR_SPEED_MAX;

speed = (speed >= MOTOR_SPEED_OFF) ? speed : MOTOR_SPEED_OFF;

}

else //must be REV

{

speed = speed + LEFT_SPEED_COMP_VAL_REV;

//check limits

speed = (speed <= MOTOR_SPEED_MAX) ? speed : MOTOR_SPEED_MAX;

speed = (speed >= MOTOR_SPEED_OFF) ? speed : MOTOR_SPEED_OFF;

}

#ifndef NO_MOTORS

Serial.print("Right Speed = "); Serial.println(speed);

analogWrite(EnB_Pin, speed);

#endif

}

void SetLeftMotorDir(boolean bIsFwdDir)

{

if (bIsFwdDir)

{

digitalWrite(In1_Pin, LOW);

digitalWrite(In2_Pin, HIGH);

}

else //must be REV

{

digitalWrite(In1_Pin, HIGH);

digitalWrite(In2_Pin, LOW);

}

bLeftMotorDirIsFwd = bIsFwdDir;

}

void SetRightMotorDir(boolean bIsFwdDir)

{

if (bIsFwdDir)

{

digitalWrite(In3_Pin, LOW);

digitalWrite(In4_Pin, HIGH);

}

else //must be REV

{

digitalWrite(In3_Pin, HIGH);

digitalWrite(In4_Pin, LOW);

}

bRightMotorDirIsFwd = bIsFwdDir;

}

#pragma endregion Motor Support Routines

bool GetIMUHeadingDeg()

{

//Purpose: Get latest yaw (heading) value from IMU

//Inputs: None. This function should only be called after mpu.dmpPacketAvailable() returns TRUE

//Outputs:

// returns true if successful, otherwise false

// global_yawval updated on success

//Plan:

//Step1: check for overflow and reset the FIFO if it occurs. In this case, wait for new packet

//Step2: read all available packets to get to latest data

//Step3: update global_yawval with latest value

//Notes:

// 10/08/19 changed return type to boolean

// 10/08/19 no longer need mpuIntStatus

// 10/21/19 completely rewritten to use Homer's algorithm

bool retval = false;

int flag = GetCurrentFIFOPacket(fifoBuffer, packetSize, MAX_GETPACKET_LOOPS); //get the latest mpu packet

if (flag != 0) //0 = error exit, 1 = normal exit, 2 = recovered from an overflow

{

// display Euler angles in degrees

mpu.dmpGetQuaternion(&q, fifoBuffer);

mpu.dmpGetGravity(&gravity, &q);

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

//compute the yaw value

global_yawval = ypr[0] * 180 / M_PI;

retval = true;

}

return retval;

}

uint8_t GetCurrentFIFOPacket(uint8_t *data, uint8_t length, uint16_t max_loops)

{

max_loops = max(10, max_loops); //added 12/04/19 to ensure we loop at least 10 times. This really IS a hard-coded number!

fifoCount = mpu.getFIFOCount();

GetPacketLoopCount = 0;

//11/10/19 I have seen this fail with fifoC > 28 on occasion, so now I loop max three times

OuterGetPacketLoopCount = 0;

while (fifoCount != packetSize && OuterGetPacketLoopCount <= 3)

{

mpu.resetFIFO();

delay(1);

fifoCount = mpu.getFIFOCount();

GetPacketLoopCount = 0;

while (fifoCount < packetSize && GetPacketLoopCount < max_loops)

{

GetPacketLoopCount++;

fifoCount = mpu.getFIFOCount();

delay(2);

}

//if we get to here, there should be exactly one packet in the FIFO

OuterGetPacketLoopCount++;

}

if (OuterGetPacketLoopCount < 3)

{

mpu.getFIFOBytes(data, packetSize);

return 1;

}

return 0; //failed to get a good packet

}

int GetLeftDistCm()

{

//Serial.print("LeftPing\t"); Serial.println(millis());

//Notes:

// 04/30/17 added limit detection/correction

int timeUsec = LeftPing.ping();

//Serial.print("Left Ping Usec = "); Serial.println(timeUsec);

int distCm = LeftPing.convert_cm(timeUsec);

//04/30/17 added limit detection/correction

distCm = (distCm > 0) ? distCm : MAX_LR_DISTANCE_CM;

return distCm;

}

//01/10/18 reverted to regular ping(). median distance function takes too long

int GetRightDistCm()

{

//Serial.print("RightPing\t"); Serial.println(millis());

//Notes:

// 04/30/17 added limit detection/correction

int timeUsec = RightPing.ping();

//Serial.print("Right Ping Usec = "); Serial.println(timeUsec);

int distCm = RightPing.convert_cm(timeUsec);

//04/30/17 added limit detection/correction

distCm = (distCm > 0) ? distCm : MAX_LR_DISTANCE_CM;

return distCm;

}

The above program was intended to help me troubleshoot the intermittent MPU6050 connection failures I have been experiencing for some time now. The purpose of the new I2C sniffer project is to create a tool to log the actual I2C traffic between this program and the IMU. The idea is that when a failure occurs, I can look back through the sniffer log to see what happened; did the Arduino Mega stop transmitting requests, or did the IMU simply stop responding, or something else entirely.

Teensy I2C Sniffer for MPU6050

1 Reply

Posted 02 January 2020

On my last post on the I2C subject, I described an Excel VBA program to parse through a 928-byte array containing the captured I2C conversation between an Arduino Mega and a MPU6050 IMU module. The Arduino was running a very simple test program that repeatedly asked the MPU6050 to report the number of bytes available in its FIFO. Then I used Kito’s I2C sniffer code to capture the SDA/SCL transitions, which I then copy/pasted into Excel.

This post describes the next step, which was to port the Excel VBA code into a Teensy sketch using the Arduino version of C++, moving toward the ultimate goal of a Teensy based, fast I2C sniffer that can be used to monitor and log long-term (hours to days) I2C bus conversations to determine what is causing the intermittent hangups I’m seeing with my Arduino Mega/MPU-6050 robot project.

The code port took a while, but mostly because of my own lack of understanding about the details of the I2C protocol and the specifics of the communication between the Arduino test program and my MPU6050 IMU module. After working through these problems, the end result was surprisingly compact – less than 500 lines, including 50 lines of test data, LOTS of comments and debugging printouts, as shown below:

/*
    Name:       Teensy_I2C_Sniffer_V5.ino
    Created:	12/31/2019 11:36:00 PM
    Author:     FRANKNEWXPS15\Frank

    This is a port of my Excel VBA code into Arduino/Teensy C++ language.
    It parses the exact same data as the Excel program, so it should produce
    the exact same I2C sequences.

    The idea here is to not only perform the port, but to figure out how to
    produce a useful human-readable output format, and to determine how much
    time is required to parse the data and output the data to the serial port

    The captured data to be parsed is held in the 'simdata' array.

    The original VBA code is saved in 'ExcelVBACode.txt'

*/

/* 'Notes:

    A typical I2C sentence when communicating with a MPU6050 IMU module goes 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
*/
const int SIM_DATA_ARRAY_SIZE = 928;
byte simdata[SIM_DATA_ARRAY_SIZE] =
{
    0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0,
    0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc,
    0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0xc,
    0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0,
    0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc,
    0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0,
    0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0,
    0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc,
    0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0,
    0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0xc, 0x4, 0x8,
    0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8,
    0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4,
    0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0,
    0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0,
    0x4, 0x8, 0xc, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc,
    0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8,
    0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0,
    0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8,
    0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc, 0x4,
    0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0,
    0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4,
    0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0,
    0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0,
    0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4,
    0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8,
    0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc,
    0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0,
    0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0,
    0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc,
    0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc,
    0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0,
    0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc,
    0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0,
    0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0,
    0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4,
    0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8,
    0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0,
    0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0,
    0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4,
    0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0,
    0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4,
    0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8,
    0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0,
    0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0,
    0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x8, 0xc
};

//#define PARSE_LOOP_DEBUG
//#define GET_8BIT_DATABYTE_DEBUG

#pragma region VARIABLES
uint8_t devAddr;
uint8_t regAddr;

//added to handle bus direction changes
enum BUSDIR
{
    WRITE,
    READ,
    UNKNOWN = -1
} RWDir;
BUSDIR BusDir = BUSDIR::UNKNOWN;

int ACKNAKFlag; //can be negative
uint8_t databyte_array[2048]; //holds multiple databytes for later output sentence construction
uint16_t databyte_idx = 0; //index into databyte_array FIFO
uint16_t numbytes = 0; //number of data bytes extracted from data stream
#pragma endregion Variables


void setup()
{
    Serial.begin(500000); //trying higher speed with teensy
    unsigned long now = millis();
    int idx = 0;
    while (!Serial && (millis() - now) < 3000)
    {
        delay(500);
        idx++;
    }

    uint16_t dataidx = 0;
    unsigned long startUsec = micros();

    while (dataidx < SIM_DATA_ARRAY_SIZE) //outer loop only necessary for simulation runs
    {
#ifdef PARSE_LOOP_DEBUG
        Serial.printf("looptop: dataidx = %d\n", dataidx);
#endif

        //Find a START sequence (0xC followed by 0x4)
        while (!IsStart(simdata, dataidx) && dataidx < SIM_DATA_ARRAY_SIZE)
        {
            dataidx++;
        }
#ifdef PARSE_LOOP_DEBUG
        Serial.printf("Start sequence found at dataidx = %d\n", dataidx);
#endif

        if (dataidx < SIM_DATA_ARRAY_SIZE - 14)//14 entries required for 7-bit address
        {
            //Get 7-bit device address
            devAddr = Get7BitDeviceAddr(simdata, dataidx);
#ifdef PARSE_LOOP_DEBUG
            Serial.printf("devAddr = %x, dataidx = %d\n", devAddr, dataidx);
#endif

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

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

            //get ACK/NAK flag
            ACKNAKFlag = GetACKNAKFlag(simdata, dataidx);

            numbytes = GetDataBytes(simdata, dataidx, databyte_array);
#ifdef PARSE_LOOP_DEBUG
            Serial.printf("Got %d bytes from GetDataBytes()\n", numbytes);
#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 = databyte_array[0];
#ifdef PARSE_LOOP_DEBUG
                Serial.printf("regAddr = %x, dataidx = %d\n", regAddr, dataidx);
#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, databyte_array[i]);
                    }
#endif

                    //1st byte is register addr, subsequent bytes are data
                    OutputFormattedSentence(BusDir, devAddr, regAddr, numbytes, databyte_array, 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, databyte_array[i]);
                }
#endif
                OutputFormattedSentence(BusDir, devAddr, regAddr, numbytes, databyte_array, 0);
            }

        }//if (dataidx < SIM_DATA_ARRAY_SIZE - 14)//14 entries required for 7-bit address

    }//while (dataidx < SIM_DATA_ARRAY_SIZE) //outer loop only necessary for simulation runs

    Serial.printf("Parsing %d bytes took %lu uSec\n", SIM_DATA_ARRAY_SIZE, micros() - startUsec);

}//Setup()

void loop()
{


}
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* simdata, uint16_t& readidx)
{
    //Purpose: Construct a 7-bit address starting from dataidx
    //Inputs:
    //  simdata = pointer to simulated 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 simdata entry
    //Plan:
    //  Step1: Convert a pair of simdata 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 (simdata[readidx] == 0x0 && simdata[readidx + 1] == 0x4)
        {
            readidx += 2; //advance the pointer, but don't add to sum
        }

        else if (simdata[readidx] == 0x8 && simdata[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* simdata, uint16_t& readidx)
{
    //Purpose: Construct a 8-bit data byte starting from dataidx
    //Inputs:
    //  simdata = pointer to simulated 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 simdata entry
    //Plan:
    //  Step1: Convert a pair of simdata 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: simdata[%d] = %x, simdata[%d] = %x\n",
        readidx, simdata[readidx], readidx + 1, simdata[readidx + 1]);
#endif

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

        else if (simdata[readidx] == 0x8 && simdata[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* simdata, uint16_t& readidx)
{
    //Purpose: decode R/W byte pair
    //Inputs:
    //  simdata = pointer to byte capture array
    //  readidx = index into simdata to start of R/W byte pair
    //Outputs:
    //  readidx = if successful, points to next byte pair in simdata
    //  returns 1 for Read (0x8/0xC), 0 for Write (0x0/0x4), -1 for failure
    //Notes:
    //  

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

    else if (simdata[readidx] == 0x0 && simdata[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* simdata, uint16_t& readidx)
{
    //Purpose: decode ACK/NAK byte pair
    //Inputs:
    //  simdata = pointer to byte capture array
    //  readidx = index into simdata to start of ACK/NAK byte pair
    //Outputs:
    //  readidx = if successful, points to next byte pair in simdata
    //  returns 1 for NAK (0x8/0xC), 0 for ACK (0x0/0x4), -1 for failure
    //Notes:
    //  

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

    else if (simdata[readidx] == 0x0 && simdata[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;
            databyte_array[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 < SIM_DATA_ARRAY_SIZE);

    
    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("I2C(%x) %s %d bytes %s %x... ",
        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");

}

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

Name: Teensy_I2C_Sniffer_V5.ino

Created: 12/31/2019 11:36:00 PM

Author: FRANKNEWXPS15\Frank

This is a port of my Excel VBA code into Arduino/Teensy C++ language.

It parses the exact same data as the Excel program, so it should produce

the exact same I2C sequences.

The idea here is to not only perform the port, but to figure out how to

produce a useful human-readable output format, and to determine how much

time is required to parse the data and output the data to the serial port

The captured data to be parsed is held in the 'simdata' array.

The original VBA code is saved in 'ExcelVBACode.txt'

/* 'Notes:

A typical I2C sentence when communicating with a MPU6050 IMU module goes 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

const int SIM_DATA_ARRAY_SIZE = 928;

byte simdata[SIM_DATA_ARRAY_SIZE] =

{

0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0,

0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc,

0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0xc,

0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,

0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0,

0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc,

0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0,

0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4,

0x0, 0x4, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0,

0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4,

0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc,

0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,

0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0,

0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4,

0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0xc, 0x4, 0x8,

0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,

0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8,

0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4,

0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0,

0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,

0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0,

0x4, 0x8, 0xc, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc,

0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8,

0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,

0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0,

0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,

0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8,

0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc, 0x4,

0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0,

0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4,

0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0,

0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4,

0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0,

0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4,

0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8,

0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc,

0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0,

0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4,

0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0,

0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc,

0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc,

0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,

0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0,

0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc,

0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0,

0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,

0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0,

0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4,

0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8,

0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4,

0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0,

0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,

0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0,

0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4,

0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0,

0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4,

0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8,

0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4,

0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0,

0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,

0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0,

0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,

0x8, 0xc

};

//#define PARSE_LOOP_DEBUG

//#define GET_8BIT_DATABYTE_DEBUG

#pragma region VARIABLES

uint8_t devAddr;

uint8_t regAddr;

//added to handle bus direction changes

enum BUSDIR

{

WRITE,

READ,

UNKNOWN = -1

} RWDir;

BUSDIR BusDir = BUSDIR::UNKNOWN;

int ACKNAKFlag; //can be negative

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

uint16_t databyte_idx = 0; //index into databyte_array FIFO

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

#pragma endregion Variables

void setup()

{

Serial.begin(500000); //trying higher speed with teensy

unsigned long now = millis();

int idx = 0;

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

{

delay(500);

idx++;

}

uint16_t dataidx = 0;

unsigned long startUsec = micros();

while (dataidx < SIM_DATA_ARRAY_SIZE) //outer loop only necessary for simulation runs

{

#ifdef PARSE_LOOP_DEBUG

Serial.printf("looptop: dataidx = %d\n", dataidx);

#endif

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

while (!IsStart(simdata, dataidx) && dataidx < SIM_DATA_ARRAY_SIZE)

{

dataidx++;

}

#ifdef PARSE_LOOP_DEBUG

Serial.printf("Start sequence found at dataidx = %d\n", dataidx);

#endif

if (dataidx < SIM_DATA_ARRAY_SIZE - 14)//14 entries required for 7-bit address

{

//Get 7-bit device address

devAddr = Get7BitDeviceAddr(simdata, dataidx);

#ifdef PARSE_LOOP_DEBUG

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

#endif

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

BusDir = (BUSDIR)GetReadWriteFlag(simdata, dataidx);

#ifdef PARSE_LOOP_DEBUG

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

#endif

//get ACK/NAK flag

ACKNAKFlag = GetACKNAKFlag(simdata, dataidx);

numbytes = GetDataBytes(simdata, dataidx, databyte_array);

#ifdef PARSE_LOOP_DEBUG

Serial.printf("Got %d bytes from GetDataBytes()\n", numbytes);

#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 = databyte_array[0];

#ifdef PARSE_LOOP_DEBUG

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

#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, databyte_array[i]);

}

#endif

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

OutputFormattedSentence(BusDir, devAddr, regAddr, numbytes, databyte_array, 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, databyte_array[i]);

}

#endif

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

}

}//if (dataidx < SIM_DATA_ARRAY_SIZE - 14)//14 entries required for 7-bit address

}//while (dataidx < SIM_DATA_ARRAY_SIZE) //outer loop only necessary for simulation runs

Serial.printf("Parsing %d bytes took %lu uSec\n", SIM_DATA_ARRAY_SIZE, micros() - startUsec);

}//Setup()

void loop()

{

}

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* simdata, uint16_t& readidx)

{

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

//Inputs:

// simdata = pointer to simulated 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 simdata entry

//Plan:

// Step1: Convert a pair of simdata 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 (simdata[readidx] == 0x0 && simdata[readidx + 1] == 0x4)

{

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

}

else if (simdata[readidx] == 0x8 && simdata[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* simdata, uint16_t& readidx)

{

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

//Inputs:

// simdata = pointer to simulated 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 simdata entry

//Plan:

// Step1: Convert a pair of simdata 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: simdata[%d] = %x, simdata[%d] = %x\n",

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

#endif

//8 bits with MSB = 0

int numbytes = 0;

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

{

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

{

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

numbytes++;

}

else if (simdata[readidx] == 0x8 && simdata[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* simdata, uint16_t& readidx)

{

//Purpose: decode R/W byte pair

//Inputs:

// simdata = pointer to byte capture array

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

//Outputs:

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

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

//Notes:

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

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

int result = 0;

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

{

result = 1; //read detected

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

}

else if (simdata[readidx] == 0x0 && simdata[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* simdata, uint16_t& readidx)

{

//Purpose: decode ACK/NAK byte pair

//Inputs:

// simdata = pointer to byte capture array

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

//Outputs:

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

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

//Notes:

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

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

int result = 0;

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

{

result = 1; //NAK detected

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

}

else if (simdata[readidx] == 0x0 && simdata[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;

databyte_array[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 < SIM_DATA_ARRAY_SIZE);

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("I2C(%x) %s %d bytes %s %x... ",

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");

}

When I ran this program against the captured data, I got the following output:

Opening port
Port open
I2C(68) reading 1 bytes from 75... 68 . Done
I2C(68) reading 1 bytes from 6a... c0 . Done
I2C(68) writing 1 bytes to 6a... c4 . Done
I2C(68) reading 2 bytes from 72... 0 1c . Done
I2C(68) reading 2 bytes from 72... 0 38 . Done
I2C(68) reading 2 bytes from 72... 0 54 . Done
I2C(68) reading 2 bytes from 72... 0 70 . Done
I2C(68) reading 2 bytes from 72... 0 8c . Done
I2C(68) reading 2 bytes from 72... 0 c4 . Done
I2C(68) reading 2 bytes from 72... 0 e0 . Done
Parsing 928 bytes took 1081 uSec

Opening port

Port open

I2C(68) reading 1 bytes from 75... 68 . Done

I2C(68) reading 1 bytes from 6a... c0 . Done

I2C(68) writing 1 bytes to 6a... c4 . Done

I2C(68) reading 2 bytes from 72... 0 1c . Done

I2C(68) reading 2 bytes from 72... 0 38 . Done

I2C(68) reading 2 bytes from 72... 0 54 . Done

I2C(68) reading 2 bytes from 72... 0 70 . Done

I2C(68) reading 2 bytes from 72... 0 8c . Done

I2C(68) reading 2 bytes from 72... 0 c4 . Done

I2C(68) reading 2 bytes from 72... 0 e0 . Done

Parsing 928 bytes took 1081 uSec

which, when compared against the debug printout from Jeff Rowberg’s I2CDev program,

I2C (0x68) reading 1 bytes from 0x75...68. Done (1 read).
I2C (0x68) reading 1 bytes from 0x6A...C0. Done (1 read).
I2C (0x68) writing 1 bytes to 0x6A...C4. Done.
I2C (0x68) reading 2 bytes from 0x72...0 1C. Done (2 read).
I2C (0x68) reading 2 bytes from 0x72...0 38. Done (2 read).
I2C (0x68) reading 2 bytes from 0x72...0 54. Done (2 read).
I2C (0x68) reading 2 bytes from 0x72...0 70. Done (2 read).
I2C (0x68) reading 2 bytes from 0x72...0 8C. Done (2 read).
I2C (0x68) reading 2 bytes from 0x72...0 C4. Done (2 read).
I2C (0x68) reading 2 bytes from 0x72...0 E0. Done (2 read).

I2C (0x68) reading 1 bytes from 0x75...68. Done (1 read).

I2C (0x68) reading 1 bytes from 0x6A...C0. Done (1 read).

I2C (0x68) writing 1 bytes to 0x6A...C4. Done.

I2C (0x68) reading 2 bytes from 0x72...0 1C. Done (2 read).

I2C (0x68) reading 2 bytes from 0x72...0 38. Done (2 read).

I2C (0x68) reading 2 bytes from 0x72...0 54. Done (2 read).

I2C (0x68) reading 2 bytes from 0x72...0 70. Done (2 read).

I2C (0x68) reading 2 bytes from 0x72...0 8C. Done (2 read).

I2C (0x68) reading 2 bytes from 0x72...0 C4. Done (2 read).

I2C (0x68) reading 2 bytes from 0x72...0 E0. Done (2 read).

shows that my Teensy program correctly decoded the entire test dataset.

The next step in the process is to modify the above program to allow long-term real-time monitoring and logging of a live I2C bus. By ‘long-term’, I mean hours if not days, as the object of the exercise is to figure out why the I2C bus connection to the MPU6050 on my two-motor robot intermittently fails when the motors are running. A failure can occur within minutes, or only after several hours, and there doesn’t seem to be any rhyme nor reason, except that the motors have to be running.

In normal operation, my two-motor robot obtains a heading value from the MPU6050 once every 200 mSec or so. This I2C bus activity might comprise only 100 SCL/SDA transitions or so, and no other I2C bus activity takes place in the times between heading value requests. So, there will be few mSec of burst activity, followed by a 150-190 mSec idle period. To monitor and log in real time, I need some sort of FIFO arrangement, where the I2C transition data can be saved into the FIFO during the burst, and then processed and saved into a log file during the idle period.

While I was searching the web for I2C sniffer code, I also ran across this thread by tonton81 describing his template based circular buffer library for the Teensy line. The thread started a little over two years ago, but has been quite active during that period, and tonton81 has made several bugfixes, updates, and enhancements to his code. This might be just the thing for my project.

06 January 2020 Update:

After integrating tonton81’s circular buffer library into the project (thanks tonton81 for being so responsive with bugfixes!), I was able to demonstrate that the circular buffer version, when run against the same 928-byte simulated dataset, produced the same output as before, as shown below:

Opening port
Port open
Port open
Serial available after 2500 mSec
3001: cb_trans contains = 928 elements
I2C(68) reading 1 bytes from 75... 68 . Done
I2C(68) reading 1 bytes from 6a... c0 . Done
I2C(68) writing 1 bytes to 6a... c4 . Done
I2C(68) reading 2 bytes from 72... 0 1c . Done
I2C(68) reading 2 bytes from 72... 0 38 . Done
I2C(68) reading 2 bytes from 72... 0 54 . Done
I2C(68) reading 2 bytes from 72... 0 70 . Done
I2C(68) reading 2 bytes from 72... 0 8c . Done
I2C(68) reading 2 bytes from 72... 0 c4 . Done
I2C(68) reading 2 bytes from 72... 0 e0 . Done
3003: cb_trans contains = 0 elements

Opening port

Port open

Serial available after 2500 mSec

3001: cb_trans contains = 928 elements

I2C(68) reading 1 bytes from 75... 68 . Done

I2C(68) reading 1 bytes from 6a... c0 . Done

I2C(68) writing 1 bytes to 6a... c4 . Done

I2C(68) reading 2 bytes from 72... 0 1c . Done

I2C(68) reading 2 bytes from 72... 0 38 . Done

I2C(68) reading 2 bytes from 72... 0 54 . Done

I2C(68) reading 2 bytes from 72... 0 70 . Done

I2C(68) reading 2 bytes from 72... 0 8c . Done

I2C(68) reading 2 bytes from 72... 0 c4 . Done

I2C(68) reading 2 bytes from 72... 0 e0 . Done

3003: cb_trans contains = 0 elements

From the output above, it is clear that the Teensy can parse and print a typical 1000-byte burst in just a few mSec (3 in the above run), so it should have no problem keeping up with a 200 mSec data burst interval, and should be able to keep up with burst intervals down to around 10 mSec (100 bursts/sec!) I suspect that the Teensy’s major problem will be not dying of boredom waiting for the next burst to process!

Here’s the full code (not including circular_buffer.h):

/*
    Name:       Teensy_I2C_Sniffer_V6.ino
    Created:	1/4/2020 8:40:20 AM
    Author:     FRANKNEWXPS15\Frank

    This is a port of my Excel VBA code into Arduino/Teensy C++ language.
    It parses the exact same sample data as the Excel program, so it should
    produce the exact same I2C sequences.

    The captured sample data to be parsed is held in the 'simdata' array.

    The original VBA code is saved in 'ExcelVBACode.txt'
*/

/* 'Notes:

    A typical I2C sentence when communicating with a MPU6050 IMU module goes 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 adds tonton81's circular buffer class (https://github.com/tonton81/Circular_Buffer)
to simulate real-time processing and display of I2C bus activity.  The sample data is loaded into
a FIFO by an ISR triggered every microsecond by a timer, and then the processing code pulls it out
and parses it as fast as possible.  If this works, then the next version will eliminate the sample
data and connect to a live I2C bus.
*/

#include <TimerOne.h> //needed for ISR
#include "circular_buffer.h"
Circular_Buffer<uint8_t, 2048> cb_trans; //holds transition values from ISR

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

const int SIM_DATA_ARRAY_SIZE = 928;
byte simdata[SIM_DATA_ARRAY_SIZE] =
{
    0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0,
    0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc,
    0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0xc,
    0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0,
    0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc,
    0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0,
    0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0,
    0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc,
    0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0,
    0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0xc, 0x4, 0x8,
    0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8,
    0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4,
    0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0,
    0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0,
    0x4, 0x8, 0xc, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc,
    0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8,
    0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0,
    0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8,
    0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc, 0x4,
    0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0,
    0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4,
    0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0,
    0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0,
    0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4,
    0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8,
    0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc,
    0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0,
    0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0,
    0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc,
    0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc,
    0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0,
    0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc,
    0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0,
    0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0,
    0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4,
    0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8,
    0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0,
    0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0,
    0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4,
    0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0,
    0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4,
    0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8,
    0xc, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0,
    0x4, 0x0, 0x4, 0x8, 0xc, 0x8, 0xc, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x0, 0x4, 0x0, 0x4, 0x8, 0xc, 0x0, 0x4, 0xc, 0x4, 0x8, 0xc, 0x8, 0xc, 0x0,
    0x4, 0x8, 0xc, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4, 0x0, 0x4,
    0x8, 0xc
};

//#define PARSE_LOOP_DEBUG
//#define GET_8BIT_DATABYTE_DEBUG
const int BUFFER_CHECK_INTERVAL_MSEC = 200;
//const int BUFFER_CHECK_INTERVAL_MSEC = 5;
#pragma region PROCESSING_VARIABLES
uint8_t devAddr;
uint8_t regAddr;

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

int ACKNAKFlag; //can be negative
uint8_t databyte_array[2048]; //holds multiple databytes for later output sentence construction
uint16_t databyte_idx = 0; //index into databyte_array
uint16_t numbytes = 0; //number of data bytes extracted from data stream
uint8_t killbuff[2]; //used to consume start/stop bytes

#pragma endregion ProcVars

#pragma region ISR_VARS
uint16_t  write_index = 0;
uint16_t  read_index = 0;
uint8_t   current_portb = 0xFF;
uint8_t   last_portb = 0xFF;
bool bBufferFull = false;
elapsedMillis mSecSinceLastBufferCheck;
#pragma endregion ISRVars

int DecodeAndPrintFIFOContents(Circular_Buffer<uint8_t, 2048>& cb); //need forward reference here


//-------------------------------------------------------------------------------
//--------------------------------    ISR    ------------------------------------
//-------------------------------------------------------------------------------
//01/04/2020 modified to 'capture' data from simdata[]
void capture_data(void)
{
    if (!bBufferFull) //for debug - writes only one set of data to FIFO
    {
        last_portb = current_portb;
        current_portb = simdata[read_index]; //pull one transition value from simdata
        read_index++;

        if (last_portb != current_portb && !bBufferFull)
        {
            cb_trans.write(current_portb); //add current transition value to FIFO
            digitalWriteFast(MONITOR_OUT1, !digitalReadFast(MONITOR_OUT1));
        }
    
        //pause writing to cb_trans circular buffer
        if (read_index >= SIM_DATA_ARRAY_SIZE)
        {
            bBufferFull = true;
            read_index = 0;
            digitalWriteFast(MONITOR_OUT1, LOW);
        }
    }
}

void setup()
{
    Serial.begin(1); //rate value ignored
    unsigned long now = millis();
    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);
    pinMode(MONITOR_OUT2, OUTPUT);
    pinMode(LED_BUILTIN, OUTPUT);
    Timer1.initialize(1); // run every mico second
    Timer1.attachInterrupt(capture_data);

    mSecSinceLastBufferCheck = 0;
}

void loop()
{
    if (mSecSinceLastBufferCheck > BUFFER_CHECK_INTERVAL_MSEC)
    {
        Serial.printf("%lu: cb_trans contains = %d elements\n", millis(), cb_trans.size());
        mSecSinceLastBufferCheck -= BUFFER_CHECK_INTERVAL_MSEC;
        DecodeAndPrintFIFOContents(cb_trans); //decode and print everything captured so far
        Serial.printf("%lu: cb_trans contains = %d elements\n", millis(), cb_trans.size());
        //cb_trans.clear();
        read_index = 0;
        bBufferFull = false;
        digitalWriteFast(MONITOR_OUT2, !digitalReadFast(MONITOR_OUT2));
        while (true)
        {

        }
    }
}

void PrintNextFIFOBytes(Circular_Buffer<uint8_t, 2048>& cb, uint8_t numbytes)
{
    Serial.printf("Next %d FIFO Bytes: ", numbytes);
    for (uint8_t i = 0; i < numbytes-1; i++)
    {
        Serial.printf("%x,", cb.peek(i));
    }
    Serial.printf("%x\n", cb.peek(numbytes-1));
}
bool IsStart(Circular_Buffer<uint8_t, 2048>& cb)
{
    bool result = false;

    uint8_t data[2]; data[0] = data[1] = 0;
    data[0] = cb.peek(0);
    data[1] = cb.peek(1);
    if (data[0] == 0xC && data[1] == 0x4)
    {
        //Serial.printf("Start detected at size = %d, data idx = %d\n", cb.size(), SIM_DATA_ARRAY_SIZE - cb.size());
        result = true;
    }

    return result;
}

bool IsStop(Circular_Buffer<uint8_t, 2048>& cb)
{
    bool result = false;

    uint8_t data[2];
    cb.peekBytes(data, 2);
    if (data[0] == 0x4 && data[1] == 0xC)
    {
        //cb.readBytes(data, 2); //consume these bytes
        result = true;
    }

    return result;

}

uint8_t Get7BitDeviceAddr(Circular_Buffer<uint8_t, 2048>& cb)
{
    //Purpose: Construct a 7-bit address starting from next FIFO element
    //Inputs:
    //  cb = reference to cb_trans FIFO
    //Outputs:
    //  returns the address as an 8-bit value with the MSB = 0, or 0x0 if unsuccessful
    //  the 14 transitions associated with the 7-bit address removed from FIFO
    //Plan:
    //  Step1: Convert a pair of FIFO elements 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

    //devAddr is exactly 7 bits long, so 8 bits with MSB = 0
    uint8_t data[2]; //holds one transition pair
    for (size_t i = 0; i < 7; i++)
    {

        cb.readBytes(data, 2);
        //data[0] = cb.read();
        //data[1] = cb.read();
        //Serial.printf("data[0] = %x, data[1] = %x\n", data[0], data[1]);

        if (data[0] == 0x8 && data[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)));

            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 GetReadWriteFlag(Circular_Buffer<uint8_t, 2048>& cb)
{
    //Purpose: decode R/W byte pair
    //Inputs:
    //  cb = reference to cb_trans FIFO
    //Outputs:
    //  readidx = if successful, points to next byte pair in simdata
    //  returns 1 for Read (0x8/0xC), 0 for Write (0x0/0x4), -1 for failure
    //Notes:
    //  

    int result = 0;
    uint8_t data[2];
    data[0] = cb.read();
    data[1] = cb.read();
    //Serial.printf("data[0] = %x, data[1] = %x\n", data[0], data[1]);

    if (data[0] == 0x8 && data[1] == 0xC)
    {
        result = 1; //read detected
    }

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

    return result;
}

int GetACKNAKFlag(Circular_Buffer<uint8_t, 2048>& cb)
{
    //Purpose: decode ACK/NAK byte pair
    //Inputs:
    //  cb = reference to cb_trans circular buffer holding transition values
    //Outputs:
    //  returns 1 for NAK (0x8/0xC), 0 for ACK (0x0/0x4), -1 for failure
    //Notes:
    //  this code is identical to the code for GetReadWriteFlag, so use it instead 

     return GetReadWriteFlag(cb_trans);

}
int Get8BitDataByte(Circular_Buffer<uint8_t, 2048>& cb)
{
    //Purpose: Construct a 8-bit data byte starting from dataidx
    //Inputs:
    //  cb = reference to cb_trans circular buffer holding transition values
    //Outputs:
    //  returns the address as an 8-bit value, or -1 if unsuccessful
    //  dataidx = pointer to next simdata entry
    //Plan:
    //  Step1: Convert a pair of simdata 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; 
    int numbits = 0;
    uint8_t data[2]{ 0x0,0x0 }; //holds one transition pair

////DEBUG!!
//    Serial.printf("Get8BitDataByte top: data[0] = %x,data[1] = %x, size = %d, idx = %d\n",
//        data[0], data[1], cb.size(), SIM_DATA_ARRAY_SIZE - cb.size());
//    PrintNextFIFOBytes(cb, 20);
////DEBUG!!

    //8 bits with MSB = 0

    for (size_t i = 0; i < 8; i++)
    {
        data[0] = cb.peek(0); data[1] = cb.peek(1);
        //Serial.printf("data[0] = %x, data[1] = %x\n", data[0], data[1]);

        if (data[0] == 0x0 && data[1] == 0x4)
        {
            cb.readBytes(data, 2);// now consume the bytes
            numbits++;
        }
        else if (data[0] == 0x8 && data[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
            cb.readBytes(data, 2);// now consume the bytes
            dataval += (1 << (7 - i)); //add 2^(8-i) to sum
            numbits++;
        }
        else //not a 1 or 0 - get me outa here!
        {
            break;
        }
    }

////DEBUG!!
//    Serial.printf("Get8BitDataByte bottom: numbits = %d, data[0] = %x,data[1] = %x, size = %d, idx = %d\n",
//       numbits, data[0], data[1], cb.size(), SIM_DATA_ARRAY_SIZE - cb.size());
//    PrintNextFIFOBytes(cb, 20);
////DEBUG!!

    if (numbits != 8)
    {
        dataval = -1; //error return value
    }

    return dataval;
}

int GetDataBytes(Circular_Buffer<uint8_t, 2048>& cb, 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;

    do
    {
        dataval = Get8BitDataByte(cb);

////DEBUG!!
//        Serial.printf("GetDataBytes() just after Get8BitDataByte(): datval = %x, size = %d, idx = %d\n", 
//            dataval, cb.size(), SIM_DATA_ARRAY_SIZE-cb.size());
//        PrintNextFIFOBytes(cb, 10);
////DEBUG!!

        //watch out for 'short byte' reads
        if (dataval >= 0)
        {
            uint8_t databyte = (uint8_t)dataval;
            databyte_array[databyte_idx] = databyte;
            databyte_idx++;
            numbytes++;
            ACKNAKFlag = GetACKNAKFlag(cb_trans); //01/05/20 moved inside 'good byte' block
        }

        //ACKNAKFlag = GetACKNAKFlag(cb_trans);
////DEBUG!!
//        Serial.printf("GetDataBytes() just after GetACKNAKFlag(): ACKNAK = %d, size = %d, idx = %d\n", 
//            ACKNAKFlag, cb.size(), SIM_DATA_ARRAY_SIZE-cb.size());
//        PrintNextFIFOBytes(cb, 10);
////DEBUG!!
        StartFlag = IsStart(cb_trans);
////DEBUG!!
//        Serial.printf("GetDataBytes() just after IsStart(): StartFlag = %d, size = %d, idx = %d\n", 
//            StartFlag, cb.size(), SIM_DATA_ARRAY_SIZE-cb.size());
//        PrintNextFIFOBytes(cb, 10);
////DEBUG!!
        StopFlag = IsStop(cb_trans);

#ifdef PARSE_LOOP_DEBUG
        Serial.printf("IsStart %d, IsStop  %d, next two bytes are %x, %x, data idx = %d\n",
            StartFlag, StopFlag, cb.peek(0), cb.peek(1), SIM_DATA_ARRAY_SIZE-cb.size());
#endif

    } while (!StartFlag && !StopFlag && cb_trans.size() > 0);

    return numbytes;
}

void OutputFormattedSentence(int RW, uint8_t dev, uint8_t reg, uint8_t numbytes, uint8_t* bytearray, uint16_t startidx)
{
    Serial.printf("I2C(%x) %s %d bytes %s %x... ",
        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");

}

int DecodeAndPrintFIFOContents(Circular_Buffer<uint8_t, 2048>& cb)
{
    //Purpose:  decode and print I2C conversation held in cb_trans FIFO
    //Inputs:  
    //  cb = 2048 element FIFO
    //Outputs:
    //  returns number of bytes processed, or -1 for failure
    //  outputs structured I2C sentence to serial monitor
    //Plan:
    //  Step1: Determine if there is anything to do (have to have more than one transition in FIFO)
    //  Step2: Parse transitions into I2C sentence structure
    //  Step3: Output sentence to serial monitor

    if (cb.size() < 2)
    {
        return 0;
    }

    while (cb.size() > 0)
    {
#ifdef PARSE_LOOP_DEBUG
        Serial.printf("At top of while (cb.size() > 0): size = %d\n", cb.size());
        Serial.printf("Next two bytes in FIFO are %x, %x\n", cb.peek(0), cb.peek(1));
#endif
        //Find a START sequence (0xC followed by 0x4)
        while (!IsStart(cb))
        {
            Serial.printf("looking for start...\n");
        }
        cb.readBytes(killbuff,2); //01/05/20 moved START byte consume out of IsStart()


    #ifdef PARSE_LOOP_DEBUG
        Serial.printf("Start sequence found, FIFO size = %d, idx = %d\n", cb.size(), SIM_DATA_ARRAY_SIZE-cb.size());
        //PrintNextFIFOBytes(cb_trans, 20);
    #endif

        if (cb.size() > 14)//14 entries required for 7-bit address
        {
            //Get 7-bit device address
            devAddr = Get7BitDeviceAddr(cb);
            //Serial.printf("devAddr = %x, FIFO size = %d, idx = %d\n", devAddr, cb.size(), SIM_DATA_ARRAY_SIZE - cb.size());
        }

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

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

        //get ACK/NAK flag
        ACKNAKFlag = GetACKNAKFlag(cb);

        numbytes = GetDataBytes(cb, databyte_array); //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 ", databyte_array[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 = databyte_array[0];
    #ifdef PARSE_LOOP_DEBUG
            Serial.printf("regAddr = %x, cb size = %d\n", regAddr, cb.size());
    #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, databyte_array[i]);
                }
    #endif
                //1st byte is register addr, subsequent bytes are data
                OutputFormattedSentence(BusDir, devAddr, regAddr, numbytes, databyte_array, 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, databyte_array[i]);
            }
#endif
            OutputFormattedSentence(BusDir, devAddr, regAddr, numbytes, databyte_array, 0);
        }
    #ifdef PARSE_LOOP_DEBUG
        Serial.printf("At end of while (cb.size() > 0): size = %d\n", cb.size());
        Serial.printf("Next two bytes in FIFO are %x, %x\n", cb.peek(0), cb.peek(1));
    #endif

    }//while (cb.size() > 0)

    return 1;
}

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

Name: Teensy_I2C_Sniffer_V6.ino

Created: 1/4/2020 8:40:20 AM

Author: FRANKNEWXPS15\Frank

This is a port of my Excel VBA code into Arduino/Teensy C++ language.

It parses the exact same sample data as the Excel program, so it should

produce the exact same I2C sequences.

The captured sample data to be parsed is held in the 'simdata' array.

The original VBA code is saved in 'ExcelVBACode.txt'

/* 'Notes:

A typical I2C sentence when communicating with a MPU6050 IMU module goes 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 adds tonton81's circular buffer class (https://github.com/tonton81/Circular_Buffer)

to simulate real-time processing and display of I2C bus activity. The sample data is loaded into

a FIFO by an ISR triggered every microsecond by a timer, and then the processing code pulls it out

and parses it as fast as possible. If this works, then the next version will eliminate the sample

data and connect to a live I2C bus.

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

#include "circular_buffer.h"

Circular_Buffer<uint8_t, 2048> cb_trans; //holds transition values from ISR