Tag Archives: HC-05

Wall-E3 Replacing Mega 2560 With Teensy 3.5

Posted 23 October, 2021

For some time now, I have been contemplating a replacement for the outdated and obsolete Mega 2560 micro-controller as the main controller module of my autonomous wall-following robot. The robot actually sports three controllers – the Mega 2560 main controller runs the overall operating system, drives the motors, and manages the speaker, the front-facing LIDAR unit, and a number of LEDs. A Teensy 3.2 manages the forward-facing IR-LED charging station beacon detection/homing algorithm, and a Teensy 3.5 manages the seven VL53L0X LIDAR distance measuring modules. So, it would make a lot of sense to replace the 2560 with another Teensy, making all the software consistent, and giving the robot a significant boost in computing power. A Teensy 3.5 at 120MHz runs at almost 10 times the 16MHz rate of the 2560, has twice the Flash memory (512K vs 256) and 32 times the RAM (256K vs 8). However, until recently (see this post) it has been very difficult/impossible to perform over-the-air (OTA) firmware updates with any of the Teensy products – a deal-breaker for me as I do that quite often with Wall-E2. Now that OTA capability has been demonstrated, the only remaining hurdle was whether or not a Teensy 3.5 has sufficient I/O to replace the Mega 2560. To address this question I created an Excel spreadsheet to document the current I/O assignments of the 2560 and then tentatively assigned Teensy 3.5 pins to match, as shown below.

As can be seen from the above, the Teensy 3.5 has plenty of pins left over after all currently assigned Mega 2560 pin assignments have been covered, so that problem goes away too.

The last piece of the puzzle was just the inconvenience of changing out a currently-working Mega 2560 just to gain performance that may or may not really be necessary. However, now that I have decided to redo the entire chassis to address the turn side-slip problem (see this post), I plan to use the opportunity to start fresh with a Teensy 3.5 as the main controller and work out any problems with just the chassis, the motors and motor drivers and the Teensy before moving on to implementing the rest of Wall-E2’s capabilities.

Motor Drivers for Wall-E3:

I have a bunch of motor driver modules left over from an earlier motor driver study, so I decided to use two of the Pololu VNH5019 motor driver modules for Wall-E3 – one for the two left motors, and one for the two right motors.

01 November 2021 Update:

The first step in bringing up the Wall-E3 robot was to assemble a very basic system on a simulated chassis bottom plate, as shown in the following photo:

Prototype Wall-E3 System on simulated chassis baseplate

The basic system consists of a TP5100 charger system and a 8.4V 7200 mAH battery pack, an Adafruit 1NA169 high-side current sensor, a Teensy 3.5 and a auxiliary board containing a 5V LDO regulator and a HC-05 Bluetooth module. The Teensy’s program at this stage consists of the OTA update code developed earlier in this post and this post, plus a few lines to read the current sensor output, convert it to a current value, and send it to the BT serial port. Here’s the program:

/*
    Name:       T35_WallE3_V1.ino
    Created:	10/25/2021 2:37:04 PM
    Author:     FRANKNEWXPS15\Frank

    10/30/21 - Added TeensyOTADemo code for basic OTA updates
*/

/*
    Name:       TeensyOTADemo.ino
    Created:	10/9/2021 11:18:19 AM
    Author:     FRANKNEWXPS15\Frank

    This program demonstrates the use of 'board.txt' post-build instructions in
    conjunction with a small C# command-line program for seamless 'over-the-air' (OTA)
    firmware update for Teensy modules.

    Implementation of OTA update requires that Joe Pasquariello's 'FlasherX'
    code be added to the Teensy sketch as it is below, and some code to allow
    an external serial communications program to trigger the update process.

    In the demo sketch below, the 'FlasherX' additions are the '#include FlasherTxx.h'
    line and the addition of the FlasherX specific code at the bottom. The trigger
    mechanism is provided by the 'CheckForUserInput();' call in loop.  If the ASCII
    code for 'U' or 'u' is present on Serial1, the update process will be launched.

*/

#include "FlashTxx.h"		// TLC/T3x/T4x flash primitives
#include <elapsedMillis.h>

elapsedMillis MsecSinceLastLEDToggle; //used for LED blink timer
const double AREF = 3.3; //teensy default for analog inputs
const double AmpsPerVolt = 1.00; //default 10K Rs
const int MAX_AD_COUNT = 1023;
const double VoltsPerCount = AREF / MAX_AD_COUNT;
const int ItotPin = A18;

//Stream* FTDIport = &Serial1;	// Serial (USB) or Serial1, Serial2, etc. (UART)

#pragma region OTA UPDATE
//******************************************************************************
// hex_info_t	struct for hex record and hex file info
//******************************************************************************
typedef struct {	// 
  char* data;		// pointer to array allocated elsewhere
  unsigned int addr;	// address in intel hex record
  unsigned int code;	// intel hex record type (0=data, etc.)
  unsigned int num;	// number of data bytes in intel hex record

  uint32_t base;	// base address to be added to intel hex 16-bit addr
  uint32_t min;		// min address in hex file
  uint32_t max;		// max address in hex file

  int eof;		// set true on intel hex EOF (code = 1)
  int lines;		// number of hex records received  
} hex_info_t;

void read_ascii_line(Stream* serial, char* line, int maxbytes);
int  parse_hex_line(const char* theline, char* bytes,
  unsigned int* addr, unsigned int* num, unsigned int* code);
int  process_hex_record(hex_info_t* hex);
void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size);

uint32_t buffer_addr, buffer_size; //09/20/21 copied from FlasherX - loop()
#pragma endregion OTA UPDATE

void setup()
{
  Serial.begin(115200);
  delay(2000); //10/06/21 - just use fixed delay instead

  Serial1.begin(115200); //used HC-05 'AT' commands to set this speed
  while (!Serial1) {}

  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(ItotPin, INPUT); //I_total 1V/Amp
  //analogReadAveraging(4);

  MsecSinceLastLEDToggle = 0;

  Serial1.printf("Msec\tADVal\tTotVolts\tTotAmps\n");
}

void loop()
{
  if (Serial1.available())
  {
    CheckForUserInput();
  }

  if (MsecSinceLastLEDToggle >= 200)
  {
    MsecSinceLastLEDToggle -= 200;
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));

    //11/01/21 read I_tot value & print out as current
    int ItotVal = analogRead(ItotPin);
    double ItotVolts = ItotVal * VoltsPerCount;
    double ItotAmps = ItotVolts * AmpsPerVolt;
    Serial1.printf("%lu\t%d\t%2.2f\t%2.2f\n", millis(), ItotVal, ItotVolts, ItotAmps);

  }
}
void CheckForUserInput()
{
  const int bufflen = 80;
  char buff[bufflen];
  memset(buff, 0, bufflen);
  //const char s[2] = ",";

  if (Serial1.available() > 0)
  {
    // read the incoming byte:
    int incomingByte = Serial1.read();

    // say what you got:
    Serial1.print("I received: ");
    Serial1.println(incomingByte, HEX); //chg to HEX 02/18/20

    //02/18/20 experiment with multiple commands
    switch (incomingByte)
    {
    case 0x55: //ASCII 'U'
    case 0x75: //ASCII 'u'
      Serial1.println(F("Start Program Update - Send new HEX file!"));


      //09/20/21 copied from FlasherX - loop()
      if (firmware_buffer_init(&buffer_addr, &buffer_size) == 0)
      {
        Serial1.printf("unable to create buffer\n");
        Serial1.flush();
        for (;;) {}
      }

      Serial1.printf("buffer = %1luK %s (%08lX - %08lX)\n",
        buffer_size / 1024, IN_FLASH(buffer_addr) ? "FLASH" : "RAM",
        buffer_addr, buffer_addr + buffer_size);

      //09/20/21 clear the serial buffer
      while (Serial1.available())
      {
        Serial1.read();
      }

      // receive hex file via serial, write new firmware to flash, clean up, reboot
      update_firmware(&Serial1, buffer_addr, buffer_size); // no return if success

      // return from update_firmware() means error or user abort, so clean up and
      // reboot to ensure that static vars get boot-up initialized before retry
      Serial1.printf("erase FLASH buffer / free RAM buffer...\n");
      firmware_buffer_free(buffer_addr, buffer_size);
      Serial1.flush();
      REBOOT;
      break;
    }
  }
}

#pragma region FLASHER_X

//09/20/21 copied from FlasherX
//******************************************************************************
// update_firmware()	read hex file and write new firmware to program flash
//******************************************************************************
void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size)
{
  static char line[96];					// buffer for hex lines
  static char data[32] __attribute__((aligned(8)));	// buffer for hex data
  hex_info_t hex = {					// intel hex info struct
    data, 0, 0, 0,					//   data,addr,num,code
    0, 0xFFFFFFFF, 0, 					//   base,min,max,
    0, 0						//   eof,lines
  };

  serial->printf("waiting for hex lines...\n");

  // read and process intel hex lines until EOF or error
//DEBUG!!
  //int line_num = 0;
//DEBUG!!
  long int start_msec = 0;
  bool bFirstTime = true;
  while (!hex.eof) {

    read_ascii_line(serial, line, sizeof(line));

    if (bFirstTime)
    {
      start_msec = millis();
      bFirstTime = false;
    }

    //DEBUG!!
        //serial->printf("%d: %s\n", line_num, line);
        //line_num++;
    //DEBUG!!

        //10/02/21 gfp added for visual xfer confirmation
    if (hex.lines % 10 == 0)
    {
      digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN));
    }

    // reliability of transfer via USB is improved by this printf/flush
    if (serial == (Stream*)&Serial)
    {
      serial->printf("%s\n", line);
      serial->flush();
    }

    if (parse_hex_line((const char*)line, hex.data, &hex.addr, &hex.num, &hex.code) == 0) {
      serial->printf("abort - bad hex line %s\n", line);
      return;
    }
    else if (process_hex_record(&hex) != 0) { // error on bad hex code
      serial->printf("abort - invalid hex code %d\n", hex.code);
      return;
    }
    else if (hex.code == 0) { // if data record
      uint32_t addr = buffer_addr + hex.base + hex.addr - FLASH_BASE_ADDR;
      if (hex.max > (FLASH_BASE_ADDR + buffer_size)) {
        serial->printf("abort - max address %08lX too large\n", hex.max);
        return;
      }
      else if (!IN_FLASH(buffer_addr)) {
        memcpy((void*)addr, (void*)hex.data, hex.num);
      }
      else if (IN_FLASH(buffer_addr)) {
        int error = flash_write_block(addr, hex.data, hex.num);
        if (error) {
          serial->printf("abort - error %02X in flash_write_block()\n", error);
          return;
        }
      }
    }
    hex.lines++;
  }

  //serial->printf("\nhex file: %1d lines %1lu bytes (%08lX - %08lX)\n",
  //  hex.lines, hex.max - hex.min, hex.min, hex.max);
  serial->printf("\nhex file: %1d lines %1lu bytes (%08lX - %08lX), %lu Msec\n",
    hex.lines, hex.max - hex.min, hex.min, hex.max, millis() - start_msec);

  // check FSEC value in new code -- abort if incorrect
#if defined(KINETISK) || defined(KINETISL)
  uint32_t value = *(uint32_t*)(0x40C + buffer_addr);
  if (value == 0xfffff9de) {
    serial->printf("new code contains correct FSEC value %08lX\n", value);
  }
  else {
    serial->printf("abort - FSEC value %08lX should be FFFFF9DE\n", value);
    return;
  }
#endif

  // check FLASH_ID in new code - abort if not found
  if (check_flash_id(buffer_addr, hex.max - hex.min)) {
    serial->printf("new code contains correct target ID %s\n", FLASH_ID);
  }
  else {
    serial->printf("abort - new code missing string %s\n", FLASH_ID);
    return;
  }

  // get user input to write to flash or abort
  int user_lines = -1;
  while (user_lines != hex.lines && user_lines != 0) {
    serial->printf("enter %d to flash or 0 to abort\n", hex.lines);
    read_ascii_line(serial, line, sizeof(line));
    sscanf(line, "%d", &user_lines);
  }

  if (user_lines == 0) {
    serial->printf("abort - user entered 0 lines\n");
    return;
  }

  // move new program from buffer to flash, free buffer, and reboot
  //serial->printf("user entered %d lines\n", user_lines);
  flash_move(FLASH_BASE_ADDR, buffer_addr, hex.max - hex.min);

  // should not return from flash_move(), but put REBOOT here as reminder
  REBOOT;
}

//******************************************************************************
// read_ascii_line()	read ascii characters until '\n', '\r', or max bytes
//******************************************************************************
void read_ascii_line(Stream* serial, char* line, int maxbytes)
{
  int c = 0, nchar = 0;
  while (nchar < maxbytes && !(c == '\n' || c == '\r')) {
    if (serial->available()) {
      c = serial->read();
      line[nchar++] = c;
    }
  }
  line[nchar - 1] = 0;	// null-terminate
}

//******************************************************************************
// process_hex_record()		process record and return okay (0) or error (1)
//******************************************************************************
int process_hex_record(hex_info_t* hex)
{
  if (hex->code == 0) { // data -- update min/max address so far
    if (hex->base + hex->addr + hex->num > hex->max)
      hex->max = hex->base + hex->addr + hex->num;
    if (hex->base + hex->addr < hex->min)
      hex->min = hex->base + hex->addr;
  }
  else if (hex->code == 1) { // EOF (:flash command not received yet)
    hex->eof = 1;
  }
  else if (hex->code == 2) { // extended segment address (top 16 of 24-bit addr)
    hex->base = ((hex->data[0] << 8) | hex->data[1]) << 4;
  }
  else if (hex->code == 3) { // start segment address (80x86 real mode only)
    return 1;
  }
  else if (hex->code == 4) { // extended linear address (top 16 of 32-bit addr)
    hex->base = ((hex->data[0] << 8) | hex->data[1]) << 16;
  }
  else if (hex->code == 5) { // start linear address (32-bit big endian addr)
    hex->base = (hex->data[0] << 24) | (hex->data[1] << 16)
      | (hex->data[2] << 8) | (hex->data[3] << 0);
  }
  else {
    return 1;
  }

  return 0;
}

//******************************************************************************
// Intel Hex record foramt:
//
// Start code:  one character, ASCII colon ':'.
// Byte count:  two hex digits, number of bytes (hex digit pairs) in data field.
// Address:     four hex digits
// Record type: two hex digits, 00 to 05, defining the meaning of the data field.
// Data:        n bytes of data represented by 2n hex digits.
// Checksum:    two hex digits, computed value used to verify record has no errors.
//
// Examples:
//  :10 9D30 00 711F0000AD38000005390000F5460000 35
//  :04 9D40 00 01480000 D6
//  :00 0000 01 FF
//******************************************************************************

/* Intel HEX read/write functions, Paul Stoffregen, paul@ece.orst.edu */
/* This code is in the public domain.  Please retain my name and */
/* email address in distributed copies, and let me know about any bugs */

/* I, Paul Stoffregen, give no warranty, expressed or implied for */
/* this software and/or documentation provided, including, without */
/* limitation, warranty of merchantability and fitness for a */
/* particular purpose. */

// type modifications by Jon Zeeff

/* parses a line of intel hex code, stores the data in bytes[] */
/* and the beginning address in addr, and returns a 1 if the */
/* line was valid, or a 0 if an error occured.  The variable */
/* num gets the number of bytes that were stored into bytes[] */

#include <stdio.h>		// sscanf(), etc.
#include <string.h>		// strlen(), etc.

int parse_hex_line(const char* theline, char* bytes,
  unsigned int* addr, unsigned int* num, unsigned int* code)
{
  unsigned sum, len, cksum;
  const char* ptr;
  int temp;

  *num = 0;
  if (theline[0] != ':')
    return 0;
  if (strlen(theline) < 11)
    return 0;
  ptr = theline + 1;
  if (!sscanf(ptr, "%02x", &len))
    return 0;
  ptr += 2;
  if (strlen(theline) < (11 + (len * 2)))
    return 0;
  if (!sscanf(ptr, "%04x", (unsigned int*)addr))
    return 0;
  ptr += 4;
  /* Serial.printf("Line: length=%d Addr=%d\n", len, *addr); */
  if (!sscanf(ptr, "%02x", code))
    return 0;
  ptr += 2;
  sum = (len & 255) + ((*addr >> 8) & 255) + (*addr & 255) + (*code & 255);
  while (*num != len)
  {
    if (!sscanf(ptr, "%02x", &temp))
      return 0;
    bytes[*num] = temp;
    ptr += 2;
    sum += bytes[*num] & 255;
    (*num)++;
    if (*num >= 256)
      return 0;
  }
  if (!sscanf(ptr, "%02x", &cksum))
    return 0;

  if (((sum & 255) + (cksum & 255)) & 255)
    return 0;     /* checksum error */
  return 1;
}
#pragma endregion FLASHER_X

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

Name: T35_WallE3_V1.ino

Created: 10/25/2021 2:37:04 PM

Author: FRANKNEWXPS15\Frank

10/30/21 - Added TeensyOTADemo code for basic OTA updates

Name: TeensyOTADemo.ino

Created: 10/9/2021 11:18:19 AM

Author: FRANKNEWXPS15\Frank

This program demonstrates the use of 'board.txt' post-build instructions in

conjunction with a small C# command-line program for seamless 'over-the-air' (OTA)

firmware update for Teensy modules.

Implementation of OTA update requires that Joe Pasquariello's 'FlasherX'

code be added to the Teensy sketch as it is below, and some code to allow

an external serial communications program to trigger the update process.

In the demo sketch below, the 'FlasherX' additions are the '#include FlasherTxx.h'

line and the addition of the FlasherX specific code at the bottom. The trigger

mechanism is provided by the 'CheckForUserInput();' call in loop. If the ASCII

code for 'U' or 'u' is present on Serial1, the update process will be launched.

#include "FlashTxx.h" // TLC/T3x/T4x flash primitives

#include <elapsedMillis.h>

elapsedMillis MsecSinceLastLEDToggle; //used for LED blink timer

const double AREF = 3.3; //teensy default for analog inputs

const double AmpsPerVolt = 1.00; //default 10K Rs

const int MAX_AD_COUNT = 1023;

const double VoltsPerCount = AREF / MAX_AD_COUNT;

const int ItotPin = A18;

//Stream* FTDIport = &Serial1; // Serial (USB) or Serial1, Serial2, etc. (UART)

#pragma region OTA UPDATE

//******************************************************************************

// hex_info_t struct for hex record and hex file info

//******************************************************************************

typedef struct { //

char* data; // pointer to array allocated elsewhere

unsigned int addr; // address in intel hex record

unsigned int code; // intel hex record type (0=data, etc.)

unsigned int num; // number of data bytes in intel hex record

uint32_t base; // base address to be added to intel hex 16-bit addr

uint32_t min; // min address in hex file

uint32_t max; // max address in hex file

int eof; // set true on intel hex EOF (code = 1)

int lines; // number of hex records received

} hex_info_t;

void read_ascii_line(Stream* serial, char* line, int maxbytes);

int parse_hex_line(const char* theline, char* bytes,

unsigned int* addr, unsigned int* num, unsigned int* code);

int process_hex_record(hex_info_t* hex);

void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size);

uint32_t buffer_addr, buffer_size; //09/20/21 copied from FlasherX - loop()

#pragma endregion OTA UPDATE

void setup()

{

Serial.begin(115200);

delay(2000); //10/06/21 - just use fixed delay instead

Serial1.begin(115200); //used HC-05 'AT' commands to set this speed

while (!Serial1) {}

pinMode(LED_BUILTIN, OUTPUT);

pinMode(ItotPin, INPUT); //I_total 1V/Amp

//analogReadAveraging(4);

MsecSinceLastLEDToggle = 0;

Serial1.printf("Msec\tADVal\tTotVolts\tTotAmps\n");

}

void loop()

{

if (Serial1.available())

{

CheckForUserInput();

}

if (MsecSinceLastLEDToggle >= 200)

{

MsecSinceLastLEDToggle -= 200;

digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));

//11/01/21 read I_tot value & print out as current

int ItotVal = analogRead(ItotPin);

double ItotVolts = ItotVal * VoltsPerCount;

double ItotAmps = ItotVolts * AmpsPerVolt;

Serial1.printf("%lu\t%d\t%2.2f\t%2.2f\n", millis(), ItotVal, ItotVolts, ItotAmps);

}

void CheckForUserInput()

{

const int bufflen = 80;

char buff[bufflen];

memset(buff, 0, bufflen);

//const char s[2] = ",";

if (Serial1.available() > 0)

{

// read the incoming byte:

int incomingByte = Serial1.read();

// say what you got:

Serial1.print("I received: ");

Serial1.println(incomingByte, HEX); //chg to HEX 02/18/20

//02/18/20 experiment with multiple commands

switch (incomingByte)

{

case 0x55: //ASCII 'U'

case 0x75: //ASCII 'u'

Serial1.println(F("Start Program Update - Send new HEX file!"));

//09/20/21 copied from FlasherX - loop()

if (firmware_buffer_init(&buffer_addr, &buffer_size) == 0)

{

Serial1.printf("unable to create buffer\n");

Serial1.flush();

for (;;) {}

}

Serial1.printf("buffer = %1luK %s (%08lX - %08lX)\n",

buffer_size / 1024, IN_FLASH(buffer_addr) ? "FLASH" : "RAM",

buffer_addr, buffer_addr + buffer_size);

//09/20/21 clear the serial buffer

while (Serial1.available())

{

Serial1.read();

}

// receive hex file via serial, write new firmware to flash, clean up, reboot

update_firmware(&Serial1, buffer_addr, buffer_size); // no return if success

// return from update_firmware() means error or user abort, so clean up and

// reboot to ensure that static vars get boot-up initialized before retry

Serial1.printf("erase FLASH buffer / free RAM buffer...\n");

firmware_buffer_free(buffer_addr, buffer_size);

Serial1.flush();

REBOOT;

break;

}

#pragma region FLASHER_X

//09/20/21 copied from FlasherX

//******************************************************************************

// update_firmware() read hex file and write new firmware to program flash

//******************************************************************************

void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size)

{

static char line[96]; // buffer for hex lines

static char data[32] __attribute__((aligned(8))); // buffer for hex data

hex_info_t hex = { // intel hex info struct

data, 0, 0, 0, // data,addr,num,code

0, 0xFFFFFFFF, 0, // base,min,max,

0, 0 // eof,lines

};

serial->printf("waiting for hex lines...\n");

// read and process intel hex lines until EOF or error

//DEBUG!!

//int line_num = 0;

//DEBUG!!

long int start_msec = 0;

bool bFirstTime = true;

while (!hex.eof) {

read_ascii_line(serial, line, sizeof(line));

if (bFirstTime)

{

start_msec = millis();

bFirstTime = false;

}

//DEBUG!!

//serial->printf("%d: %s\n", line_num, line);

//line_num++;

//DEBUG!!

//10/02/21 gfp added for visual xfer confirmation

if (hex.lines % 10 == 0)

{

digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN));

}

// reliability of transfer via USB is improved by this printf/flush

if (serial == (Stream*)&Serial)

{

serial->printf("%s\n", line);

serial->flush();

}

if (parse_hex_line((const char*)line, hex.data, &hex.addr, &hex.num, &hex.code) == 0) {

serial->printf("abort - bad hex line %s\n", line);

return;

}

else if (process_hex_record(&hex) != 0) { // error on bad hex code

serial->printf("abort - invalid hex code %d\n", hex.code);

return;

}

else if (hex.code == 0) { // if data record

uint32_t addr = buffer_addr + hex.base + hex.addr - FLASH_BASE_ADDR;

if (hex.max > (FLASH_BASE_ADDR + buffer_size)) {

serial->printf("abort - max address %08lX too large\n", hex.max);

return;

}

else if (!IN_FLASH(buffer_addr)) {

memcpy((void*)addr, (void*)hex.data, hex.num);

}

else if (IN_FLASH(buffer_addr)) {

int error = flash_write_block(addr, hex.data, hex.num);

if (error) {

serial->printf("abort - error %02X in flash_write_block()\n", error);

return;

}

hex.lines++;

}

//serial->printf("\nhex file: %1d lines %1lu bytes (%08lX - %08lX)\n",

// hex.lines, hex.max - hex.min, hex.min, hex.max);

serial->printf("\nhex file: %1d lines %1lu bytes (%08lX - %08lX), %lu Msec\n",

hex.lines, hex.max - hex.min, hex.min, hex.max, millis() - start_msec);

// check FSEC value in new code -- abort if incorrect

#if defined(KINETISK) || defined(KINETISL)

uint32_t value = *(uint32_t*)(0x40C + buffer_addr);

if (value == 0xfffff9de) {

serial->printf("new code contains correct FSEC value %08lX\n", value);

}

else {

serial->printf("abort - FSEC value %08lX should be FFFFF9DE\n", value);

return;

}

#endif

// check FLASH_ID in new code - abort if not found

if (check_flash_id(buffer_addr, hex.max - hex.min)) {

serial->printf("new code contains correct target ID %s\n", FLASH_ID);

}

else {

serial->printf("abort - new code missing string %s\n", FLASH_ID);

return;

}

// get user input to write to flash or abort

int user_lines = -1;

while (user_lines != hex.lines && user_lines != 0) {

serial->printf("enter %d to flash or 0 to abort\n", hex.lines);

read_ascii_line(serial, line, sizeof(line));

sscanf(line, "%d", &user_lines);

}

if (user_lines == 0) {

serial->printf("abort - user entered 0 lines\n");

return;

}

// move new program from buffer to flash, free buffer, and reboot

//serial->printf("user entered %d lines\n", user_lines);

flash_move(FLASH_BASE_ADDR, buffer_addr, hex.max - hex.min);

// should not return from flash_move(), but put REBOOT here as reminder

REBOOT;

}

//******************************************************************************

// read_ascii_line() read ascii characters until '\n', '\r', or max bytes

//******************************************************************************

void read_ascii_line(Stream* serial, char* line, int maxbytes)

{

int c = 0, nchar = 0;

while (nchar < maxbytes && !(c == '\n' || c == '\r')) {

if (serial->available()) {

c = serial->read();

line[nchar++] = c;

}

line[nchar - 1] = 0; // null-terminate

}

//******************************************************************************

// process_hex_record() process record and return okay (0) or error (1)

//******************************************************************************

int process_hex_record(hex_info_t* hex)

{

if (hex->code == 0) { // data -- update min/max address so far

if (hex->base + hex->addr + hex->num > hex->max)

hex->max = hex->base + hex->addr + hex->num;

if (hex->base + hex->addr < hex->min)

hex->min = hex->base + hex->addr;

}

else if (hex->code == 1) { // EOF (:flash command not received yet)

hex->eof = 1;

}

else if (hex->code == 2) { // extended segment address (top 16 of 24-bit addr)

hex->base = ((hex->data[0] << 8) | hex->data[1]) << 4;

}

else if (hex->code == 3) { // start segment address (80x86 real mode only)

return 1;

}

else if (hex->code == 4) { // extended linear address (top 16 of 32-bit addr)

hex->base = ((hex->data[0] << 8) | hex->data[1]) << 16;

}

else if (hex->code == 5) { // start linear address (32-bit big endian addr)

hex->base = (hex->data[0] << 24) | (hex->data[1] << 16)

| (hex->data[2] << 8) | (hex->data[3] << 0);

}

else {

return 1;

}

return 0;

}

//******************************************************************************

// Intel Hex record foramt:

// Start code: one character, ASCII colon ':'.

// Byte count: two hex digits, number of bytes (hex digit pairs) in data field.

// Address: four hex digits

// Record type: two hex digits, 00 to 05, defining the meaning of the data field.

// Data: n bytes of data represented by 2n hex digits.

// Checksum: two hex digits, computed value used to verify record has no errors.

// Examples:

// :10 9D30 00 711F0000AD38000005390000F5460000 35

// :04 9D40 00 01480000 D6

// :00 0000 01 FF

//******************************************************************************

/* Intel HEX read/write functions, Paul Stoffregen, paul@ece.orst.edu */

/* This code is in the public domain. Please retain my name and */

/* email address in distributed copies, and let me know about any bugs */

/* I, Paul Stoffregen, give no warranty, expressed or implied for */

/* this software and/or documentation provided, including, without */

/* limitation, warranty of merchantability and fitness for a */

/* particular purpose. */

// type modifications by Jon Zeeff

/* parses a line of intel hex code, stores the data in bytes[] */

/* and the beginning address in addr, and returns a 1 if the */

/* line was valid, or a 0 if an error occured. The variable */

/* num gets the number of bytes that were stored into bytes[] */

#include <stdio.h> // sscanf(), etc.

#include <string.h> // strlen(), etc.

int parse_hex_line(const char* theline, char* bytes,

unsigned int* addr, unsigned int* num, unsigned int* code)

{

unsigned sum, len, cksum;

const char* ptr;

int temp;

*num = 0;

if (theline[0] != ':')

return 0;

if (strlen(theline) < 11)

return 0;

ptr = theline + 1;

if (!sscanf(ptr, "%02x", &len))

return 0;

ptr += 2;

if (strlen(theline) < (11 + (len * 2)))

return 0;

if (!sscanf(ptr, "%04x", (unsigned int*)addr))

return 0;

ptr += 4;

/* Serial.printf("Line: length=%d Addr=%d\n", len, *addr); */

if (!sscanf(ptr, "%02x", code))

return 0;

ptr += 2;

sum = (len & 255) + ((*addr >> 8) & 255) + (*addr & 255) + (*code & 255);

while (*num != len)

{

if (!sscanf(ptr, "%02x", &temp))

return 0;

bytes[*num] = temp;

ptr += 2;

sum += bytes[*num] & 255;

(*num)++;

if (*num >= 256)

return 0;

}

if (!sscanf(ptr, "%02x", &cksum))

return 0;

if (((sum & 255) + (cksum & 255)) & 255)

return 0; /* checksum error */

return 1;

}

#pragma endregion FLASHER_X

And here is some of the output:

I received: 55
Start Program Update - Send new HEX file!
buffer = 460K FLASH (0000D000 - 00080000)
waiting for hex lines...

hex file: 3194 lines 51048 bytes (00000000 - 0000C768), 13742 Msec
new code contains correct FSEC value FFFFF9DE
new code contains correct target ID fw_teensy35
enter 3194 to flash or 0 to abort
Msec    ADVal   TotVolts        TotAmps
2500    475     1.53    1.53
2700    465     1.50    1.50
2900    466     1.50    1.50
3100    499     1.61    1.61
3300    32      0.10    0.10
3500    459     1.48    1.48
3700    323     1.04    1.04
3900    473     1.53    1.53
4100    9       0.03    0.03
4300    317     1.02    1.02
4500    467     1.51    1.51
4700    460     1.48    1.48
4900    466     1.50    1.50
5100    262     0.85    0.85
5300    28      0.09    0.09
5500    467     1.51    1.51
5700    471     1.52    1.52
5900    469     1.51    1.51
6100    471     1.52    1.52

I received: 55

Start Program Update - Send new HEX file!

buffer = 460K FLASH (0000D000 - 00080000)

waiting for hex lines...

hex file: 3194 lines 51048 bytes (00000000 - 0000C768), 13742 Msec

new code contains correct FSEC value FFFFF9DE

new code contains correct target ID fw_teensy35

enter 3194 to flash or 0 to abort

Msec ADVal TotVolts TotAmps

2500 475 1.53 1.53

2700 465 1.50 1.50

2900 466 1.50 1.50

3100 499 1.61 1.61

3300 32 0.10 0.10

3500 459 1.48 1.48

3700 323 1.04 1.04

3900 473 1.53 1.53

4100 9 0.03 0.03

4300 317 1.02 1.02

4500 467 1.51 1.51

4700 460 1.48 1.48

4900 466 1.50 1.50

5100 262 0.85 0.85

5300 28 0.09 0.09

5500 467 1.51 1.51

5700 471 1.52 1.52

5900 469 1.51 1.51

6100 471 1.52 1.52

With this setup I noticed there were a lot of ‘dropouts’ in the sensor outputs, so I added a 1uF cap between the sensor Vout and GND. This seemed to cure the dropouts as shown in the next output snippet (after some charging time resulting in lower charging current)

Msec    ADVal   TotVolts        TotAmps
2500    265     0.85    0.85
2700    263     0.85    0.85
2900    266     0.86    0.86
3100    267     0.86    0.86
3300    269     0.87    0.87
3500    265     0.85    0.85
3700    266     0.86    0.86
3900    264     0.85    0.85
4100    266     0.86    0.86
4300    269     0.87    0.87
4500    268     0.86    0.86
4700    268     0.86    0.86
4900    265     0.85    0.85
5100    267     0.86    0.86
5300    266     0.86    0.86
5500    265     0.85    0.85
5700    267     0.86    0.86
5900    265     0.85    0.85
6100    263     0.85    0.85
6300    264     0.85    0.85
6500    266     0.86    0.86
6700    262     0.85    0.85
6900    261     0.84    0.84
7100    263     0.85    0.85
7300    259     0.84    0.84
7500    262     0.85    0.85
7700    261     0.84    0.84
7900    262     0.85    0.85
8100    262     0.85    0.85
8300    261     0.84    0.84
8500    261     0.84    0.84
8700    262     0.85    0.85
8900    260     0.84    0.84
9100    261     0.84    0.84
9300    258     0.83    0.83
9500    262     0.85    0.85
9700    258     0.83    0.83
9900    257     0.83    0.83
10100   259     0.84    0.84
10300   261     0.84    0.84

Msec ADVal TotVolts TotAmps

2500 265 0.85 0.85

2700 263 0.85 0.85

2900 266 0.86 0.86

3100 267 0.86 0.86

3300 269 0.87 0.87

3500 265 0.85 0.85

3700 266 0.86 0.86

3900 264 0.85 0.85

4100 266 0.86 0.86

4300 269 0.87 0.87

4500 268 0.86 0.86

4700 268 0.86 0.86

4900 265 0.85 0.85

5100 267 0.86 0.86

5300 266 0.86 0.86

5500 265 0.85 0.85

5700 267 0.86 0.86

5900 265 0.85 0.85

6100 263 0.85 0.85

6300 264 0.85 0.85

6500 266 0.86 0.86

6700 262 0.85 0.85

6900 261 0.84 0.84

7100 263 0.85 0.85

7300 259 0.84 0.84

7500 262 0.85 0.85

7700 261 0.84 0.84

7900 262 0.85 0.85

8100 262 0.85 0.85

8300 261 0.84 0.84

8500 261 0.84 0.84

8700 262 0.85 0.85

8900 260 0.84 0.84

9100 261 0.84 0.84

9300 258 0.83 0.83

9500 262 0.85 0.85

9700 258 0.83 0.83

9900 257 0.83 0.83

10100 259 0.84 0.84

10300 261 0.84 0.84

04 November 2021 Update:

I installed two Pololu VNH5019 drivers onto the prototype bottom plate, and copied the associated motor support code from my latest Wall-E2 version. I modified ‘SetLeftMotorDirAndSpeed(bool bIsFwd, int speed)’ and ‘SetRightMotorDirAndSpeed(bool bIsFwd, int speed)’ for the VNH5019 pinout and truth table, and that was pretty much all I had to do. Then I copied all of ‘CheckForUserInput()’ from Wall-E2 (and added the ‘U/u’ case for OTA updates) so I could control the motor direction and speed via the OTA serial connection, and the motors and drivers behaved pretty much right away. Here’s a short video showing the action:

05 November 2021 Update

I finally got the new 200 x 230 mm aluminum chassis finished, as shown in the following photo:

10 November 2021 Update:

After getting the new aluminum chassis fabricated, it was time to start populating it with subsystems from the prototype chassis and from Wall-E2. As shown in the following photo, the next big milestone was to populate it with four Pololu D-20 motors, the battery/charger and 5V LDO regulator subsystems, and the two Pololu VNH5019 motor drivers from the proto chassis. With the addition of four 3D printed wheels/tires from Wall-E2, and Wall-E3 was officially ‘mobile’!

As can be seen above, the Teensy 3.5 controller and its companion 5V LDO regulator board/HC-05 Bluetooth module were simply hot-glued to the battery pack for initial testing; they will be moved to the top plate next.

After successful movement tests with the above arrangement (see the companion post), the next step was to install the Teensy 3.5 controller and the LDO/HC-05 module on the top plate, and permanently install the charging connector and the ON/OFF switch. I decided that a single hole punched into the center rear of the top plate would suffice for bringing necessary wiring up from the internal battery/motor bay onto the top plate, and placing the hole toward the rear would allow the top plate to be removed and placed upside down at the back of the chassis to allow access to the battery/motor bay as needed. As shown in the following photo, the top plate is secured upside-down on the main chassis by two of the normal mounting screws, thus keeping the top-plate-mounted subsystems from contacting the ground.

Also note that the motor/battery bay is much cleaner than the Wall-E2 layout, even though both motor drivers are in this bay rather than mounted to the top plate as they are for Wall-E2. The next photos below show the chassis closed up with the Teensy 3.5 and the 5V LDO module mounted on the top plate, with the charging connector and the ON/OFF switch permanently installed.

Front & rear aspect views of the ‘closed’ chassis

After getting everything closed up, I re-ran the ‘spin turn’ trials, as shown below:

‘Spin Turn’ trials with T3.5 and 5V LDO mounted to top plate

At this point, there are only three significant modules (the MPU6050 IMU, the ‘Run Current’ 1NA169 high-side current sensor, and the charging station beacon homing module) remaining to install on the top plate. The first step will be to install and test the MPU6050, as that will give Wall-E3 the capability to do angle-controlled turns.

20 November 2021 Update:

As described in the companion post to this one, my plan is to move forward with the Teensy program (Teensy_MPU6050_DMP6_V3.ino) and the older I2CDevlib/MPU6050 library versions while waiting for Jeff Rowberg and company to figure out why the current versions of this library are no longer compatible with the Teensy 3.x line of microcontrollers.

The first step in this process is to remove the Arduino UNO/Wixel Shield module from the robot, and get the already-installed Teensy 3.5 talking to the already-installed MPU6050 module using the above mentioned Teensy_MPU6050_DMP6_V3.ino and the older I2CDevlib/MPU6050 library versions. Here’s the hardware layout:

Teensy 3.5, MPU6050, 5V LDO Regulator/HC-05 BT module, ‘I_Run’ current sensor

And here’s some output from Teensy_MPU6050_DMP6_V3.ino showing a ‘live’ connection to the MPU6050:

Opening port
Port open
In Setup
Testing device connections...
getDeviceID() returns 0X34
MPU6050 connection successful
Initializing DMP...
Enabling DMP...
DMP ready! Waiting for MPU6050 drift rate to settle...

MPU6050 Ready at 3.76 Sec
3973	0.19
4173	0.49
4375	0.80
4575	1.09
4775	1.35
4975	1.58
5175	1.78
5375	1.96
5575	2.12
5775	2.28
5975	2.43
6175	2.57
6375	2.66
6587	1.04
6764	-3.44
6964	-10.12
7164	-13.49
7364	-19.00
7564	-23.03
7768	-21.80
7968	-16.39
8168	-8.59
8368	0.90
8568	10.14
8768	15.36
8968	15.97
9168	14.49
9368	14.45
9568	13.57
9768	6.65
9970	-4.99
10170	-15.33
10370	-24.65
10570	-28.25
10770	-25.79
10970	-23.11
11170	-14.95
11370	-3.79
11570	9.58
11770	19.47
11973	23.61
12173	22.41
12373	21.69
12573	21.23
12773	20.94
12973	20.76
13173	20.67
13373	20.65
13573	20.66
13773	20.71
13975	20.77
14175	20.85
14375	20.95
14575	21.05
14775	21.15

Port closed

Opening port

Port open

In Setup

Testing device connections...

getDeviceID() returns 0X34

MPU6050 connection successful

Initializing DMP...

Enabling DMP...

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

MPU6050 Ready at 3.76 Sec

3973 0.19

4173 0.49

4375 0.80

4575 1.09

4775 1.35

4975 1.58

5175 1.78

5375 1.96

5575 2.12

5775 2.28

5975 2.43

6175 2.57

6375 2.66

6587 1.04

6764 -3.44

6964 -10.12

7164 -13.49

7364 -19.00

7564 -23.03

7768 -21.80

7968 -16.39

8168 -8.59

8368 0.90

8568 10.14

8768 15.36

8968 15.97

9168 14.49

9368 14.45

9568 13.57

9768 6.65

9970 -4.99

10170 -15.33

10370 -24.65

10570 -28.25

10770 -25.79

10970 -23.11

11170 -14.95

11370 -3.79

11570 9.58

11770 19.47

11973 23.61

12173 22.41

12373 21.69

12573 21.23

12773 20.94

12973 20.76

13173 20.67

13373 20.65

13573 20.66

13773 20.71

13975 20.77

14175 20.85

14375 20.95

14575 21.05

14775 21.15

Port closed

At this point, we have demonstrated we can talk to the MPU6050 using Jeff Rowberg’s (old) I2CDevlib library and can pull off yaw values, so we should also be able to do the same turn-rate-controlled turns as before.

So now I have a Teensy project (Teensy_MPU6050_DMP6_V3) that demonstrates a working interface to the MPU6050, a prior project (T35_WallE3_V1) that demonstrated Teensy OTA updates using an HC-05 Bluetooth module, and a Teensy project demonstrating turn-rate controlled turns using the MPU6050 (T35_MPU6050_Demo_V2). The next step is to create yet another new project, this time cleverly called ‘T35_WallE3_V2’, to merge all these features into one project, and then hopefully proceed from there.

When I created the T35_WallE3_V2 project, the first thing I did was copy in T35_WallE3_V1.ino and supporting files, and then I tested it to make sure everything was OK. However, this project wouldn’t connect to the MPU6050 even though I was sure it was using the older I2CDevlib files. After a very careful comparison, I found there were a very few differences. When I instead used the support files from my Teensy_MPU6050_DMP6_V3 project, then T35_WallE3_V2 was able to connect to the MPU6050. The i2Cdev.h/cpp files were essentially identical. The MPU6050.h/cpp files were essentially identical. The MPU6050_6Axis_MotionApps_V6_12.h files were essentially identical, so I’m not really sure why the magic happened — but it did!

So now the T35_WallE3_V2 talks to the MPU6050. Next I enabled ‘board.txt’ and verified that I can still do OTA firmware updates.

21 November 2021 (an almost palindromic date 21_11_21) Update:

After verifying OTA update capability with T35_WallE3_V2, I started porting in turn-rate control code from the Teensy_MPU6050_DMP6_V3 project, consisting mainly of the PID values empirically found in the companion ‘form-factor’ post, and the PIDCalcs() function.

Replaced T35_WallE3_V2 ‘CheckForUserInput()’ with version from T35_MPU6050_Demo_V2
Replaced T35_WallE3_V2 ‘PIDCalcs()’ with version from T35_MPU6050_Demo_V2
Replaced T35_WallE3_V2 ‘SpinTurn()’ with version from T35_MPU6050_Demo_V2 and added TURN_START_SPEED constant.
Updated TurnRate_Kp/Ki/Kd to 1.8/1.0/0.4

22 November 2021 Update:

At this point I have T35_WallE3_V2 to the point where I can do OTA firmware updates via the HC-05 Bluetooth link, and I can remotely command CW & CCW turns, forward and backward, speed up/down. Here’s the snapshot of the code at this point.

/*
    Name:       T35_WallE3_V2.ino
    Created:	11/20/2021 4:41:25 PM
    Author:     FRANKNEWXPS15\Frank
*/

/*
    Name:       T35_WallE3_V1.ino
    Created:	10/25/2021 2:37:04 PM
    Author:     FRANKNEWXPS15\Frank

    10/30/21 - Added TeensyOTADemo code for basic OTA updates
*/

/*
    Name:       TeensyOTADemo.ino
    Created:	10/9/2021 11:18:19 AM
    Author:     FRANKNEWXPS15\Frank

    This program demonstrates the use of 'board.txt' post-build instructions in
    conjunction with a small C# command-line program for seamless 'over-the-air' (OTA)
    firmware update for Teensy modules.

    Implementation of OTA update requires that Joe Pasquariello's 'FlasherX'
    code be added to the Teensy sketch as it is below, and some code to allow
    an external serial communications program to trigger the update process.

    In the demo sketch below, the 'FlasherX' additions are the '#include FlasherTxx.h'
    line and the addition of the FlasherX specific code at the bottom. The trigger
    mechanism is provided by the 'CheckForUserInput();' call in loop.  If the ASCII
    code for 'U' or 'u' is present on Serial1, the update process will be launched.

*/

#pragma region INCLUDES
#include "FlashTxx.h"		// TLC/T3x/T4x flash primitives
#include <elapsedMillis.h>
#include "MPU6050_6Axis_MotionApps_V6_12.h"  //changed to this version 10/05/19
#pragma endregion Includes


#pragma region DEFINES
//02/29/16 hardware defines
//#define NO_MOTORS
//#define IR_HOMING_ONLY

//#define NO_LIDAR
//#define NO_PINGS
//#define NO_IRDET //added 04/05/17 for daytime in-atrium testing (too much ambient IR)
//#define DISTANCES_ONLY //added 11/14/18 to just display distances in infinite loop
#define NO_STUCK //added 03/10/19 to disable 'stuck' detection
//#define BATTERY_DISCHARGE //added 03/04/20 to discharge battery safely
#define NO_POST //added 04/12/20 to skip all the POST checks

//11/07/2020 moved all I2C Address declarations here
#define IRDET_I2C_ADDR 0x08
#define MPU6050_I2C_ADDR 0x68

#pragma endregion Program #Defines

#pragma region PRE_SETUP
MPU6050 mpu(MPU6050_I2C_ADDR);
elapsedMillis MsecSinceLastLEDToggle; //used for LED blink timer
const double ADC_REF_VOLTS = 3.3; //teensy default for analog inputs
const double AmpsPerVolt = 1.00; //default 10K Rs
const int MAX_AD_COUNT = 1023;
const double VoltsPerCount = ADC_REF_VOLTS / MAX_AD_COUNT;

//Battery constants
const float ZENER_VOLTAGE_OFFSET = 5.84; //measured zener voltage

#pragma region PIN ASSIGNMENTS

//vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv//
//===================  START PIN ASSIGNMENTS ===================//
//vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv//

#pragma region MOTOR_PINS
//11/04/21 Now using Pololu VNH5019 drivers for all 4 motors
const int InA_Left = 22;
const int InB_Left = 21;
const int Spd_Left = 23;

const int InA_Right = 34;
const int InB_Right = 33;
const int Spd_Right = 35;
#pragma endregion Motor Pin Assignments

const int ChgConnectPin = 36;
const int ItotPin = A1;
const int IRunPin = A2;
const int BATT_MON_PIN = A0;

#pragma endregion PIN ASSIGNMENTS

#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_QTR = 75; //added 09/25/20
const int MOTOR_SPEED_LOW = 50; //added 01/22/15
const int MOTOR_SPEED_OFF = 0; //range is 0-255
const int MOTOR_SPEED_CAPTURE_OFFSET = 75; //added 06/21/20 for offset capture
const int TURN_START_SPEED = MOTOR_SPEED_QTR; //added 11/14/21

//drive wheel direction constants
const boolean FWD_DIR = true;
const boolean REV_DIR = !FWD_DIR;
const bool TURNDIR_CCW = true;
const bool TURNDIR_CW = false;

//Motor direction variables
bool bIsForwardDir = true; //default is foward direction

#pragma endregion Motor Parameters

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

//MPU6050 status flags
bool bMPU6050Ready = true;
bool dmpReady = false;  // set true if DMP init was successful
volatile float IMUHdgValDeg = 0; //updated by UpdateIMUHdgValDeg()//11/02/20 now updated in ISR
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;
//#define MPU6050_CCW_INCREASES_YAWVAL //added 12/05/19 commented out 11/22/21 as now the MPU6050 module is mounted 'Z-up'
#pragma endregion MPU6050 Support


#pragma region HEADING_AND_RATE_BASED_TURN_PARAMETERS
elapsedMillis MsecSinceLastTurnRateUpdate;

const int MAX_SPIN_MOTOR_SPEED = 250;
const int MIN_SPIN_MOTOR_SPEED = 50;
const int TURN_RATE_UPDATE_INTERVAL_MSEC = 30; //30 mSec is as fast as it can go

double TurnRateOutput;
double TurnRateSetPoint_DPS;
double Ival = 0;
double lastErr = 0;
double lastTurnRateVal_DPS;
double TurnRateVal_DPS;
double Prev_HdgDeg = 0;
float tgt_deg;
float timeout_sec;

//11/16/21 almost perfect for 45 deg/sec, 100mSec
//11/17/21 and pretty good for 90 deg/sec too!
double TurnRate_Kp = 1.8;
double TurnRate_Ki = 1.0;
double TurnRate_Kd = 0.4;

//ported from FourWD_PulseTurnRateTest.ino
double TurnRatePIDOutput;

//06/02/
const float HDG_NEAR_MATCH_VAL = 0.8; //slow the turn down here
const float HDG_FULL_MATCH_VAL = 0.99; //stop the turn here //rev 06/01/21
const float HDG_MIN_MATCH_VAL = 0.6; //added 09/08/18: don't start checking slope until turn is well started
#pragma endregion HEADING_AND_RATE_BASED_TURN_PARAMETERS


#pragma region OTA UPDATE
//******************************************************************************
// hex_info_t	struct for hex record and hex file info
//******************************************************************************
typedef struct {	// 
  char* data;		// pointer to array allocated elsewhere
  unsigned int addr;	// address in intel hex record
  unsigned int code;	// intel hex record type (0=data, etc.)
  unsigned int num;	// number of data bytes in intel hex record

  uint32_t base;	// base address to be added to intel hex 16-bit addr
  uint32_t min;		// min address in hex file
  uint32_t max;		// max address in hex file

  int eof;		// set true on intel hex EOF (code = 1)
  int lines;		// number of hex records received  
} hex_info_t;

void read_ascii_line(Stream* serial, char* line, int maxbytes);
int  parse_hex_line(const char* theline, char* bytes,
  unsigned int* addr, unsigned int* num, unsigned int* code);
int  process_hex_record(hex_info_t* hex);
void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size);

uint32_t buffer_addr, buffer_size; //09/20/21 copied from FlasherX - loop()
#pragma endregion OTA UPDATE
#pragma endregion PRE_SETUP

void setup()
{
  Serial.begin(115200);
  delay(2000); //10/06/21 - just use fixed delay instead

  Serial1.begin(115200); //used HC-05 'AT' commands to set this speed
  //while (!Serial1) {}
  delay(2000); //11/20/21 use fixed delay instead of waiting
  Wire.begin(I2C_MASTER, 0x00, I2C_PINS_18_19, I2C_PULLUP_EXT, 400000);

  //DEBUG!!
  if (Serial)
  {
    Serial.printf("Serial = %p, Serial1 = %p\n", &Serial, &Serial1);
  }
  //DEBUG!!
  // 
  //DEBUG!!
  if (Serial1)
  {
    Serial.printf("Serial = %p, Serial1 = %p\n", &Serial, &Serial1);
  }
  //DEBUG!!


#pragma region PIN INITIALIZATION
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(ItotPin, INPUT); //I_total 1V/Amp
  pinMode(BATT_MON_PIN, INPUT); //Battery voltage monitor

  //motor pins
  pinMode(InA_Left, OUTPUT);
  pinMode(InB_Left, OUTPUT);
  pinMode(Spd_Left, OUTPUT);

  pinMode(InA_Right, OUTPUT);
  pinMode(InB_Right, OUTPUT);
  pinMode(Spd_Right, OUTPUT);
#pragma endregion PIN INITIALIZATION


#pragma region MPU6050
  Serial.printf("\nChecking for MPU6050 IMU at I2C Addr 0x%x\n", MPU6050_I2C_ADDR);
  mpu.initialize();

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

  float StartSec = 0; //used to time MPU6050 init
  Serial.println(F("Initializing DMP..."));
  devStatus = mpu.dmpInitialize();

  // make sure it worked (returns 0 if successful)
  if (devStatus == 0)
  {
    // 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();

    Serial.printf("Just after MPU6050 Init\n");
    Serial.printf("Calibrating...\n");
    mpu.CalibrateGyro(); //using default value of 15
    Serial.printf("Retrieving Calibration Values\n\n");
    mpu.PrintActiveOffsets();

    //loop heading display until stabilized
    Serial.printf("\nMsec\tHdg\n");

    UpdateIMUHdgValDeg();
    Prev_HdgDeg = IMUHdgValDeg;
    delay(100);
    UpdateIMUHdgValDeg();

    Serial.printf("%lu\t%2.3f\t%2.3f\n", millis(), IMUHdgValDeg, Prev_HdgDeg);
    while (abs(IMUHdgValDeg - Prev_HdgDeg) > 0.1f)
    {
      Serial.printf("%lu\t%2.3f\n", millis(), IMUHdgValDeg);
      Prev_HdgDeg = IMUHdgValDeg;
      delay(100);
      UpdateIMUHdgValDeg();
    }

    StartSec = millis() / 1000.f;
    Serial.printf("MPU6050 Ready at %2.2f Sec with delta = %2.3f\n", StartSec, IMUHdgValDeg - Prev_HdgDeg);
    bMPU6050Ready = true;

    delay(1000);
  }
  else //MPU6050 Init failed for some reason
  {
    // 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(")"));

    //08/29/21 print out battery voltage on failure
    float batV = GetBattVoltage();
    Serial.printf("Battery Voltage = %2.2f\n", batV);

    bMPU6050Ready = false;
  }
#pragma endregion MPU6050


  analogReadAveraging(4); //applies to all analogRead() operations?
  MsecSinceLastLEDToggle = 0;

  Serial1.printf("Msec\tBattV\tTotAmps\tRunAmps\tHdgDeg\n");
}

void loop()
{
  //if (Serial1.available())
  if (Serial1.available()||Serial.available())
  {
    CheckForUserInput();
  }

  if (MsecSinceLastLEDToggle >= 200)
  {
    MsecSinceLastLEDToggle -= 200;
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));

    //11/01/21 read I_tot value & cvt to current
    int ItotVal = analogRead(ItotPin);
    double ItotVolts = ItotVal * VoltsPerCount;
    double ItotAmps = ItotVolts * AmpsPerVolt;

    //Get battery voltage
    float calc_volts = GetBattVoltage();

    //print out battery voltage & charge current
    Serial1.printf("%lu\t%2.2f\t%2.2f\n", millis(), calc_volts, ItotAmps);
    Serial.printf("%lu\t%2.2f\t%2.2f\n", millis(), calc_volts, ItotAmps);
  }
}


float GetBattVoltage()
{
  //02/18/17 get corrected battery voltage.  Voltage reading is 1/3 actual Vbatt value
  //int analog_batt_reading = GetAverageAnalogReading(BATT_MON_PIN, VOLTS_AVERAGE_NUMBER);//rev 03/01/19 to average readings
  int analog_batt_reading = analogRead(BATT_MON_PIN);//analogReadAveraging(4) in setup() does internal averaging
  float calc_volts = ZENER_VOLTAGE_OFFSET + ADC_REF_VOLTS * (double)analog_batt_reading / (double)MAX_AD_COUNT;

  ////DEBUG!!
  //	Serial1.printf("a/d = %d, calc = %2.2f\n", analog_batt_reading,calc_volts);
  ////DEBUG!!

  return calc_volts;
}



//void CheckForUserInput()
//{
//  //Notes:
//  //  11/21/21 rev to accomodate cmd input from either serial, and output to both
//
//  const int bufflen = 80;
//  char buff[bufflen];
//  memset(buff, 0, bufflen);
//  float OffsetCm;
//  float Kp, Ki, Kd;
//  const char s[2] = ",";
//  char* token;
//  byte incomingByte = 0; //moved here 11/21/21
//
//  if (Serial.available() > 0)
//  {
//    // read the incoming byte:
//    //int incomingByte = Serial.read();
//    incomingByte = Serial.read();
//
//    // say what you got:
//    Serial.print("I received: ");
//    Serial.println(incomingByte, HEX); //chg to HEX 02/18/20
//  }
//
//  //11/21/21 now input can come from Serial1 too
//  else if (Serial1.available() > 0)
//  {
//    // read the incoming byte:
//    incomingByte = Serial1.read();
//
//    // say what you got:
//    Serial1.print("I received: ");
//    Serial1.println(incomingByte, HEX); //chg to HEX 02/18/20
//  }
//
//  //11/21/21 incomingByte can come from either serial input
//  if (incomingByte != 0)
//  {
//    //02/18/20 experiment with multiple commands
//    switch (incomingByte)
//    {
//    case 0x55: //ASCII 'U'
//    case 0x75: //ASCII 'u'
//#pragma region FIRMWARE UPDATE
//      Serial1.println(F("Start Program Update - Send new HEX file!"));
//
//
//      //09/20/21 copied from FlasherX - loop()
//      if (firmware_buffer_init(&buffer_addr, &buffer_size) == 0)
//      {
//        Serial1.printf("unable to create buffer\n");
//        Serial1.flush();
//        for (;;) {}
//      }
//
//      Serial1.printf("buffer = %1luK %s (%08lX - %08lX)\n",
//        buffer_size / 1024, IN_FLASH(buffer_addr) ? "FLASH" : "RAM",
//        buffer_addr, buffer_addr + buffer_size);
//
//      //09/20/21 clear the serial buffer
//      while (Serial1.available())
//      {
//        Serial1.read();
//      }
//
//      // receive hex file via serial, write new firmware to flash, clean up, reboot
//      update_firmware(&Serial1, buffer_addr, buffer_size); // no return if success
//
//      // return from update_firmware() means error or user abort, so clean up and
//      // reboot to ensure that static vars get boot-up initialized before retry
//      Serial1.printf("erase FLASH buffer / free RAM buffer...\n");
//      firmware_buffer_free(buffer_addr, buffer_size);
//      Serial1.flush();
//      REBOOT;
//      break;
//#pragma endregion FIRMWARE UPDATE
//    case 0x43: //ASCII 'C'
//    case 0x63: //ASCII 'c'
//#pragma region MANUALCONTROL
//      //enter infinite loop for direct remote control
//      Serial.println(F("ENTERING COMMAND MODE:"));
//      Serial.println(F("0 = 180 deg CCW Turn"));
//      Serial.println(F("1 = 180 deg CW Turn"));
//      Serial.println(F("A = Back to Auto Mode"));
//      Serial.println(F("S = Stop"));
//      Serial.println(F("F = Forward"));
//      Serial.println(F("R = Reverse"));
//      Serial.println(F(""));
//      Serial.println(F("       Faster"));
//      Serial.println(F("\t8"));
//      Serial.println(F("Left 4\t5  6 Right"));
//      Serial.println(F("\t2"));
//      Serial.println(F("       Slower"));
//
//      Serial1.println(F("ENTERING COMMAND MODE:"));
//      Serial1.println(F("0 = 180 deg CCW Turn"));
//      Serial1.println(F("1 = 180 deg CW Turn"));
//      Serial1.println(F("A = Back to Auto Mode"));
//      Serial1.println(F("S = Stop"));
//      Serial1.println(F("F = Forward"));
//      Serial1.println(F("R = Reverse"));
//      Serial1.println(F(""));
//      Serial1.println(F("       Faster"));
//      Serial1.println(F("\t8"));
//      Serial1.println(F("Left 4\t5  6 Right"));
//      Serial1.println(F("\t2"));
//      Serial1.println(F("       Slower"));
//
//      StopBothMotors();
//      int speed = 0;
//
//      bool bAutoMode = false;
//      while (!bAutoMode)
//      {
//        if (Serial.available() > 0)
//        {
//          // read the incoming byte:
//          incomingByte = Serial.read();
//
//          // say what you got:
//          Serial.print("I received: ");
//          Serial.println(incomingByte, HEX); //chg to HEX 02/18/20
//        }
//
//        //11/21/21 now input can come from Serial1 too
//        else if (Serial1.available() > 0)
//        {
//          // read the incoming byte:
//          incomingByte = Serial1.read();
//
//          // say what you got:
//          Serial1.print("I received: ");
//          Serial1.println(incomingByte, HEX); //chg to HEX 02/18/20
//        }
//
//        //11/21/21 incomingByte can come from either serial input
//        if (incomingByte != 0)
//        {
//          switch (incomingByte)
//          {
//          case 0x30: //Dec '0'
//            Serial.println(F("CCW 180 deg Turn"));
//            Serial1.println(F("CCW 180 deg Turn"));
//            SpinTurn(true, 180, 90);
//            MoveAhead(speed, speed);
//            break;
//          case 0x31: //Dec '1'
//            Serial.println(F("CW 180 deg Turn"));
//            Serial1.println(F("CW 180 deg Turn"));
//            SpinTurn(false, 180, 45);
//            break;
//          case 0x34: //Turn left 10 deg and keep moving
//            Serial.println(F("CCW 10 deg Turn"));
//            Serial1.println(F("CCW 10 deg Turn"));
//            SpinTurn(true, 10, 30);
//
//            if (bIsForwardDir)
//            {
//              MoveAhead(speed, speed);
//            }
//            else
//            {
//              MoveReverse(speed, speed);
//            }
//            break;
//          case 0x36: //Turn right 10 deg and keep moving
//            Serial.print("CW 10 deg Turn\n");
//            Serial1.print("CW 10 deg Turn\n");
//            SpinTurn(false, 10, 30);
//
//            //added 05/03/20
//            if (bIsForwardDir)
//            {
//              MoveAhead(speed, speed);
//            }
//            else
//            {
//              MoveReverse(speed, speed);
//            }
//            break;
//          case 0x38: //Speed up 
//            speed += 50;
//            speed = (speed >= MOTOR_SPEED_MAX) ? MOTOR_SPEED_MAX : speed;
//            Serial.printf("Speeding up: speed now %d\n", speed);
//            Serial1.printf("Speeding up: speed now %d\n", speed);
//            if (bIsForwardDir)
//            {
//              MoveAhead(speed, speed);
//            }
//            else
//            {
//              MoveReverse(speed, speed);
//            }
//            break;
//          case 0x32: //Slow down 
//            speed -= 50;
//            speed = (speed < 0) ? 0 : speed;
//            Serial.printf("Slowing down: speed now %d\n", speed);
//            Serial1.printf("Slowing down: speed now %d\n", speed);
//            if (bIsForwardDir)
//            {
//              MoveAhead(speed, speed);
//            }
//            else
//            {
//              MoveReverse(speed, speed);
//            }
//            break;
//          case 0x35: //05/07/20 changed to use '5' vs 'S'
//            Serial.println(F("Stopping Motors!"));
//            Serial1.println(F("Stopping Motors!"));
//            StopBothMotors();
//            speed = 0;
//            break;
//          case 0x41: //ASCII 'A'
//          case 0x61: //ASCII 'a'
//            StopBothMotors();
//            Serial.println(F("Re-entering AUTO mode"));
//            Serial1.println(F("Re-entering AUTO mode"));
//            bAutoMode = true;
//            break;
//          case 0x52: //ASCII 'R'
//          case 0x72: //ASCII 'r'
//            Serial.println(F("Setting both motors to reverse"));
//            Serial1.println(F("Setting both motors to reverse"));
//            bIsForwardDir = false;
//            //MoveReverse(speed, speed);
//            break;
//          case 0x46: //ASCII 'F'
//          case 0x66: //ASCII 'f'
//            Serial.println(F("Setting both motors to forward"));
//            Serial1.println(F("Setting both motors to forward"));
//            bIsForwardDir = true;
//            MoveAhead(speed, speed);
//#pragma endregion MANUALCONTROL
//            break;
//
//#pragma region	WALL OFFSET TRACKING CASES
//            //left side wall tracking
//          case 0x4C: //ASCII 'L'
//          case 0x6C: //ASCII 'l'
//            StopBothMotors();
//            Serial.println(F("Setting Kp value"));
//
//            //consume CR/LF chars
//            while (Serial.available() > 0)
//            {
//              int byte = Serial.read();
//              Serial.printf("consumed %d\n", byte);
//            }
//
//            while (!Serial.available())
//            {
//            }
//
//            Serial.readBytes(buff, bufflen);
//            Serial.printf("%s\n", buff);
//
//            /* extract Kp */
//            token = strtok(buff, s);
//            Kp = atof(token);
//
//            /* extract Ki */
//            token = strtok(NULL, s);
//            Ki = atof(token);
//
//            /* extract Kd */
//            token = strtok(NULL, s);
//            Kd = atof(token);
//
//            /* extract Offset in cm */
//            token = strtok(NULL, s);
//            OffsetCm = atof(token);
//
//            Serial.printf("Kp,Ki,Kd,OffsetCm =  %2.2f, %2.2f, %2.2f, %2.2f\n",
//              Kp, Ki, Kd, OffsetCm);
//
//            //TrackLeftWallOffset(Kp, Ki, Kd, OffsetCm);
//            break;
//          case 0x4D: //ASCII 'M'
//          case 0x6D: //ASCII 'm'
//            StopBothMotors();
//            Serial.println(F("Setting Kp value"));
//
//            //consume CR/LF chars
//            while (Serial.available() > 0)
//            {
//              int byte = Serial.read();
//              Serial.printf("consumed %d\n", byte);
//            }
//
//            while (!Serial.available())
//            {
//            }
//
//            Serial.readBytes(buff, bufflen);
//            Serial.printf("%s\n", buff);
//
//            /* extract Kp */
//            token = strtok(buff, s);
//            Kp = atof(token);
//
//            /* extract Ki */
//            token = strtok(NULL, s);
//            Ki = atof(token);
//
//            /* extract Kd */
//            token = strtok(NULL, s);
//            Kd = atof(token);
//
//            /* extract Offset in cm */
//            token = strtok(NULL, s);
//            OffsetCm = atof(token);
//
//            Serial.printf("Kp,Ki,Kd,OffsetCm =  %2.2f, %2.2f, %2.2f, %2.2f\n",
//              Kp, Ki, Kd, OffsetCm);
//
//            //TrackRightWallOffset(Kp, Ki, Kd, OffsetCm);
//            break;
//#pragma endregion	WALL OFFSET TRACKING CASES
//          default:
//            Serial.println(F("In Default Case: Stopping Motors!"));
//            Serial1.println(F("In Default Case: Stopping Motors!"));
//            StopBothMotors();
//            while (true)
//            {
//
//            }
//          }
//        }
//      }
//    }
//  }
//}


void CheckForUserInput()
{
  //Notes:
  //  11/21/21 rev to accomodate cmd input from either serial, and output to both

  const int bufflen = 3;
  char buff[bufflen];
  memset(buff, 0, bufflen);
  byte incomingByte = 0; //moved here 11/21/21
  int numchars = 0;

  if (Serial.available() > 0)
  {
    // read the incoming byte:
    //incomingByte = Serial.read();
    numchars = Serial.readBytesUntil('\n', buff, sizeof(buff));
    incomingByte = buff[0];

    // say what you got:
    Serial.printf("I received %d chars, first char 0X%X on Serial\n", numchars, incomingByte);
  }

  //11/21/21 now input can come from Serial1 too
  else if (Serial1.available() > 0)
  {
    // read the incoming byte:
    //incomingByte = Serial1.read();
    numchars = Serial1.readBytesUntil('\n', buff, sizeof(buff));
    incomingByte = buff[0];

    // say what you got:
    Serial1.printf("I received %d chars, first char 0X%X on Serial1\n", numchars, incomingByte);
  }

  //11/21/21 incomingByte can come from either serial input
  if (incomingByte != 0)
  {
    //02/18/20 experiment with multiple commands
    switch (incomingByte)
    {
    case 0x55: //ASCII 'U'
    case 0x75: //ASCII 'u'
#pragma region FIRMWARE UPDATE
      Serial1.println(F("Start Program Update - Send new HEX file!"));


      //09/20/21 copied from FlasherX - loop()
      if (firmware_buffer_init(&buffer_addr, &buffer_size) == 0)
      {
        Serial1.printf("unable to create buffer\n");
        Serial1.flush();
        for (;;) {}
      }

      Serial1.printf("buffer = %1luK %s (%08lX - %08lX)\n",
        buffer_size / 1024, IN_FLASH(buffer_addr) ? "FLASH" : "RAM",
        buffer_addr, buffer_addr + buffer_size);

      //09/20/21 clear the serial buffer
      while (Serial1.available())
      {
        Serial1.read();
      }

      // receive hex file via serial, write new firmware to flash, clean up, reboot
      update_firmware(&Serial1, buffer_addr, buffer_size); // no return if success

      // return from update_firmware() means error or user abort, so clean up and
      // reboot to ensure that static vars get boot-up initialized before retry
      Serial1.printf("erase FLASH buffer / free RAM buffer...\n");
      firmware_buffer_free(buffer_addr, buffer_size);
      Serial1.flush();
      REBOOT;
      break;
#pragma endregion FIRMWARE UPDATE
    case 0x43: //ASCII 'C'
    case 0x63: //ASCII 'c'
#pragma region MANUALCONTROL
      //enter infinite loop for direct remote control
      Serial.println(F("ENTERING COMMAND MODE:"));
      Serial.println(F("0 = 180 deg CCW Turn"));
      Serial.println(F("1 = 180 deg CW Turn"));
      Serial.println(F("A = Back to Auto Mode"));
      Serial.println(F("S = Stop"));
      Serial.println(F("F = Forward"));
      Serial.println(F("R = Reverse"));
      Serial.println(F(""));
      Serial.println(F("       Faster"));
      Serial.println(F("\t8"));
      Serial.println(F("Left 4\t5  6 Right"));
      Serial.println(F("\t2"));
      Serial.println(F("       Slower"));

      Serial1.println(F("ENTERING COMMAND MODE:"));
      Serial1.println(F("0 = 180 deg CCW Turn"));
      Serial1.println(F("1 = 180 deg CW Turn"));
      Serial1.println(F("A = Back to Auto Mode"));
      Serial1.println(F("S = Stop"));
      Serial1.println(F("F = Forward"));
      Serial1.println(F("R = Reverse"));
      Serial1.println(F(""));
      Serial1.println(F("       Faster"));
      Serial1.println(F("\t8"));
      Serial1.println(F("Left 4\t5  6 Right"));
      Serial1.println(F("\t2"));
      Serial1.println(F("       Slower"));

      StopBothMotors();
      int speed = 0;
      bool bAutoMode = false;
      while (Serial.available())
      {
        incomingByte = Serial.read();
        //Serial.printf("I removed 0X%X from Serial\n",incomingByte);
      }
      while (Serial1.available())
      {
        incomingByte = Serial1.read();
        //Serial1.printf("I removed 0X%X from Serial1\n", incomingByte);
      }

      incomingByte = 0;

      while (!bAutoMode)
      {
        if (Serial.available() > 0)
        {
          // read the incoming bytes:
          numchars = Serial.readBytesUntil('\n', buff, sizeof(buff));
          incomingByte = buff[0];

          // say what you got:
          Serial.printf("I received %d chars, first char 0X%X on Serial\n", numchars, incomingByte);

          while (Serial.available())
          {
            Serial.read();
            Serial.printf("I removed 0X%X from Serial\n",incomingByte);
          }
        }

        //11/21/21 now input can come from Serial1 too
        else if (Serial1.available() > 0)
        {
          // read the incoming bytes:
          numchars = Serial1.readBytesUntil('\n', buff, sizeof(buff));
          incomingByte = buff[0];

          // say what you got:
          Serial1.printf("I received %d chars, first char 0X%X on Serial1\n", numchars, incomingByte);

          while (Serial1.available())
          {
            Serial1.read();
            Serial1.printf("I removed 0X%X from Serial1\n", incomingByte);
          }
        }


        //11/21/21 incomingByte can come from either serial input
        if (incomingByte != 0)
        {
          switch (incomingByte)
          {
          case 0x30: //Dec '0'
            Serial.println(F("CCW 180 deg Turn"));
            Serial1.println(F("CCW 180 deg Turn"));
            SpinTurn(true, 180, 90);
            MoveAhead(speed, speed);
            break;
          case 0x31: //Dec '1'
            Serial.println(F("CW 180 deg Turn"));
            Serial1.println(F("CW 180 deg Turn"));
            SpinTurn(false, 180, 45);
            break;
          case 0x34: //Turn left 10 deg and keep moving
            Serial.println(F("CCW 10 deg Turn"));
            Serial1.println(F("CCW 10 deg Turn"));
            SpinTurn(true, 10, 30);

            if (bIsForwardDir)
            {
              MoveAhead(speed, speed);
            }
            else
            {
              MoveReverse(speed, speed);
            }
            break;
          case 0x36: //Turn right 10 deg and keep moving
            Serial.print("CW 10 deg Turn\n");
            Serial1.print("CW 10 deg Turn\n");
            SpinTurn(false, 10, 30);

            //added 05/03/20
            if (bIsForwardDir)
            {
              MoveAhead(speed, speed);
            }
            else
            {
              MoveReverse(speed, speed);
            }
            break;
          case 0x38: //Speed up 
            speed += 50;
            speed = (speed >= MOTOR_SPEED_MAX) ? MOTOR_SPEED_MAX : speed;
            Serial.printf("Speeding up: speed now %d\n", speed);
            Serial1.printf("Speeding up: speed now %d\n", speed);
            if (bIsForwardDir)
            {
              MoveAhead(speed, speed);
            }
            else
            {
              MoveReverse(speed, speed);
            }
            break;
          case 0x32: //Slow down 
            speed -= 50;
            speed = (speed < 0) ? 0 : speed;
            Serial.printf("Slowing down: speed now %d\n", speed);
            Serial1.printf("Slowing down: speed now %d\n", speed);
            if (bIsForwardDir)
            {
              MoveAhead(speed, speed);
            }
            else
            {
              MoveReverse(speed, speed);
            }
            break;
          case 0x35: //05/07/20 changed to use '5' vs 'S'
            Serial.println(F("Stopping Motors!"));
            Serial1.println(F("Stopping Motors!"));
            StopBothMotors();
            speed = 0;
            break;
          case 0x41: //ASCII 'A'
          case 0x61: //ASCII 'a'
            StopBothMotors();
            Serial.println(F("Re-entering AUTO mode"));
            Serial1.println(F("Re-entering AUTO mode"));
            bAutoMode = true;
            break;
          case 0x52: //ASCII 'R'
          case 0x72: //ASCII 'r'
            Serial.println(F("Setting both motors to reverse"));
            Serial1.println(F("Setting both motors to reverse"));
            bIsForwardDir = false;
            //MoveReverse(speed, speed);
            break;
          case 0x46: //ASCII 'F'
          case 0x66: //ASCII 'f'
            Serial.println(F("Setting both motors to forward"));
            Serial1.println(F("Setting both motors to forward"));
            bIsForwardDir = true;
            MoveAhead(speed, speed);
#pragma endregion MANUALCONTROL
            break;
          default:
            Serial.println(F("In Default Case: Stopping Motors!"));
            Serial1.println(F("In Default Case: Stopping Motors!"));
            StopBothMotors();
            //while (true)
            //{

            //}
          }
          incomingByte = 0;
        }
      }
    }
  }
}


#pragma region MOTOR SUPPORT
//09/08/20 modified for DRV8871 motor driver
void MoveReverse(int leftspeednum, int rightspeednum)
{
  //Purpose:  Move in reverse direction continuously - companion to MoveAhead()
  //ProvEnA_Pinnce: G. Frank Paynter 09/08/18
  //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 reverse direction for both wheels
  //    Step 2: Run both Motors at specified speeds
  //Notes:
  //	01/22/20 now using Adafruit DRV8871 drivers

  //Step 1: Set reverse direction and speed for both wheels
  SetLeftMotorDirAndSpeed(REV_DIR, leftspeednum);
  SetRightMotorDirAndSpeed(REV_DIR, rightspeednum);
}

//09/08/20 modified for DRV8871 motor driver
void MoveAhead(int leftspeednum, int rightspeednum)
{
  //Purpose:  Move ahead continuously
  //ProvEnA_Pinnce: 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
  //Notes:
  //	01/22/20 now using Adafruit DRV8871 drivers

  //Serial1.printf("InMoveAhead(%d,%d)\n", leftspeednum, rightspeednum);

  //Step 1: Set forward direction and speed for both wheels
  SetLeftMotorDirAndSpeed(true, leftspeednum);
  SetRightMotorDirAndSpeed(true, rightspeednum);
}

//09/08/20 modified for DRV8871 motor driver
//11/04/21 modified for Pololu VNH5019 motor driver
void StopLeftMotors()
{
  digitalWrite(InA_Left, LOW);
  digitalWrite(InB_Left, LOW);
  analogWrite(Spd_Left, MOTOR_SPEED_OFF);
}

//11/04/21 modified for Pololu VNH5019 motor driver
void StopRightMotors()
{
  digitalWrite(InA_Right, LOW);
  digitalWrite(InB_Right, LOW);
  analogWrite(Spd_Right, MOTOR_SPEED_OFF);
}

//09/08/20 added bool bisFwd param for DRV8871 motor driver
void RunBothMotors(bool bisFwd, 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:
  //    Step 1: Apply drive to both wheels
  //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
  //Step 1: Apply drive to both wheels

//DEBUG!!
  //Serial1.printf("In RunBothMotors(%s, %d,%d)\n", bisFwd? "FWD":"REV", leftspeednum, rightspeednum);
//DEBUG!!

  SetLeftMotorDirAndSpeed(bisFwd, leftspeednum);
  SetRightMotorDirAndSpeed(bisFwd, rightspeednum);
}

void RunBothMotorsBidirectional(int leftspeed, int rightspeed)
{
  //Purpose:  Accommodate the need for independent bidirectional wheel motion
  //Inputs:
  //	leftspeed - integer denoting left wheel speed.  Positive value is fwd, negative is rev
  //	rightspeed - integer denoting right wheel speed.  Positive value is fwd, negative is rev
  //Outputs:
  //	left/right wheel motors direction and speed set as appropriate
  //Plan:
  //	Step1: Set left wheel direction and speed
  //	Step2: Set right wheel direction and speed

//Step1: Set left wheel direction and speed

  //DEBUG!!
  //Serial1.printf("In RunBothMotorsBidirectional(%d, %d)\n", leftspeed, rightspeed);
  if (leftspeed < 0)
  {
    SetLeftMotorDirAndSpeed(false, -leftspeed); //neg value ==> reverse
  }
  else
  {
    SetLeftMotorDirAndSpeed(true, leftspeed); //pos or zero value ==> fwd
  }

  //Step2: Set right wheel direction and speed
  if (rightspeed < 0)
  {
    SetRightMotorDirAndSpeed(false, -rightspeed); //neg value ==> reverse
  }
  else
  {
    SetRightMotorDirAndSpeed(true, rightspeed); //pos or zero value ==> fwd
  }
}

//09/08/20 added bool bisFwd param for DRV8871 motor driver
void RunBothMotorsMsec(bool bisFwd, int timeMsec, int leftspeednum, int rightspeednum)
{
  //Purpose: Run both Motors for timesec seconds at speednum speed
  //Inputs:
  //    timesec = time in seconds to run the Motors
  //    speednum = speed value (0 = OFF, 255 = full speed)
  //Outputs: Both Motors run for timesec seconds at speednum speed
  //Plan:
  //    Step 1: Apply drive to both wheels
  //    Step 2: Delay timsec seconds
  //    Step 3: Remove drive from both wheels.
  //Notes:
  //    01/14/15 - added left/right speed offset for straightness compensation
  //    01/22/15 - added code to restrict fast/slow values
  //	11/25/15 - rev to use motor driver class object
  //	09/08/20 added bool bisFwd param for DRV8871 motor driver

  RunBothMotors(bisFwd, leftspeednum, rightspeednum);

  //Step 2: Delay timsec seconds
  delay(timeMsec);

  //Step3: Stop motors added 04/12/21
  StopBothMotors();
}

//11/25/15 added for symmetry ;-).
void StopBothMotors()
{
  StopLeftMotors();
  StopRightMotors();
}

void SetLeftMotorDirAndSpeed(bool bIsFwd, int speed)
{
//DEBUG!!
  //Serial.printf("In SetLeftMotorDirAndSpeed(%s, %d)\n",
  //  (bIsFwd == true) ? "true" : "false", speed);
  //Serial1.printf("In SetLeftMotorDirAndSpeed(%s, %d)\n",
  //  (bIsFwd == true) ? "true" : "false", speed);
//DEBUG!!

  //11/04/21 fwd for right motors is CCW when looking at shaft
#ifndef NO_MOTORS
  if (bIsFwd)
  {
    digitalWrite(InA_Left, LOW);
    digitalWrite(InB_Left, HIGH);
    analogWrite(Spd_Left, speed);

//DEBUG!!
    //Serial.printf("In TRUE block of SetLeftMotorDirAndSpeed(%s, %d)\n",
    //  (bIsFwd == true) ? "true" : "false", speed);
    //Serial1.printf("In TRUE block of SetLeftMotorDirAndSpeed(%s, %d)\n",
    //  (bIsFwd == true) ? "true" : "false", speed);
//DEBUG!!
  }
  else
  {
//DEBUG!!
    //Serial.printf("In FALSE block of SetLeftMotorDirAndSpeed(%s, %d)\n",
    //  (bIsFwd == true) ? "true" : "false", speed);
    //Serial1.printf("In FALSE block of SetLeftMotorDirAndSpeed(%s, %d)\n",
    //  (bIsFwd == true) ? "true" : "false", speed);
//DEBUG!!

    digitalWrite(InA_Left, HIGH);
    digitalWrite(InB_Left, LOW);
    analogWrite(Spd_Left, speed);
  }
#endif // !NO_MOTORS
}

void SetRightMotorDirAndSpeed(bool bIsFwd, int speed)
{
//DEBUG!!
  //Serial.printf("In SetRightMotorDirAndSpeed(%s, %d)\n",
  //  (bIsFwd == true) ? "true" : "false", speed);
  //Serial1.printf("In SetRightMotorDirAndSpeed(%s, %d)\n",
  //  (bIsFwd == true) ? "true" : "false", speed);
//DEBUG!!

  //11/04/21 fwd for right motors is CW when looking at shaft
#ifndef NO_MOTORS

  if (bIsFwd)
  {
//DEBUG!!
    //Serial.printf("In TRUE block of SetRighttMotorDirAndSpeed(%s, %d)\n",
    //  (bIsFwd == true) ? "true" : "false", speed);
    //Serial1.printf("In TRUE block of SetRighttMotorDirAndSpeed(%s, %d)\n",
    //  (bIsFwd == true) ? "true" : "false", speed);
//DEBUG!!

    digitalWrite(InA_Right, HIGH);
    digitalWrite(InB_Right, LOW);
    analogWrite(Spd_Right, speed);
  }
  else
  {
//DEBUG!!
    //Serial.printf("In FALSE block of SetRightMotorDirAndSpeed(%s, %d)\n",
    //  (bIsFwd == true) ? "true" : "false", speed);
    //Serial1.printf("In FALSE block of SetRightMotorDirAndSpeed(%s, %d)\n",
    //  (bIsFwd == true) ? "true" : "false", speed);
    //DEBUG!!

    digitalWrite(InA_Right, LOW);
    digitalWrite(InB_Right, HIGH);
    analogWrite(Spd_Right, speed);
  }

#endif // !NO_MOTORS
}
#pragma endregion Motor Support Functions

#pragma region HDG_BASED_TURN_SUPPORT

bool SpinTurn(bool b_ccw, float numDeg, float degPersec) //04/25/21 added turn-rate arg (default = TURN_RATE_TARGET_DEGPERSEC)
{
  //Purpose: Make a numDeg CW or CCW 'spin' turn
  //Inputs:
  //	b_ccw - True if turn is to be ccw, false otherwise
  //	numDeg - angle to be swept out in the turn
  //	ROLLING_TURN_MAX_SEC_PER_DEG = const used to generate timeout proportional to turn deg
  //	IMUHdgValDeg = IMU heading value updated by UpdateIMUHdgValDeg() //11/02/20 now updated in ISR
  //	degPerSec = float value denoting desired turn rate
  //Plan:
  //	Step1: Get current heading as starting point
  //	Step2: Disable TIMER5 interrupts
  //	Step3: Compute new target value & timeout value
  //	Step4: Run motors until target reached, using inline PID algorithm to control turn rate
  //	Step5: Re-enable TIMER5 interrupts
  //Notes:
  //	06/06/21 we-written to remove PID library - now uses custom 'PIDCalcs()' function
  //	06/06/21 added re-try for 180.00 return from IMU - could be bad value
  //	06/11/21 added code to correct dHdg errors due to 179/-179 transition & bad IMU values
  //	06/12/21 cleaned up & commented out debug code
  //	11/14/21 removed 'first time skip' block; added motor start before entering loop

  float tgt_deg;
  float timeout_sec;
  bool bDoneTurning = false;
  bool bTimedOut = false;
  bool bResult = true; //04/21/20 added so will be only one exit point

  //DEBUG!!
  Serial.printf("In SpinTurn(%s, %2.2f, %2.2f)\n", b_ccw == TURNDIR_CCW ? "CCW" : "CW", numDeg, degPersec);
  Serial1.printf("In SpinTurn(%s, %2.2f, %2.2f)\n", b_ccw == TURNDIR_CCW ? "CCW" : "CW", numDeg, degPersec);
  //Serial.printf("TurnRatePID started with Kp/Ki/Kd = %2.1f,%2.1f,%2.1f, SampleTime(mSec) = %d\n",
    //TurnRate_Kp, TurnRate_Ki, TurnRate_Kd, TURN_RATE_UPDATE_INTERVAL_MSEC);
  //DEBUG!!

  //no need to continue if the IMU isn't available
  if (!dmpReady)
  {
    Serial.printf("DMP Failure - returning FALSE\n");
    return false;
  }

  //Step1: Get current heading as starting point
    //06/06/21 it is possible for IMU to return 180.00 on failure
    //so try again.  If it really IS 180, then 
    //it will eventually time out and go on

  //08/26/21 re-wrote using 3-value array to make sure initial heading is a steady value
  UpdateIMUHdgValDeg();

  int retries = 0;
  if ((IMUHdgValDeg == 180.f || IMUHdgValDeg == 0.f) && retries < 5)
  {
    //DEBUG!!
    Serial.printf("Got 180.00 or 0.00 exactly (%2.3f) from IMU - retrying %d...\n", IMUHdgValDeg, retries);
    Serial1.printf("Got 180.00 or 0.00 exactly (%2.3f) from IMU - retrying %d...\n", IMUHdgValDeg, retries);
    //DEBUG!!
    UpdateIMUHdgValDeg();
    retries++;
    delay(100);
  }

  //Step2: Compute new target value & timeout value
  //timeout_sec = 3 * numDeg / degPersec; //05/29/21 rev to use new turn rate parmeter
  timeout_sec = 2 * numDeg / degPersec; //05/29/21 rev to use new turn rate parmeter

  //05/17/20 limit timeout_sec to 1 sec or more
  timeout_sec = (timeout_sec < 1) ? 1.f : timeout_sec;

  //12/05/19 added #define back in to manage which direction increases yaw values
#ifdef MPU6050_CCW_INCREASES_YAWVAL
  tgt_deg = b_ccw ? IMUHdgValDeg + numDeg : IMUHdgValDeg - numDeg;
#else
  tgt_deg = b_ccw ? IMUHdgValDeg - numDeg : IMUHdgValDeg + numDeg;

#endif // MPU6050_CCW_INCREASES_YAWVAL

  //correct for -180/180 transition
  if (tgt_deg < -180)
  {
    tgt_deg += 360;
  }

  //07/29/19 bugfix
  if (tgt_deg > 180)
  {
    tgt_deg -= 360;
  }

  //DEBUG!!
  Serial.printf("Init hdg = %4.2f deg, Turn = %4.2f  deg, tgt = %4.2f deg, timeout = %4.2f sec\n\n",
    IMUHdgValDeg, numDeg, tgt_deg, timeout_sec);
  Serial1.printf("Init hdg = %4.2f deg, Turn = %4.2f  deg, tgt = %4.2f deg, timeout = %4.2f sec\n\n",
    IMUHdgValDeg, numDeg, tgt_deg, timeout_sec);
  //DEBUG!!

  float curHdgMatchVal = 0;

  //09/08/18 added to bolster end-of-turn detection
  float prevHdgMatchVal = 0;
  float matchSlope = 0;

  //Step3: Run motors until target reached, using PID algorithm to control turn rate
  Prev_HdgDeg = IMUHdgValDeg; //06/10/21 synch Prev_HdgDeg & IMUHdgValDeg just before entering loop

  //11/14/21 start motors before entering loop.  For CCW turn, left motors go backwards, right ones forward
  int startSpd = (degPersec <= 45) ? TURN_START_SPEED : 2 * TURN_START_SPEED;
  SetLeftMotorDirAndSpeed(!b_ccw, startSpd);
  SetRightMotorDirAndSpeed(b_ccw, startSpd);



  elapsedMillis sinceLastTimeCheck = 0;
  elapsedMillis sinceLastComputeTime = 0;
  double lastError = 0;
  double lastInput = 0;
  double lastIval = 0;
  double lastDerror = 0;
  //bool bFirstIMUHdg = true;

  //DEBUG!!
  Serial.printf("Msec\tHdg\tPrvHdg\tdHdg\tRate\ttgtDPS\terr\tKp*err\tIval\tKd*Derr\tspeed\tMatch\tSlope\n");
  Serial1.printf("Msec\tHdg\tPrvHdg\tdHdg\tRate\ttgtDPS\terr\tKp*err\tIval\tKd*Derr\tspeed\tMatch\tSlope\n");
  //DEBUG!!

  while (!bDoneTurning && !bTimedOut)
  {
    //11/06/20 now just loops between PID calcs
    CheckForUserInput();

    if (sinceLastComputeTime >= TURN_RATE_UPDATE_INTERVAL_MSEC)
    {
      sinceLastComputeTime -= TURN_RATE_UPDATE_INTERVAL_MSEC;

      UpdateIMUHdgValDeg(); //update IMUHdgValDeg

      double dHdg = IMUHdgValDeg - Prev_HdgDeg;
      if (dHdg > 180)
      {
        dHdg -= 360;
        //Serial.printf("dHdg > 180 - subtracting 360\n");
      }
      else if (dHdg < -180)
      {
        dHdg += 360;
        //Serial.printf("dHdg < -180 - adding 360\n");
      }

      //watch for turn rates that are wildly off
      double rate = abs(1000 * dHdg / TURN_RATE_UPDATE_INTERVAL_MSEC);
      //if (rate > 3 * degPersec)
      //{
      //	//DEBUG!!
      //	Serial.printf("hdg/prevhdg/dHdg/rate = %2.2f\t%2.2f\t%2.2f\t%2.2f, excessive rate - replacing with %2.2f\n", IMUHdgValDeg, Prev_HdgDeg, dHdg, rate, degPersec);
      //	//DEBUG!!
      //	rate = degPersec;
      //}

      TurnRatePIDOutput = PIDCalcs(rate, degPersec, TURN_RATE_UPDATE_INTERVAL_MSEC, lastError, lastInput, lastIval, lastDerror, TurnRate_Kp, TurnRate_Ki, TurnRate_Kd);

      int speed = 0;

      (TurnRatePIDOutput > MOTOR_SPEED_MAX) ? speed = MOTOR_SPEED_MAX : speed = (int)TurnRatePIDOutput;
      (TurnRatePIDOutput <= MOTOR_SPEED_LOW) ? speed = MOTOR_SPEED_LOW : speed = (int)TurnRatePIDOutput;

      SetLeftMotorDirAndSpeed(!b_ccw, speed);
      SetRightMotorDirAndSpeed(b_ccw, speed);

      //check for nearly there and all the way there
      curHdgMatchVal = GetHdgMatchVal(tgt_deg, IMUHdgValDeg);
      matchSlope = curHdgMatchVal - prevHdgMatchVal;

      Serial.printf("%lu\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%d\t%2.2f\t%2.2f\n",
        millis(),
        IMUHdgValDeg,
        Prev_HdgDeg,
        dHdg,
        rate,
        degPersec,
        lastError,
        TurnRate_Kp * lastError,
        lastIval,
        TurnRate_Kd * lastDerror,
        speed,
        curHdgMatchVal,
        matchSlope);

      Serial1.printf("%lu\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%d\t%2.2f\t%2.2f\n",
        millis(),
        IMUHdgValDeg,
        Prev_HdgDeg,
        dHdg,
        rate,
        degPersec,
        lastError,
        TurnRate_Kp * lastError,
        lastIval,
        TurnRate_Kd * lastDerror,
        speed,
        curHdgMatchVal,
        matchSlope);
      //DEBUG!!

      Prev_HdgDeg = IMUHdgValDeg; //re-synch prev to curr hdg for next time

      //look for full match
      bDoneTurning = (curHdgMatchVal >= HDG_FULL_MATCH_VAL
        || (prevHdgMatchVal >= HDG_MIN_MATCH_VAL && matchSlope <= -0.01)); //have to use < vs <= as slope == 0 at start

      //Serial.printf("curHdgMatchVal = %2.2f, prevHdgMatchVal = %2.2f, matchslope = %2.2f, bDoneTurning = %d\n",
      //	curHdgMatchVal,
      //	prevHdgMatchVal,
      //	matchSlope,
      //	bDoneTurning);

      prevHdgMatchVal = curHdgMatchVal; //07/31/21 moved below bDoneTurning chk so can use prevHdgMatchVal vs curHdgMatchVal in slope check

      bTimedOut = (sinceLastTimeCheck > timeout_sec * 1000);

      if (bTimedOut)
      {
        //DEBUG!!
        Serial.printf("timed out with yaw = %3.2f, tgt = %3.2f, and match = %1.3f\n", IMUHdgValDeg, tgt_deg, curHdgMatchVal);
        Serial1.printf("timed out with yaw = %3.2f, tgt = %3.2f, and match = %1.3f\n", IMUHdgValDeg, tgt_deg, curHdgMatchVal);
        //DEBUG!!

        bResult = false;
        break;
      }

      if (bDoneTurning)
      {
        Serial.printf("Completed turn with yaw = %3.2f, tgt = %3.2f, and match = %1.3f\n", IMUHdgValDeg, tgt_deg, curHdgMatchVal);
        Serial1.printf("Completed turn with yaw = %3.2f, tgt = %3.2f, and match = %1.3f\n", IMUHdgValDeg, tgt_deg, curHdgMatchVal);

        bResult = true;
        break;
      }
    }
  }

  StopBothMotors();
  delay(1000); //added 04/27/21 for debug
  return bResult;
}

double PIDCalcs(double input, double setpoint, uint16_t sampleTime, double& lastError, double& lastInput, double& lastIval, double& lastDerror, double Kp, double Ki, double Kd)
{
  //Purpose:  Encapsulate PID algorithm so can get rid of PID library. Library too cumbersome and won't synch with TIMER5 ISR
  //Inputs:
  //	input = double denoting current input value (turn rate, speed, whatever)
  //	setpoint = double denoting desired setpoint in same units as input
  //	sampleTime = int denoting sample time to be used in calcs.
  //	lastError = ref to double denoting error saved from prev calc
  //	lastInput = ref to double denoting input saved from prev calc
  //	Kp/Ki/Kd = doubles denoting PID values to be used for calcs
  //	Output = ref to double denoting output from calc

  double error = setpoint - input;
  //double dInput = (input - lastInput);
  //lastIval += (error);
  lastIval += (Ki * error);

  //11/16/21 rev to clamp integral term
  lastIval = (lastIval > MOTOR_SPEED_MAX) ? MOTOR_SPEED_MAX : lastIval;
  lastIval = (lastIval < MOTOR_SPEED_OFF) ? MOTOR_SPEED_OFF : lastIval;
  double dErr = (error - lastError);

  //Serial.printf("PIDCalcs: error/dInput/lastIval/dErr/kp/ki/kd = %2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\n", error, dInput, lastIval, dErr,
  //	Kp,Ki,Kd);

  /*Compute PID Output*/
  //11/16/21 rev to subtract differential term rather than add.
  //double output = Kp * error + Ki * lastIval + Kd * dErr;
  double output = Kp * error + lastIval - Kd * dErr;

  //11/16/21 now clamping output value as well as I term
  output = (output > MOTOR_SPEED_MAX) ? MOTOR_SPEED_MAX : output;
  output = (output < MOTOR_SPEED_OFF) ? MOTOR_SPEED_OFF : output;

  /*Remember some variables for next time*/
  lastError = error;
  lastInput = input;
  lastDerror = dErr;

  return output; //added 09/03/21
}

float GetHdgMatchVal(float tgt_deg, float cur_deg)
{
  //Purpose:  Compute the match ratio between two compass headings
  //Inputs:
  //	tgt_deg = float representing target heading in +/-180 range
  //	IMUHdgValDeg = float representing sensor yaw value in +/-180 deg range
  //Outputs:
  //	returns result of 1 - abs(Tgt_deg - Hdg_deg)/180, all angles in 0-360 deg range
  //Plan:
  //	Step1: convert both inputs to 0-360 deg range
  //	Step2: compute match ratio
  //Notes:
  //	formula from https://gis.stackexchange.com/questions/129954/comparing-compass-bearings

//Step1: convert both inputs to 0-360 deg range
  float tgthdg = (tgt_deg < 0) ? tgt_deg + 360 : tgt_deg;
  float curhdg = (cur_deg < 0) ? cur_deg + 360 : cur_deg;

  //Step2: compute match ratio
  float match_ratio = 1 - abs(tgthdg - curhdg) / 180;

  //DEBUG!!
    //Serial1.printf("tgt\tcur\tmatch = %4.2f\t%4.2f\t%1.3f\n", tgthdg, curhdg, match_ratio);
  //DEBUG!!
  return abs(match_ratio);
}

float UpdateIMUHdgValDeg()
{
  //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
  //	IMUHdgValDeg 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 IMUHdgValDeg 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
  //	05/05/20 changed return type to float vs bool.

  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
    IMUHdgValDeg = ypr[0] * 180 / M_PI;
  }

  return IMUHdgValDeg;//05/05/20 now returns updated value for use convenience
}

uint8_t GetCurrentFIFOPacket(uint8_t* data, uint8_t length, uint16_t max_loops)
{
  mpu.resetFIFO();
  delay(1);
  //int countloop = 0;

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

  //Serial1.printf("In GetCurrentFIFOPacket: before loop fifoC = %d\t", fifoCount);
  while (fifoCount < packetSize && GetPacketLoopCount < max_loops)
  {
    GetPacketLoopCount++;
    fifoCount = mpu.getFIFOCount();
    delay(2);
  }

  //Serial1.printf("In GetCurrentFIFOPacket: after loop fifoC = %d, loop count = %d\n", fifoCount, GetPacketLoopCount);

  if (GetPacketLoopCount >= max_loops)
  {
    return 0;
  }

  //if we get to here, there should be exactly one packet in the FIFO
  mpu.getFIFOBytes(data, packetSize);
  return 1;
}

//void BackupAndTurn90Deg(bool b_ccw, bool b_fwd, int motor_speed)
//{
//  //Purpose: Backup 1 second and then turn 90 degrees
//  //Provenance: G. Frank Paynter 06/27/2020
//  //Inputs:
//  //	bIsCCW = bool denoting direction for the turn
//  //	bIsFwd = bool denoting fwd/bkwd direction for the turn
//  //	motor_speed = int denoting motor speed to use for the maneuver
//  //Outputs:
//  //	Robot backs up 1 sec, then turns 90 deg in the specified direction
//  //Plan:
//  //	Step1: Back up for 1 sec
//  //	Step2: Turn 90 deg in specified direction
//  //Notes:
//  //	06/27/20 Replaces BackupAndTurn in all Tracking modes
//  //10/13/20 rev to terminate backup at Wall Offset Distance
//
////Step1: Back up for 1 sec
//  BackupSignal(true);	//turn backup LEDs ON
//  MoveReverse(MOTOR_SPEED_HALF, MOTOR_SPEED_HALF);
//  //delay(1000);
//
//  //10/13/20 rev to terminate backup at Wall Offset Distance
//  while (frontdistval < WALL_OFFSET_TGTDIST_CM && !bIsStuck)
//  {
//    if (bTimeForNavUpdate) //wait for next ISR hit
//    {
//      bTimeForNavUpdate = false;
//      Serial.print(F("BackupAndTurn90Deg: ")); Serial1.printf("%lu\t% d\n", millis(), frontdistval);
//    }
//  }
//  BackupSignal(false);//turn them back OFF
//
//  //Serial1.printf("BackupAndTurn90Deg terminated with frontdist = %d\n", frontdistval);
//  Serial.print(F("BackupAndTurn90Deg terminated with frontdist = ")); Serial1.printf("%d\n", frontdistval);
//
//  //Step2: Turn 90 deg fwd or backward in specified direction
//  SpinTurn(b_ccw, 90); //06/27/20 experiment
//}
#pragma endregion HDG_BASED_TURN_SUPPORT





#pragma region FLASHER_X

//09/20/21 copied from FlasherX
//******************************************************************************
// update_firmware()	read hex file and write new firmware to program flash
//******************************************************************************
void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size)
{
  static char line[96];					// buffer for hex lines
  static char data[32] __attribute__((aligned(8)));	// buffer for hex data
  hex_info_t hex = {					// intel hex info struct
    data, 0, 0, 0,					//   data,addr,num,code
    0, 0xFFFFFFFF, 0, 					//   base,min,max,
    0, 0						//   eof,lines
  };

  serial->printf("waiting for hex lines...\n");

  // read and process intel hex lines until EOF or error
//DEBUG!!
  //int line_num = 0;
//DEBUG!!
  long int start_msec = 0;
  bool bFirstTime = true;
  while (!hex.eof) {

    read_ascii_line(serial, line, sizeof(line));

    if (bFirstTime)
    {
      start_msec = millis();
      bFirstTime = false;
    }

    //DEBUG!!
        //serial->printf("%d: %s\n", line_num, line);
        //line_num++;
    //DEBUG!!

        //10/02/21 gfp added for visual xfer confirmation
    if (hex.lines % 10 == 0)
    {
      digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN));
    }

    // reliability of transfer via USB is improved by this printf/flush
    if (serial == (Stream*)&Serial)
    {
      serial->printf("%s\n", line);
      serial->flush();
    }

    if (parse_hex_line((const char*)line, hex.data, &hex.addr, &hex.num, &hex.code) == 0) {
      serial->printf("abort - bad hex line %s\n", line);
      return;
    }
    else if (process_hex_record(&hex) != 0) { // error on bad hex code
      serial->printf("abort - invalid hex code %d\n", hex.code);
      return;
    }
    else if (hex.code == 0) { // if data record
      uint32_t addr = buffer_addr + hex.base + hex.addr - FLASH_BASE_ADDR;
      if (hex.max > (FLASH_BASE_ADDR + buffer_size)) {
        serial->printf("abort - max address %08lX too large\n", hex.max);
        return;
      }
      else if (!IN_FLASH(buffer_addr)) {
        memcpy((void*)addr, (void*)hex.data, hex.num);
      }
      else if (IN_FLASH(buffer_addr)) {
        int error = flash_write_block(addr, hex.data, hex.num);
        if (error) {
          serial->printf("abort - error %02X in flash_write_block()\n", error);
          return;
        }
      }
    }
    hex.lines++;
  }

  //serial->printf("\nhex file: %1d lines %1lu bytes (%08lX - %08lX)\n",
  //  hex.lines, hex.max - hex.min, hex.min, hex.max);
  serial->printf("\nhex file: %1d lines %1lu bytes (%08lX - %08lX), %lu Msec\n",
    hex.lines, hex.max - hex.min, hex.min, hex.max, millis() - start_msec);

  // check FSEC value in new code -- abort if incorrect
#if defined(KINETISK) || defined(KINETISL)
  uint32_t value = *(uint32_t*)(0x40C + buffer_addr);
  if (value == 0xfffff9de) {
    serial->printf("new code contains correct FSEC value %08lX\n", value);
  }
  else {
    serial->printf("abort - FSEC value %08lX should be FFFFF9DE\n", value);
    return;
  }
#endif

  // check FLASH_ID in new code - abort if not found
  if (check_flash_id(buffer_addr, hex.max - hex.min)) {
    serial->printf("new code contains correct target ID %s\n", FLASH_ID);
  }
  else {
    serial->printf("abort - new code missing string %s\n", FLASH_ID);
    return;
  }

  // get user input to write to flash or abort
  int user_lines = -1;
  while (user_lines != hex.lines && user_lines != 0) {
    serial->printf("enter %d to flash or 0 to abort\n", hex.lines);
    read_ascii_line(serial, line, sizeof(line));
    sscanf(line, "%d", &user_lines);
  }

  if (user_lines == 0) {
    serial->printf("abort - user entered 0 lines\n");
    return;
  }

  // move new program from buffer to flash, free buffer, and reboot
  //serial->printf("user entered %d lines\n", user_lines);
  flash_move(FLASH_BASE_ADDR, buffer_addr, hex.max - hex.min);

  // should not return from flash_move(), but put REBOOT here as reminder
  REBOOT;
}

//******************************************************************************
// read_ascii_line()	read ascii characters until '\n', '\r', or max bytes
//******************************************************************************
void read_ascii_line(Stream* serial, char* line, int maxbytes)
{
  int c = 0, nchar = 0;
  while (nchar < maxbytes && !(c == '\n' || c == '\r')) {
    if (serial->available()) {
      c = serial->read();
      line[nchar++] = c;
    }
  }
  line[nchar - 1] = 0;	// null-terminate
}

//******************************************************************************
// process_hex_record()		process record and return okay (0) or error (1)
//******************************************************************************
int process_hex_record(hex_info_t* hex)
{
  if (hex->code == 0) { // data -- update min/max address so far
    if (hex->base + hex->addr + hex->num > hex->max)
      hex->max = hex->base + hex->addr + hex->num;
    if (hex->base + hex->addr < hex->min)
      hex->min = hex->base + hex->addr;
  }
  else if (hex->code == 1) { // EOF (:flash command not received yet)
    hex->eof = 1;
  }
  else if (hex->code == 2) { // extended segment address (top 16 of 24-bit addr)
    hex->base = ((hex->data[0] << 8) | hex->data[1]) << 4;
  }
  else if (hex->code == 3) { // start segment address (80x86 real mode only)
    return 1;
  }
  else if (hex->code == 4) { // extended linear address (top 16 of 32-bit addr)
    hex->base = ((hex->data[0] << 8) | hex->data[1]) << 16;
  }
  else if (hex->code == 5) { // start linear address (32-bit big endian addr)
    hex->base = (hex->data[0] << 24) | (hex->data[1] << 16)
      | (hex->data[2] << 8) | (hex->data[3] << 0);
  }
  else {
    return 1;
  }

  return 0;
}

//******************************************************************************
// Intel Hex record foramt:
//
// Start code:  one character, ASCII colon ':'.
// Byte count:  two hex digits, number of bytes (hex digit pairs) in data field.
// Address:     four hex digits
// Record type: two hex digits, 00 to 05, defining the meaning of the data field.
// Data:        n bytes of data represented by 2n hex digits.
// Checksum:    two hex digits, computed value used to verify record has no errors.
//
// Examples:
//  :10 9D30 00 711F0000AD38000005390000F5460000 35
//  :04 9D40 00 01480000 D6
//  :00 0000 01 FF
//******************************************************************************

/* Intel HEX read/write functions, Paul Stoffregen, paul@ece.orst.edu */
/* This code is in the public domain.  Please retain my name and */
/* email address in distributed copies, and let me know about any bugs */

/* I, Paul Stoffregen, give no warranty, expressed or implied for */
/* this software and/or documentation provided, including, without */
/* limitation, warranty of merchantability and fitness for a */
/* particular purpose. */

// type modifications by Jon Zeeff

/* parses a line of intel hex code, stores the data in bytes[] */
/* and the beginning address in addr, and returns a 1 if the */
/* line was valid, or a 0 if an error occured.  The variable */
/* num gets the number of bytes that were stored into bytes[] */

#include <stdio.h>		// sscanf(), etc.
#include <string.h>		// strlen(), etc.

int parse_hex_line(const char* theline, char* bytes,
  unsigned int* addr, unsigned int* num, unsigned int* code)
{
  unsigned sum, len, cksum;
  const char* ptr;
  int temp;

  *num = 0;
  if (theline[0] != ':')
    return 0;
  if (strlen(theline) < 11)
    return 0;
  ptr = theline + 1;
  if (!sscanf(ptr, "%02x", &len))
    return 0;
  ptr += 2;
  if (strlen(theline) < (11 + (len * 2)))
    return 0;
  if (!sscanf(ptr, "%04x", (unsigned int*)addr))
    return 0;
  ptr += 4;
  /* Serial1.printf("Line: length=%d Addr=%d\n", len, *addr); */
  if (!sscanf(ptr, "%02x", code))
    return 0;
  ptr += 2;
  sum = (len & 255) + ((*addr >> 8) & 255) + (*addr & 255) + (*code & 255);
  while (*num != len)
  {
    if (!sscanf(ptr, "%02x", &temp))
      return 0;
    bytes[*num] = temp;
    ptr += 2;
    sum += bytes[*num] & 255;
    (*num)++;
    if (*num >= 256)
      return 0;
  }
  if (!sscanf(ptr, "%02x", &cksum))
    return 0;

  if (((sum & 255) + (cksum & 255)) & 255)
    return 0;     /* checksum error */
  return 1;
}
#pragma endregion FLASHER_X

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

1001

1002

1003

1004

1005

1006

1007

1008

1009

1010

1011

1012

1013

1014

1015

1016

1017

1018

1019

1020

1021

1022

1023

1024

1025

1026

1027

1028

1029

1030

1031

1032

1033

1034

1035

1036

1037

1038

1039

1040

1041

1042

1043

1044

1045

1046

1047

1048

1049

1050

1051

1052

1053

1054

1055

1056

1057

1058

1059

1060

1061

1062

1063

1064

1065

1066

1067

1068

1069

1070

1071

1072

1073

1074

1075

1076

1077

1078

1079

1080

1081

1082

1083

1084

1085

1086

1087

1088

1089

1090

1091

1092

1093

1094

1095

1096

1097

1098

1099

1100

1101

1102

1103

1104

1105

1106

1107

1108

1109

1110

1111

1112

1113

1114

1115

1116

1117

1118

1119

1120

1121

1122

1123

1124

1125

1126

1127

1128

1129

1130

1131

1132

1133

1134

1135

1136

1137

1138

1139

1140

1141

1142

1143

1144

1145

1146

1147

1148

1149

1150

1151

1152

1153

1154

1155

1156

1157

1158

1159

1160

1161

1162

1163

1164

1165

1166

1167

1168

1169

1170

1171

1172

1173

1174

1175

1176

1177

1178

1179

1180

1181

1182

1183

1184

1185

1186

1187

1188

1189

1190

1191

1192

1193

1194

1195

1196

1197

1198

1199

1200

1201

1202

1203

1204

1205

1206

1207

1208

1209

1210

1211

1212

1213

1214

1215

1216

1217

1218

1219

1220

1221

1222

1223

1224

1225

1226

1227

1228

1229

1230

1231

1232

1233

1234

1235

1236

1237

1238

1239

1240

1241

1242

1243

1244

1245

1246

1247

1248

1249

1250

1251

1252

1253

1254

1255

1256

1257

1258

1259

1260

1261

1262

1263

1264

1265

1266

1267

1268

1269

1270

1271

1272

1273

1274

1275

1276

1277

1278

1279

1280

1281

1282

1283

1284

1285

1286

1287

1288

1289

1290

1291

1292

1293

1294

1295

1296

1297

1298

1299

1300

1301

1302

1303

1304

1305

1306

1307

1308

1309

1310

1311

1312

1313

1314

1315

1316

1317

1318

1319

1320

1321

1322

1323

1324

1325

1326

1327

1328

1329

1330

1331

1332

1333

1334

1335

1336

1337

1338

1339

1340

1341

1342

1343

1344

1345

1346

1347

1348

1349

1350

1351

1352

1353

1354

1355

1356

1357

1358

1359

1360

1361

1362

1363

1364

1365

1366

1367

1368

1369

1370

1371

1372

1373

1374

1375

1376

1377

1378

1379

1380

1381

1382

1383

1384

1385

1386

1387

1388

1389

1390

1391

1392

1393

1394

1395

1396

1397

1398

1399

1400

1401

1402

1403

1404

1405

1406

1407

1408

1409

1410

1411

1412

1413

1414

1415

1416

1417

1418

1419

1420

1421

1422

1423

1424

1425

1426

1427

1428

1429

1430

1431

1432

1433

1434

1435

1436

1437

1438

1439

1440

1441

1442

1443

1444

1445

1446

1447

1448

1449

1450

1451

1452

1453

1454

1455

1456

1457

1458

1459

1460

1461

1462

1463

1464

1465

1466

1467

1468

1469

1470

1471

1472

1473

1474

1475

1476

1477

1478

1479

1480

1481

1482

1483

1484

1485

1486

1487

1488

1489

1490

1491

1492

1493

1494

1495

1496

1497

1498

1499

1500

1501

1502

1503

1504

1505

1506

1507

1508

1509

1510

1511

1512

1513

1514

1515

1516

1517

1518

1519

1520

1521

1522

1523

1524

1525

1526

1527

1528

1529

1530

1531

1532

1533

1534

1535

1536

1537

1538

1539

1540

1541

1542

1543

1544

1545

1546

1547

1548

1549

1550

1551

1552

1553

1554

1555

1556

1557

1558

1559

1560

1561

1562

1563

1564

1565

1566

1567

1568

1569

1570

1571

1572

1573

1574

1575

1576

1577

1578

1579

1580

1581

1582

1583

1584

1585

1586

1587

1588

1589

1590

1591

1592

1593

1594

1595

1596

1597

1598

1599

1600

1601

1602

1603

1604

1605

1606

1607

1608

1609

1610

1611

1612

1613

1614

1615

1616

1617

1618

1619

1620

1621

1622

1623

1624

1625

1626

1627

1628

1629

1630

1631

1632

1633

1634

1635

1636

1637

1638

1639

1640

1641

1642

1643

1644

1645

1646

1647

1648

1649

1650

1651

1652

1653

1654

1655

1656

1657

1658

1659

1660

1661

1662

1663

1664

1665

1666

1667

1668

1669

1670

1671

1672

1673

1674

1675

1676

1677

1678

1679

1680

1681

1682

1683

1684

1685

1686

1687

1688

1689

1690

1691

1692

1693

1694

1695

1696

1697

1698

1699

1700

1701

1702

1703

1704

1705

1706

1707

1708

1709

1710

1711

1712

1713

1714

1715

1716

1717

1718

1719

1720

1721

1722

1723

1724

1725

1726

1727

1728

1729

1730

1731

1732

1733

1734

1735

1736

1737

1738

1739

1740

1741

1742

1743

1744

1745

1746

1747

1748

1749

1750

1751

1752

1753

1754

1755

1756

1757

1758

1759

1760

1761

1762

1763

1764

1765

1766

1767

1768

1769

1770

1771

1772

1773

1774

1775

1776

1777

1778

1779

1780

1781

1782

1783

1784

1785

1786

1787

1788

1789

1790

1791

1792

1793

1794

1795

1796

1797

1798

1799

1800

1801

1802

1803

1804

1805

1806

1807

1808

1809

1810

1811

1812

1813

1814

1815

1816

1817

1818

1819

1820

1821

1822

1823

1824

1825

1826

1827

1828

1829

1830

1831

1832

1833

1834

1835

1836

1837

1838

1839

1840

1841

1842

1843

1844

1845

1846

1847

1848

1849

1850

1851

1852

1853

1854

1855

1856

1857

1858

1859

1860

1861

1862

1863

1864

1865

1866

1867

1868

1869

1870

1871

1872

1873

1874

1875

1876

1877

1878

1879

1880

1881

1882

1883

1884

1885

1886

1887

1888

1889

1890

1891

1892

1893

1894

1895

1896

1897

1898

1899

1900

1901

1902

1903

Name: T35_WallE3_V2.ino

Created: 11/20/2021 4:41:25 PM

Author: FRANKNEWXPS15\Frank

Name: T35_WallE3_V1.ino

Created: 10/25/2021 2:37:04 PM

Author: FRANKNEWXPS15\Frank

10/30/21 - Added TeensyOTADemo code for basic OTA updates

Name: TeensyOTADemo.ino

Created: 10/9/2021 11:18:19 AM

Author: FRANKNEWXPS15\Frank

This program demonstrates the use of 'board.txt' post-build instructions in

conjunction with a small C# command-line program for seamless 'over-the-air' (OTA)

firmware update for Teensy modules.

Implementation of OTA update requires that Joe Pasquariello's 'FlasherX'

code be added to the Teensy sketch as it is below, and some code to allow

an external serial communications program to trigger the update process.

In the demo sketch below, the 'FlasherX' additions are the '#include FlasherTxx.h'

line and the addition of the FlasherX specific code at the bottom. The trigger

mechanism is provided by the 'CheckForUserInput();' call in loop. If the ASCII

code for 'U' or 'u' is present on Serial1, the update process will be launched.

#pragma region INCLUDES

#include "FlashTxx.h" // TLC/T3x/T4x flash primitives

#include <elapsedMillis.h>

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

#pragma endregion Includes

#pragma region DEFINES

//02/29/16 hardware defines

//#define NO_MOTORS

//#define IR_HOMING_ONLY

//#define NO_LIDAR

//#define NO_PINGS

//#define NO_IRDET //added 04/05/17 for daytime in-atrium testing (too much ambient IR)

//#define DISTANCES_ONLY //added 11/14/18 to just display distances in infinite loop

#define NO_STUCK //added 03/10/19 to disable 'stuck' detection

//#define BATTERY_DISCHARGE //added 03/04/20 to discharge battery safely

#define NO_POST //added 04/12/20 to skip all the POST checks

//11/07/2020 moved all I2C Address declarations here

#define IRDET_I2C_ADDR 0x08

#define MPU6050_I2C_ADDR 0x68

#pragma endregion Program #Defines

#pragma region PRE_SETUP

MPU6050 mpu(MPU6050_I2C_ADDR);

elapsedMillis MsecSinceLastLEDToggle; //used for LED blink timer

const double ADC_REF_VOLTS = 3.3; //teensy default for analog inputs

const double AmpsPerVolt = 1.00; //default 10K Rs

const int MAX_AD_COUNT = 1023;

const double VoltsPerCount = ADC_REF_VOLTS / MAX_AD_COUNT;

//Battery constants

const float ZENER_VOLTAGE_OFFSET = 5.84; //measured zener voltage

#pragma region PIN ASSIGNMENTS

//vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv//

//=================== START PIN ASSIGNMENTS ===================//

//vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv//

#pragma region MOTOR_PINS

//11/04/21 Now using Pololu VNH5019 drivers for all 4 motors

const int InA_Left = 22;

const int InB_Left = 21;

const int Spd_Left = 23;

const int InA_Right = 34;

const int InB_Right = 33;

const int Spd_Right = 35;

#pragma endregion Motor Pin Assignments

const int ChgConnectPin = 36;

const int ItotPin = A1;

const int IRunPin = A2;

const int BATT_MON_PIN = A0;

#pragma endregion PIN ASSIGNMENTS

#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_QTR = 75; //added 09/25/20

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

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

const int MOTOR_SPEED_CAPTURE_OFFSET = 75; //added 06/21/20 for offset capture

const int TURN_START_SPEED = MOTOR_SPEED_QTR; //added 11/14/21

//drive wheel direction constants

const boolean FWD_DIR = true;

const boolean REV_DIR = !FWD_DIR;

const bool TURNDIR_CCW = true;

const bool TURNDIR_CW = false;

//Motor direction variables

bool bIsForwardDir = true; //default is foward direction

#pragma endregion Motor Parameters

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

//MPU6050 status flags

bool bMPU6050Ready = true;

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

volatile float IMUHdgValDeg = 0; //updated by UpdateIMUHdgValDeg()//11/02/20 now updated in ISR

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;

//#define MPU6050_CCW_INCREASES_YAWVAL //added 12/05/19 commented out 11/22/21 as now the MPU6050 module is mounted 'Z-up'

#pragma endregion MPU6050 Support

#pragma region HEADING_AND_RATE_BASED_TURN_PARAMETERS

elapsedMillis MsecSinceLastTurnRateUpdate;

const int MAX_SPIN_MOTOR_SPEED = 250;

const int MIN_SPIN_MOTOR_SPEED = 50;

const int TURN_RATE_UPDATE_INTERVAL_MSEC = 30; //30 mSec is as fast as it can go

double TurnRateOutput;

double TurnRateSetPoint_DPS;

double Ival = 0;

double lastErr = 0;

double lastTurnRateVal_DPS;

double TurnRateVal_DPS;

double Prev_HdgDeg = 0;

float tgt_deg;

float timeout_sec;

//11/16/21 almost perfect for 45 deg/sec, 100mSec

//11/17/21 and pretty good for 90 deg/sec too!

double TurnRate_Kp = 1.8;

double TurnRate_Ki = 1.0;

double TurnRate_Kd = 0.4;

//ported from FourWD_PulseTurnRateTest.ino

double TurnRatePIDOutput;

//06/02/

const float HDG_NEAR_MATCH_VAL = 0.8; //slow the turn down here

const float HDG_FULL_MATCH_VAL = 0.99; //stop the turn here //rev 06/01/21

const float HDG_MIN_MATCH_VAL = 0.6; //added 09/08/18: don't start checking slope until turn is well started

#pragma endregion HEADING_AND_RATE_BASED_TURN_PARAMETERS

#pragma region OTA UPDATE

//******************************************************************************

// hex_info_t struct for hex record and hex file info

//******************************************************************************

typedef struct { //

char* data; // pointer to array allocated elsewhere

unsigned int addr; // address in intel hex record

unsigned int code; // intel hex record type (0=data, etc.)

unsigned int num; // number of data bytes in intel hex record

uint32_t base; // base address to be added to intel hex 16-bit addr

uint32_t min; // min address in hex file

uint32_t max; // max address in hex file

int eof; // set true on intel hex EOF (code = 1)

int lines; // number of hex records received

} hex_info_t;

void read_ascii_line(Stream* serial, char* line, int maxbytes);

int parse_hex_line(const char* theline, char* bytes,

unsigned int* addr, unsigned int* num, unsigned int* code);

int process_hex_record(hex_info_t* hex);

void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size);

uint32_t buffer_addr, buffer_size; //09/20/21 copied from FlasherX - loop()

#pragma endregion OTA UPDATE

#pragma endregion PRE_SETUP

void setup()

{

Serial.begin(115200);

delay(2000); //10/06/21 - just use fixed delay instead

Serial1.begin(115200); //used HC-05 'AT' commands to set this speed

//while (!Serial1) {}

delay(2000); //11/20/21 use fixed delay instead of waiting

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

//DEBUG!!

if (Serial)

{

Serial.printf("Serial = %p, Serial1 = %p\n", &Serial, &Serial1);

}

//DEBUG!!

if (Serial1)

{

Serial.printf("Serial = %p, Serial1 = %p\n", &Serial, &Serial1);

}

//DEBUG!!

#pragma region PIN INITIALIZATION

pinMode(LED_BUILTIN, OUTPUT);

pinMode(ItotPin, INPUT); //I_total 1V/Amp

pinMode(BATT_MON_PIN, INPUT); //Battery voltage monitor

//motor pins

pinMode(InA_Left, OUTPUT);

pinMode(InB_Left, OUTPUT);

pinMode(Spd_Left, OUTPUT);

pinMode(InA_Right, OUTPUT);

pinMode(InB_Right, OUTPUT);

pinMode(Spd_Right, OUTPUT);

#pragma endregion PIN INITIALIZATION

#pragma region MPU6050

Serial.printf("\nChecking for MPU6050 IMU at I2C Addr 0x%x\n", MPU6050_I2C_ADDR);

mpu.initialize();

// verify connection

Serial.println(mpu.testConnection() ? F("MPU6050 connection successful") : F("MPU6050 connection failed"));

float StartSec = 0; //used to time MPU6050 init

Serial.println(F("Initializing DMP..."));

devStatus = mpu.dmpInitialize();

// make sure it worked (returns 0 if successful)

if (devStatus == 0)

{

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

Serial.printf("Just after MPU6050 Init\n");

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

mpu.CalibrateGyro(); //using default value of 15

Serial.printf("Retrieving Calibration Values\n\n");

mpu.PrintActiveOffsets();

//loop heading display until stabilized

Serial.printf("\nMsec\tHdg\n");

UpdateIMUHdgValDeg();

Prev_HdgDeg = IMUHdgValDeg;

delay(100);

UpdateIMUHdgValDeg();

Serial.printf("%lu\t%2.3f\t%2.3f\n", millis(), IMUHdgValDeg, Prev_HdgDeg);

while (abs(IMUHdgValDeg - Prev_HdgDeg) > 0.1f)

{

Serial.printf("%lu\t%2.3f\n", millis(), IMUHdgValDeg);

Prev_HdgDeg = IMUHdgValDeg;

delay(100);

UpdateIMUHdgValDeg();

}

StartSec = millis() / 1000.f;

Serial.printf("MPU6050 Ready at %2.2f Sec with delta = %2.3f\n", StartSec, IMUHdgValDeg - Prev_HdgDeg);

bMPU6050Ready = true;

delay(1000);

}

else //MPU6050 Init failed for some reason

{

// 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(")"));

//08/29/21 print out battery voltage on failure

float batV = GetBattVoltage();

Serial.printf("Battery Voltage = %2.2f\n", batV);

bMPU6050Ready = false;

}

#pragma endregion MPU6050

analogReadAveraging(4); //applies to all analogRead() operations?

MsecSinceLastLEDToggle = 0;

Serial1.printf("Msec\tBattV\tTotAmps\tRunAmps\tHdgDeg\n");

}

void loop()

{

//if (Serial1.available())

if (Serial1.available()||Serial.available())

{

CheckForUserInput();

}

if (MsecSinceLastLEDToggle >= 200)

{

MsecSinceLastLEDToggle -= 200;

digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));

//11/01/21 read I_tot value & cvt to current

int ItotVal = analogRead(ItotPin);

double ItotVolts = ItotVal * VoltsPerCount;

double ItotAmps = ItotVolts * AmpsPerVolt;

//Get battery voltage

float calc_volts = GetBattVoltage();

//print out battery voltage & charge current

Serial1.printf("%lu\t%2.2f\t%2.2f\n", millis(), calc_volts, ItotAmps);

Serial.printf("%lu\t%2.2f\t%2.2f\n", millis(), calc_volts, ItotAmps);

}

float GetBattVoltage()

{

//02/18/17 get corrected battery voltage. Voltage reading is 1/3 actual Vbatt value

//int analog_batt_reading = GetAverageAnalogReading(BATT_MON_PIN, VOLTS_AVERAGE_NUMBER);//rev 03/01/19 to average readings

int analog_batt_reading = analogRead(BATT_MON_PIN);//analogReadAveraging(4) in setup() does internal averaging

float calc_volts = ZENER_VOLTAGE_OFFSET + ADC_REF_VOLTS * (double)analog_batt_reading / (double)MAX_AD_COUNT;

////DEBUG!!

// Serial1.printf("a/d = %d, calc = %2.2f\n", analog_batt_reading,calc_volts);

////DEBUG!!

return calc_volts;

}

//void CheckForUserInput()

//{

// //Notes:

// // 11/21/21 rev to accomodate cmd input from either serial, and output to both

// const int bufflen = 80;

// char buff[bufflen];

// memset(buff, 0, bufflen);

// float OffsetCm;

// float Kp, Ki, Kd;

// const char s[2] = ",";

// char* token;

// byte incomingByte = 0; //moved here 11/21/21

// if (Serial.available() > 0)

// {

// // read the incoming byte:

// //int incomingByte = Serial.read();

// incomingByte = Serial.read();

// // say what you got:

// Serial.print("I received: ");

// Serial.println(incomingByte, HEX); //chg to HEX 02/18/20

// }

// //11/21/21 now input can come from Serial1 too

// else if (Serial1.available() > 0)

// {

// // read the incoming byte:

// incomingByte = Serial1.read();

// // say what you got:

// Serial1.print("I received: ");

// Serial1.println(incomingByte, HEX); //chg to HEX 02/18/20

// }

// //11/21/21 incomingByte can come from either serial input

// if (incomingByte != 0)

// {

// //02/18/20 experiment with multiple commands

// switch (incomingByte)

// {

// case 0x55: //ASCII 'U'

// case 0x75: //ASCII 'u'

//#pragma region FIRMWARE UPDATE

// Serial1.println(F("Start Program Update - Send new HEX file!"));

// //09/20/21 copied from FlasherX - loop()

// if (firmware_buffer_init(&buffer_addr, &buffer_size) == 0)

// {

// Serial1.printf("unable to create buffer\n");

// Serial1.flush();

// for (;;) {}

// }

// Serial1.printf("buffer = %1luK %s (%08lX - %08lX)\n",

// buffer_size / 1024, IN_FLASH(buffer_addr) ? "FLASH" : "RAM",

// buffer_addr, buffer_addr + buffer_size);

// //09/20/21 clear the serial buffer

// while (Serial1.available())

// {

// Serial1.read();

// }

// // receive hex file via serial, write new firmware to flash, clean up, reboot

// update_firmware(&Serial1, buffer_addr, buffer_size); // no return if success

// // return from update_firmware() means error or user abort, so clean up and

// // reboot to ensure that static vars get boot-up initialized before retry

// Serial1.printf("erase FLASH buffer / free RAM buffer...\n");

// firmware_buffer_free(buffer_addr, buffer_size);

// Serial1.flush();

// REBOOT;

// break;

//#pragma endregion FIRMWARE UPDATE

// case 0x43: //ASCII 'C'

// case 0x63: //ASCII 'c'

//#pragma region MANUALCONTROL

// //enter infinite loop for direct remote control

// Serial.println(F("ENTERING COMMAND MODE:"));

// Serial.println(F("0 = 180 deg CCW Turn"));

// Serial.println(F("1 = 180 deg CW Turn"));

// Serial.println(F("A = Back to Auto Mode"));

// Serial.println(F("S = Stop"));

// Serial.println(F("F = Forward"));

// Serial.println(F("R = Reverse"));

// Serial.println(F(""));

// Serial.println(F(" Faster"));

// Serial.println(F("\t8"));

// Serial.println(F("Left 4\t5 6 Right"));

// Serial.println(F("\t2"));

// Serial.println(F(" Slower"));

// Serial1.println(F("ENTERING COMMAND MODE:"));

// Serial1.println(F("0 = 180 deg CCW Turn"));

// Serial1.println(F("1 = 180 deg CW Turn"));

// Serial1.println(F("A = Back to Auto Mode"));

// Serial1.println(F("S = Stop"));

// Serial1.println(F("F = Forward"));

// Serial1.println(F("R = Reverse"));

// Serial1.println(F(""));

// Serial1.println(F(" Faster"));

// Serial1.println(F("\t8"));

// Serial1.println(F("Left 4\t5 6 Right"));

// Serial1.println(F("\t2"));

// Serial1.println(F(" Slower"));

// StopBothMotors();

// int speed = 0;

// bool bAutoMode = false;

// while (!bAutoMode)

// {

// if (Serial.available() > 0)

// {

// // read the incoming byte:

// incomingByte = Serial.read();

// // say what you got:

// Serial.print("I received: ");

// Serial.println(incomingByte, HEX); //chg to HEX 02/18/20

// }

// //11/21/21 now input can come from Serial1 too

// else if (Serial1.available() > 0)

// {

// // read the incoming byte:

// incomingByte = Serial1.read();

// // say what you got:

// Serial1.print("I received: ");

// Serial1.println(incomingByte, HEX); //chg to HEX 02/18/20

// }

// //11/21/21 incomingByte can come from either serial input

// if (incomingByte != 0)

// {

// switch (incomingByte)

// {

// case 0x30: //Dec '0'

// Serial.println(F("CCW 180 deg Turn"));

// Serial1.println(F("CCW 180 deg Turn"));

// SpinTurn(true, 180, 90);

// MoveAhead(speed, speed);

// break;

// case 0x31: //Dec '1'

// Serial.println(F("CW 180 deg Turn"));

// Serial1.println(F("CW 180 deg Turn"));

// SpinTurn(false, 180, 45);

// break;

// case 0x34: //Turn left 10 deg and keep moving

// Serial.println(F("CCW 10 deg Turn"));

// Serial1.println(F("CCW 10 deg Turn"));

// SpinTurn(true, 10, 30);

// if (bIsForwardDir)

// {

// MoveAhead(speed, speed);

// }

// else

// {

// MoveReverse(speed, speed);

// }

// break;

// case 0x36: //Turn right 10 deg and keep moving

// Serial.print("CW 10 deg Turn\n");

// Serial1.print("CW 10 deg Turn\n");

// SpinTurn(false, 10, 30);

// //added 05/03/20

// if (bIsForwardDir)

// {

// MoveAhead(speed, speed);

// }

// else

// {

// MoveReverse(speed, speed);

// }

// break;

// case 0x38: //Speed up

// speed += 50;

// speed = (speed >= MOTOR_SPEED_MAX) ? MOTOR_SPEED_MAX : speed;

// Serial.printf("Speeding up: speed now %d\n", speed);

// Serial1.printf("Speeding up: speed now %d\n", speed);

// if (bIsForwardDir)

// {

// MoveAhead(speed, speed);

// }

// else

// {

// MoveReverse(speed, speed);

// }

// break;

// case 0x32: //Slow down

// speed -= 50;

// speed = (speed < 0) ? 0 : speed;

// Serial.printf("Slowing down: speed now %d\n", speed);

// Serial1.printf("Slowing down: speed now %d\n", speed);

// if (bIsForwardDir)

// {

// MoveAhead(speed, speed);

// }

// else

// {

// MoveReverse(speed, speed);

// }

// break;

// case 0x35: //05/07/20 changed to use '5' vs 'S'

// Serial.println(F("Stopping Motors!"));

// Serial1.println(F("Stopping Motors!"));

// StopBothMotors();

// speed = 0;

// break;

// case 0x41: //ASCII 'A'

// case 0x61: //ASCII 'a'

// StopBothMotors();

// Serial.println(F("Re-entering AUTO mode"));

// Serial1.println(F("Re-entering AUTO mode"));

// bAutoMode = true;

// break;

// case 0x52: //ASCII 'R'

// case 0x72: //ASCII 'r'

// Serial.println(F("Setting both motors to reverse"));

// Serial1.println(F("Setting both motors to reverse"));

// bIsForwardDir = false;

// //MoveReverse(speed, speed);

// break;

// case 0x46: //ASCII 'F'

// case 0x66: //ASCII 'f'

// Serial.println(F("Setting both motors to forward"));

// Serial1.println(F("Setting both motors to forward"));

// bIsForwardDir = true;

// MoveAhead(speed, speed);

//#pragma endregion MANUALCONTROL

// break;

//#pragma region WALL OFFSET TRACKING CASES

// //left side wall tracking

// case 0x4C: //ASCII 'L'

// case 0x6C: //ASCII 'l'

// StopBothMotors();

// Serial.println(F("Setting Kp value"));

// //consume CR/LF chars

// while (Serial.available() > 0)

// {

// int byte = Serial.read();

// Serial.printf("consumed %d\n", byte);

// }

// while (!Serial.available())

// {

// }

// Serial.readBytes(buff, bufflen);

// Serial.printf("%s\n", buff);

// /* extract Kp */

// token = strtok(buff, s);

// Kp = atof(token);

// /* extract Ki */

// token = strtok(NULL, s);

// Ki = atof(token);

// /* extract Kd */

// token = strtok(NULL, s);

// Kd = atof(token);

// /* extract Offset in cm */

// token = strtok(NULL, s);

// OffsetCm = atof(token);

// Serial.printf("Kp,Ki,Kd,OffsetCm = %2.2f, %2.2f, %2.2f, %2.2f\n",

// Kp, Ki, Kd, OffsetCm);

// //TrackLeftWallOffset(Kp, Ki, Kd, OffsetCm);

// break;

// case 0x4D: //ASCII 'M'

// case 0x6D: //ASCII 'm'

// StopBothMotors();

// Serial.println(F("Setting Kp value"));

// //consume CR/LF chars

// while (Serial.available() > 0)

// {

// int byte = Serial.read();

// Serial.printf("consumed %d\n", byte);

// }

// while (!Serial.available())

// {

// }

// Serial.readBytes(buff, bufflen);

// Serial.printf("%s\n", buff);

// /* extract Kp */

// token = strtok(buff, s);

// Kp = atof(token);

// /* extract Ki */

// token = strtok(NULL, s);

// Ki = atof(token);

// /* extract Kd */

// token = strtok(NULL, s);

// Kd = atof(token);

// /* extract Offset in cm */

// token = strtok(NULL, s);

// OffsetCm = atof(token);

// Serial.printf("Kp,Ki,Kd,OffsetCm = %2.2f, %2.2f, %2.2f, %2.2f\n",

// Kp, Ki, Kd, OffsetCm);

// //TrackRightWallOffset(Kp, Ki, Kd, OffsetCm);

// break;

//#pragma endregion WALL OFFSET TRACKING CASES

// default:

// Serial.println(F("In Default Case: Stopping Motors!"));

// Serial1.println(F("In Default Case: Stopping Motors!"));

// StopBothMotors();

// while (true)

// {

// }

//}

void CheckForUserInput()

{

//Notes:

// 11/21/21 rev to accomodate cmd input from either serial, and output to both

const int bufflen = 3;

char buff[bufflen];

memset(buff, 0, bufflen);

byte incomingByte = 0; //moved here 11/21/21

int numchars = 0;

if (Serial.available() > 0)

{

// read the incoming byte:

//incomingByte = Serial.read();

numchars = Serial.readBytesUntil('\n', buff, sizeof(buff));

incomingByte = buff[0];

// say what you got:

Serial.printf("I received %d chars, first char 0X%X on Serial\n", numchars, incomingByte);

}

//11/21/21 now input can come from Serial1 too

else if (Serial1.available() > 0)

{

// read the incoming byte:

//incomingByte = Serial1.read();

numchars = Serial1.readBytesUntil('\n', buff, sizeof(buff));

incomingByte = buff[0];

// say what you got:

Serial1.printf("I received %d chars, first char 0X%X on Serial1\n", numchars, incomingByte);

}

//11/21/21 incomingByte can come from either serial input

if (incomingByte != 0)

{

//02/18/20 experiment with multiple commands

switch (incomingByte)

{

case 0x55: //ASCII 'U'

case 0x75: //ASCII 'u'

#pragma region FIRMWARE UPDATE

Serial1.println(F("Start Program Update - Send new HEX file!"));

//09/20/21 copied from FlasherX - loop()

if (firmware_buffer_init(&buffer_addr, &buffer_size) == 0)

{

Serial1.printf("unable to create buffer\n");

Serial1.flush();

for (;;) {}

}

Serial1.printf("buffer = %1luK %s (%08lX - %08lX)\n",

buffer_size / 1024, IN_FLASH(buffer_addr) ? "FLASH" : "RAM",

buffer_addr, buffer_addr + buffer_size);

//09/20/21 clear the serial buffer

while (Serial1.available())

{

Serial1.read();

}

// receive hex file via serial, write new firmware to flash, clean up, reboot

update_firmware(&Serial1, buffer_addr, buffer_size); // no return if success

// return from update_firmware() means error or user abort, so clean up and

// reboot to ensure that static vars get boot-up initialized before retry

Serial1.printf("erase FLASH buffer / free RAM buffer...\n");

firmware_buffer_free(buffer_addr, buffer_size);

Serial1.flush();

REBOOT;

break;

#pragma endregion FIRMWARE UPDATE

case 0x43: //ASCII 'C'

case 0x63: //ASCII 'c'

#pragma region MANUALCONTROL

//enter infinite loop for direct remote control

Serial.println(F("ENTERING COMMAND MODE:"));

Serial.println(F("0 = 180 deg CCW Turn"));

Serial.println(F("1 = 180 deg CW Turn"));

Serial.println(F("A = Back to Auto Mode"));

Serial.println(F("S = Stop"));

Serial.println(F("F = Forward"));

Serial.println(F("R = Reverse"));

Serial.println(F(""));

Serial.println(F(" Faster"));

Serial.println(F("\t8"));

Serial.println(F("Left 4\t5 6 Right"));

Serial.println(F("\t2"));

Serial.println(F(" Slower"));

Serial1.println(F("ENTERING COMMAND MODE:"));

Serial1.println(F("0 = 180 deg CCW Turn"));

Serial1.println(F("1 = 180 deg CW Turn"));

Serial1.println(F("A = Back to Auto Mode"));

Serial1.println(F("S = Stop"));

Serial1.println(F("F = Forward"));

Serial1.println(F("R = Reverse"));

Serial1.println(F(""));

Serial1.println(F(" Faster"));

Serial1.println(F("\t8"));

Serial1.println(F("Left 4\t5 6 Right"));

Serial1.println(F("\t2"));

Serial1.println(F(" Slower"));

StopBothMotors();

int speed = 0;

bool bAutoMode = false;

while (Serial.available())

{

incomingByte = Serial.read();

//Serial.printf("I removed 0X%X from Serial\n",incomingByte);

}

while (Serial1.available())

{

incomingByte = Serial1.read();

//Serial1.printf("I removed 0X%X from Serial1\n", incomingByte);

}

incomingByte = 0;

while (!bAutoMode)

{

if (Serial.available() > 0)

{

// read the incoming bytes:

numchars = Serial.readBytesUntil('\n', buff, sizeof(buff));

incomingByte = buff[0];

// say what you got:

Serial.printf("I received %d chars, first char 0X%X on Serial\n", numchars, incomingByte);

while (Serial.available())

{

Serial.read();

Serial.printf("I removed 0X%X from Serial\n",incomingByte);

}

//11/21/21 now input can come from Serial1 too

else if (Serial1.available() > 0)

{

// read the incoming bytes:

numchars = Serial1.readBytesUntil('\n', buff, sizeof(buff));

incomingByte = buff[0];

// say what you got:

Serial1.printf("I received %d chars, first char 0X%X on Serial1\n", numchars, incomingByte);

while (Serial1.available())

{

Serial1.read();

Serial1.printf("I removed 0X%X from Serial1\n", incomingByte);

}

//11/21/21 incomingByte can come from either serial input

if (incomingByte != 0)

{

switch (incomingByte)

{

case 0x30: //Dec '0'

Serial.println(F("CCW 180 deg Turn"));

Serial1.println(F("CCW 180 deg Turn"));

SpinTurn(true, 180, 90);

MoveAhead(speed, speed);

break;

case 0x31: //Dec '1'

Serial.println(F("CW 180 deg Turn"));

Serial1.println(F("CW 180 deg Turn"));

SpinTurn(false, 180, 45);

break;

case 0x34: //Turn left 10 deg and keep moving

Serial.println(F("CCW 10 deg Turn"));

Serial1.println(F("CCW 10 deg Turn"));

SpinTurn(true, 10, 30);

if (bIsForwardDir)

{

MoveAhead(speed, speed);

}

else

{

MoveReverse(speed, speed);

}

break;

case 0x36: //Turn right 10 deg and keep moving

Serial.print("CW 10 deg Turn\n");

Serial1.print("CW 10 deg Turn\n");

SpinTurn(false, 10, 30);

//added 05/03/20

if (bIsForwardDir)

{

MoveAhead(speed, speed);

}

else

{

MoveReverse(speed, speed);

}

break;

case 0x38: //Speed up

speed += 50;

speed = (speed >= MOTOR_SPEED_MAX) ? MOTOR_SPEED_MAX : speed;

Serial.printf("Speeding up: speed now %d\n", speed);

Serial1.printf("Speeding up: speed now %d\n", speed);

if (bIsForwardDir)

{

MoveAhead(speed, speed);

}

else

{

MoveReverse(speed, speed);

}

break;

case 0x32: //Slow down

speed -= 50;

speed = (speed < 0) ? 0 : speed;

Serial.printf("Slowing down: speed now %d\n", speed);

Serial1.printf("Slowing down: speed now %d\n", speed);

if (bIsForwardDir)

{

MoveAhead(speed, speed);

}

else

{

MoveReverse(speed, speed);

}

break;

case 0x35: //05/07/20 changed to use '5' vs 'S'

Serial.println(F("Stopping Motors!"));

Serial1.println(F("Stopping Motors!"));

StopBothMotors();

speed = 0;

break;

case 0x41: //ASCII 'A'

case 0x61: //ASCII 'a'

StopBothMotors();

Serial.println(F("Re-entering AUTO mode"));

Serial1.println(F("Re-entering AUTO mode"));

bAutoMode = true;

break;

case 0x52: //ASCII 'R'

case 0x72: //ASCII 'r'

Serial.println(F("Setting both motors to reverse"));

Serial1.println(F("Setting both motors to reverse"));

bIsForwardDir = false;

//MoveReverse(speed, speed);

break;

case 0x46: //ASCII 'F'

case 0x66: //ASCII 'f'

Serial.println(F("Setting both motors to forward"));

Serial1.println(F("Setting both motors to forward"));

bIsForwardDir = true;

MoveAhead(speed, speed);

#pragma endregion MANUALCONTROL

break;

default:

Serial.println(F("In Default Case: Stopping Motors!"));

Serial1.println(F("In Default Case: Stopping Motors!"));

StopBothMotors();

//while (true)

//{

//}

}

incomingByte = 0;

}

#pragma region MOTOR SUPPORT

//09/08/20 modified for DRV8871 motor driver

void MoveReverse(int leftspeednum, int rightspeednum)

{

//Purpose: Move in reverse direction continuously - companion to MoveAhead()

//ProvEnA_Pinnce: G. Frank Paynter 09/08/18

//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 reverse direction for both wheels

// Step 2: Run both Motors at specified speeds

//Notes:

// 01/22/20 now using Adafruit DRV8871 drivers

//Step 1: Set reverse direction and speed for both wheels

SetLeftMotorDirAndSpeed(REV_DIR, leftspeednum);

SetRightMotorDirAndSpeed(REV_DIR, rightspeednum);

}

//09/08/20 modified for DRV8871 motor driver

void MoveAhead(int leftspeednum, int rightspeednum)

{

//Purpose: Move ahead continuously

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

//Notes:

// 01/22/20 now using Adafruit DRV8871 drivers

//Serial1.printf("InMoveAhead(%d,%d)\n", leftspeednum, rightspeednum);

//Step 1: Set forward direction and speed for both wheels

SetLeftMotorDirAndSpeed(true, leftspeednum);

SetRightMotorDirAndSpeed(true, rightspeednum);

}

//09/08/20 modified for DRV8871 motor driver

//11/04/21 modified for Pololu VNH5019 motor driver

void StopLeftMotors()

{

digitalWrite(InA_Left, LOW);

digitalWrite(InB_Left, LOW);

analogWrite(Spd_Left, MOTOR_SPEED_OFF);

}

//11/04/21 modified for Pololu VNH5019 motor driver

void StopRightMotors()

{

digitalWrite(InA_Right, LOW);

digitalWrite(InB_Right, LOW);

analogWrite(Spd_Right, MOTOR_SPEED_OFF);

}

//09/08/20 added bool bisFwd param for DRV8871 motor driver

void RunBothMotors(bool bisFwd, 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:

// Step 1: Apply drive to both wheels

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

//Step 1: Apply drive to both wheels

//DEBUG!!

//Serial1.printf("In RunBothMotors(%s, %d,%d)\n", bisFwd? "FWD":"REV", leftspeednum, rightspeednum);

//DEBUG!!

SetLeftMotorDirAndSpeed(bisFwd, leftspeednum);

SetRightMotorDirAndSpeed(bisFwd, rightspeednum);

}

void RunBothMotorsBidirectional(int leftspeed, int rightspeed)

{

//Purpose: Accommodate the need for independent bidirectional wheel motion

//Inputs:

// leftspeed - integer denoting left wheel speed. Positive value is fwd, negative is rev

// rightspeed - integer denoting right wheel speed. Positive value is fwd, negative is rev

//Outputs:

// left/right wheel motors direction and speed set as appropriate

//Plan:

// Step1: Set left wheel direction and speed

// Step2: Set right wheel direction and speed

//Step1: Set left wheel direction and speed

//DEBUG!!

//Serial1.printf("In RunBothMotorsBidirectional(%d, %d)\n", leftspeed, rightspeed);

if (leftspeed < 0)

{

SetLeftMotorDirAndSpeed(false, -leftspeed); //neg value ==> reverse

}

else

{

SetLeftMotorDirAndSpeed(true, leftspeed); //pos or zero value ==> fwd

}

//Step2: Set right wheel direction and speed

if (rightspeed < 0)

{

SetRightMotorDirAndSpeed(false, -rightspeed); //neg value ==> reverse

}

else

{

SetRightMotorDirAndSpeed(true, rightspeed); //pos or zero value ==> fwd

}

//09/08/20 added bool bisFwd param for DRV8871 motor driver

void RunBothMotorsMsec(bool bisFwd, int timeMsec, int leftspeednum, int rightspeednum)

{

//Purpose: Run both Motors for timesec seconds at speednum speed

//Inputs:

// timesec = time in seconds to run the Motors

// speednum = speed value (0 = OFF, 255 = full speed)

//Outputs: Both Motors run for timesec seconds at speednum speed

//Plan:

// Step 1: Apply drive to both wheels

// Step 2: Delay timsec seconds

// Step 3: Remove drive from both wheels.

//Notes:

// 01/14/15 - added left/right speed offset for straightness compensation

// 01/22/15 - added code to restrict fast/slow values

// 11/25/15 - rev to use motor driver class object

// 09/08/20 added bool bisFwd param for DRV8871 motor driver

RunBothMotors(bisFwd, leftspeednum, rightspeednum);

//Step 2: Delay timsec seconds

delay(timeMsec);

//Step3: Stop motors added 04/12/21

StopBothMotors();

}

//11/25/15 added for symmetry ;-).

void StopBothMotors()

{

StopLeftMotors();

StopRightMotors();

}

void SetLeftMotorDirAndSpeed(bool bIsFwd, int speed)

{

//DEBUG!!

//Serial.printf("In SetLeftMotorDirAndSpeed(%s, %d)\n",

// (bIsFwd == true) ? "true" : "false", speed);

//Serial1.printf("In SetLeftMotorDirAndSpeed(%s, %d)\n",

// (bIsFwd == true) ? "true" : "false", speed);

//DEBUG!!

//11/04/21 fwd for right motors is CCW when looking at shaft

#ifndef NO_MOTORS

if (bIsFwd)

{

digitalWrite(InA_Left, LOW);

digitalWrite(InB_Left, HIGH);

analogWrite(Spd_Left, speed);

//DEBUG!!

//Serial.printf("In TRUE block of SetLeftMotorDirAndSpeed(%s, %d)\n",

// (bIsFwd == true) ? "true" : "false", speed);

//Serial1.printf("In TRUE block of SetLeftMotorDirAndSpeed(%s, %d)\n",

// (bIsFwd == true) ? "true" : "false", speed);

//DEBUG!!

}

else

{

//DEBUG!!

//Serial.printf("In FALSE block of SetLeftMotorDirAndSpeed(%s, %d)\n",

// (bIsFwd == true) ? "true" : "false", speed);

//Serial1.printf("In FALSE block of SetLeftMotorDirAndSpeed(%s, %d)\n",

// (bIsFwd == true) ? "true" : "false", speed);

//DEBUG!!

digitalWrite(InA_Left, HIGH);

digitalWrite(InB_Left, LOW);

analogWrite(Spd_Left, speed);

}

#endif // !NO_MOTORS

}

void SetRightMotorDirAndSpeed(bool bIsFwd, int speed)

{

//DEBUG!!

//Serial.printf("In SetRightMotorDirAndSpeed(%s, %d)\n",

// (bIsFwd == true) ? "true" : "false", speed);

//Serial1.printf("In SetRightMotorDirAndSpeed(%s, %d)\n",

// (bIsFwd == true) ? "true" : "false", speed);

//DEBUG!!

//11/04/21 fwd for right motors is CW when looking at shaft

#ifndef NO_MOTORS

if (bIsFwd)

{

//DEBUG!!

//Serial.printf("In TRUE block of SetRighttMotorDirAndSpeed(%s, %d)\n",

// (bIsFwd == true) ? "true" : "false", speed);

//Serial1.printf("In TRUE block of SetRighttMotorDirAndSpeed(%s, %d)\n",

// (bIsFwd == true) ? "true" : "false", speed);

//DEBUG!!

digitalWrite(InA_Right, HIGH);

digitalWrite(InB_Right, LOW);

analogWrite(Spd_Right, speed);

}

else

{

//DEBUG!!

//Serial.printf("In FALSE block of SetRightMotorDirAndSpeed(%s, %d)\n",

// (bIsFwd == true) ? "true" : "false", speed);

//Serial1.printf("In FALSE block of SetRightMotorDirAndSpeed(%s, %d)\n",

// (bIsFwd == true) ? "true" : "false", speed);

//DEBUG!!

digitalWrite(InA_Right, LOW);

digitalWrite(InB_Right, HIGH);

analogWrite(Spd_Right, speed);

}

#endif // !NO_MOTORS

}

#pragma endregion Motor Support Functions

#pragma region HDG_BASED_TURN_SUPPORT

bool SpinTurn(bool b_ccw, float numDeg, float degPersec) //04/25/21 added turn-rate arg (default = TURN_RATE_TARGET_DEGPERSEC)

{

//Purpose: Make a numDeg CW or CCW 'spin' turn

//Inputs:

// b_ccw - True if turn is to be ccw, false otherwise

// numDeg - angle to be swept out in the turn

// ROLLING_TURN_MAX_SEC_PER_DEG = const used to generate timeout proportional to turn deg

// IMUHdgValDeg = IMU heading value updated by UpdateIMUHdgValDeg() //11/02/20 now updated in ISR

// degPerSec = float value denoting desired turn rate

//Plan:

// Step1: Get current heading as starting point

// Step2: Disable TIMER5 interrupts

// Step3: Compute new target value & timeout value

// Step4: Run motors until target reached, using inline PID algorithm to control turn rate

// Step5: Re-enable TIMER5 interrupts

//Notes:

// 06/06/21 we-written to remove PID library - now uses custom 'PIDCalcs()' function

// 06/06/21 added re-try for 180.00 return from IMU - could be bad value

// 06/11/21 added code to correct dHdg errors due to 179/-179 transition & bad IMU values

// 06/12/21 cleaned up & commented out debug code

// 11/14/21 removed 'first time skip' block; added motor start before entering loop

float tgt_deg;

float timeout_sec;

bool bDoneTurning = false;

bool bTimedOut = false;

bool bResult = true; //04/21/20 added so will be only one exit point

//DEBUG!!

Serial.printf("In SpinTurn(%s, %2.2f, %2.2f)\n", b_ccw == TURNDIR_CCW ? "CCW" : "CW", numDeg, degPersec);

Serial1.printf("In SpinTurn(%s, %2.2f, %2.2f)\n", b_ccw == TURNDIR_CCW ? "CCW" : "CW", numDeg, degPersec);

//Serial.printf("TurnRatePID started with Kp/Ki/Kd = %2.1f,%2.1f,%2.1f, SampleTime(mSec) = %d\n",

//TurnRate_Kp, TurnRate_Ki, TurnRate_Kd, TURN_RATE_UPDATE_INTERVAL_MSEC);

//DEBUG!!

//no need to continue if the IMU isn't available

if (!dmpReady)

{

Serial.printf("DMP Failure - returning FALSE\n");

return false;

}

//Step1: Get current heading as starting point

//06/06/21 it is possible for IMU to return 180.00 on failure

//so try again. If it really IS 180, then

//it will eventually time out and go on

//08/26/21 re-wrote using 3-value array to make sure initial heading is a steady value

UpdateIMUHdgValDeg();

int retries = 0;

if ((IMUHdgValDeg == 180.f || IMUHdgValDeg == 0.f) && retries < 5)

{

//DEBUG!!

Serial.printf("Got 180.00 or 0.00 exactly (%2.3f) from IMU - retrying %d...\n", IMUHdgValDeg, retries);

Serial1.printf("Got 180.00 or 0.00 exactly (%2.3f) from IMU - retrying %d...\n", IMUHdgValDeg, retries);

//DEBUG!!

UpdateIMUHdgValDeg();

retries++;

delay(100);

}

//Step2: Compute new target value & timeout value

//timeout_sec = 3 * numDeg / degPersec; //05/29/21 rev to use new turn rate parmeter

timeout_sec = 2 * numDeg / degPersec; //05/29/21 rev to use new turn rate parmeter

//05/17/20 limit timeout_sec to 1 sec or more

timeout_sec = (timeout_sec < 1) ? 1.f : timeout_sec;

//12/05/19 added #define back in to manage which direction increases yaw values

#ifdef MPU6050_CCW_INCREASES_YAWVAL

tgt_deg = b_ccw ? IMUHdgValDeg + numDeg : IMUHdgValDeg - numDeg;

#else

tgt_deg = b_ccw ? IMUHdgValDeg - numDeg : IMUHdgValDeg + numDeg;

#endif // MPU6050_CCW_INCREASES_YAWVAL

//correct for -180/180 transition

if (tgt_deg < -180)

{

tgt_deg += 360;

}

//07/29/19 bugfix

if (tgt_deg > 180)

{

tgt_deg -= 360;

}

//DEBUG!!

Serial.printf("Init hdg = %4.2f deg, Turn = %4.2f deg, tgt = %4.2f deg, timeout = %4.2f sec\n\n",

IMUHdgValDeg, numDeg, tgt_deg, timeout_sec);

Serial1.printf("Init hdg = %4.2f deg, Turn = %4.2f deg, tgt = %4.2f deg, timeout = %4.2f sec\n\n",

IMUHdgValDeg, numDeg, tgt_deg, timeout_sec);

//DEBUG!!

float curHdgMatchVal = 0;

//09/08/18 added to bolster end-of-turn detection

float prevHdgMatchVal = 0;

float matchSlope = 0;

//Step3: Run motors until target reached, using PID algorithm to control turn rate

Prev_HdgDeg = IMUHdgValDeg; //06/10/21 synch Prev_HdgDeg & IMUHdgValDeg just before entering loop

//11/14/21 start motors before entering loop. For CCW turn, left motors go backwards, right ones forward

int startSpd = (degPersec <= 45) ? TURN_START_SPEED : 2 * TURN_START_SPEED;

SetLeftMotorDirAndSpeed(!b_ccw, startSpd);

SetRightMotorDirAndSpeed(b_ccw, startSpd);

elapsedMillis sinceLastTimeCheck = 0;

elapsedMillis sinceLastComputeTime = 0;

double lastError = 0;

double lastInput = 0;

double lastIval = 0;

double lastDerror = 0;

//bool bFirstIMUHdg = true;

//DEBUG!!

Serial.printf("Msec\tHdg\tPrvHdg\tdHdg\tRate\ttgtDPS\terr\tKp*err\tIval\tKd*Derr\tspeed\tMatch\tSlope\n");

Serial1.printf("Msec\tHdg\tPrvHdg\tdHdg\tRate\ttgtDPS\terr\tKp*err\tIval\tKd*Derr\tspeed\tMatch\tSlope\n");

//DEBUG!!

while (!bDoneTurning && !bTimedOut)

{

//11/06/20 now just loops between PID calcs

CheckForUserInput();

if (sinceLastComputeTime >= TURN_RATE_UPDATE_INTERVAL_MSEC)

{

sinceLastComputeTime -= TURN_RATE_UPDATE_INTERVAL_MSEC;

UpdateIMUHdgValDeg(); //update IMUHdgValDeg

double dHdg = IMUHdgValDeg - Prev_HdgDeg;

if (dHdg > 180)

{

dHdg -= 360;

//Serial.printf("dHdg > 180 - subtracting 360\n");

}

else if (dHdg < -180)

{

dHdg += 360;

//Serial.printf("dHdg < -180 - adding 360\n");

}

//watch for turn rates that are wildly off

double rate = abs(1000 * dHdg / TURN_RATE_UPDATE_INTERVAL_MSEC);

//if (rate > 3 * degPersec)

//{

// //DEBUG!!

// Serial.printf("hdg/prevhdg/dHdg/rate = %2.2f\t%2.2f\t%2.2f\t%2.2f, excessive rate - replacing with %2.2f\n", IMUHdgValDeg, Prev_HdgDeg, dHdg, rate, degPersec);

// //DEBUG!!

// rate = degPersec;

//}

TurnRatePIDOutput = PIDCalcs(rate, degPersec, TURN_RATE_UPDATE_INTERVAL_MSEC, lastError, lastInput, lastIval, lastDerror, TurnRate_Kp, TurnRate_Ki, TurnRate_Kd);

int speed = 0;

(TurnRatePIDOutput > MOTOR_SPEED_MAX) ? speed = MOTOR_SPEED_MAX : speed = (int)TurnRatePIDOutput;

(TurnRatePIDOutput <= MOTOR_SPEED_LOW) ? speed = MOTOR_SPEED_LOW : speed = (int)TurnRatePIDOutput;

SetLeftMotorDirAndSpeed(!b_ccw, speed);

SetRightMotorDirAndSpeed(b_ccw, speed);

//check for nearly there and all the way there

curHdgMatchVal = GetHdgMatchVal(tgt_deg, IMUHdgValDeg);

matchSlope = curHdgMatchVal - prevHdgMatchVal;

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

millis(),

IMUHdgValDeg,

Prev_HdgDeg,

dHdg,

rate,

degPersec,

lastError,

TurnRate_Kp * lastError,

lastIval,

TurnRate_Kd * lastDerror,

speed,

curHdgMatchVal,

matchSlope);

Serial1.printf("%lu\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%d\t%2.2f\t%2.2f\n",

millis(),

IMUHdgValDeg,

Prev_HdgDeg,

dHdg,

rate,

degPersec,

lastError,

TurnRate_Kp * lastError,

lastIval,

TurnRate_Kd * lastDerror,

speed,

curHdgMatchVal,

matchSlope);

//DEBUG!!

Prev_HdgDeg = IMUHdgValDeg; //re-synch prev to curr hdg for next time

//look for full match

bDoneTurning = (curHdgMatchVal >= HDG_FULL_MATCH_VAL

|| (prevHdgMatchVal >= HDG_MIN_MATCH_VAL && matchSlope <= -0.01)); //have to use < vs <= as slope == 0 at start

//Serial.printf("curHdgMatchVal = %2.2f, prevHdgMatchVal = %2.2f, matchslope = %2.2f, bDoneTurning = %d\n",

// curHdgMatchVal,

// prevHdgMatchVal,

// matchSlope,

// bDoneTurning);

prevHdgMatchVal = curHdgMatchVal; //07/31/21 moved below bDoneTurning chk so can use prevHdgMatchVal vs curHdgMatchVal in slope check

bTimedOut = (sinceLastTimeCheck > timeout_sec * 1000);

if (bTimedOut)

{

//DEBUG!!

Serial.printf("timed out with yaw = %3.2f, tgt = %3.2f, and match = %1.3f\n", IMUHdgValDeg, tgt_deg, curHdgMatchVal);

Serial1.printf("timed out with yaw = %3.2f, tgt = %3.2f, and match = %1.3f\n", IMUHdgValDeg, tgt_deg, curHdgMatchVal);

//DEBUG!!

bResult = false;

break;

}

if (bDoneTurning)

{

Serial.printf("Completed turn with yaw = %3.2f, tgt = %3.2f, and match = %1.3f\n", IMUHdgValDeg, tgt_deg, curHdgMatchVal);

Serial1.printf("Completed turn with yaw = %3.2f, tgt = %3.2f, and match = %1.3f\n", IMUHdgValDeg, tgt_deg, curHdgMatchVal);

bResult = true;

break;

}

StopBothMotors();

delay(1000); //added 04/27/21 for debug

return bResult;

}

double PIDCalcs(double input, double setpoint, uint16_t sampleTime, double& lastError, double& lastInput, double& lastIval, double& lastDerror, double Kp, double Ki, double Kd)

{

//Purpose: Encapsulate PID algorithm so can get rid of PID library. Library too cumbersome and won't synch with TIMER5 ISR

//Inputs:

// input = double denoting current input value (turn rate, speed, whatever)

// setpoint = double denoting desired setpoint in same units as input

// sampleTime = int denoting sample time to be used in calcs.

// lastError = ref to double denoting error saved from prev calc

// lastInput = ref to double denoting input saved from prev calc

// Kp/Ki/Kd = doubles denoting PID values to be used for calcs

// Output = ref to double denoting output from calc

double error = setpoint - input;

//double dInput = (input - lastInput);

//lastIval += (error);

lastIval += (Ki * error);

//11/16/21 rev to clamp integral term

lastIval = (lastIval > MOTOR_SPEED_MAX) ? MOTOR_SPEED_MAX : lastIval;

lastIval = (lastIval < MOTOR_SPEED_OFF) ? MOTOR_SPEED_OFF : lastIval;

double dErr = (error - lastError);

//Serial.printf("PIDCalcs: error/dInput/lastIval/dErr/kp/ki/kd = %2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\t%2.2f\n", error, dInput, lastIval, dErr,

// Kp,Ki,Kd);

/*Compute PID Output*/

//11/16/21 rev to subtract differential term rather than add.

//double output = Kp * error + Ki * lastIval + Kd * dErr;

double output = Kp * error + lastIval - Kd * dErr;

//11/16/21 now clamping output value as well as I term

output = (output > MOTOR_SPEED_MAX) ? MOTOR_SPEED_MAX : output;

output = (output < MOTOR_SPEED_OFF) ? MOTOR_SPEED_OFF : output;

/*Remember some variables for next time*/

lastError = error;

lastInput = input;

lastDerror = dErr;

return output; //added 09/03/21

}

float GetHdgMatchVal(float tgt_deg, float cur_deg)

{

//Purpose: Compute the match ratio between two compass headings

//Inputs:

// tgt_deg = float representing target heading in +/-180 range

// IMUHdgValDeg = float representing sensor yaw value in +/-180 deg range

//Outputs:

// returns result of 1 - abs(Tgt_deg - Hdg_deg)/180, all angles in 0-360 deg range

//Plan:

// Step1: convert both inputs to 0-360 deg range

// Step2: compute match ratio

//Notes:

// formula from https://gis.stackexchange.com/questions/129954/comparing-compass-bearings

//Step1: convert both inputs to 0-360 deg range

float tgthdg = (tgt_deg < 0) ? tgt_deg + 360 : tgt_deg;

float curhdg = (cur_deg < 0) ? cur_deg + 360 : cur_deg;

//Step2: compute match ratio

float match_ratio = 1 - abs(tgthdg - curhdg) / 180;

//DEBUG!!

//Serial1.printf("tgt\tcur\tmatch = %4.2f\t%4.2f\t%1.3f\n", tgthdg, curhdg, match_ratio);

//DEBUG!!

return abs(match_ratio);

}

float UpdateIMUHdgValDeg()

{

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

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

// 05/05/20 changed return type to float vs bool.

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

IMUHdgValDeg = ypr[0] * 180 / M_PI;

}

return IMUHdgValDeg;//05/05/20 now returns updated value for use convenience

}

uint8_t GetCurrentFIFOPacket(uint8_t* data, uint8_t length, uint16_t max_loops)

{

mpu.resetFIFO();

delay(1);

//int countloop = 0;

fifoCount = mpu.getFIFOCount();

GetPacketLoopCount = 0;

//Serial1.printf("In GetCurrentFIFOPacket: before loop fifoC = %d\t", fifoCount);

while (fifoCount < packetSize && GetPacketLoopCount < max_loops)

{

GetPacketLoopCount++;

fifoCount = mpu.getFIFOCount();

delay(2);

}

//Serial1.printf("In GetCurrentFIFOPacket: after loop fifoC = %d, loop count = %d\n", fifoCount, GetPacketLoopCount);

if (GetPacketLoopCount >= max_loops)

{

return 0;

}

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

mpu.getFIFOBytes(data, packetSize);

return 1;

}

//void BackupAndTurn90Deg(bool b_ccw, bool b_fwd, int motor_speed)

//{

// //Purpose: Backup 1 second and then turn 90 degrees

// //Provenance: G. Frank Paynter 06/27/2020

// //Inputs:

// // bIsCCW = bool denoting direction for the turn

// // bIsFwd = bool denoting fwd/bkwd direction for the turn

// // motor_speed = int denoting motor speed to use for the maneuver

// //Outputs:

// // Robot backs up 1 sec, then turns 90 deg in the specified direction

// //Plan:

// // Step1: Back up for 1 sec

// // Step2: Turn 90 deg in specified direction

// //Notes:

// // 06/27/20 Replaces BackupAndTurn in all Tracking modes

// //10/13/20 rev to terminate backup at Wall Offset Distance

////Step1: Back up for 1 sec

// BackupSignal(true); //turn backup LEDs ON

// MoveReverse(MOTOR_SPEED_HALF, MOTOR_SPEED_HALF);

// //delay(1000);

// //10/13/20 rev to terminate backup at Wall Offset Distance

// while (frontdistval < WALL_OFFSET_TGTDIST_CM && !bIsStuck)

// {

// if (bTimeForNavUpdate) //wait for next ISR hit

// {

// bTimeForNavUpdate = false;

// Serial.print(F("BackupAndTurn90Deg: ")); Serial1.printf("%lu\t% d\n", millis(), frontdistval);

// }

// BackupSignal(false);//turn them back OFF

// //Serial1.printf("BackupAndTurn90Deg terminated with frontdist = %d\n", frontdistval);

// Serial.print(F("BackupAndTurn90Deg terminated with frontdist = ")); Serial1.printf("%d\n", frontdistval);

// //Step2: Turn 90 deg fwd or backward in specified direction

// SpinTurn(b_ccw, 90); //06/27/20 experiment

//}

#pragma endregion HDG_BASED_TURN_SUPPORT

#pragma region FLASHER_X

//09/20/21 copied from FlasherX

//******************************************************************************

// update_firmware() read hex file and write new firmware to program flash

//******************************************************************************

void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size)

{

static char line[96]; // buffer for hex lines

static char data[32] __attribute__((aligned(8))); // buffer for hex data

hex_info_t hex = { // intel hex info struct

data, 0, 0, 0, // data,addr,num,code

0, 0xFFFFFFFF, 0, // base,min,max,

0, 0 // eof,lines

};

serial->printf("waiting for hex lines...\n");

// read and process intel hex lines until EOF or error

//DEBUG!!

//int line_num = 0;

//DEBUG!!

long int start_msec = 0;

bool bFirstTime = true;

while (!hex.eof) {

read_ascii_line(serial, line, sizeof(line));

if (bFirstTime)

{

start_msec = millis();

bFirstTime = false;

}

//DEBUG!!

//serial->printf("%d: %s\n", line_num, line);

//line_num++;

//DEBUG!!

//10/02/21 gfp added for visual xfer confirmation

if (hex.lines % 10 == 0)

{

digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN));

}

// reliability of transfer via USB is improved by this printf/flush

if (serial == (Stream*)&Serial)

{

serial->printf("%s\n", line);

serial->flush();

}

if (parse_hex_line((const char*)line, hex.data, &hex.addr, &hex.num, &hex.code) == 0) {

serial->printf("abort - bad hex line %s\n", line);

return;

}

else if (process_hex_record(&hex) != 0) { // error on bad hex code

serial->printf("abort - invalid hex code %d\n", hex.code);

return;

}

else if (hex.code == 0) { // if data record

uint32_t addr = buffer_addr + hex.base + hex.addr - FLASH_BASE_ADDR;

if (hex.max > (FLASH_BASE_ADDR + buffer_size)) {

serial->printf("abort - max address %08lX too large\n", hex.max);

return;

}

else if (!IN_FLASH(buffer_addr)) {

memcpy((void*)addr, (void*)hex.data, hex.num);

}

else if (IN_FLASH(buffer_addr)) {

int error = flash_write_block(addr, hex.data, hex.num);

if (error) {

serial->printf("abort - error %02X in flash_write_block()\n", error);

return;

}

hex.lines++;

}

//serial->printf("\nhex file: %1d lines %1lu bytes (%08lX - %08lX)\n",

// hex.lines, hex.max - hex.min, hex.min, hex.max);

serial->printf("\nhex file: %1d lines %1lu bytes (%08lX - %08lX), %lu Msec\n",

hex.lines, hex.max - hex.min, hex.min, hex.max, millis() - start_msec);

// check FSEC value in new code -- abort if incorrect

#if defined(KINETISK) || defined(KINETISL)

uint32_t value = *(uint32_t*)(0x40C + buffer_addr);

if (value == 0xfffff9de) {

serial->printf("new code contains correct FSEC value %08lX\n", value);

}

else {

serial->printf("abort - FSEC value %08lX should be FFFFF9DE\n", value);

return;

}

#endif

// check FLASH_ID in new code - abort if not found

if (check_flash_id(buffer_addr, hex.max - hex.min)) {

serial->printf("new code contains correct target ID %s\n", FLASH_ID);

}

else {

serial->printf("abort - new code missing string %s\n", FLASH_ID);

return;

}

// get user input to write to flash or abort

int user_lines = -1;

while (user_lines != hex.lines && user_lines != 0) {

serial->printf("enter %d to flash or 0 to abort\n", hex.lines);

read_ascii_line(serial, line, sizeof(line));

sscanf(line, "%d", &user_lines);

}

if (user_lines == 0) {

serial->printf("abort - user entered 0 lines\n");

return;

}

// move new program from buffer to flash, free buffer, and reboot

//serial->printf("user entered %d lines\n", user_lines);

flash_move(FLASH_BASE_ADDR, buffer_addr, hex.max - hex.min);

// should not return from flash_move(), but put REBOOT here as reminder

REBOOT;

}

//******************************************************************************

// read_ascii_line() read ascii characters until '\n', '\r', or max bytes

//******************************************************************************

void read_ascii_line(Stream* serial, char* line, int maxbytes)

{

int c = 0, nchar = 0;

while (nchar < maxbytes && !(c == '\n' || c == '\r')) {

if (serial->available()) {

c = serial->read();

line[nchar++] = c;

}

line[nchar - 1] = 0; // null-terminate

}

//******************************************************************************

// process_hex_record() process record and return okay (0) or error (1)

//******************************************************************************

int process_hex_record(hex_info_t* hex)

{

if (hex->code == 0) { // data -- update min/max address so far

if (hex->base + hex->addr + hex->num > hex->max)

hex->max = hex->base + hex->addr + hex->num;

if (hex->base + hex->addr < hex->min)

hex->min = hex->base + hex->addr;

}

else if (hex->code == 1) { // EOF (:flash command not received yet)

hex->eof = 1;

}

else if (hex->code == 2) { // extended segment address (top 16 of 24-bit addr)

hex->base = ((hex->data[0] << 8) | hex->data[1]) << 4;

}

else if (hex->code == 3) { // start segment address (80x86 real mode only)

return 1;

}

else if (hex->code == 4) { // extended linear address (top 16 of 32-bit addr)

hex->base = ((hex->data[0] << 8) | hex->data[1]) << 16;

}

else if (hex->code == 5) { // start linear address (32-bit big endian addr)

hex->base = (hex->data[0] << 24) | (hex->data[1] << 16)

| (hex->data[2] << 8) | (hex->data[3] << 0);

}

else {

return 1;

}

return 0;

}

//******************************************************************************

// Intel Hex record foramt:

// Start code: one character, ASCII colon ':'.

// Byte count: two hex digits, number of bytes (hex digit pairs) in data field.

// Address: four hex digits

// Record type: two hex digits, 00 to 05, defining the meaning of the data field.

// Data: n bytes of data represented by 2n hex digits.

// Checksum: two hex digits, computed value used to verify record has no errors.

// Examples:

// :10 9D30 00 711F0000AD38000005390000F5460000 35

// :04 9D40 00 01480000 D6

// :00 0000 01 FF

//******************************************************************************

/* Intel HEX read/write functions, Paul Stoffregen, paul@ece.orst.edu */

/* This code is in the public domain. Please retain my name and */

/* email address in distributed copies, and let me know about any bugs */

/* I, Paul Stoffregen, give no warranty, expressed or implied for */

/* this software and/or documentation provided, including, without */

/* limitation, warranty of merchantability and fitness for a */

/* particular purpose. */

// type modifications by Jon Zeeff

/* parses a line of intel hex code, stores the data in bytes[] */

/* and the beginning address in addr, and returns a 1 if the */

/* line was valid, or a 0 if an error occured. The variable */

/* num gets the number of bytes that were stored into bytes[] */

#include <stdio.h> // sscanf(), etc.

#include <string.h> // strlen(), etc.

int parse_hex_line(const char* theline, char* bytes,

unsigned int* addr, unsigned int* num, unsigned int* code)

{

unsigned sum, len, cksum;

const char* ptr;

int temp;

*num = 0;

if (theline[0] != ':')

return 0;

if (strlen(theline) < 11)

return 0;

ptr = theline + 1;

if (!sscanf(ptr, "%02x", &len))

return 0;

ptr += 2;

if (strlen(theline) < (11 + (len * 2)))

return 0;

if (!sscanf(ptr, "%04x", (unsigned int*)addr))

return 0;

ptr += 4;

/* Serial1.printf("Line: length=%d Addr=%d\n", len, *addr); */

if (!sscanf(ptr, "%02x", code))

return 0;

ptr += 2;

sum = (len & 255) + ((*addr >> 8) & 255) + (*addr & 255) + (*code & 255);

while (*num != len)

{

if (!sscanf(ptr, "%02x", &temp))

return 0;

bytes[*num] = temp;

ptr += 2;

sum += bytes[*num] & 255;

(*num)++;

if (*num >= 256)

return 0;

}

if (!sscanf(ptr, "%02x", &cksum))

return 0;

if (((sum & 255) + (cksum & 255)) & 255)

return 0; /* checksum error */

return 1;

}

#pragma endregion FLASHER_X

Now that I have turn-rate-based turns working properly, it’s time to turn my attention to the other peripherals – namely the ‘I_total’ and ‘I_run’ 1A169 high-side current sensors, the battery voltage output from the 5V LDO regulator module, and the charge connection status line.

Ported GetTotalAmps(), GetRunningAmps(), IsStillCharging(), IsChargerConnected, and MonitorChargerUntilDone() from FourWD_WallE2_V12.ino.
Ported CHG_SUPP_PARAMETERS into PRE-SETUP
Ported charger support pin init into setup()

After these ports, I got a lot of ‘mySerial was not declared’ errors – not surprising as I needed ‘mySerial’ in the Arduino world to access ‘printf’ formatting, but the Teensy has that feature built-in. After replacing 5 instances of ‘mySerial.’ with ‘Serial1.’, I recompiled – still lots of errors – oh well.

In the Arduino code, I used a function called ‘GetAverageAnalogReading()’ to average A/D readings with a ‘CURRENT_AVERAGE_NUMBER’ parameter. However, in the Teensy world there is a function called

analogReadAveraging(unsigned int num)

1	analogReadAveraging(unsigned int num)

which causes all the ADC channels to average every reading by ‘num’ (where ‘num’ is internally forced to be 0,4,8,16, or 32). So, I can eliminate the ‘GetAverageAnalogReading()’ function entirely for the T3.5, and just use analogRead().

After some minor fumbling around to comment out or bypass non-relevant (to this phase, at least) code, I got the program to compile. Now to test for proper behavior…

Testing for the two 1NA169 current sensors went OK, but I hit a snag when testing the ‘Charger Connected’ line from the charging plug. This line is tied to GND with no jack inserted, and the GND connection is broken when the plug is fully inserted. The pin is initialized for INPUT_PULLUP, meaning the line will be pulled HIGH via the internal pullup resistor when the charging cable is plugged in, and pulled to GND when the plug is removed. My initial pin assignment for this pin was 36/A17, but I discovered this wouldn’t work as some analog inputs didn’t have pullup resistors available. So, I more or less randomly chose pin 28 on the other side for this, only to find out that for no apparent reason, the pullup on pin 28 no longer seemed to exist. The charge connect line indeed measured GND with the plug removed, but only about 0.1-0.2V with the plug engaged, instead of 3.3V as it should. After some screwing around, I finally constructed a very small test program to exercise pins 28-32, whereupon I found that 29-32 operated properly, but 28 refused to behave. I posted about this to the Teensy forum, and another forum member tried my program on one of their T3.5’s and reported that pin 28 behaved properly on their module – rats! In any case, I can move the line to pin 29 no problem, but it’s frustrating to realize that of all the pins I could have picked, I managed to hit the one that misbehaved :(.

25 November 2021 Update (Happy Thanksgiving!)

I’m writing this from the home of my stepson and his family in St. Louis, MO, where we are all gathered for the traditional Turkey Day dinner. Of course I brought my Wall-E3 robot so I could continue to work on bringing it along. While here I managed to get the CHG_CONNECT issue solved, but in the process may have killed another port on the Teensy 3.5. At the moment I have the CHG_CONNECT input assigned to pin 31, and the CHG_CONNECT_LED output assigned to pin 30. Pins 28 and 32 appear to be inactive and might have been casualties in some previous project, or casualties of this one – hard to tell. In any case that all appears to be working now.

The following photo shows the current pin assignments for the T3.5. These may well change before the whole adventure ends, but it’s a good starting point.

29 November 2021 Update:

Here’s my first cut at a system-level schematic for the new Wall-E3 robot:

The above schematic has the same basic layout as for Wall-E2, with the following changes:

The Wixel RF serial extender module has been replaced by the HC-05 Bluetooth module (physically located on the small perf-board module along with the 5V LDO voltage regulator)
The left and right motor drivers are now VNH5019 parts instead of DRV8871
The MPU6050 & IR Detector modules now use their own I2C channel (SDA1/SCL1) instead of everything being serviced on the single I2C channel available on the Mega 2560
The VL53L0X ToF sensor array is still managed by a separate Teensy 3.5, but now is the only device on the primary (SDA0/SCL0) I2C bus

At this point I have verified proper operation for both VNH5019 motor drivers, both 1NA169 inline current sensors, the MPU6050 IMU and the HC-05 Bluetooth module.

The next big milestone is to get the second-deck mounted and verify proper operation of the forward-looking LIDAR and the VL53L0X side and rear ToF distance sensors.

Stay tuned,

Frank

Over-the-Air (OTA) Firmware Updates For Teensy 3 & 4.x, Part II

1 Reply

Posted 16 October 2021,

In my previous post on this subject, I described my effort to automate over-the-air (OTA) updates of a Teensy 3.5 using a C# command-line program called by a post-build script from Visual Studio 2019 with the Visual Micro Arduino IDE extension, combined with Joe Pasquariello’s find ‘FlasherX’ code. As the article described, I was successful in doing this, but the time required to transfer the .HEX file using the C# .NET serial interface appeared to be about 2-3 times slower than that required by using the Tera Term serial comms program manually.

So, I went back to the drawing board, and started searching for a way to automate Tera Term, rather than building my own serial port management applet. I found the Tera Term help index, and subsequently I found that there is indeed a quite rich macro language associated with Tera Term, so I started learning the language and trying to apply it to my problem of using Visual Micro’s post-build commands via the ‘board.txt’ feature to automate the process of OTA for the Teensy microcontroller.

After the normal amount of fumbling around with the macro language, I was able to create a reasonably functional macro file that accepts three arguments from the Visual Micro ‘board.txt’ post-build command line and then automates the process of uploading the associated .HEX file to my Teensy 3.5 and then rebooting the Teensy to run the updated program. The ‘board.txt’ contents are:

# Teensy OTA Demo build property overrides
# 10/05/21 gfp - trying to run a post-build command
# 10/15/21 gfp - change to use Tera Term macro vs custom C# program
recipe.hooks.postbuild.1.pattern=cmd.exe /c "c:\Program Files (x86)\teraterm\ttpmacro.exe" /v "c:\users\Frank\Documents\Arduino\Teensy Projects\TeensyOTADemo\TeensyOTA1.ttl" "{vm.runtime.build.final_output_path}" {serial.port} {build.project_name}

# Teensy OTA Demo build property overrides

# 10/05/21 gfp - trying to run a post-build command

# 10/15/21 gfp - change to use Tera Term macro vs custom C# program

recipe.hooks.postbuild.1.pattern=cmd.exe /c "c:\Program Files (x86)\teraterm\ttpmacro.exe" /v "c:\users\Frank\Documents\Arduino\Teensy Projects\TeensyOTADemo\TeensyOTA1.ttl" "{vm.runtime.build.final_output_path}" {serial.port} {build.project_name}

The post-build command launches the Tera Term Pro Macro interpreter (ttpmacro.exe) and passes three arguments; the first is the build path – the folder in which the compiled .HEX file will be placed. The second is the COM port number assigned to the HC-05 bluetooth link with my laptop, and the third is the project file name, i.e. ‘TeensyOTADemo.INO’.

The Tera Term macro uses the first and third argument to build a path to the compiler’s .HEX file for the project, i.e. <build_path>\<project file name minus extension>.HEX. Then it uses the COM port specified in the second argument to connect to the Teensy and send a ‘trigger character’ to force the Teensy into ‘update mode’, and upload the .HEX file. After the .HEX file has been uploaded, the macro responds to the ‘enter xxxx to update or 0 to abort’ response from the Teensy by sending back the xxxx value, which causes the Teensy to reboot and begin running the new program.

Here is the complete Tera Term macro file:

/*
16 October 2021 G. Frank Paynter
Tera Term macro to connect to Teensy and send latest .HEX file

Tera Term is called via a post-build command in VS2019/VMicro
like <path_to_ttpmacro.exe> /v <path_to_TeensyOTA1.ttl> <build_path>\<project_name>.hex> <COM port>
 
The actual post-build command is contained in the 'board.txt' file as follows:
 recipe.hooks.postbuild.1.pattern=cmd.exe /c "c:\Program Files (x86)\teraterm\ttpmacro.exe" /v "c:\users\Frank\Documents\Arduino\Teensy Projects\TeensyOTADemo\Test2.ttl" "{vm.runtime.build.final_output_path}" {serial.port} {build.project_name}
 
When this is passed to tera term the arguments appear as follows:

BuildPath = param2 ; used to find the .HEX file to transfer, like "C:\Ussers\Frank\Arduino\Teensy Projects\TeensyOTADemo\Release\"
CommPortStr = param3 ;"COMx" where 'x' is the actual number assigned
ProjectFileName = param4 ;project file name like "TeensyOTADemo.ino"
 

 Notes:
	10/16/21: for verbose output, set VERBOSE = 1 (default is 0)
*/
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

VERBOSE = 0; set this to 1 for verbose progress indications


pathtoHexfile = param2
COMportstr = param3
strtrim COMportstr ' ' ; remove any leading/trailing spaces
ComPortNumStr = COMportstr
strremove ComPortNumStr 1 3 ;isolate the com port number
INOfilename = param4

if VERBOSE then
	 sprintf2 msgstr "%s, %s, %s" param2 param3 param4;<param1> is ttl filename
	 messagebox msgstr 'script calling arguments'

	 sprintf2 msgstr "path to HEX file: %s" param2
	 messagebox msgstr 'script calling arguments'
	 sprintf2 msgstr "COM port number: %s" ComPortNumStr
	 messagebox msgstr 'script calling arguments'
	 sprintf2 msgstr "INO filename: %s" param4
	 messagebox msgstr 'script calling arguments'
endif

;connect to Teensy via COM <param2>

if VERBOSE then
	sprintf2 msgstr "attempting to connnect to Teensy on COM%s" ComPortNumStr
	messagebox msgstr 'info'
endif

sprintf2 cnct_str "/C=%s" ComPortNumStr ; actual string used by TT

if VERBOSE then
	messagebox cnct_str 'connect string'
endif

testlink; TT could already be connected
; if result = 0 connect cnct_str; actually launch TT and make the connection. <result> = 2 for success
if result = 0 connect cnct_str; actually launch TT and make the connection. <result> = 2 for success


if result <> 2 then
	sprintf2 errstr "unable to connect to Teensy on %s - aborting" COMportstr
	messagebox errstr "Error"
	goto ERROR ;error exit - closes COM connection and TT
else 
	;if we get to here, we have a valid COM port connection
	if VERBOSE then
		sprintf2 msgstr "sending trigger command (%s) and waiting for %s" "U" "waiting"
		messagebox msgstr "info"
	endif
	
	send 'U' ;actually send the trigger character
	timeout = 5 ; seconds
	wait 'waiting'
	
	if result = 0 then
		messagebox "Oops - timed out waiting for 'waiting' from Teensy" "Error"
		goto ERROR ;error exit - closes COM connection and TT
	else ; OK, got 'waiting'...
		if VERBOSE then
			msgstr = "got 'waiting' string - sending file" 
			messagebox  msgstr 'info'
		endif
		
		hexfilestr = 'C:\Users\Frank\Documents\Arduino\Teensy Projects\TeensyOTADemo\Release\TeensyOTADemo.hex'
		if VERBOSE then
			messagebox hexfilestr 'sendfile'
		endif
		sendfile hexfilestr 0 ;actually send the file. Note the 0 is required to make it work
		
		;now we have to extract the number of lines from the 'enter xxxx to flash...' string
		wait 'enter' ;get the next line from Teensy
		if result = 0 then
			messagebox "Oops - timed out waiting for 'enter' from Teensy" "Error"
			goto ERROR ;error exit - closes COM connection and TT
		else ; OK, got 'enter'...
			if VERBOSE then
				msgstr = "got string containing 'enter'"
				messagebox msgstr 'info'
			endif
			
			recvln; this puts received line into 'inputstr'
			if result = 1 then
				; if VERBOSE then
					; messagebox inputstr 'From Teensy'
				; endif
				
				;now extract number of lines from inputstr
				strsplit inputstr ' ' ;puts numlines string into <groupmatchstr2>
				strtrim groupmatchstr2 ' ';trim any leading/trailing spaces

				if result <> 0 then
				if VERBOSE then
					sprintf2 msgstr '%s lines received' groupmatchstr2 
					messagebox msgstr 'From Teensy'
				endif
					
					;now send <groupmatchstr2> to Teensy to confirm update
					if VERBOSE then
						sprintf2 msgstr "sending '%s' to Teensy" groupmatchstr2
						messagebox msgstr 'To Teensy'
					endif

					sendln groupmatchstr2; actually sends the <numlines> value
				else
					messagebox 'groupmatchstr2 send failed' 'error'
					goto ERROR ;error exit - closes COM connection and TT
				endif

			else
				messagebox "nothing received from Teensy" info
				goto ERROR ;error exit - closes COM connection and TT
			endif
		endif
	endif
endif

:ERROR
if VERBOSE then
	messagebox "closing COM port and Tera Term" "info"
endif

testlink ;TT may or may not be connnected
if result <> 0 then
	disconnect 1 ;closes the COM port connection
	closett; closes teraterm
endif

end

;endif
;filenamebox 'File selection' 0
;if result<>0 then
;	messagebox inputstr 'title' 0
;	sendfile inputstr 1
;endif

;c:\Program Files (x86)\teraterm>ttpmacro.exe /v "c:\users\Frank\Documents\Arduino\Teensy Projects\TeensyOTADemo\TeensyOTA1.ttl" 4

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

16 October 2021 G. Frank Paynter

Tera Term macro to connect to Teensy and send latest .HEX file

Tera Term is called via a post-build command in VS2019/VMicro

like <path_to_ttpmacro.exe> /v <path_to_TeensyOTA1.ttl> <build_path>\<project_name>.hex> <COM port>

The actual post-build command is contained in the 'board.txt' file as follows:

recipe.hooks.postbuild.1.pattern=cmd.exe /c "c:\Program Files (x86)\teraterm\ttpmacro.exe" /v "c:\users\Frank\Documents\Arduino\Teensy Projects\TeensyOTADemo\Test2.ttl" "{vm.runtime.build.final_output_path}" {serial.port} {build.project_name}

When this is passed to tera term the arguments appear as follows:

BuildPath = param2 ; used to find the .HEX file to transfer, like "C:\Ussers\Frank\Arduino\Teensy Projects\TeensyOTADemo\Release\"

CommPortStr = param3 ;"COMx" where 'x' is the actual number assigned

ProjectFileName = param4 ;project file name like "TeensyOTADemo.ino"

Notes:

10/16/21: for verbose output, set VERBOSE = 1 (default is 0)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

VERBOSE = 0; set this to 1 for verbose progress indications

pathtoHexfile = param2

COMportstr = param3

strtrim COMportstr ' ' ; remove any leading/trailing spaces

ComPortNumStr = COMportstr

strremove ComPortNumStr 1 3 ;isolate the com port number

INOfilename = param4

if VERBOSE then

sprintf2 msgstr "%s, %s, %s" param2 param3 param4;<param1> is ttl filename

messagebox msgstr 'script calling arguments'

sprintf2 msgstr "path to HEX file: %s" param2

messagebox msgstr 'script calling arguments'

sprintf2 msgstr "COM port number: %s" ComPortNumStr

messagebox msgstr 'script calling arguments'

sprintf2 msgstr "INO filename: %s" param4

messagebox msgstr 'script calling arguments'

endif

;connect to Teensy via COM <param2>

if VERBOSE then

sprintf2 msgstr "attempting to connnect to Teensy on COM%s" ComPortNumStr

messagebox msgstr 'info'

endif

sprintf2 cnct_str "/C=%s" ComPortNumStr ; actual string used by TT

if VERBOSE then

messagebox cnct_str 'connect string'

endif

testlink; TT could already be connected

; if result = 0 connect cnct_str; actually launch TT and make the connection. <result> = 2 for success

if result = 0 connect cnct_str; actually launch TT and make the connection. <result> = 2 for success

if result <> 2 then

sprintf2 errstr "unable to connect to Teensy on %s - aborting" COMportstr

messagebox errstr "Error"

goto ERROR ;error exit - closes COM connection and TT

else

;if we get to here, we have a valid COM port connection

if VERBOSE then

sprintf2 msgstr "sending trigger command (%s) and waiting for %s" "U" "waiting"

messagebox msgstr "info"

endif

send 'U' ;actually send the trigger character

timeout = 5 ; seconds

wait 'waiting'

if result = 0 then

messagebox "Oops - timed out waiting for 'waiting' from Teensy" "Error"

goto ERROR ;error exit - closes COM connection and TT

else ; OK, got 'waiting'...

if VERBOSE then

msgstr = "got 'waiting' string - sending file"

messagebox msgstr 'info'

endif

hexfilestr = 'C:\Users\Frank\Documents\Arduino\Teensy Projects\TeensyOTADemo\Release\TeensyOTADemo.hex'

if VERBOSE then

messagebox hexfilestr 'sendfile'

endif

sendfile hexfilestr 0 ;actually send the file. Note the 0 is required to make it work

;now we have to extract the number of lines from the 'enter xxxx to flash...' string

wait 'enter' ;get the next line from Teensy

if result = 0 then

messagebox "Oops - timed out waiting for 'enter' from Teensy" "Error"

goto ERROR ;error exit - closes COM connection and TT

else ; OK, got 'enter'...

if VERBOSE then

msgstr = "got string containing 'enter'"

messagebox msgstr 'info'

endif

recvln; this puts received line into 'inputstr'

if result = 1 then

; if VERBOSE then

; messagebox inputstr 'From Teensy'

; endif

;now extract number of lines from inputstr

strsplit inputstr ' ' ;puts numlines string into <groupmatchstr2>

strtrim groupmatchstr2 ' ';trim any leading/trailing spaces

if result <> 0 then

if VERBOSE then

sprintf2 msgstr '%s lines received' groupmatchstr2

messagebox msgstr 'From Teensy'

endif

;now send <groupmatchstr2> to Teensy to confirm update

if VERBOSE then

sprintf2 msgstr "sending '%s' to Teensy" groupmatchstr2

messagebox msgstr 'To Teensy'

endif

sendln groupmatchstr2; actually sends the <numlines> value

else

messagebox 'groupmatchstr2 send failed' 'error'

goto ERROR ;error exit - closes COM connection and TT

endif

else

messagebox "nothing received from Teensy" info

goto ERROR ;error exit - closes COM connection and TT

endif

:ERROR

if VERBOSE then

messagebox "closing COM port and Tera Term" "info"

endif

testlink ;TT may or may not be connnected

if result <> 0 then

disconnect 1 ;closes the COM port connection

closett; closes teraterm

endif

end

;endif

;filenamebox 'File selection' 0

;if result<>0 then

; messagebox inputstr 'title' 0

; sendfile inputstr 1

;endif

;c:\Program Files (x86)\teraterm>ttpmacro.exe /v "c:\users\Frank\Documents\Arduino\Teensy Projects\TeensyOTADemo\TeensyOTA1.ttl" 4

and here are two short videos showing the OTA update process. The first video shows the process from the PC’s point of view, and the second one shows the same thing, but from the Teensy’s point of view.

Teensy OTA from PC’s point of view

Teensy OTA from Teensy’s point of view

Summary:

Over-the-air (OTA) update of a Teensy microcontroller is now practical using Joe Pasquariello’s fine ‘FlasherX’ program, combined with a Tera Term macro that is launched using Visual Micro’s ‘board.txt’ post-build feature. The things you need to make this happen are:

Obviously any Teensy program must incorporate Joe Pasquariello’s ‘FlasherX’ functionality. See my previous post for my complete demo sketch that does this.
You must have a way of triggering the update functionality provided by ‘FlasherX’. In my demo I accomplished this via my ‘CheckForUserInput()’ function that runs each time ‘loop()’ executes. If this function detects the letter ‘U’ or ‘u’ on Serial1, it launches FlasherX’s ‘update_firmware’ function which does the rest.
You have to have a serial comms application to upload the .HEX file produced by compiling the program update. I used Tera Term for this, and it worked very well.
To automate the above process, you need a script file (macro) like the one I provided above to manage the upload process.

I created a new GitHub repository here containing the Tera Term macro file, the ‘board.txt’ file I used with VS/VM, and the OTA demo sketch I used to demonstrate this functionality. Enjoy!

Frank

27 October 2021 Update:

As part of my Wall-E3 project, I constructed a small perf-board module to carry the low-dropout (LD0) 5V Regulator, and added a HC-05 module for OTA updates to Wall-E3’s Teensy firmware, as shown in the following photo

5V regulator board with HC-05 BT module added for OTA updates

And here is a short video showing an OTA update:

Teensy OTA firmware update using HC-05 BT module and Tera Term script

Over-the-Air (OTA) Firmware Updates For Teensy 3.x & 4.x

2 Replies

Posted 23 September 2021

For some time now I have been following developments on Paul Stoffregen’s Teensy forum with respect to OTA updates for Teensy products. As it turns out, doing OTA updates is less than straightforward due to the Teensy architecture (I’m waving my hands here).

However, in recent months, thanks to Teensy forum member joepasquariello, there is a new set of programs that seem to address the Teensy OTA issue in a much more comprehensive manner. See this thread (starting with post #85) on the Teensy forum for the details. After reading through the posts, and asking some more dumb questions (which joe was fortunately willing to answer), I decided to give this a try to see if I could achieve OTA updates for a Teensy controller, and maybe make it as convenient as OTA updates are now with Arduino products using the Pololu Wixel RF serial pipe.

The FlasherX package is actually three different files; FlasherX.ino is a demo program that #includes FlashTxx.h and FlashTxx.cpp. The FlasherX.ino program is loaded into the target Teensy device in the normal manner, just like any other Teensy program. However, once it is there, it adds the capability to update the Teensy’s firmware using the .HEX file (produced by the normal compile process) transmitted over any serial port. Of course, in order to make this magic happen, the updated Teensy program must also have this capability, so that means that any Teensy program destined for OTA updates must include the basic ‘FlasherX’ components.

In order to get started, I dl’d all three files and programmed a Teensy 3.5 with the FlasherX.ino program using my normal VS2019/Visual Micro setup. Then I created a new Arduino Project in VS2019 called ‘TeensyFlasher_V1’ and copied the entire contents of FlasherX.ino. I compiled it for a T3.5 target and used my normal Teensy bootload process to transfer it to the Teensy 3.5. Here is the serial port output after the upload:

Initial output from FlasherX.ino after upload to Teensy 3.5

Next I used Tera Term’s ‘file send’ capability to send the FlasherX.hex file to the Teensy using the wired USB connection as just another serial port. When I first launched Tera Term I got an error dialog saying it “Cannot open COM11. Access denied” – reminding me that I had to close the normal connection in order for Tera Term to operate properly. Once I had done this, I used the ‘File->New Connection menu item in Tera Term to create a new connection to COM11 (the Teensy 3.5 USB port), as shown:

Next I used ‘File->Send File… to select the .HEX file created by the compiler, and transfer its contents over to the Teensy using the COM11 serial port

After selecting the .HEX file and clicking ‘Open’, the HEX contents were sent over the serial connection as shown below:

The reason for using the HEX file created from compiling FlasherX.ino (as opposed to a random Teensy app) is because FlasherX.ino already contains all the pieces needed to do OTA updates. Although a bit recursive, using the FlasherX app demonstrates that a Teensy device can be updated via a serial connection repeatedly, as long as the newly updated firmware contains the pieces needed to support the next OTA update.

The next step was to figure out how to get VS2019/Visual Micro to do the update automatically, so that the process emulates what happens with an Arduino controller when F5 is pressed. VS2019 supports post-build scripts, but they aren’t used in the Visual Micro environment. Instead, as I learned from VM guru Tim Leek, VM supports post-build operations via a special file called ‘board.txt’ in the project directory. If this file is present, properly formatted lines are treated as ‘build property overrides’. For instance, this is the line in ‘board.txt’ that calls a C# console app to actually communicate with the target Teensy.

recipe.hooks.postbuild.1.pattern=cmd.exe /c "C:\Users\Frank\Documents\Visual Studio 2019\Projects\TeensyFlash\bin\Release\netcoreapp3.1\TeensyFlash.exe" "{sketch_path}" "{ProjectDir}" {serial.port.num}

1	recipe.hooks.postbuild.1.pattern=cmd.exe /c "C:\Users\Frank\Documents\Visual Studio 2019\Projects\TeensyFlash\bin\Release\netcoreapp3.1\TeensyFlash.exe" "{sketch_path}" "{ProjectDir}" {serial.port.num}

This command launches the console app, and provides it with the path to the project, the path to the sketch, and the currently selected port number. See this thread on the VM forum for all the gory details.

I ran into a problem when I tried to use the above command line with my C# console app, because the arg[] string array in the console app was interpreting spaces in the strings in the calling command differently than expected, so when I sent three strings to the command, the console app thought I was only sending two – somehow concatenating the com port number into the second string (the sketch path). After playing around some more, I found that the following treatment:

recipe.hooks.postbuild.2.pattern=cmd.exe /c "C:\Users\Frank\Documents\Visual Studio 2019\Projects\TeensyFlash\bin\Release\netcoreapp3.1\TeensyFlash.exe" "{sketch_path}" "\"{ProjectDir}"" {serial.port.num}

1	recipe.hooks.postbuild.2.pattern=cmd.exe /c "C:\Users\Frank\Documents\Visual Studio 2019\Projects\TeensyFlash\bin\Release\netcoreapp3.1\TeensyFlash.exe" "{sketch_path}" "\"{ProjectDir}"" {serial.port.num}

when passed as an argument to this small code snippet

namespace TeensyFlash
{
    class Program
    {
        static void Main(string[] args)
        {
            //Extract the project path and selected COMPORT number from the arguments to the call to Main()
            Console.WriteLine("Teensy Flash Console");
            Console.WriteLine("Number of arguments in args = {0}\n", args.Length);
            foreach (string str in args)
            {
                Console.WriteLine("{0}\n", str);
            }
        }
    }
}

namespace TeensyFlash

{

class Program

{

static void Main(string[] args)

{

//Extract the project path and selected COMPORT number from the arguments to the call to Main()

Console.WriteLine("Teensy Flash Console");

Console.WriteLine("Number of arguments in args = {0}\n", args.Length);

foreach (string str in args)

{

Console.WriteLine("{0}\n", str);

}

produced the following output:

Compiling 'Teensy Flash Demo V1' for 'Teensy 3.5'
Using previously compiled file: C:\Users\Frank\AppData\Local\Temp\VMBuilds\Teensy Flash Demo V1\teensy35\Release\pch\Arduino.h.gch
Program size: 47,584 bytes (used 9% of a 524,288 byte maximum) (0.93 secs)
Minimum Memory Usage: 5140 bytes (2% of a 262136 byte maximum)
 
C:\Program Files (x86)\Arduino\java\bin>ECHO Sat 09/25/2021 20:14:24.26 Postbuild Hook 1 
Sat 09/25/2021 20:14:24.26 Postbuild Hook 1
C:\Program Files (x86)\Arduino\java\bin>"C:\Users\Frank\Documents\Visual Studio 2019\Projects\TeensyFlash\bin\Release\netcoreapp3.1\TeensyFlash.exe" "C:\Users\Frank\Documents\Arduino\Teensy Flash Demo V1" "\"C:\Users\Frank\Documents\Arduino\Teensy Flash Demo V1\"" 6 
Teensy Flash Console
Number of arguments in args = 3
C:\Users\Frank\Documents\Arduino\Teensy Flash Demo V1
"C:\Users\Frank\Documents\Arduino\Teensy Flash Demo V1"
6

Compiling 'Teensy Flash Demo V1' for 'Teensy 3.5'

Using previously compiled file: C:\Users\Frank\AppData\Local\Temp\VMBuilds\Teensy Flash Demo V1\teensy35\Release\pch\Arduino.h.gch

Program size: 47,584 bytes (used 9% of a 524,288 byte maximum) (0.93 secs)

Minimum Memory Usage: 5140 bytes (2% of a 262136 byte maximum)

C:\Program Files (x86)\Arduino\java\bin>ECHO Sat 09/25/2021 20:14:24.26 Postbuild Hook 1

Sat 09/25/2021 20:14:24.26 Postbuild Hook 1

C:\Program Files (x86)\Arduino\java\bin>"C:\Users\Frank\Documents\Visual Studio 2019\Projects\TeensyFlash\bin\Release\netcoreapp3.1\TeensyFlash.exe" "C:\Users\Frank\Documents\Arduino\Teensy Flash Demo V1" "\"C:\Users\Frank\Documents\Arduino\Teensy Flash Demo V1\"" 6

Teensy Flash Console

Number of arguments in args = 3

C:\Users\Frank\Documents\Arduino\Teensy Flash Demo V1

"C:\Users\Frank\Documents\Arduino\Teensy Flash Demo V1"

With the correct number of arguments, and the comport number on its own line – yay. I have no idea why this works and the other formulations don’t, and why the second argument has to be have it’s quotes escaped with ‘\’, but hey – it works.

As it turns out, this exercise was a bit academic anyway, because both the {ProjectDir} and {sketch_path} expand to identical results, so I only need one of them and the comport number to proceed. So, the ‘final’ (for now) call argument list looks like:

recipe.hooks.postbuild.2.pattern=cmd.exe /c "C:\Users\Frank\Documents\Visual Studio 2019\Projects\TeensyFlash\bin\Release\netcoreapp3.1\TeensyFlash.exe" "\"{ProjectDir}"" {serial.port.num}

1	recipe.hooks.postbuild.2.pattern=cmd.exe /c "C:\Users\Frank\Documents\Visual Studio 2019\Projects\TeensyFlash\bin\Release\netcoreapp3.1\TeensyFlash.exe" "\"{ProjectDir}"" {serial.port.num}

which produces:

C:\Program Files (x86)\Arduino\java\bin>ECHO Sat 09/25/2021 20:30:09.68 Postbuild Hook 1 
Sat 09/25/2021 20:30:09.68 Postbuild Hook 1
C:\Program Files (x86)\Arduino\java\bin>"C:\Users\Frank\Documents\Visual Studio 2019\Projects\TeensyFlash\bin\Release\netcoreapp3.1\TeensyFlash.exe" "\"C:\Users\Frank\Documents\Arduino\Teensy Flash Demo V1\"" 6 
Teensy Flash Console
Number of arguments in args = 2
"C:\Users\Frank\Documents\Arduino\Teensy Flash Demo V1"
6

C:\Program Files (x86)\Arduino\java\bin>ECHO Sat 09/25/2021 20:30:09.68 Postbuild Hook 1

Sat 09/25/2021 20:30:09.68 Postbuild Hook 1

C:\Program Files (x86)\Arduino\java\bin>"C:\Users\Frank\Documents\Visual Studio 2019\Projects\TeensyFlash\bin\Release\netcoreapp3.1\TeensyFlash.exe" "\"C:\Users\Frank\Documents\Arduino\Teensy Flash Demo V1\"" 6

Teensy Flash Console

Number of arguments in args = 2

"C:\Users\Frank\Documents\Arduino\Teensy Flash Demo V1"

27 September 2021 Update

In order to do OTA updates, I need to be able to connect to one of the Teensy’s hardware serial ports. Up til now I have been just using the USB serial port for convenience, so I thought I would try using a FTDI Pro USB/Serial converter module to connect to Serial1 on the teensy, as shown in the following photo:

In the above photo, the normal USB connection provides 5V power for the Teensy, and also allows ‘direct’ programming via the normal VS2019/VM route. The FTDI module connection shows up as COM3, a ‘regular’ USB serial port. With this setup I was able to upload a .HEX file to the Teensy using Tera Term, confirming that I can indeed use a hardware serial port for this purpose.

04 October Update:

Between the last update and now, I spent a lot of time trying to get the command-line post-build console app working, mostly to no avail. I kept getting wrapped around the axle trying to deal with three different serial connections; two to the teensy itself, and one from the command-line app to VS2019’s Console service. This got to the point where at one time the ‘Console’ output was going to my computer display, which made the mouse jump around wildly, occasionally launching or closing apps! Even trying to restart the PC was a trial-and-error process, because about half the time the screen focus would jump away from the target button before I could get it clicked!

So, I decided to go back to basics and use just the FTDI serial adaptor to run the Teensy. This required using the Vcc connection from the FTDI module to power the Teensy, which worked OK once I figured out how to switch the FTDI module from 3.3V out to 5V out.

FTDI USB-serial module now powering Teensy 3.5

With this setup I am able to upload programs to the Teensy using Tera Term, as before, but now I don’t have the other USB connection to confuse things. It does mean however, that now I MUST use Tera Term to upload sketches, as I no longer have the capability to use the Teensy bootloader from VS2019.

With this simpler setup, ‘Console’ statements from the command-line app should go only to the VS2019 debug session, and serial port operations from the command-line app should go only to Teensy’s ‘serial1’ hardware serial port.

05 October 2021 Update:

I expanded the above operation to restore the USB connection to the PC, and created a small Arduino program to (at first) just echo serial data from one serial port to the other. Here’s the program:

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

    Serial1.begin(115200);
    while (!Serial1) {}

    pinMode(LED_BUILTIN, OUTPUT);
    Serial.printf("\nFlasherX OTA firmware update v1 %s %s\n", __DATE__, __TIME__);

    MsecSinceLastLEDToggle = 0;
}

void loop()
{

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

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

  if (MsecSinceLastLEDToggle >= 200)
  {
    MsecSinceLastLEDToggle -= 200;
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
  }
}

void setup()

{

Serial.begin(115200);

while (!Serial) {}

Serial1.begin(115200);

while (!Serial1) {}

pinMode(LED_BUILTIN, OUTPUT);

Serial.printf("\nFlasherX OTA firmware update v1 %s %s\n", __DATE__, __TIME__);

MsecSinceLastLEDToggle = 0;

}

void loop()

{

if (Serial.available())

{

Serial1.write(Serial.read());

}

if (Serial1.available())

{

Serial.write(Serial1.read());

}

if (MsecSinceLastLEDToggle >= 200)

{

MsecSinceLastLEDToggle -= 200;

digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));

}

Once I had this going to my satisfaction, I started adding pieces from my ‘TeensyFlashDemoV2’ project until I had a complete working program, as shown below:

Here’s the Arduino code:

/*
    Name:       TeensySerialBridgeV1.ino
    Created:	10/4/2021 5:07:47 PM
    Author:     FRANKNEWXPS15\Frank
*/

#include "FlashTxx.h"		// TLC/T3x/T4x flash primitives
#include <elapsedMillis.h>

elapsedMillis MsecSinceLastLEDToggle;

Stream* FTDIport = &Serial1;	// Serial (USB) or Serial1, Serial2, etc. (UART)
Stream* USBport = &Serial1;	// Serial (USB) or Serial1, Serial2, etc. (UART)

//******************************************************************************
// hex_info_t	struct for hex record and hex file info
//******************************************************************************
typedef struct {	// 
  char* data;		// pointer to array allocated elsewhere
  unsigned int addr;	// address in intel hex record
  unsigned int code;	// intel hex record type (0=data, etc.)
  unsigned int num;	// number of data bytes in intel hex record

  uint32_t base;	// base address to be added to intel hex 16-bit addr
  uint32_t min;		// min address in hex file
  uint32_t max;		// max address in hex file

  int eof;		// set true on intel hex EOF (code = 1)
  int lines;		// number of hex records received  
} hex_info_t;

void read_ascii_line(Stream* serial, char* line, int maxbytes);
int  parse_hex_line(const char* theline, char* bytes,
  unsigned int* addr, unsigned int* num, unsigned int* code);
int  process_hex_record(hex_info_t* hex);
void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size);

uint32_t buffer_addr, buffer_size; //09/20/21 copied from FlasherX - loop()

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

    Serial1.begin(115200);
    while (!Serial1) {}

    pinMode(LED_BUILTIN, OUTPUT);
    Serial.printf("\nFlasherX OTA firmware update v1 %s %s\n", __DATE__, __TIME__);

    MsecSinceLastLEDToggle = 0;
}

void loop()
{

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

  if (Serial1.available())
  {
    //Serial.println("Got something from Serial1!");
    CheckForUserInput();
    Serial.write(Serial1.read());
  }

  if (MsecSinceLastLEDToggle >= 200)
  {
    MsecSinceLastLEDToggle -= 200;
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
    //Serial.printf(".");
  }
}
void CheckForUserInput()
{
  const int bufflen = 80;
  char buff[bufflen];
  memset(buff, 0, bufflen);
  //const char s[2] = ",";

  //if (Serial.available() > 0)
  if (Serial1.available() > 0)
  {
    // read the incoming byte:
    int incomingByte = Serial1.read();

    // say what you got:
    Serial1.print("I received: ");
    Serial1.println(incomingByte, HEX); //chg to HEX 02/18/20

    //02/18/20 experiment with multiple commands
    switch (incomingByte)
    {
    case 0x43: //ASCII 'C'
    case 0x63: //ASCII 'c'
      Serial1.println(F("Start Program Update - Send new HEX file!"));


      //09/20/21 copied from FlasherX - loop()
      if (firmware_buffer_init(&buffer_addr, &buffer_size) == 0)
      {
        Serial1.printf("unable to create buffer\n");
        Serial1.flush();
        for (;;) {}
      }

      Serial1.printf("buffer = %1luK %s (%08lX - %08lX)\n",
        buffer_size / 1024, IN_FLASH(buffer_addr) ? "FLASH" : "RAM",
        buffer_addr, buffer_addr + buffer_size);

      //09/20/21 clear the serial buffer
      while (Serial1.available())
      {
        Serial1.read();
      }

      // receive hex file via serial, write new firmware to flash, clean up, reboot
      update_firmware(&Serial1, buffer_addr, buffer_size); // no return if success

      // return from update_firmware() means error or user abort, so clean up and
      // reboot to ensure that static vars get boot-up initialized before retry
      Serial1.printf("erase FLASH buffer / free RAM buffer...\n");
      firmware_buffer_free(buffer_addr, buffer_size);
      Serial1.flush();
      REBOOT;
      break;
    }
  }
}

//09/20/21 copied from FlasherX

//******************************************************************************
// update_firmware()	read hex file and write new firmware to program flash
//******************************************************************************
void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size)
{
  static char line[96];					// buffer for hex lines
  static char data[32] __attribute__((aligned(8)));	// buffer for hex data
  hex_info_t hex = {					// intel hex info struct
    data, 0, 0, 0,					//   data,addr,num,code
    0, 0xFFFFFFFF, 0, 					//   base,min,max,
    0, 0						//   eof,lines
  };

  serial->printf("waiting for hex lines...\n");

  // read and process intel hex lines until EOF or error
  while (!hex.eof) {

    read_ascii_line(serial, line, sizeof(line));

    //10/02/21 gfp added for visual xfer confirmation
    if (hex.lines % 10 == 0)
    {
      digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN));
    }

    // reliability of transfer via USB is improved by this printf/flush
    if (serial == (Stream*)&Serial)
    {
      serial->printf("%s\n", line);
      serial->flush();
    }

    if (parse_hex_line((const char*)line, hex.data, &hex.addr, &hex.num, &hex.code) == 0) {
      serial->printf("abort - bad hex line %s\n", line);
      return;
    }
    else if (process_hex_record(&hex) != 0) { // error on bad hex code
      serial->printf("abort - invalid hex code %d\n", hex.code);
      return;
    }
    else if (hex.code == 0) { // if data record
      uint32_t addr = buffer_addr + hex.base + hex.addr - FLASH_BASE_ADDR;
      if (hex.max > (FLASH_BASE_ADDR + buffer_size)) {
        serial->printf("abort - max address %08lX too large\n", hex.max);
        return;
      }
      else if (!IN_FLASH(buffer_addr)) {
        memcpy((void*)addr, (void*)hex.data, hex.num);
      }
      else if (IN_FLASH(buffer_addr)) {
        int error = flash_write_block(addr, hex.data, hex.num);
        if (error) {
          serial->printf("abort - error %02X in flash_write_block()\n", error);
          return;
        }
      }
    }
    hex.lines++;
  }

  serial->printf("\nhex file: %1d lines %1lu bytes (%08lX - %08lX)\n",
    hex.lines, hex.max - hex.min, hex.min, hex.max);

  // check FSEC value in new code -- abort if incorrect
#if defined(KINETISK) || defined(KINETISL)
  uint32_t value = *(uint32_t*)(0x40C + buffer_addr);
  if (value == 0xfffff9de) {
    serial->printf("new code contains correct FSEC value %08lX\n", value);
  }
  else {
    serial->printf("abort - FSEC value %08lX should be FFFFF9DE\n", value);
    return;
  }
#endif

  // check FLASH_ID in new code - abort if not found
  if (check_flash_id(buffer_addr, hex.max - hex.min)) {
    serial->printf("new code contains correct target ID %s\n", FLASH_ID);
  }
  else {
    serial->printf("abort - new code missing string %s\n", FLASH_ID);
    return;
  }

  // get user input to write to flash or abort
  int user_lines = -1;
  while (user_lines != hex.lines && user_lines != 0) {
    serial->printf("enter %d to flash or 0 to abort\n", hex.lines);
    read_ascii_line(serial, line, sizeof(line));
    sscanf(line, "%d", &user_lines);
  }

  if (user_lines == 0) {
    serial->printf("abort - user entered 0 lines\n");
    return;
  }

  // move new program from buffer to flash, free buffer, and reboot
  flash_move(FLASH_BASE_ADDR, buffer_addr, hex.max - hex.min);

  // should not return from flash_move(), but put REBOOT here as reminder
  REBOOT;
}

//******************************************************************************
// read_ascii_line()	read ascii characters until '\n', '\r', or max bytes
//******************************************************************************
void read_ascii_line(Stream* serial, char* line, int maxbytes)
{
  int c = 0, nchar = 0;
  while (nchar < maxbytes && !(c == '\n' || c == '\r')) {
    if (serial->available()) {
      c = serial->read();
      line[nchar++] = c;
    }
  }
  line[nchar - 1] = 0;	// null-terminate
}

//******************************************************************************
// process_hex_record()		process record and return okay (0) or error (1)
//******************************************************************************
int process_hex_record(hex_info_t* hex)
{
  if (hex->code == 0) { // data -- update min/max address so far
    if (hex->base + hex->addr + hex->num > hex->max)
      hex->max = hex->base + hex->addr + hex->num;
    if (hex->base + hex->addr < hex->min)
      hex->min = hex->base + hex->addr;
  }
  else if (hex->code == 1) { // EOF (:flash command not received yet)
    hex->eof = 1;
  }
  else if (hex->code == 2) { // extended segment address (top 16 of 24-bit addr)
    hex->base = ((hex->data[0] << 8) | hex->data[1]) << 4;
  }
  else if (hex->code == 3) { // start segment address (80x86 real mode only)
    return 1;
  }
  else if (hex->code == 4) { // extended linear address (top 16 of 32-bit addr)
    hex->base = ((hex->data[0] << 8) | hex->data[1]) << 16;
  }
  else if (hex->code == 5) { // start linear address (32-bit big endian addr)
    hex->base = (hex->data[0] << 24) | (hex->data[1] << 16)
      | (hex->data[2] << 8) | (hex->data[3] << 0);
  }
  else {
    return 1;
  }

  return 0;
}

//******************************************************************************
// Intel Hex record foramt:
//
// Start code:  one character, ASCII colon ':'.
// Byte count:  two hex digits, number of bytes (hex digit pairs) in data field.
// Address:     four hex digits
// Record type: two hex digits, 00 to 05, defining the meaning of the data field.
// Data:        n bytes of data represented by 2n hex digits.
// Checksum:    two hex digits, computed value used to verify record has no errors.
//
// Examples:
//  :10 9D30 00 711F0000AD38000005390000F5460000 35
//  :04 9D40 00 01480000 D6
//  :00 0000 01 FF
//******************************************************************************

/* Intel HEX read/write functions, Paul Stoffregen, paul@ece.orst.edu */
/* This code is in the public domain.  Please retain my name and */
/* email address in distributed copies, and let me know about any bugs */

/* I, Paul Stoffregen, give no warranty, expressed or implied for */
/* this software and/or documentation provided, including, without */
/* limitation, warranty of merchantability and fitness for a */
/* particular purpose. */

// type modifications by Jon Zeeff

/* parses a line of intel hex code, stores the data in bytes[] */
/* and the beginning address in addr, and returns a 1 if the */
/* line was valid, or a 0 if an error occured.  The variable */
/* num gets the number of bytes that were stored into bytes[] */

#include <stdio.h>		// sscanf(), etc.
#include <string.h>		// strlen(), etc.

int parse_hex_line(const char* theline, char* bytes,
  unsigned int* addr, unsigned int* num, unsigned int* code)
{
  unsigned sum, len, cksum;
  const char* ptr;
  int temp;

  *num = 0;
  if (theline[0] != ':')
    return 0;
  if (strlen(theline) < 11)
    return 0;
  ptr = theline + 1;
  if (!sscanf(ptr, "%02x", &len))
    return 0;
  ptr += 2;
  if (strlen(theline) < (11 + (len * 2)))
    return 0;
  if (!sscanf(ptr, "%04x", (unsigned int*)addr))
    return 0;
  ptr += 4;
  /* Serial.printf("Line: length=%d Addr=%d\n", len, *addr); */
  if (!sscanf(ptr, "%02x", code))
    return 0;
  ptr += 2;
  sum = (len & 255) + ((*addr >> 8) & 255) + (*addr & 255) + (*code & 255);
  while (*num != len)
  {
    if (!sscanf(ptr, "%02x", &temp))
      return 0;
    bytes[*num] = temp;
    ptr += 2;
    sum += bytes[*num] & 255;
    (*num)++;
    if (*num >= 256)
      return 0;
  }
  if (!sscanf(ptr, "%02x", &cksum))
    return 0;

  if (((sum & 255) + (cksum & 255)) & 255)
    return 0;     /* checksum error */
  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

Name: TeensySerialBridgeV1.ino

Created: 10/4/2021 5:07:47 PM

Author: FRANKNEWXPS15\Frank

#include "FlashTxx.h" // TLC/T3x/T4x flash primitives

#include <elapsedMillis.h>

elapsedMillis MsecSinceLastLEDToggle;

Stream* FTDIport = &Serial1; // Serial (USB) or Serial1, Serial2, etc. (UART)

Stream* USBport = &Serial1; // Serial (USB) or Serial1, Serial2, etc. (UART)

//******************************************************************************

// hex_info_t struct for hex record and hex file info

//******************************************************************************

typedef struct { //

char* data; // pointer to array allocated elsewhere

unsigned int addr; // address in intel hex record

unsigned int code; // intel hex record type (0=data, etc.)

unsigned int num; // number of data bytes in intel hex record

uint32_t base; // base address to be added to intel hex 16-bit addr

uint32_t min; // min address in hex file

uint32_t max; // max address in hex file

int eof; // set true on intel hex EOF (code = 1)

int lines; // number of hex records received

} hex_info_t;

void read_ascii_line(Stream* serial, char* line, int maxbytes);

int parse_hex_line(const char* theline, char* bytes,

unsigned int* addr, unsigned int* num, unsigned int* code);

int process_hex_record(hex_info_t* hex);

void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size);

uint32_t buffer_addr, buffer_size; //09/20/21 copied from FlasherX - loop()

void setup()

{

Serial.begin(115200);

while (!Serial) {}

Serial1.begin(115200);

while (!Serial1) {}

pinMode(LED_BUILTIN, OUTPUT);

Serial.printf("\nFlasherX OTA firmware update v1 %s %s\n", __DATE__, __TIME__);

MsecSinceLastLEDToggle = 0;

}

void loop()

{

if (Serial.available())

{

Serial1.write(Serial.read());

}

if (Serial1.available())

{

//Serial.println("Got something from Serial1!");

CheckForUserInput();

Serial.write(Serial1.read());

}

if (MsecSinceLastLEDToggle >= 200)

{

MsecSinceLastLEDToggle -= 200;

digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));

//Serial.printf(".");

}

void CheckForUserInput()

{

const int bufflen = 80;

char buff[bufflen];

memset(buff, 0, bufflen);

//const char s[2] = ",";

//if (Serial.available() > 0)

if (Serial1.available() > 0)

{

// read the incoming byte:

int incomingByte = Serial1.read();

// say what you got:

Serial1.print("I received: ");

Serial1.println(incomingByte, HEX); //chg to HEX 02/18/20

//02/18/20 experiment with multiple commands

switch (incomingByte)

{

case 0x43: //ASCII 'C'

case 0x63: //ASCII 'c'

Serial1.println(F("Start Program Update - Send new HEX file!"));

//09/20/21 copied from FlasherX - loop()

if (firmware_buffer_init(&buffer_addr, &buffer_size) == 0)

{

Serial1.printf("unable to create buffer\n");

Serial1.flush();

for (;;) {}

}

Serial1.printf("buffer = %1luK %s (%08lX - %08lX)\n",

buffer_size / 1024, IN_FLASH(buffer_addr) ? "FLASH" : "RAM",

buffer_addr, buffer_addr + buffer_size);

//09/20/21 clear the serial buffer

while (Serial1.available())

{

Serial1.read();

}

// receive hex file via serial, write new firmware to flash, clean up, reboot

update_firmware(&Serial1, buffer_addr, buffer_size); // no return if success

// return from update_firmware() means error or user abort, so clean up and

// reboot to ensure that static vars get boot-up initialized before retry

Serial1.printf("erase FLASH buffer / free RAM buffer...\n");

firmware_buffer_free(buffer_addr, buffer_size);

Serial1.flush();

REBOOT;

break;

}

//09/20/21 copied from FlasherX

//******************************************************************************

// update_firmware() read hex file and write new firmware to program flash

//******************************************************************************

void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size)

{

static char line[96]; // buffer for hex lines

static char data[32] __attribute__((aligned(8))); // buffer for hex data

hex_info_t hex = { // intel hex info struct

data, 0, 0, 0, // data,addr,num,code

0, 0xFFFFFFFF, 0, // base,min,max,

0, 0 // eof,lines

};

serial->printf("waiting for hex lines...\n");

// read and process intel hex lines until EOF or error

while (!hex.eof) {

read_ascii_line(serial, line, sizeof(line));

//10/02/21 gfp added for visual xfer confirmation

if (hex.lines % 10 == 0)

{

digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN));

}

// reliability of transfer via USB is improved by this printf/flush

if (serial == (Stream*)&Serial)

{

serial->printf("%s\n", line);

serial->flush();

}

if (parse_hex_line((const char*)line, hex.data, &hex.addr, &hex.num, &hex.code) == 0) {

serial->printf("abort - bad hex line %s\n", line);

return;

}

else if (process_hex_record(&hex) != 0) { // error on bad hex code

serial->printf("abort - invalid hex code %d\n", hex.code);

return;

}

else if (hex.code == 0) { // if data record

uint32_t addr = buffer_addr + hex.base + hex.addr - FLASH_BASE_ADDR;

if (hex.max > (FLASH_BASE_ADDR + buffer_size)) {

serial->printf("abort - max address %08lX too large\n", hex.max);

return;

}

else if (!IN_FLASH(buffer_addr)) {

memcpy((void*)addr, (void*)hex.data, hex.num);

}

else if (IN_FLASH(buffer_addr)) {

int error = flash_write_block(addr, hex.data, hex.num);

if (error) {

serial->printf("abort - error %02X in flash_write_block()\n", error);

return;

}

hex.lines++;

}

serial->printf("\nhex file: %1d lines %1lu bytes (%08lX - %08lX)\n",

hex.lines, hex.max - hex.min, hex.min, hex.max);

// check FSEC value in new code -- abort if incorrect

#if defined(KINETISK) || defined(KINETISL)

uint32_t value = *(uint32_t*)(0x40C + buffer_addr);

if (value == 0xfffff9de) {

serial->printf("new code contains correct FSEC value %08lX\n", value);

}

else {

serial->printf("abort - FSEC value %08lX should be FFFFF9DE\n", value);

return;

}

#endif

// check FLASH_ID in new code - abort if not found

if (check_flash_id(buffer_addr, hex.max - hex.min)) {

serial->printf("new code contains correct target ID %s\n", FLASH_ID);

}

else {

serial->printf("abort - new code missing string %s\n", FLASH_ID);

return;

}

// get user input to write to flash or abort

int user_lines = -1;

while (user_lines != hex.lines && user_lines != 0) {

serial->printf("enter %d to flash or 0 to abort\n", hex.lines);

read_ascii_line(serial, line, sizeof(line));

sscanf(line, "%d", &user_lines);

}

if (user_lines == 0) {

serial->printf("abort - user entered 0 lines\n");

return;

}

// move new program from buffer to flash, free buffer, and reboot

flash_move(FLASH_BASE_ADDR, buffer_addr, hex.max - hex.min);

// should not return from flash_move(), but put REBOOT here as reminder

REBOOT;

}

//******************************************************************************

// read_ascii_line() read ascii characters until '\n', '\r', or max bytes

//******************************************************************************

void read_ascii_line(Stream* serial, char* line, int maxbytes)

{

int c = 0, nchar = 0;

while (nchar < maxbytes && !(c == '\n' || c == '\r')) {

if (serial->available()) {

c = serial->read();

line[nchar++] = c;

}

line[nchar - 1] = 0; // null-terminate

}

//******************************************************************************

// process_hex_record() process record and return okay (0) or error (1)

//******************************************************************************

int process_hex_record(hex_info_t* hex)

{

if (hex->code == 0) { // data -- update min/max address so far

if (hex->base + hex->addr + hex->num > hex->max)

hex->max = hex->base + hex->addr + hex->num;

if (hex->base + hex->addr < hex->min)

hex->min = hex->base + hex->addr;

}

else if (hex->code == 1) { // EOF (:flash command not received yet)

hex->eof = 1;

}

else if (hex->code == 2) { // extended segment address (top 16 of 24-bit addr)

hex->base = ((hex->data[0] << 8) | hex->data[1]) << 4;

}

else if (hex->code == 3) { // start segment address (80x86 real mode only)

return 1;

}

else if (hex->code == 4) { // extended linear address (top 16 of 32-bit addr)

hex->base = ((hex->data[0] << 8) | hex->data[1]) << 16;

}

else if (hex->code == 5) { // start linear address (32-bit big endian addr)

hex->base = (hex->data[0] << 24) | (hex->data[1] << 16)

| (hex->data[2] << 8) | (hex->data[3] << 0);

}

else {

return 1;

}

return 0;

}

//******************************************************************************

// Intel Hex record foramt:

// Start code: one character, ASCII colon ':'.

// Byte count: two hex digits, number of bytes (hex digit pairs) in data field.

// Address: four hex digits

// Record type: two hex digits, 00 to 05, defining the meaning of the data field.

// Data: n bytes of data represented by 2n hex digits.

// Checksum: two hex digits, computed value used to verify record has no errors.

// Examples:

// :10 9D30 00 711F0000AD38000005390000F5460000 35

// :04 9D40 00 01480000 D6

// :00 0000 01 FF

//******************************************************************************

/* Intel HEX read/write functions, Paul Stoffregen, paul@ece.orst.edu */

/* This code is in the public domain. Please retain my name and */

/* email address in distributed copies, and let me know about any bugs */

/* I, Paul Stoffregen, give no warranty, expressed or implied for */

/* this software and/or documentation provided, including, without */

/* limitation, warranty of merchantability and fitness for a */

/* particular purpose. */

// type modifications by Jon Zeeff

/* parses a line of intel hex code, stores the data in bytes[] */

/* and the beginning address in addr, and returns a 1 if the */

/* line was valid, or a 0 if an error occured. The variable */

/* num gets the number of bytes that were stored into bytes[] */

#include <stdio.h> // sscanf(), etc.

#include <string.h> // strlen(), etc.

int parse_hex_line(const char* theline, char* bytes,

unsigned int* addr, unsigned int* num, unsigned int* code)

{

unsigned sum, len, cksum;

const char* ptr;

int temp;

*num = 0;

if (theline[0] != ':')

return 0;

if (strlen(theline) < 11)

return 0;

ptr = theline + 1;

if (!sscanf(ptr, "%02x", &len))

return 0;

ptr += 2;

if (strlen(theline) < (11 + (len * 2)))

return 0;

if (!sscanf(ptr, "%04x", (unsigned int*)addr))

return 0;

ptr += 4;

/* Serial.printf("Line: length=%d Addr=%d\n", len, *addr); */

if (!sscanf(ptr, "%02x", code))

return 0;

ptr += 2;

sum = (len & 255) + ((*addr >> 8) & 255) + (*addr & 255) + (*code & 255);

while (*num != len)

{

if (!sscanf(ptr, "%02x", &temp))

return 0;

bytes[*num] = temp;

ptr += 2;

sum += bytes[*num] & 255;

(*num)++;

if (*num >= 256)

return 0;

}

if (!sscanf(ptr, "%02x", &cksum))

return 0;

if (((sum & 255) + (cksum & 255)) & 255)

return 0; /* checksum error */

return 1;

}

and here is the companion C# command-line app:

using System;
using System.IO.Ports;
using System.Threading;
using System.Timers;

/*
Small console app to facilitate over-the-air (OTA) updates to a Teensy 3.x/4.x controller.
This app is called by a post-build 'hook' statement located in whatever Teensy program is 
being updated.  This app does the following:

 - Extract the project path and selected COMPORT number from the arguments to the call to Main()
 - Opens a UART serial port connection to the Teensy, typically one provided by a BT adaptor
   operating in 'pass-through' mode. The serial port COMPORT number is passed into this app
   as an argument.
 - Sends whatever command is required to put the existing Teensy firmware into 'update' mode
 - Using the path of the updating program (passed in as an argument), locate the .HEX file 
   associated with the project, and send it's contents to the Teensy, one line at a time, counting
   lines and confirming checksums line-by-line
 - Compare the number of bytes sent to the Teensy with the number of bytes received by the Teensy,
   and if there is a match, allow the Teensy update process to complete; otherwise abort
  
*/

namespace TeensyFlash
{  
    class Program
    {
        const string startCmdStr = "C"; //used in 'GetUserInput()' to start upload sequence
        static string rcvStr = string.Empty;
        private static System.Timers.Timer aTimer;
        private static bool bTimedOut;

        static void Main(string[] args)
        {
            //Extract the build path and selected COMPORT number from the arguments to the call to Main()
            Console.WriteLine("Teensy Flash Console");
            Console.WriteLine("Number of arguments in args = {0}\n", args.Length);
            int argindex = 0;
            string comPortStr = string.Empty;
            foreach (var item in args)
            {
                Console.WriteLine(item);
                if (item.Contains("COM"))
                {
                    comPortStr = args[argindex];
                }

                argindex++;
            }

            string build_path = args[0];
            //string projectName = args[args.Length - 1];
            //projectName = projectName.Substring(0, projectName.Length - 4); //remove extension
            string projectName = "TeensyFlashDemoV2";
            build_path = build_path.Replace("\"", string.Empty).Trim();
            Console.WriteLine("path = {0}", build_path);
            Console.WriteLine("comport = {0}", comPortStr);
            Console.WriteLine("build name = {0}", projectName);
            Console.WriteLine("path to HEX file = {0}", build_path + "\\" + projectName + ".hex");

            //Find and open .HEX file - maybe pre-process to confirm checksums and get number of bytes.
            string[] lines = System.IO.File.ReadAllLines(build_path + "\\" + projectName + ".hex");
            int numlines = 0;
            int numbytes = 0;

            //Console.WriteLine("No\t\t\t\t\tLine\t\t\t\t\tChk\tBytes\n");
            //foreach (string item in lines)
            //{
            //    numlines++;
            //    string line = item.Replace(":", string.Empty).Trim();
            //    numbytes += (line.Length - 2) / 2;
            //    Console.WriteLine("{0}:{1} {2} {3}",numlines, line, chksum(line), numbytes);
            //}



            //Open UART serial port connection to the Teensy, typically one provided by a BT adaptor
            //Send whatever command is required to put the existing Teensy firmware into 'update' mode
            try
            {
                SerialPort _serport = new SerialPort(comPortStr, 115200);
                _serport.Open();
                _serport.DiscardOutBuffer();
                _serport.DiscardInBuffer();
                _serport.DataReceived += new SerialDataReceivedEventHandler(ResponseHandler);
                Thread.Sleep(100);
                Console.WriteLine(startCmdStr);
                _serport.Write(startCmdStr);

                rcvStr = string.Empty;
                aTimer = new System.Timers.Timer();
                aTimer.Interval = 5000;
                aTimer.Elapsed += OnTimedEvent;

                aTimer.Start();
                while (!rcvStr.Contains("waiting") && !bTimedOut)
                {
                    Thread.Sleep(100);
                }
                aTimer.Stop();
                //aTimer.Dispose();

                if (bTimedOut)
                {
                    Console.WriteLine("Timed out waiting for response from Teensy");
                }
                else
                {
                    //if we get to here, the Teensy is ready to receive HEX file contents
                    //Console.WriteLine("Got "+ rcvStr + "from Teensy");
                    Thread.Sleep(500);
                    numlines = 0;
                    foreach (string item in lines)
                    {
                        numlines++;
                        Console.WriteLine(item);
                        _serport.WriteLine(item);
                    }
                    Console.WriteLine("total lines = {0}", numlines);

                    //now we wait for Teensy to emit "hex file: xx lines xx bytes..." and then "enter xx to flash..."

                    //aTimer.Start();
                    while (!rcvStr.Contains("hex file:") && !bTimedOut)
                    {
                        Thread.Sleep(100);
                    }
                    aTimer.Stop();
                    //aTimer.Dispose();

                    if (bTimedOut)
                    {
                        Console.WriteLine("Timed out waiting for response from Teensy");
                    }
                    else
                    {
                        //extract number of lines from Teensy string, and compare with numlines.
                        //If they match, then send the number back to Teensy to complete the update.
                        //Otherwise, send '0' to abort

                        int colonIdx = rcvStr.IndexOf(':');
                        int lineIdx = rcvStr.IndexOf("lines");
                        string compareStr = rcvStr.Substring(colonIdx+1, lineIdx - colonIdx-1);
                        compareStr = compareStr.Trim();
                        int numTeensyLines = Convert.ToInt16(compareStr);

                        if (numTeensyLines == numlines)
                        {
                            Console.WriteLine("numlines {0} matches numTeensyLines {1} - send confirmation",
                                numlines, numTeensyLines);

                            _serport.WriteLine(compareStr);
                        }
                    }


                    //Send [project_name].Hex file to the Teensy, confirming checksum and counting lines
                    //If sent bytes match received bytes, allow the update to complete.
                }
            }
            catch (Exception exc)
            {
                Console.WriteLine(exc.Message);
            }// end CATCH portion of TRY/CATCH block


        }

        private static void ResponseHandler(object sender, SerialDataReceivedEventArgs args)
        {
            //Console.WriteLine("In ResponseHandler");
            SerialPort sp = (SerialPort)sender;
            rcvStr = sp.ReadExisting();
            Console.WriteLine(rcvStr);
            //rcvStr = string.Empty;
            sp.DiscardInBuffer();
            //Environment.Exit(0);
        }

        static string chksum(string input)
        {
            int TwosComplement(string s)
            {
                if (s.Length % 2 != 0)
                    throw new FormatException(nameof(input));

                var checksum = 0;

                for (var i = 0; i < s.Length; i += 2)
                {
                    var value = int.Parse(s.Substring(i, 2), System.Globalization.NumberStyles.AllowHexSpecifier);

                    checksum = (checksum + value) & 0xFF;
                }

                return 256 - checksum & 0xFF;
            }

            //return string.Concat(":", input, " ", TwosComplement(input).ToString("X2"));
            return TwosComplement(input).ToString("X2");
        }
        private static void SetTimer()
        {
            // Create a timer with a two second interval.
            aTimer = new System.Timers.Timer(2000);
            // Hook up the Elapsed event for the timer. 
            aTimer.Elapsed += OnTimedEvent;
            //aTimer.AutoReset = true;
            aTimer.Enabled = true;
        }

        private static void OnTimedEvent(Object source, ElapsedEventArgs e)
        {
            Console.WriteLine("The Elapsed event was raised at {0:HH:mm:ss.fff}",
                              e.SignalTime);
            bTimedOut = true;
        }
    }

}

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

using System;

using System.IO.Ports;

using System.Threading;

using System.Timers;

Small console app to facilitate over-the-air (OTA) updates to a Teensy 3.x/4.x controller.

This app is called by a post-build 'hook' statement located in whatever Teensy program is

being updated. This app does the following:

- Extract the project path and selected COMPORT number from the arguments to the call to Main()

- Opens a UART serial port connection to the Teensy, typically one provided by a BT adaptor

operating in 'pass-through' mode. The serial port COMPORT number is passed into this app

as an argument.

- Sends whatever command is required to put the existing Teensy firmware into 'update' mode

- Using the path of the updating program (passed in as an argument), locate the .HEX file

associated with the project, and send it's contents to the Teensy, one line at a time, counting

lines and confirming checksums line-by-line

- Compare the number of bytes sent to the Teensy with the number of bytes received by the Teensy,

and if there is a match, allow the Teensy update process to complete; otherwise abort

namespace TeensyFlash

{

class Program

{

const string startCmdStr = "C"; //used in 'GetUserInput()' to start upload sequence

static string rcvStr = string.Empty;

private static System.Timers.Timer aTimer;

private static bool bTimedOut;

static void Main(string[] args)

{

//Extract the build path and selected COMPORT number from the arguments to the call to Main()

Console.WriteLine("Teensy Flash Console");

Console.WriteLine("Number of arguments in args = {0}\n", args.Length);

int argindex = 0;

string comPortStr = string.Empty;

foreach (var item in args)

{

Console.WriteLine(item);

if (item.Contains("COM"))

{

comPortStr = args[argindex];

}

argindex++;

}

string build_path = args[0];

//string projectName = args[args.Length - 1];

//projectName = projectName.Substring(0, projectName.Length - 4); //remove extension

string projectName = "TeensyFlashDemoV2";

build_path = build_path.Replace("\"", string.Empty).Trim();

Console.WriteLine("path = {0}", build_path);

Console.WriteLine("comport = {0}", comPortStr);

Console.WriteLine("build name = {0}", projectName);

Console.WriteLine("path to HEX file = {0}", build_path + "\\" + projectName + ".hex");

//Find and open .HEX file - maybe pre-process to confirm checksums and get number of bytes.

string[] lines = System.IO.File.ReadAllLines(build_path + "\\" + projectName + ".hex");

int numlines = 0;

int numbytes = 0;

//Console.WriteLine("No\t\t\t\t\tLine\t\t\t\t\tChk\tBytes\n");

//foreach (string item in lines)

//{

// numlines++;

// string line = item.Replace(":", string.Empty).Trim();

// numbytes += (line.Length - 2) / 2;

// Console.WriteLine("{0}:{1} {2} {3}",numlines, line, chksum(line), numbytes);

//}

//Open UART serial port connection to the Teensy, typically one provided by a BT adaptor

//Send whatever command is required to put the existing Teensy firmware into 'update' mode

try

{

SerialPort _serport = new SerialPort(comPortStr, 115200);

_serport.Open();

_serport.DiscardOutBuffer();

_serport.DiscardInBuffer();

_serport.DataReceived += new SerialDataReceivedEventHandler(ResponseHandler);

Thread.Sleep(100);

Console.WriteLine(startCmdStr);

_serport.Write(startCmdStr);

rcvStr = string.Empty;

aTimer = new System.Timers.Timer();

aTimer.Interval = 5000;

aTimer.Elapsed += OnTimedEvent;

aTimer.Start();

while (!rcvStr.Contains("waiting") && !bTimedOut)

{

Thread.Sleep(100);

}

aTimer.Stop();

//aTimer.Dispose();

if (bTimedOut)

{

Console.WriteLine("Timed out waiting for response from Teensy");

}

else

{

//if we get to here, the Teensy is ready to receive HEX file contents

//Console.WriteLine("Got "+ rcvStr + "from Teensy");

Thread.Sleep(500);

numlines = 0;

foreach (string item in lines)

{

numlines++;

Console.WriteLine(item);

_serport.WriteLine(item);

}

Console.WriteLine("total lines = {0}", numlines);

//now we wait for Teensy to emit "hex file: xx lines xx bytes..." and then "enter xx to flash..."

//aTimer.Start();

while (!rcvStr.Contains("hex file:") && !bTimedOut)

{

Thread.Sleep(100);

}

aTimer.Stop();

//aTimer.Dispose();

if (bTimedOut)

{

Console.WriteLine("Timed out waiting for response from Teensy");

}

else

{

//extract number of lines from Teensy string, and compare with numlines.

//If they match, then send the number back to Teensy to complete the update.

//Otherwise, send '0' to abort

int colonIdx = rcvStr.IndexOf(':');

int lineIdx = rcvStr.IndexOf("lines");

string compareStr = rcvStr.Substring(colonIdx+1, lineIdx - colonIdx-1);

compareStr = compareStr.Trim();

int numTeensyLines = Convert.ToInt16(compareStr);

if (numTeensyLines == numlines)

{

Console.WriteLine("numlines {0} matches numTeensyLines {1} - send confirmation",

numlines, numTeensyLines);

_serport.WriteLine(compareStr);

}

//Send [project_name].Hex file to the Teensy, confirming checksum and counting lines

//If sent bytes match received bytes, allow the update to complete.

}

catch (Exception exc)

{

Console.WriteLine(exc.Message);

}// end CATCH portion of TRY/CATCH block

}

private static void ResponseHandler(object sender, SerialDataReceivedEventArgs args)

{

//Console.WriteLine("In ResponseHandler");

SerialPort sp = (SerialPort)sender;

rcvStr = sp.ReadExisting();

Console.WriteLine(rcvStr);

//rcvStr = string.Empty;

sp.DiscardInBuffer();

//Environment.Exit(0);

}

static string chksum(string input)

{

int TwosComplement(string s)

{

if (s.Length % 2 != 0)

throw new FormatException(nameof(input));

var checksum = 0;

for (var i = 0; i < s.Length; i += 2)

{

var value = int.Parse(s.Substring(i, 2), System.Globalization.NumberStyles.AllowHexSpecifier);

checksum = (checksum + value) & 0xFF;

}

return 256 - checksum & 0xFF;

}

//return string.Concat(":", input, " ", TwosComplement(input).ToString("X2"));

return TwosComplement(input).ToString("X2");

}

private static void SetTimer()

{

// Create a timer with a two second interval.

aTimer = new System.Timers.Timer(2000);

// Hook up the Elapsed event for the timer.

aTimer.Elapsed += OnTimedEvent;

//aTimer.AutoReset = true;

aTimer.Enabled = true;

}

private static void OnTimedEvent(Object source, ElapsedEventArgs e)

{

Console.WriteLine("The Elapsed event was raised at {0:HH:mm:ss.fff}",

e.SignalTime);

bTimedOut = true;

}

And here is the command-line output from my last run:

Teensy Flash Console
Number of arguments in args = 2

C:\Users\Frank\Documents\Arduino\TeensyFlashDemoV2\Release
COM3
path = C:\Users\Frank\Documents\Arduino\TeensyFlashDemoV2\Release
comport = COM3
build name = TeensyFlashDemoV2
path to HEX file = C:\Users\Frank\Documents\Arduino\TeensyFlashDemoV2\Release\TeensyFlashDemoV2.hex
C
I received: 43
Start Program Update - Send new HEX file!
buffer = 460K FLASH (0000D000 - 00080000)
waiting for hex lines...

:10000000F8FF022099010000850C00003D0C000063
:100010003D0C00003D0C00003D0C00003D0C0000BC
:100020003D0C00003D0C00003D0C0000850C000064
:10003000850C00003D0C0000952000009920000078
:10004000850C0000850C0000850C0000850C00006C
...
...
...
:10B80C005011FF1F5011FF1F5811FF1F5811FF1F20
:10B81C006011FF1F6011FF1F6811FF1F6811FF1FD0
:10B82C007011FF1F7011FF1F7811FF1F7811FF1F80
:10B83C008011FF1F8011FF1F8811FF1F8811FF1F30
:10B84C009011FF1F9011FF1F9811FF1F9811FF1FE0
:10B85C00A011FF1FA011FF1FA811FF1FA811FF1F90
:10B86C00B011FF1FB011FF1FB811FF1FB811FF1F40
:10B87C00C011FF1FC011FF1FC811FF1FC811FF1FF0
:10B88C00D011FF1FD011FF1FD811FF1FD811FF1FA0
:10B89C00E011FF1FE011FF1FE811FF1FE811FF1F50
:10B8AC00F011FF1FF011FF1FF811FF1FF811FF1F00
:10B8BC000012FF1F0012FF1F0812FF1F0812FF1FAC
:10B8CC001012FF1F1012FF1F1812FF1F1812FF1F5C
:10B8DC002012FF1F2012FF1F2812FF1F2812FF1F0C
:10B8EC003012FF1F3012FF1F3812FF1F3812FF1FBC
:10B8FC004012FF1F4012FF1F4812FF1F4812FF1F6C
:10B90C005012FF1F5012FF1F5812FF1F5812FF1F1B
:10B91C006012FF1F6012FF1F6812FF1F6812FF1FCB
:10B92C007012FF1F7012FF1F7812FF1F7812FF1F7B
:10B93C008012FF1F8012FF1F8812FF1F8812FF1F2B
:10B94C009012FF1F9012FF1F9812FF1F9812FF1FDB
:10B95C00A012FF1FA012FF1FA812FF1FA812FF1F8B
:10B96C00B012FF1FB012FF1FB812FF1FB812FF1F3B
:10B97C00C012FF1FC012FF1FC812FF1FC812FF1FEB
:10B98C00D012FF1FD012FF1FD812FF1FD812FF1F9B
:10B99C00E012FF1FE012FF1FE812FF1FE812FF1F4B
:10B9AC00F012FF1FF012FF1FF812FF1FF812FF1FFB
:10B9BC000013FF1F0013FF1F0813FF1F0813FF1FA7
:10B9CC001013FF1F1013FF1F1813FF1F1813FF1F57
:10B9DC002013FF1F2013FF1F00000200FFFFFFFFBB
:00000001FF
total lines = 2977

hex file: 2977 lines 47596 bytes (00000000 - 0000B9EC)
new code contains correct FSEC value FFFFF9DE
new code contains correct target ID fw_teensy35
enter 2977 to flash or 0 to abort

numlines 2977 matches numTeensyLines 2977 - send confirmation

C:\Users\Frank\Documents\Visual Studio 2019\Projects\TeensyFlash\bin\Debug\netcoreapp3.1\TeensyFlash.exe (process 6548) exited with code 0.
To automatically close the console when debugging stops, enable Tools->Options->Debugging->Automatically close the console when debugging stops.
Press any key to close this window . . .

Teensy Flash Console

Number of arguments in args = 2

C:\Users\Frank\Documents\Arduino\TeensyFlashDemoV2\Release

COM3

path = C:\Users\Frank\Documents\Arduino\TeensyFlashDemoV2\Release

comport = COM3

build name = TeensyFlashDemoV2

path to HEX file = C:\Users\Frank\Documents\Arduino\TeensyFlashDemoV2\Release\TeensyFlashDemoV2.hex

I received: 43

Start Program Update - Send new HEX file!

buffer = 460K FLASH (0000D000 - 00080000)

waiting for hex lines...

:10000000F8FF022099010000850C00003D0C000063

:100010003D0C00003D0C00003D0C00003D0C0000BC

:100020003D0C00003D0C00003D0C0000850C000064

:10003000850C00003D0C0000952000009920000078

:10004000850C0000850C0000850C0000850C00006C

...

:10B80C005011FF1F5011FF1F5811FF1F5811FF1F20

:10B81C006011FF1F6011FF1F6811FF1F6811FF1FD0

:10B82C007011FF1F7011FF1F7811FF1F7811FF1F80

:10B83C008011FF1F8011FF1F8811FF1F8811FF1F30

:10B84C009011FF1F9011FF1F9811FF1F9811FF1FE0

:10B85C00A011FF1FA011FF1FA811FF1FA811FF1F90

:10B86C00B011FF1FB011FF1FB811FF1FB811FF1F40

:10B87C00C011FF1FC011FF1FC811FF1FC811FF1FF0

:10B88C00D011FF1FD011FF1FD811FF1FD811FF1FA0

:10B89C00E011FF1FE011FF1FE811FF1FE811FF1F50

:10B8AC00F011FF1FF011FF1FF811FF1FF811FF1F00

:10B8BC000012FF1F0012FF1F0812FF1F0812FF1FAC

:10B8CC001012FF1F1012FF1F1812FF1F1812FF1F5C

:10B8DC002012FF1F2012FF1F2812FF1F2812FF1F0C

:10B8EC003012FF1F3012FF1F3812FF1F3812FF1FBC

:10B8FC004012FF1F4012FF1F4812FF1F4812FF1F6C

:10B90C005012FF1F5012FF1F5812FF1F5812FF1F1B

:10B91C006012FF1F6012FF1F6812FF1F6812FF1FCB

:10B92C007012FF1F7012FF1F7812FF1F7812FF1F7B

:10B93C008012FF1F8012FF1F8812FF1F8812FF1F2B

:10B94C009012FF1F9012FF1F9812FF1F9812FF1FDB

:10B95C00A012FF1FA012FF1FA812FF1FA812FF1F8B

:10B96C00B012FF1FB012FF1FB812FF1FB812FF1F3B

:10B97C00C012FF1FC012FF1FC812FF1FC812FF1FEB

:10B98C00D012FF1FD012FF1FD812FF1FD812FF1F9B

:10B99C00E012FF1FE012FF1FE812FF1FE812FF1F4B

:10B9AC00F012FF1FF012FF1FF812FF1FF812FF1FFB

:10B9BC000013FF1F0013FF1F0813FF1F0813FF1FA7

:10B9CC001013FF1F1013FF1F1813FF1F1813FF1F57

:10B9DC002013FF1F2013FF1F00000200FFFFFFFFBB

:00000001FF

total lines = 2977

hex file: 2977 lines 47596 bytes (00000000 - 0000B9EC)

new code contains correct FSEC value FFFFF9DE

new code contains correct target ID fw_teensy35

enter 2977 to flash or 0 to abort

numlines 2977 matches numTeensyLines 2977 - send confirmation

C:\Users\Frank\Documents\Visual Studio 2019\Projects\TeensyFlash\bin\Debug\netcoreapp3.1\TeensyFlash.exe (process 6548) exited with code 0.

To automatically close the console when debugging stops, enable Tools->Options->Debugging->Automatically close the console when debugging stops.

Press any key to close this window . . .

In the above printout, most of the HEX lines were removed just to keep the line count down, but all 2977 lines were successfully sent to the Teensy. The lines

hex file: 2977 lines 47596 bytes (00000000 - 0000B9EC)
new code contains correct FSEC value FFFFF9DE
new code contains correct target ID fw_teensy35
enter 2977 to flash or 0 to abort

hex file: 2977 lines 47596 bytes (00000000 - 0000B9EC)

new code contains correct FSEC value FFFFF9DE

new code contains correct target ID fw_teensy35

enter 2977 to flash or 0 to abort

were emitted from the Teensy at the conclusion of the HEX file upload. The line

numlines 2977 matches numTeensyLines 2977 - send confirmation

1	numlines 2977 matches numTeensyLines 2977 - send confirmation

was from the command-line app comparing the number of lines sent with the number of lines received. The numbers matched, so ‘2977’ was sent to the Teensy to complete the update.

At this point I have a working automated update system except the COM port number and HEX file location was passed to the C# program as a set of fixed arguments (as shown below), to disconnect the command-line app from the Arduino sketch, instead of dynamically providing the same parameters from VM build properties

Now that I have some confidence that the command-line app does what it is supposed to do, I can go back and make that connection again, hopefully with better results this time.

A problem with the Arduino-to-C# command-line app is that the ‘build properties’ exposed by Visual Micro aren’t always the same, so what works for one sketch may or may not work for another. Here’s the ‘build properties’ output from my expanded ‘TeensySerialBridgeV1.ino’ file:

Board Properties
name=Teensy 3.5
upload.maximum_size=524288
upload.maximum_data_size=262136
upload.tool=teensyloader
upload.protocol=halfkay
build.board=TEENSY35
build.core=teensy3
build.mcu=mk64fx512
build.warn_data_percentage=98
build.toolchain=arm/bin/
build.command.gcc=arm-none-eabi-gcc
build.command.g++=arm-none-eabi-g++
build.command.ar=arm-none-eabi-gcc-ar
build.command.objcopy=arm-none-eabi-objcopy
build.command.objdump=arm-none-eabi-objdump
build.command.linker=arm-none-eabi-gcc
build.command.size=arm-none-eabi-size
build.flags.common=-g -Wall -ffunction-sections -fdata-sections -nostdlib
build.flags.dep=-MMD
build.flags.optimize=-O2
build.flags.cpu=-mthumb -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16 -fsingle-precision-constant
build.flags.defs=-D__MK64FX512__ -DTEENSYDUINO=153
build.flags.cpp=-fno-exceptions -fpermissive -felide-constructors -std=gnu++14 -Wno-error=narrowing -fno-rtti
build.flags.c=
build.flags.S=-x assembler-with-cpp
build.flags.ld=-Wl,--gc-sections,--relax,--defsym=__rtc_localtime={extra.time.local} "-T{build.core.path}/mk64fx512.ld"
build.flags.libs=-larm_cortexM4lf_math -lm -lstdc++
serial.restart_cmd=false
menu.usb.serial=Serial
menu.usb.serial.build.usbtype=USB_SERIAL
menu.usb.serial2=Dual Serial
menu.usb.serial2.build.usbtype=USB_DUAL_SERIAL
menu.usb.serial3=Triple Serial
menu.usb.serial3.build.usbtype=USB_TRIPLE_SERIAL
menu.usb.keyboard=Keyboard
menu.usb.keyboard.build.usbtype=USB_KEYBOARDONLY
menu.usb.keyboard.fake_serial=teensy_gateway
menu.usb.touch=Keyboard + Touch Screen
menu.usb.touch.build.usbtype=USB_TOUCHSCREEN
menu.usb.touch.fake_serial=teensy_gateway
menu.usb.hidtouch=Keyboard + Mouse + Touch Screen
menu.usb.hidtouch.build.usbtype=USB_HID_TOUCHSCREEN
menu.usb.hidtouch.fake_serial=teensy_gateway
menu.usb.hid=Keyboard + Mouse + Joystick
menu.usb.hid.build.usbtype=USB_HID
menu.usb.hid.fake_serial=teensy_gateway
menu.usb.serialhid=Serial + Keyboard + Mouse + Joystick
menu.usb.serialhid.build.usbtype=USB_SERIAL_HID
menu.usb.midi=MIDI
menu.usb.midi.build.usbtype=USB_MIDI
menu.usb.midi.fake_serial=teensy_gateway
menu.usb.midi4=MIDIx4
menu.usb.midi4.build.usbtype=USB_MIDI4
menu.usb.midi4.fake_serial=teensy_gateway
menu.usb.midi16=MIDIx16
menu.usb.midi16.build.usbtype=USB_MIDI16
menu.usb.midi16.fake_serial=teensy_gateway
menu.usb.serialmidi=Serial + MIDI
menu.usb.serialmidi.build.usbtype=USB_MIDI_SERIAL
menu.usb.serialmidi4=Serial + MIDIx4
menu.usb.serialmidi4.build.usbtype=USB_MIDI4_SERIAL
menu.usb.serialmidi16=Serial + MIDIx16
menu.usb.serialmidi16.build.usbtype=USB_MIDI16_SERIAL
menu.usb.audio=Audio
menu.usb.audio.build.usbtype=USB_AUDIO
menu.usb.audio.fake_serial=teensy_gateway
menu.usb.serialmidiaudio=Serial + MIDI + Audio
menu.usb.serialmidiaudio.build.usbtype=USB_MIDI_AUDIO_SERIAL
menu.usb.serialmidi16audio=Serial + MIDIx16 + Audio
menu.usb.serialmidi16audio.build.usbtype=USB_MIDI16_AUDIO_SERIAL
menu.usb.mtp=MTP Disk (Experimental)
menu.usb.mtp.build.usbtype=USB_MTPDISK
menu.usb.mtp.fake_serial=teensy_gateway
menu.usb.rawhid=Raw HID
menu.usb.rawhid.build.usbtype=USB_RAWHID
menu.usb.rawhid.fake_serial=teensy_gateway
menu.usb.flightsim=Flight Sim Controls
menu.usb.flightsim.build.usbtype=USB_FLIGHTSIM
menu.usb.flightsim.fake_serial=teensy_gateway
menu.usb.flightsimjoystick=Flight Sim Controls + Joystick
menu.usb.flightsimjoystick.build.usbtype=USB_FLIGHTSIM_JOYSTICK
menu.usb.flightsimjoystick.fake_serial=teensy_gateway
menu.usb.everything=All of the Above
menu.usb.everything.build.usbtype=USB_EVERYTHING
menu.usb.disable=No USB
menu.usb.disable.build.usbtype=USB_DISABLED
menu.speed.120=120 MHz
menu.speed.96=96 MHz
menu.speed.72=72 MHz
menu.speed.48=48 MHz
menu.speed.24=24 MHz
menu.speed.16=16 MHz (No USB)
menu.speed.8=8 MHz (No USB)
menu.speed.4=4 MHz (No USB)
menu.speed.2=2 MHz (No USB)
menu.speed.144=144 MHz (overclock)
menu.speed.168=168 MHz (overclock)
menu.speed.168.build.fcpu=168000000
menu.speed.144.build.fcpu=144000000
menu.speed.120.build.fcpu=120000000
menu.speed.96.build.fcpu=96000000
menu.speed.72.build.fcpu=72000000
menu.speed.48.build.fcpu=48000000
menu.speed.24.build.fcpu=24000000
menu.speed.16.build.fcpu=16000000
menu.speed.8.build.fcpu=8000000
menu.speed.4.build.fcpu=4000000
menu.speed.2.build.fcpu=2000000
menu.opt.o2std=Faster
menu.opt.o2std.build.flags.optimize=-O2
menu.opt.o2std.build.flags.ldspecs=
menu.opt.o2lto=Faster with LTO
menu.opt.o2lto.build.flags.optimize=-O2 -flto -fno-fat-lto-objects
menu.opt.o2lto.build.flags.ldspecs=-fuse-linker-plugin
menu.opt.o1std=Fast
menu.opt.o1std.build.flags.optimize=-O1
menu.opt.o1std.build.flags.ldspecs=
menu.opt.o1lto=Fast with LTO
menu.opt.o1lto.build.flags.optimize=-O1 -flto -fno-fat-lto-objects
menu.opt.o1lto.build.flags.ldspecs=-fuse-linker-plugin
menu.opt.o3std=Fastest
menu.opt.o3std.build.flags.optimize=-O3
menu.opt.o3std.build.flags.ldspecs=
menu.opt.o3purestd=Fastest + pure-code
menu.opt.o3purestd.build.flags.optimize=-O3 -mpure-code -D__PURE_CODE__
menu.opt.o3purestd.build.flags.ldspecs=
menu.opt.o3lto=Fastest with LTO
menu.opt.o3lto.build.flags.optimize=-O3 -flto -fno-fat-lto-objects
menu.opt.o3lto.build.flags.ldspecs=-fuse-linker-plugin
menu.opt.o3purelto=Fastest + pure-code with LTO
menu.opt.o3purelto.build.flags.optimize=-O3 -mpure-code -D__PURE_CODE__ -flto -fno-fat-lto-objects
menu.opt.o3purelto.build.flags.ldspecs=-fuse-linker-plugin
menu.opt.ogstd=Debug
menu.opt.ogstd.build.flags.optimize=-Og
menu.opt.ogstd.build.flags.ldspecs=
menu.opt.oglto=Debug with LTO
menu.opt.oglto.build.flags.optimize=-Og -flto -fno-fat-lto-objects
menu.opt.oglto.build.flags.ldspecs=-fuse-linker-plugin
menu.opt.osstd=Smallest Code
menu.opt.osstd.build.flags.optimize=-Os --specs=nano.specs
menu.opt.osstd.build.flags.ldspecs=
menu.opt.oslto=Smallest Code with LTO
menu.opt.oslto.build.flags.optimize=-Os -flto -fno-fat-lto-objects --specs=nano.specs
menu.opt.oslto.build.flags.ldspecs=-fuse-linker-plugin
menu.keys.en-us=US English
menu.keys.en-us.build.keylayout=US_ENGLISH
menu.keys.fr-ca=Canadian French
menu.keys.fr-ca.build.keylayout=CANADIAN_FRENCH
menu.keys.xx-ca=Canadian Multilingual
menu.keys.xx-ca.build.keylayout=CANADIAN_MULTILINGUAL
menu.keys.cz-cz=Czech
menu.keys.cz-cz.build.keylayout=CZECH
menu.keys.da-da=Danish
menu.keys.da-da.build.keylayout=DANISH
menu.keys.fi-fi=Finnish
menu.keys.fi-fi.build.keylayout=FINNISH
menu.keys.fr-fr=French
menu.keys.fr-fr.build.keylayout=FRENCH
menu.keys.fr-be=French Belgian
menu.keys.fr-be.build.keylayout=FRENCH_BELGIAN
menu.keys.fr-ch=French Swiss
menu.keys.fr-ch.build.keylayout=FRENCH_SWISS
menu.keys.de-de=German
menu.keys.de-de.build.keylayout=GERMAN
menu.keys.de-dm=German (Mac)
menu.keys.de-dm.build.keylayout=GERMAN_MAC
menu.keys.de-ch=German Swiss
menu.keys.de-ch.build.keylayout=GERMAN_SWISS
menu.keys.is-is=Icelandic
menu.keys.is-is.build.keylayout=ICELANDIC
menu.keys.en-ie=Irish
menu.keys.en-ie.build.keylayout=IRISH
menu.keys.it-it=Italian
menu.keys.it-it.build.keylayout=ITALIAN
menu.keys.no-no=Norwegian
menu.keys.no-no.build.keylayout=NORWEGIAN
menu.keys.pt-pt=Portuguese
menu.keys.pt-pt.build.keylayout=PORTUGUESE
menu.keys.pt-br=Portuguese Brazilian
menu.keys.pt-br.build.keylayout=PORTUGUESE_BRAZILIAN
menu.keys.rs-rs=Serbian (Latin Only)
menu.keys.rs-rs.build.keylayout=SERBIAN_LATIN_ONLY
menu.keys.es-es=Spanish
menu.keys.es-es.build.keylayout=SPANISH
menu.keys.es-mx=Spanish Latin America
menu.keys.es-mx.build.keylayout=SPANISH_LATIN_AMERICA
menu.keys.sv-se=Swedish
menu.keys.sv-se.build.keylayout=SWEDISH
menu.keys.tr-tr=Turkish (partial)
menu.keys.tr-tr.build.keylayout=TURKISH
menu.keys.en-gb=United Kingdom
menu.keys.en-gb.build.keylayout=UNITED_KINGDOM
menu.keys.usint=US International
menu.keys.usint.build.keylayout=US_INTERNATIONAL
runtime.ide.path=C:\Program Files (x86)\Arduino
runtime.os=windows
build.system.path=C:\Program Files (x86)\Arduino\hardware\teensy\avr\system
runtime.ide.version=108013
target_package=teensy
target_platform=teensy3
runtime.hardware.path=C:\Program Files (x86)\Arduino\hardware\teensy
originalid=teensy35
vm.run_sketch_prebuild_before_build=true
intellisense.include.paths.more={vmresolved.compiler.path}arm\arm-none-eabi\include;{vmresolved.compiler.path}arm\lib\gcc\arm-none-eabi\5.4.1\include;{vmresolved.compiler.path}arm\arm-none-eabi\include\c++\5.4.1;{vmresolved.compiler.path}arm\arm-none-eabi\include\c++\5.4.1\tr1;{vmresolved.compiler.path}arm\arm-none-eabi\include\c++\5.4.1\bits;{vmresolved.compiler.path}arm\arm-none-eabi\include\c++\5.4.1\arm-none-eabi;
vmboard.totalpins=16
vmboard.totalanalogpins=14
tools.teensy_gdbstub.cmd=arm-none-eabi-gdb.exe
tools.teensy_gdbstub.debug.path={runtime.hardware.path}/../tools/arm/bin
tools.teensy_gdbstub.initCmd=-ex "init halt"
vs-cmd.Debug.AttachtoProcess.tools.teensy_gdbstub.initCmd=-ex "init"
tools.teensy_gdbstub.debug.args=-ex "target remote \\.\{serial.debug.port}" {initCmd}
build.vm.ignore_gdb_extra_flags=1
tools.teensy_gdbstub.showLocalSerialPort=true
debug_menu.hwdebugger.teensy=GDBStub
debug_menu.hwdebugger.teensy.debug.tool=teensy_gdbstub
meta_teensy.sentence=This debugger requires the TeensyDebug Library from https://github.com/ftrias/TeensyDebug to be installed, and the <TeensyDebug.h> to be included, as well as a call to debug.begin(Serialxx);
meta_teensy.comment=Ensure the COM Port for the configured Debug Port is selected before attaching the Debugger, depending on your code. . Set vMicro > Debugger > 'Compiler Optimization' to 'No Project', 'No Project + Libraries' or 'None' when debugging. (NOTE: Changing the optimization setting for this platform might cause compilation errors with certain code such as HardwareSerial.)
meta_teensy.image.connect=https://www.visualmicro.com/pics/Debug-Help-TEENSY4-GDBSTUB-Connections.png
meta_teensy.image.operation=https://www.visualmicro.com/pics/Debug-Break-TEENSY4-GDBSTUB-VSOnly.png
meta_teensy.reference.usage.url=https://www.visualmicro.com/page/User-Guide.aspx?doc=Arduino-gdb-Tutorial.html
version=1.8.5
rewriting=disabled
compiler.path={runtime.hardware.path}/../tools/
compiler.objcopy.eep.flags=-O ihex -j .eeprom --set-section-flags=.eeprom=alloc,load --no-change-warnings --change-section-lma .eeprom=0
compiler.elf2hex.flags=-O ihex -R .eeprom
recipe.preproc.includes="{compiler.path}{build.toolchain}{build.command.g++}" -M -MG -MP -x c++ -w {build.flags.cpp} {build.flags.cpu} {build.flags.defs} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DF_CPU={build.fcpu} -D{build.usbtype} -DLAYOUT_{build.keylayout} {includes} "{source_file}"
recipe.preproc.macros="{compiler.path}{build.toolchain}{build.command.g++}" -E -CC -x c++ -w {compiler.cpp.flags} {build.flags.common} {build.flags.cpp} {build.flags.cpu} {build.flags.defs} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DF_CPU={build.fcpu} -D{build.usbtype} -DLAYOUT_{build.keylayout} {includes} "{source_file}" -o "{preprocessed_file_path}"
tools.arduino-preprocessor.path={runtime.tools.arduino-preprocessor.path}
tools.arduino-preprocessor.cmd.path={path}/arduino-preprocessor
tools.arduino-preprocessor.pattern="{cmd.path}" "{source_file}" "{codecomplete}" -- -std=gnu++14
recipe.hooks.sketch.prebuild.1.pattern="{compiler.path}precompile_helper" "{runtime.platform.path}/cores/{build.core}" "{build.path}" "{compiler.path}{build.toolchain}{build.command.g++}" -x c++-header {build.flags.optimize} {build.flags.common} {build.flags.dep} {build.flags.cpp} {build.flags.cpu} {build.flags.defs} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DF_CPU={build.fcpu} -D{build.usbtype} -DLAYOUT_{build.keylayout} "-I{runtime.platform.path}/cores/{build.core}" "{build.path}/pch/Arduino.h" -o "{build.path}/pch/Arduino.h.gch"
recipe.cpp.o.pattern="{compiler.path}{build.toolchain}{build.command.g++}" -c {build.flags.optimize} {build.flags.common} {build.flags.dep} {build.flags.cpp} {build.flags.cpu} {build.flags.defs} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DF_CPU={build.fcpu} -D{build.usbtype} -DLAYOUT_{build.keylayout} "-I{build.path}/pch" {includes} "{source_file}" -o "{object_file}"
recipe.c.o.pattern="{compiler.path}{build.toolchain}{build.command.gcc}" -c {build.flags.optimize} {build.flags.common} {build.flags.dep} {build.flags.c} {build.flags.cpu} {build.flags.defs} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DF_CPU={build.fcpu} -D{build.usbtype} -DLAYOUT_{build.keylayout} {includes} "{source_file}" -o "{object_file}"
recipe.S.o.pattern="{compiler.path}{build.toolchain}{build.command.gcc}" -c {build.flags.optimize} {build.flags.common} {build.flags.dep} {build.flags.S} {build.flags.cpu} {build.flags.defs} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DF_CPU={build.fcpu} -D{build.usbtype} -DLAYOUT_{build.keylayout} {includes} "{source_file}" -o "{object_file}"
recipe.ar.pattern="{compiler.path}{build.toolchain}{build.command.ar}" rcs "{archive_file_path}" "{object_file}"
recipe.c.combine.pattern="{compiler.path}{build.toolchain}{build.command.linker}" {build.flags.optimize} {build.flags.ld} {build.flags.ldspecs} {build.flags.cpu} -o "{build.path}/{build.project_name}.elf" {object_files} "{build.path}/{archive_file}" "-L{build.path}" {build.flags.libs}
recipe.elfpatch.pattern="{compiler.path}/hardware/tools/{build.elfpatch}" -mmcu={build.mcu} "{build.path}/{build.project_name}.elf" "{sketch_path}/disk"
recipe.objcopy.eep.pattern="{compiler.path}{build.toolchain}{build.command.objcopy}" {compiler.objcopy.eep.flags} "{build.path}/{build.project_name}.elf" "{build.path}/{build.project_name}.eep"
recipe.objcopy.hex.pattern="{compiler.path}{build.toolchain}{build.command.objcopy}" {compiler.elf2hex.flags} "{build.path}/{build.project_name}.elf" "{build.path}/{build.project_name}.hex"
recipe.hooks.postbuild.1.pattern="{compiler.path}stdout_redirect" "{build.path}/{build.project_name}.lst" "{compiler.path}{build.toolchain}{build.command.objdump}" -d -S -C "{build.path}/{build.project_name}.elf"
recipe.hooks.postbuild.2.pattern="{compiler.path}stdout_redirect" "{build.path}/{build.project_name}.sym" "{compiler.path}{build.toolchain}{build.command.objdump}" -t -C "{build.path}/{build.project_name}.elf"
recipe.hooks.postbuild.3.pattern="{compiler.path}teensy_post_compile" "-file={build.project_name}" "-path={build.path}" "-tools={compiler.path}" "-board={build.board}"
recipe.size.pattern="{compiler.path}{build.toolchain}{build.command.size}" -A "{build.path}/{build.project_name}.elf"
recipe.size.regex=^(?:\.text|\.text\.progmem|\.text\.itcm|\.data)\s+([0-9]+).*
recipe.size.regex.data=^(?:\.usbdescriptortable|\.dmabuffers|\.usbbuffers|\.data|\.bss|\.noinit|\.text\.itcm|\.text\.itcm\.padding)\s+([0-9]+).*
recipe.size.regex.eeprom=^(?:\.eeprom)\s+([0-9]+).*
discovery.teensy.pattern="{runtime.hardware.path}/../tools/teensy_ports" -J2
tools.teensyloader.cmd.path={runtime.hardware.path}/../tools
tools.teensyloader.upload.params.quiet=
tools.teensyloader.upload.params.verbose=-verbose
tools.teensyloader.upload.pattern="{cmd.path}/teensy_post_compile" "-file={build.project_name}" "-path={build.path}" "-tools={cmd.path}" "-board={build.board}" -reboot "-port={serial.port}" "-portlabel={serial.port.label}" "-portprotocol={serial.port.protocol}"
recipe.output.tmp_file={build.project_name}.hex
recipe.output.save_file={build.project_name}.{build.board}.hex
recipe.output.tmp_file2={build.project_name}.elf
recipe.output.save_file2={build.project_name}.elf
upload.verify=
tools.vmopenocd.cmd=bin/openocd.exe
tools.vmopenocd.cmd.windows=bin/openocd.exe
tools.vmopenocd.debug.params.verbose=-d2
tools.vmopenocd.debug.params.quiet=-d0
tools.vmopenocd.debug.address=localhost:3333
tools.vmopenocd.path={runtime.tools.openocd-0.10.0.20200213.path}
tools.vmopenocd.scriptPath=-s "{path}/scripts/"
tools.vmopenocd.logging=-l "{{build.path}/{build.project_name}_DebugOpenOCD.log}"
tools.vmopenocd.boardCmd=
tools.vmopenocd.targetCmd=
tools.vmopenocd.initCmd=
tools.vmopenocd.debug.pattern="{path}/{cmd}" {debug.verbose} {logging} {scriptPath} {boardCmd} {targetCmd} {initCmd}
tools.vmopenocd.program.cmd=bin/openocd.exe
tools.vmopenocd.program.cmd.windows=bin/openocd.exe
tools.vmopenocd.program.path={runtime.tools.openocd-0.10.0.20200213.path}
tools.vmopenocd.program.address=localhost:3333
tools.vmopenocd.program.params.verbose=-d2
tools.vmopenocd.program.params.quiet=-d0
tools.vmopenocd.program.elf.message=****[vMicro]**** Uploading ELF :
tools.vmopenocd.program.pattern="{path}/{cmd}" {program.verbose} {scriptPath} {boardCmd} {targetCmd} -c "echo -n {{program.elf.message}}" {programCmd}
tools.atmelICE.protocol=
tools.atmelICE.debug.cmd=arm-none-eabi-gdb.exe
tools.atmelICE.debug.path={runtime.tools.arm-none-eabi-gcc.path}/bin
tools.atmelICE.debug.pattern="{path}/{cmd}"
tools.atmelICE.server.initCmd=-c "init; reset halt"
vs-cmd.Debug.AttachtoProcess.tools.atmelICE.server.initCmd=-c "init"
tools.atmelICE.server.boardCmd=-c "adapter driver cmsis-dap" -c "cmsis_dap_vid_pid 0x03eb 0x2141"
tools.atmelICE.server.tool=vmopenocd
tools.atmelICE.debug.server=vmopenocd
tools.atmelICE.program.scriptPath=-s "{program.path}/scripts/"
tools.atmelICE.program.boardCmd=-c "adapter driver cmsis-dap" -c "cmsis_dap_vid_pid 0x03eb 0x2141"
tools.atmelICE.program.cmd=bin/openocd.exe
tools.atmelICE.program.cmd.windows=bin/openocd.exe
tools.atmelICE.program.path={runtime.tools.openocd-0.10.0.20200213.path}
tools.atmelICE.program.address=localhost:3333
tools.atmelICE.program.params.verbose=-d2
tools.atmelICE.program.params.quiet=-d0
tools.atmelICE.program.elf.message=****[vMicro]**** Uploading ELF :
tools.atmelICE.program.pattern="{program.path}/{program.cmd}" {program.verbose} {program.scriptPath} {program.boardCmd} {program.targetCmd} -c "echo -n {{program.elf.message}}" {program.programCmd}
tools.atmelICE.program.extra_params=
tools.atmelICE.program.protocol=
tools.atmelICE.erase.params.verbose=-d3
tools.atmelICE.erase.params.quiet=-d0
tools.atmelICE.erase.pattern=
tools.jlink.cmd=arm-none-eabi-gdb.exe
tools.jlink.path={runtime.tools.arm-none-eabi-gcc.path}/bin
tools.jlink.pattern="{path}/{cmd}"
tools.jlink.server.tool=vmopenocd
tools.jlink.debug.server=vmopenocd
tools.jlink.server.boardCmd=-f "interface/jlink.cfg"
tools.jlink.server.initCmd=-c "init; reset halt"
vs-cmd.Debug.AttachtoProcess.tools.jlink.server.initCmd=-c "init"
tools.jlink.program.scriptPath=-s "{program.path}/scripts/"
tools.jlink.program.boardCmd=-f "interface/jlink.cfg"
tools.jlink.program.cmd=bin/openocd.exe
tools.jlink.program.cmd.windows=bin/openocd.exe
tools.jlink.program.path={runtime.tools.openocd-0.10.0.20200213.path}
tools.jlink.program.address=localhost:3333
tools.jlink.program.params.verbose=-d2
tools.jlink.program.params.quiet=-d0
tools.jlink.program.elf.message=****[vMicro]**** Uploading ELF :
tools.jlink.program.pattern="{program.path}/{program.cmd}" {program.verbose} {program.scriptPath} {program.boardCmd} {program.targetCmd} -c "echo -n {{program.elf.message}}" {program.programCmd}
tools.jlink.upload.scriptPath=-s "{upload.path}/scripts/"
tools.jlink.upload.boardCmd=-f "interface/jlink.cfg"
tools.jlink.upload.cmd=bin/openocd.exe
tools.jlink.upload.cmd.windows=bin/openocd.exe
tools.jlink.upload.path={runtime.tools.openocd-0.10.0.20200213.path}
tools.jlink.upload.address=localhost:3333
tools.jlink.upload.params.verbose=-d2
tools.jlink.upload.params.quiet=-d0
tools.jlink.upload.elf.message=****[vMicro]**** Uploading ELF :
tools.jlink.upload.pattern="{upload.path}/{upload.cmd}" {upload.verbose} {upload.scriptPath} {upload.boardCmd} {upload.targetCmd} -c "echo -n {{upload.elf.message}}" {upload.programCmd}
tools.bmp_upload.cmd=arm-none-eabi-gdb.exe
tools.bmp_upload.debug.path={runtime.tools.arm-none-eabi-gcc.path}/bin/
tools.bmp_upload.program.cmd=bin/arm-none-eabi-gdb.exe
tools.bmp_upload.program.cmd.windows=bin/arm-none-eabi-gdb.exe
tools.bmp_upload.program.path={runtime.tools.arm-none-eabi-gcc.path}
tools.bmp_upload.upload.cmd=bin/arm-none-eabi-gdb.exe
tools.bmp_upload.upload.cmd.windows=bin/arm-none-eabi-gdb.exe
tools.bmp_upload.upload.path={runtime.tools.arm-none-eabi-gcc.path}
tools.bmp_upload.server.initCmd=-c "init; reset halt"
vs-cmd.Debug.AttachtoProcess.tools.bmp_upload.server.initCmd=-c "init"
tools.bmp_upload.showLocalSerialPort=true
tools.bmp_upload.debug.server=
tools.stlinkv2.description=
tools.stlinkv2.cmd=arm-none-eabi-gdb.exe
tools.stlinkv2.path={runtime.tools.arm-none-eabi-gcc.path}/bin
tools.stlinkv2.pattern="{path}/{cmd}"
tools.stlinkv2.server.tool=vmopenocd
tools.stlinkv2.debug.server=vmopenocd
tools.stlinkv2.server.boardCmd=-f "interface/stlink.cfg"
tools.stlinkv2.server.initCmd=-c "init; reset halt"
vs-cmd.Debug.AttachtoProcess.tools.stlinkv2.server.initCmd=-c "init"
tools.stlinkv2.upload.scriptPath=-s "{upload.path}/scripts/"
tools.stlinkv2.upload.boardCmd=-f "interface/stlink.cfg"
tools.stlinkv2.upload.cmd=bin/openocd.exe
tools.stlinkv2.upload.cmd.windows=bin/openocd.exe
tools.stlinkv2.upload.path={runtime.tools.openocd-0.10.0.20200213.path}
tools.stlinkv2.upload.address=localhost:3333
tools.stlinkv2.upload.params.verbose=-d2
tools.stlinkv2.upload.params.quiet=-d0
tools.stlinkv2.upload.elf.message=****[vMicro]**** Uploading ELF :
tools.stlinkv2.upload.pattern="{upload.path}/{upload.cmd}" {upload.verbose} {upload.scriptPath} {upload.boardCmd} {upload.targetCmd} -c "echo -n {{upload.elf.message}}" {upload.programCmd}
tools.stlinkv2.upload.extra_params=
tools.stlinkv2.upload.protocol=
tools.stlinkv2.protocol=
tools.f2232mm.cmd=arm-none-eabi-gdb.exe
tools.f2232mm.path={runtime.tools.arm-none-eabi-gcc.path}/bin
tools.f2232mm.pattern="{path}/{cmd}" {args}
tools.f2232mm.server.tool=vmopenocd
tools.f2232mm.debug.server=vmopenocd
tools.f2232mm.server.boardCmd=-f "interface/ftdi/minimodule.cfg"
tools.f2232mm.server.initCmd=-c "init; reset halt"
vs-cmd.Debug.AttachtoProcess.tools.f2232mm.server.initCmd=-c "init"
tools.f2232mm.upload.scriptPath=-s "{upload.path}/scripts/"
tools.f2232mm.upload.boardCmd=-f "interface/ftdi/minimodule.cfg"
tools.f2232mm.upload.cmd=bin/openocd.exe
tools.f2232mm.upload.cmd.windows=bin/openocd.exe
tools.f2232mm.upload.path={runtime.tools.openocd-0.10.0.20200213.path}
tools.f2232mm.upload.address=localhost:3333
tools.f2232mm.upload.params.verbose=-d2
tools.f2232mm.upload.params.quiet=-d0
tools.f2232mm.upload.elf.message=****[vMicro]**** Uploading ELF :
tools.f2232mm.upload.pattern="{upload.path}/{upload.cmd}" {upload.verbose} {upload.scriptPath} {upload.boardCmd} {upload.targetCmd} -c "echo -n {{upload.elf.message}}" {upload.programCmd}
tools.f2232mm.upload.extra_params=
tools.f2232mm.upload.protocol=
tools.f2232mm.protocol=
tools.f2232h.server.boardCmd=-f "interface/ftdi/minimodule-lowcost.cfg"
tools.f2232h.cmd=arm-none-eabi-gdb.exe
tools.f2232h.path={runtime.tools.arm-none-eabi-gcc.path}/bin
tools.f2232h.pattern="{path}/{cmd}"
tools.f2232h.server.tool=vmopenocd
tools.f2232h.debug.server=vmopenocd
tools.f2232h.server.initCmd=-c "init; reset halt"
vs-cmd.Debug.AttachtoProcess.tools.f2232h.server.initCmd=-c "init"
tools.f2232h.upload.scriptPath=-s "{upload.path}/scripts/"
tools.f2232h.upload.boardCmd=-f "interface/ftdi/minimodule-lowcost.cfg"
tools.f2232h.upload.cmd=bin/openocd.exe
tools.f2232h.upload.cmd.windows=bin/openocd.exe
tools.f2232h.upload.path={runtime.tools.openocd-0.10.0.20200213.path}
tools.f2232h.upload.address=localhost:3333
tools.f2232h.upload.params.verbose=-d2
tools.f2232h.upload.params.quiet=-d0
tools.f2232h.upload.elf.message=****[vMicro]**** Uploading ELF :
tools.f2232h.upload.pattern="{upload.path}/{upload.cmd}" {upload.verbose} {upload.scriptPath} {upload.boardCmd} {upload.targetCmd} -c "echo -n {{upload.elf.message}}" {upload.programCmd}
tools.f2232h.upload.extra_params=
tools.f2232h.upload.protocol=
tools.f2232h.protocol=
tools.daplink.server.boardCmd=-f "interface/cmsis-dap.cfg" -c "adapter speed 1000"
tools.daplink.cmd=arm-none-eabi-gdb.exe
tools.daplink.path={runtime.tools.arm-none-eabi-gcc.path}/bin
tools.daplink.pattern="{path}/{cmd}" {args}
tools.daplink.server.tool=vmopenocd
tools.daplink.debug.server=vmopenocd
tools.daplink.server.initCmd=-c "init; reset halt"
vs-cmd.Debug.AttachtoProcess.tools.daplink.server.initCmd=-c "init"
tools.daplink.upload.scriptPath=-s "{upload.path}/scripts/"
tools.daplink.upload.boardCmd=-f "interface/cmsis-dap.cfg" -c "adapter speed 1000"
tools.daplink.upload.cmd=bin/openocd.exe
tools.daplink.upload.cmd.windows=bin/openocd.exe
tools.daplink.upload.path={runtime.tools.openocd-0.10.0.20200213.path}
tools.daplink.upload.address=localhost:3333
tools.daplink.upload.params.verbose=-d2
tools.daplink.upload.params.quiet=-d0
tools.daplink.upload.elf.message=****[vMicro]**** Uploading ELF :
tools.daplink.upload.pattern="{upload.path}/{upload.cmd}" {upload.verbose} {upload.scriptPath} {upload.boardCmd} {upload.targetCmd} -c "echo -n {{upload.elf.message}}" {upload.programCmd}
tools.daplink.upload.extra_params=
tools.daplink.upload.protocol=
tools.daplink.protocol=
vm.platform.root.path=c:\program files (x86)\microsoft visual studio\2019\community\common7\ide\extensions\53lzl3xe.1x1\Micro Platforms\arduino16x
runtime.tools.arduinoOTA.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\arduinoOTA\1.3.0
runtime.tools.arduinoOTA-1.3.0.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\arduinoOTA\1.3.0
runtime.tools.arm-none-eabi-gcc.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\arm-none-eabi-gcc\4.8.3-2014q1
runtime.tools.arm-none-eabi-gcc-4.8.3-2014q1.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\arm-none-eabi-gcc\4.8.3-2014q1
runtime.tools.avrdude.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\avrdude\6.3.0-arduino17
runtime.tools.avrdude-6.3.0-arduino17.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\avrdude\6.3.0-arduino17
runtime.tools.avr-gcc.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\avr-gcc\7.3.0-atmel3.6.1-arduino7
runtime.tools.avr-gcc-7.3.0-atmel3.6.1-arduino7.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\avr-gcc\7.3.0-atmel3.6.1-arduino7
runtime.tools.bossac.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\bossac\1.6.1-arduino
runtime.tools.bossac-1.6.1-arduino.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\bossac\1.6.1-arduino
runtime.tools.CMSIS.path=C:\Users\Frank\AppData\Local\arduino15\packages\STM32\tools\CMSIS\5.5.1
runtime.tools.CMSIS-5.5.1.path=C:\Users\Frank\AppData\Local\arduino15\packages\STM32\tools\CMSIS\5.5.1
runtime.tools.esptool_py.path=C:\Users\Frank\AppData\Local\arduino15\packages\esp32\tools\esptool_py\3.0.0
runtime.tools.esptool_py-3.0.0.path=C:\Users\Frank\AppData\Local\arduino15\packages\esp32\tools\esptool_py\3.0.0
runtime.tools.mkspiffs.path=C:\Users\Frank\AppData\Local\arduino15\packages\esp32\tools\mkspiffs\0.2.3
runtime.tools.mkspiffs-0.2.3.path=C:\Users\Frank\AppData\Local\arduino15\packages\esp32\tools\mkspiffs\0.2.3
runtime.tools.STM32Tools.path=C:\Users\Frank\AppData\Local\arduino15\packages\STM32\tools\STM32Tools\1.4.0
runtime.tools.STM32Tools-1.4.0.path=C:\Users\Frank\AppData\Local\arduino15\packages\STM32\tools\STM32Tools\1.4.0
runtime.tools.xpack-arm-none-eabi-gcc.path=C:\Users\Frank\AppData\Local\arduino15\packages\STM32\tools\xpack-arm-none-eabi-gcc\9.2.1-1.1
runtime.tools.xpack-arm-none-eabi-gcc-9.2.1-1.1.path=C:\Users\Frank\AppData\Local\arduino15\packages\STM32\tools\xpack-arm-none-eabi-gcc\9.2.1-1.1
runtime.tools.xtensa-esp32-elf-gcc.path=C:\Users\Frank\AppData\Local\arduino15\packages\esp32\tools\xtensa-esp32-elf-gcc\1.22.0-97-gc752ad5-5.2.0
runtime.tools.xtensa-esp32-elf-gcc-1.22.0-97-gc752ad5-5.2.0.path=C:\Users\Frank\AppData\Local\arduino15\packages\esp32\tools\xtensa-esp32-elf-gcc\1.22.0-97-gc752ad5-5.2.0
runtime.vm.boardinfo.id=teensy35
runtime.vm.boardinfo.name=teensy35
runtime.vm.boardinfo.desc=Teensy 3.5
runtime.vm.boardinfo.src_location=C:\Program Files (x86)\Arduino\hardware\teensy\avr
ide.hint=Use installed IDE (hardware, reference/help + libraries)
ide.location.key=Arduino16x
ide.location.ide.winreg=Arduino 1.6.x Application
ide.location.sketchbook.winreg=Arduino 1.6.x Sketchbook
ide.location.sketchbook.preferences=sketchbook.path
ide.default.revision_name=1.8.13
ide.default.version=10800
ide.default.package=arduino
ide.default.platform=avr
ide.multiplatform=true
ide.includes=Arduino.h
ide.exe_name=arduino
ide.recipe.preproc.defines.flags=-w -x c++ -E -dM
ide.platformswithoutpackage=false
ide.includes.fallback=wprogram.h
ide.extension=ino
ide.extension.fallback=pde
ide.versionGTEQ=160
ide.exe=arduino.exe
ide.builder.exe=arduinobuilder.exe
ide.builder.name=Arduino Builder
ide.hosts=atmel
ide.url=https://www.visualmicro.com/page/Download-Arduino-Or-Other-Supporting-IDEs.aspx
ide.help.reference.path=reference
ide.help.reference.path2=reference\www.arduino.cc\en\Reference
ide.help.reference.serial=reference\www.arduino.cc\en\Serial
ide.location.preferences.portable={runtime.ide.path}\portable
ide.location.preferences.arduinoData={runtime.sketchbook.path}\ArduinoData
ide.location.preferences=%VM_APPDATA_LOCAL%\arduino15\preferences.txt
ide.location.preferences_fallback=%VM_APPDATA_ROAMING%\arduino15\preferences.txt
ide.location.contributions=%VM_APPDATA_LOCAL%\arduino15
ide.location.contributions_fallback=%VM_APPDATA_ROAMING%\arduino15
ide.contributions.boards.allow=true
ide.contributions.boards.ignore_unless_rewrite_found=true
ide.contributions.libraries.allow=true
ide.contributions.boards.support.urls.wiki=https://github.com/arduino/Arduino/wiki/Unofficial-list-of-3rd-party-boards-support-urls
ide.create_platforms_from_boardsTXT.teensy=build.core
vm.debug=true
software=ARDUINO
ssh.user.name=root
ssh.user.default.password=arduino
ssh.host.wwwfiles.path=/www/sd
build.working_directory={runtime.ide.path}\java\bin
runtime.tools.vm_web_debugger.path={vm.platform.root.path}/../../Micro Debuggers/WebDebugger
recipe.hooks.vmdeploy.vm_web_debugger_postupload.1.pattern="{runtime.tools.vm_web_debugger.path}/DeployMicroWebserver.exe" "{sketch_path}" "{serial.port}" "{runtime.hardware.path}\.."
recipe.hooks.vmlaunch.vm_web_debugger_preopen.1.pattern=notepad.exe "{sketch_path}\__vm\vmWebDebugger\Start-WebServer.bat"
recipe.hooks.vmlaunch.vm_web_debugger_preopen.2.pattern={sketch_path}\__vm\vmWebDebugger\Start-WebServer.bat
ide.debug_menu.debugger_type=Debug
ide.debug_menu.debugger_type.none=Off
ide.debug_menu.none.debug.tool=no_debug
ide.debug_menu.debugger_type.universal=Serial
ide.debug_menu.universal.debug.tool=universal
ide.debug_menu.debugger_type.hwdebugger=Hardware
ide.debug_menu.hwdebugger=Debugger
ide.debug_menu.hwdebugger.custom_debugger=Manual/Custom
ide.debug_menu.hwdebugger.custom_debugger.debug.tool=dbg_external
ide.meta_custom_debugger.sentence=Provides a build that includes debug defines and will launch a custom debugger if one is provided.
ide.meta_custom_debugger.paragraph=This is option is for advanced use. It is recommended that a pre-configured debugger be selected when available in this list. Usage: Optionally add a customer debugger to the project. A 'debugger_launch.json' file shares the same command syntax that is used by the VsCode debugger. Custom debuggers can be targeted at a board and/or variant and/or configuration name. IE: [variant].[configuration_name][.]debugger_launch.json
ide.meta_custom_debugger.reference.usage.url=https://github.com/Microsoft/vscode-cpptools/blob/master/launch.md#customlaunchsetupcommands
ide.meta_custom_debugger.reference.connect.url=https://docs.microsoft.com/en-us/visualstudio/debugger/create-custom-views-of-native-objects?view=vs-2019
ide.compiler_flags_no_opt=-O0
ide.debug_menu.vm_disable_optimization=Disable Optimization
ide.debug_menu.vm_disable_optimization.vm_disable_opt_default=Default Optimization
ide.debug_menu.vm_disable_optimization.vm_disable_opt_proj=No Project  Optimization
ide.debug_menu.vm_disable_opt_proj.vm_disable_opt_project={ide.compiler_flags_no_opt}
ide.debug_menu.vm_disable_optimization.vm_disable_opt_proj_libs=No Project + Libraries Optimization
ide.debug_menu.vm_disable_opt_proj_libs.vm_disable_opt_project={ide.compiler_flags_no_opt}
ide.debug_menu.vm_disable_opt_proj_libs.vm_disable_opt_libraries={ide.compiler_flags_no_opt}
ide.debug_menu.vm_disable_optimization.vm_disable_opt_all=No Optimization
ide.meta_vm_disable_opt_all.sentence=Disable compiler optimization for all sources:- Project, Library and Platform.
ide.meta_vm_disable_opt_all.comment=After switching between 'No Optimization' and other optimization values, please click "Solution Clean" or switch off (or cycle) 'vMicro>Compiler>Shared Cache For Cores'. NOTE: Changing optimization settings can cause build errors or result in overly large programs.
ide.debug_menu.vm_disable_opt_all.vm_disable_opt_project={ide.compiler_flags_no_opt}
ide.debug_menu.vm_disable_opt_all.vm_disable_opt_libraries={ide.compiler_flags_no_opt}
ide.debug_menu.vm_disable_opt_all.vm_disable_opt_core={ide.compiler_flags_no_opt}
ide.appid=arduino16x
location.sketchbook=C:\Users\Frank\Documents\Arduino
build.core.path=C:\Program Files (x86)\Arduino\hardware\teensy\avr\cores\teensy3
vm.core.include=arduino.h
vm.boardsource.path=C:\Program Files (x86)\Arduino\hardware\teensy\avr
runtime.platform.path=C:\Program Files (x86)\Arduino\hardware\teensy\avr
vm.platformname.name=teensy3
build.arch=TEENSY3
debug.tool=no_debug
build.usbtype=USB_SERIAL
build.fcpu=120000000
build.flags.ldspecs=
build.keylayout=US_ENGLISH
vm.runtime.compiler.cached_cores_path=C:\Users\Frank\AppData\Local\Temp\VMBCore\arduino16x
vm.runtime.compiler.showwarnings=false
vm.runtime.compiler.showwarnings_core=true
vm.runtime.compiler.showwarnings_library=false
vm.runtime.upload.verbose=false
vm.runtime.upload.verify=false
runtime.vm.ide.platforms.path=c:\program files (x86)\microsoft visual studio\2019\community\common7\ide\extensions\53lzl3xe.1x1\Micro Platforms
runtime.vm.ide.tools.openocd.path={runtime.tools.openocd-0.9.0.path}
runtime.vm.openocd.path={runtime.tools.openocd-0.9.0.path}
vm.runtime.build.intermediate_output_path=C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1\Release\
vm.runtime.build.final_output_path=C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1\Release\
compiler.always_include_sketchfolder=true
compiler.always_include_sharedprojectfolders=true
vm.runtime.compiler.auto_discover_includes=true
vm.runtime.compiler.auto_discover_includes_shallow=true
vm.runtime.compiler.allow_library_debugging=false
vm.sketch_ino_cpp_name=TeensySerialBridgeV1.cpp
serial.port.file=COM11
serial.port=COM11
serial.port.num=11
port.caption=COM11 - USB Serial Device
Caption=USB Serial Device (COM11)
ClassGuid={4d36e978-e325-11ce-bfc1-08002be10318}
CompatibleID.value0=USB\Class_02
ConfigManagerErrorCode=0
ConfigManagerUserConfig=False
CreationClassName=Win32_PnPEntity
Description=USB Serial Device
DeviceID=USB\VID_16C0&PID_0483\3016580
HardwareID.value0=USB\VID_16C0&PID_0483
Manufacturer=Microsoft
Name=USB Serial Device (COM11)
PNPClass=Ports
PNPDeviceID=USB\VID_16C0&PID_0483\3016580
Present=True
Service=usbser
Status=OK
SystemCreationClassName=Win32_ComputerSystem
SystemName=FRANKNEWXPS15
vid=0x16C0
pid=0x0483
vidpid=16C00483
vid_pid=0x16C0_0x0483
iserial=3016580
extra.time.local=1633459396
extra.time.utc=1633473796
extra.time.dst=-14400
extra.time.zone=14400
serial.port.caption=COM11 - USB Serial Device
serial.Caption=USB Serial Device (COM11)
serial.ClassGuid={4d36e978-e325-11ce-bfc1-08002be10318}
serial.CompatibleID.value0=USB\Class_02
serial.ConfigManagerErrorCode=0
serial.ConfigManagerUserConfig=False
serial.CreationClassName=Win32_PnPEntity
serial.Description=USB Serial Device
serial.DeviceID=USB\VID_16C0&PID_0483\3016580
serial.HardwareID.value0=USB\VID_16C0&PID_0483
serial.Manufacturer=Microsoft
serial.Name=USB Serial Device (COM11)
serial.PNPClass=Ports
serial.PNPDeviceID=USB\VID_16C0&PID_0483\3016580
serial.Present=True
serial.Service=usbser
serial.Status=OK
serial.SystemCreationClassName=Win32_ComputerSystem
serial.SystemName=FRANKNEWXPS15
serial.vid=0x16C0
serial.pid=0x0483
serial.vidpid=16C00483
serial.vid_pid=0x16C0_0x0483
serial.iserial=3016580
serial.port.iserial=3016580
build.project_name=TeensySerialBridgeV1.ino
build.project_path=C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1
sketch_path=C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1
ProjectDir=C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1\
build.path=C:\Users\Frank\AppData\Local\Temp\VMBuilds\TeensySerialBridgeV1\teensy35\Release
vm.runtime.compile.skip_library_file_if_exists_in_project=true
vm.runtime.compiler.auto_discover_includes_cache=true
build.vm.build.vmdebug=0
build.vm.build.isgdb=0
build.vm.build.optimised=1
vm.last.buildpath=C:\Users\Frank\AppData\Local\Temp\VMBuilds\TeensySerialBridgeV1\teensy35\Release
build.architecture=hardware
vmresolved.compiler.path=C:\Program Files (x86)\Arduino\hardware\tools\
vmresolved.tools.path=C:\Program Files (x86)\Arduino\hardware


Compiling 'TeensySerialBridgeV1' for 'Teensy 3.5'
Using previously compiled file: C:\Users\Frank\AppData\Local\Temp\VMBuilds\TeensySerialBridgeV1\teensy35\Release\pch\Arduino.h.gch
Program size: 50,268 bytes (used 10% of a 524,288 byte maximum) (0.84 secs)
Minimum Memory Usage: 5316 bytes (2% of a 262136 byte maximum)

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

Board Properties

name=Teensy 3.5

upload.maximum_size=524288

upload.maximum_data_size=262136

upload.tool=teensyloader

upload.protocol=halfkay

build.board=TEENSY35

build.core=teensy3

build.mcu=mk64fx512

build.warn_data_percentage=98

build.toolchain=arm/bin/

build.command.gcc=arm-none-eabi-gcc

build.command.g++=arm-none-eabi-g++

build.command.ar=arm-none-eabi-gcc-ar

build.command.objcopy=arm-none-eabi-objcopy

build.command.objdump=arm-none-eabi-objdump

build.command.linker=arm-none-eabi-gcc

build.command.size=arm-none-eabi-size

build.flags.common=-g -Wall -ffunction-sections -fdata-sections -nostdlib

build.flags.dep=-MMD

build.flags.optimize=-O2

build.flags.cpu=-mthumb -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16 -fsingle-precision-constant

build.flags.defs=-D__MK64FX512__ -DTEENSYDUINO=153

build.flags.cpp=-fno-exceptions -fpermissive -felide-constructors -std=gnu++14 -Wno-error=narrowing -fno-rtti

build.flags.c=

build.flags.S=-x assembler-with-cpp

build.flags.ld=-Wl,--gc-sections,--relax,--defsym=__rtc_localtime={extra.time.local} "-T{build.core.path}/mk64fx512.ld"

build.flags.libs=-larm_cortexM4lf_math -lm -lstdc++

serial.restart_cmd=false

menu.usb.serial=Serial

menu.usb.serial.build.usbtype=USB_SERIAL

menu.usb.serial2=Dual Serial

menu.usb.serial2.build.usbtype=USB_DUAL_SERIAL

menu.usb.serial3=Triple Serial

menu.usb.serial3.build.usbtype=USB_TRIPLE_SERIAL

menu.usb.keyboard=Keyboard

menu.usb.keyboard.build.usbtype=USB_KEYBOARDONLY

menu.usb.keyboard.fake_serial=teensy_gateway

menu.usb.touch=Keyboard + Touch Screen

menu.usb.touch.build.usbtype=USB_TOUCHSCREEN

menu.usb.touch.fake_serial=teensy_gateway

menu.usb.hidtouch=Keyboard + Mouse + Touch Screen

menu.usb.hidtouch.build.usbtype=USB_HID_TOUCHSCREEN

menu.usb.hidtouch.fake_serial=teensy_gateway

menu.usb.hid=Keyboard + Mouse + Joystick

menu.usb.hid.build.usbtype=USB_HID

menu.usb.hid.fake_serial=teensy_gateway

menu.usb.serialhid=Serial + Keyboard + Mouse + Joystick

menu.usb.serialhid.build.usbtype=USB_SERIAL_HID

menu.usb.midi=MIDI

menu.usb.midi.build.usbtype=USB_MIDI

menu.usb.midi.fake_serial=teensy_gateway

menu.usb.midi4=MIDIx4

menu.usb.midi4.build.usbtype=USB_MIDI4

menu.usb.midi4.fake_serial=teensy_gateway

menu.usb.midi16=MIDIx16

menu.usb.midi16.build.usbtype=USB_MIDI16

menu.usb.midi16.fake_serial=teensy_gateway

menu.usb.serialmidi=Serial + MIDI

menu.usb.serialmidi.build.usbtype=USB_MIDI_SERIAL

menu.usb.serialmidi4=Serial + MIDIx4

menu.usb.serialmidi4.build.usbtype=USB_MIDI4_SERIAL

menu.usb.serialmidi16=Serial + MIDIx16

menu.usb.serialmidi16.build.usbtype=USB_MIDI16_SERIAL

menu.usb.audio=Audio

menu.usb.audio.build.usbtype=USB_AUDIO

menu.usb.audio.fake_serial=teensy_gateway

menu.usb.serialmidiaudio=Serial + MIDI + Audio

menu.usb.serialmidiaudio.build.usbtype=USB_MIDI_AUDIO_SERIAL

menu.usb.serialmidi16audio=Serial + MIDIx16 + Audio

menu.usb.serialmidi16audio.build.usbtype=USB_MIDI16_AUDIO_SERIAL

menu.usb.mtp=MTP Disk (Experimental)

menu.usb.mtp.build.usbtype=USB_MTPDISK

menu.usb.mtp.fake_serial=teensy_gateway

menu.usb.rawhid=Raw HID

menu.usb.rawhid.build.usbtype=USB_RAWHID

menu.usb.rawhid.fake_serial=teensy_gateway

menu.usb.flightsim=Flight Sim Controls

menu.usb.flightsim.build.usbtype=USB_FLIGHTSIM

menu.usb.flightsim.fake_serial=teensy_gateway

menu.usb.flightsimjoystick=Flight Sim Controls + Joystick

menu.usb.flightsimjoystick.build.usbtype=USB_FLIGHTSIM_JOYSTICK

menu.usb.flightsimjoystick.fake_serial=teensy_gateway

menu.usb.everything=All of the Above

menu.usb.everything.build.usbtype=USB_EVERYTHING

menu.usb.disable=No USB

menu.usb.disable.build.usbtype=USB_DISABLED

menu.speed.120=120 MHz

menu.speed.96=96 MHz

menu.speed.72=72 MHz

menu.speed.48=48 MHz

menu.speed.24=24 MHz

menu.speed.16=16 MHz (No USB)

menu.speed.8=8 MHz (No USB)

menu.speed.4=4 MHz (No USB)

menu.speed.2=2 MHz (No USB)

menu.speed.144=144 MHz (overclock)

menu.speed.168=168 MHz (overclock)

menu.speed.168.build.fcpu=168000000

menu.speed.144.build.fcpu=144000000

menu.speed.120.build.fcpu=120000000

menu.speed.96.build.fcpu=96000000

menu.speed.72.build.fcpu=72000000

menu.speed.48.build.fcpu=48000000

menu.speed.24.build.fcpu=24000000

menu.speed.16.build.fcpu=16000000

menu.speed.8.build.fcpu=8000000

menu.speed.4.build.fcpu=4000000

menu.speed.2.build.fcpu=2000000

menu.opt.o2std=Faster

menu.opt.o2std.build.flags.optimize=-O2

menu.opt.o2std.build.flags.ldspecs=

menu.opt.o2lto=Faster with LTO

menu.opt.o2lto.build.flags.optimize=-O2 -flto -fno-fat-lto-objects

menu.opt.o2lto.build.flags.ldspecs=-fuse-linker-plugin

menu.opt.o1std=Fast

menu.opt.o1std.build.flags.optimize=-O1

menu.opt.o1std.build.flags.ldspecs=

menu.opt.o1lto=Fast with LTO

menu.opt.o1lto.build.flags.optimize=-O1 -flto -fno-fat-lto-objects

menu.opt.o1lto.build.flags.ldspecs=-fuse-linker-plugin

menu.opt.o3std=Fastest

menu.opt.o3std.build.flags.optimize=-O3

menu.opt.o3std.build.flags.ldspecs=

menu.opt.o3purestd=Fastest + pure-code

menu.opt.o3purestd.build.flags.optimize=-O3 -mpure-code -D__PURE_CODE__

menu.opt.o3purestd.build.flags.ldspecs=

menu.opt.o3lto=Fastest with LTO

menu.opt.o3lto.build.flags.optimize=-O3 -flto -fno-fat-lto-objects

menu.opt.o3lto.build.flags.ldspecs=-fuse-linker-plugin

menu.opt.o3purelto=Fastest + pure-code with LTO

menu.opt.o3purelto.build.flags.optimize=-O3 -mpure-code -D__PURE_CODE__ -flto -fno-fat-lto-objects

menu.opt.o3purelto.build.flags.ldspecs=-fuse-linker-plugin

menu.opt.ogstd=Debug

menu.opt.ogstd.build.flags.optimize=-Og

menu.opt.ogstd.build.flags.ldspecs=

menu.opt.oglto=Debug with LTO

menu.opt.oglto.build.flags.optimize=-Og -flto -fno-fat-lto-objects

menu.opt.oglto.build.flags.ldspecs=-fuse-linker-plugin

menu.opt.osstd=Smallest Code

menu.opt.osstd.build.flags.optimize=-Os --specs=nano.specs

menu.opt.osstd.build.flags.ldspecs=

menu.opt.oslto=Smallest Code with LTO

menu.opt.oslto.build.flags.optimize=-Os -flto -fno-fat-lto-objects --specs=nano.specs

menu.opt.oslto.build.flags.ldspecs=-fuse-linker-plugin

menu.keys.en-us=US English

menu.keys.en-us.build.keylayout=US_ENGLISH

menu.keys.fr-ca=Canadian French

menu.keys.fr-ca.build.keylayout=CANADIAN_FRENCH

menu.keys.xx-ca=Canadian Multilingual

menu.keys.xx-ca.build.keylayout=CANADIAN_MULTILINGUAL

menu.keys.cz-cz=Czech

menu.keys.cz-cz.build.keylayout=CZECH

menu.keys.da-da=Danish

menu.keys.da-da.build.keylayout=DANISH

menu.keys.fi-fi=Finnish

menu.keys.fi-fi.build.keylayout=FINNISH

menu.keys.fr-fr=French

menu.keys.fr-fr.build.keylayout=FRENCH

menu.keys.fr-be=French Belgian

menu.keys.fr-be.build.keylayout=FRENCH_BELGIAN

menu.keys.fr-ch=French Swiss

menu.keys.fr-ch.build.keylayout=FRENCH_SWISS

menu.keys.de-de=German

menu.keys.de-de.build.keylayout=GERMAN

menu.keys.de-dm=German (Mac)

menu.keys.de-dm.build.keylayout=GERMAN_MAC

menu.keys.de-ch=German Swiss

menu.keys.de-ch.build.keylayout=GERMAN_SWISS

menu.keys.is-is=Icelandic

menu.keys.is-is.build.keylayout=ICELANDIC

menu.keys.en-ie=Irish

menu.keys.en-ie.build.keylayout=IRISH

menu.keys.it-it=Italian

menu.keys.it-it.build.keylayout=ITALIAN

menu.keys.no-no=Norwegian

menu.keys.no-no.build.keylayout=NORWEGIAN

menu.keys.pt-pt=Portuguese

menu.keys.pt-pt.build.keylayout=PORTUGUESE

menu.keys.pt-br=Portuguese Brazilian

menu.keys.pt-br.build.keylayout=PORTUGUESE_BRAZILIAN

menu.keys.rs-rs=Serbian (Latin Only)

menu.keys.rs-rs.build.keylayout=SERBIAN_LATIN_ONLY

menu.keys.es-es=Spanish

menu.keys.es-es.build.keylayout=SPANISH

menu.keys.es-mx=Spanish Latin America

menu.keys.es-mx.build.keylayout=SPANISH_LATIN_AMERICA

menu.keys.sv-se=Swedish

menu.keys.sv-se.build.keylayout=SWEDISH

menu.keys.tr-tr=Turkish (partial)

menu.keys.tr-tr.build.keylayout=TURKISH

menu.keys.en-gb=United Kingdom

menu.keys.en-gb.build.keylayout=UNITED_KINGDOM

menu.keys.usint=US International

menu.keys.usint.build.keylayout=US_INTERNATIONAL

runtime.ide.path=C:\Program Files (x86)\Arduino

runtime.os=windows

build.system.path=C:\Program Files (x86)\Arduino\hardware\teensy\avr\system

runtime.ide.version=108013

target_package=teensy

target_platform=teensy3

runtime.hardware.path=C:\Program Files (x86)\Arduino\hardware\teensy

originalid=teensy35

vm.run_sketch_prebuild_before_build=true

intellisense.include.paths.more={vmresolved.compiler.path}arm\arm-none-eabi\include;{vmresolved.compiler.path}arm\lib\gcc\arm-none-eabi\5.4.1\include;{vmresolved.compiler.path}arm\arm-none-eabi\include\c++\5.4.1;{vmresolved.compiler.path}arm\arm-none-eabi\include\c++\5.4.1\tr1;{vmresolved.compiler.path}arm\arm-none-eabi\include\c++\5.4.1\bits;{vmresolved.compiler.path}arm\arm-none-eabi\include\c++\5.4.1\arm-none-eabi;

vmboard.totalpins=16

vmboard.totalanalogpins=14

tools.teensy_gdbstub.cmd=arm-none-eabi-gdb.exe

tools.teensy_gdbstub.debug.path={runtime.hardware.path}/../tools/arm/bin

tools.teensy_gdbstub.initCmd=-ex "init halt"

vs-cmd.Debug.AttachtoProcess.tools.teensy_gdbstub.initCmd=-ex "init"

tools.teensy_gdbstub.debug.args=-ex "target remote \\.\{serial.debug.port}" {initCmd}

build.vm.ignore_gdb_extra_flags=1

tools.teensy_gdbstub.showLocalSerialPort=true

debug_menu.hwdebugger.teensy=GDBStub

debug_menu.hwdebugger.teensy.debug.tool=teensy_gdbstub

meta_teensy.sentence=This debugger requires the TeensyDebug Library from https://github.com/ftrias/TeensyDebug to be installed, and the <TeensyDebug.h> to be included, as well as a call to debug.begin(Serialxx);

meta_teensy.comment=Ensure the COM Port for the configured Debug Port is selected before attaching the Debugger, depending on your code. . Set vMicro > Debugger > 'Compiler Optimization' to 'No Project', 'No Project + Libraries' or 'None' when debugging. (NOTE: Changing the optimization setting for this platform might cause compilation errors with certain code such as HardwareSerial.)

meta_teensy.image.connect=https://www.visualmicro.com/pics/Debug-Help-TEENSY4-GDBSTUB-Connections.png

meta_teensy.image.operation=https://www.visualmicro.com/pics/Debug-Break-TEENSY4-GDBSTUB-VSOnly.png

meta_teensy.reference.usage.url=https://www.visualmicro.com/page/User-Guide.aspx?doc=Arduino-gdb-Tutorial.html

version=1.8.5

rewriting=disabled

compiler.path={runtime.hardware.path}/../tools/

compiler.objcopy.eep.flags=-O ihex -j .eeprom --set-section-flags=.eeprom=alloc,load --no-change-warnings --change-section-lma .eeprom=0

compiler.elf2hex.flags=-O ihex -R .eeprom

recipe.preproc.includes="{compiler.path}{build.toolchain}{build.command.g++}" -M -MG -MP -x c++ -w {build.flags.cpp} {build.flags.cpu} {build.flags.defs} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DF_CPU={build.fcpu} -D{build.usbtype} -DLAYOUT_{build.keylayout} {includes} "{source_file}"

recipe.preproc.macros="{compiler.path}{build.toolchain}{build.command.g++}" -E -CC -x c++ -w {compiler.cpp.flags} {build.flags.common} {build.flags.cpp} {build.flags.cpu} {build.flags.defs} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DF_CPU={build.fcpu} -D{build.usbtype} -DLAYOUT_{build.keylayout} {includes} "{source_file}" -o "{preprocessed_file_path}"

tools.arduino-preprocessor.path={runtime.tools.arduino-preprocessor.path}

tools.arduino-preprocessor.cmd.path={path}/arduino-preprocessor

tools.arduino-preprocessor.pattern="{cmd.path}" "{source_file}" "{codecomplete}" -- -std=gnu++14

recipe.hooks.sketch.prebuild.1.pattern="{compiler.path}precompile_helper" "{runtime.platform.path}/cores/{build.core}" "{build.path}" "{compiler.path}{build.toolchain}{build.command.g++}" -x c++-header {build.flags.optimize} {build.flags.common} {build.flags.dep} {build.flags.cpp} {build.flags.cpu} {build.flags.defs} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DF_CPU={build.fcpu} -D{build.usbtype} -DLAYOUT_{build.keylayout} "-I{runtime.platform.path}/cores/{build.core}" "{build.path}/pch/Arduino.h" -o "{build.path}/pch/Arduino.h.gch"

recipe.cpp.o.pattern="{compiler.path}{build.toolchain}{build.command.g++}" -c {build.flags.optimize} {build.flags.common} {build.flags.dep} {build.flags.cpp} {build.flags.cpu} {build.flags.defs} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DF_CPU={build.fcpu} -D{build.usbtype} -DLAYOUT_{build.keylayout} "-I{build.path}/pch" {includes} "{source_file}" -o "{object_file}"

recipe.c.o.pattern="{compiler.path}{build.toolchain}{build.command.gcc}" -c {build.flags.optimize} {build.flags.common} {build.flags.dep} {build.flags.c} {build.flags.cpu} {build.flags.defs} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DF_CPU={build.fcpu} -D{build.usbtype} -DLAYOUT_{build.keylayout} {includes} "{source_file}" -o "{object_file}"

recipe.S.o.pattern="{compiler.path}{build.toolchain}{build.command.gcc}" -c {build.flags.optimize} {build.flags.common} {build.flags.dep} {build.flags.S} {build.flags.cpu} {build.flags.defs} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DF_CPU={build.fcpu} -D{build.usbtype} -DLAYOUT_{build.keylayout} {includes} "{source_file}" -o "{object_file}"

recipe.ar.pattern="{compiler.path}{build.toolchain}{build.command.ar}" rcs "{archive_file_path}" "{object_file}"

recipe.c.combine.pattern="{compiler.path}{build.toolchain}{build.command.linker}" {build.flags.optimize} {build.flags.ld} {build.flags.ldspecs} {build.flags.cpu} -o "{build.path}/{build.project_name}.elf" {object_files} "{build.path}/{archive_file}" "-L{build.path}" {build.flags.libs}

recipe.elfpatch.pattern="{compiler.path}/hardware/tools/{build.elfpatch}" -mmcu={build.mcu} "{build.path}/{build.project_name}.elf" "{sketch_path}/disk"

recipe.objcopy.eep.pattern="{compiler.path}{build.toolchain}{build.command.objcopy}" {compiler.objcopy.eep.flags} "{build.path}/{build.project_name}.elf" "{build.path}/{build.project_name}.eep"

recipe.objcopy.hex.pattern="{compiler.path}{build.toolchain}{build.command.objcopy}" {compiler.elf2hex.flags} "{build.path}/{build.project_name}.elf" "{build.path}/{build.project_name}.hex"

recipe.hooks.postbuild.1.pattern="{compiler.path}stdout_redirect" "{build.path}/{build.project_name}.lst" "{compiler.path}{build.toolchain}{build.command.objdump}" -d -S -C "{build.path}/{build.project_name}.elf"

recipe.hooks.postbuild.2.pattern="{compiler.path}stdout_redirect" "{build.path}/{build.project_name}.sym" "{compiler.path}{build.toolchain}{build.command.objdump}" -t -C "{build.path}/{build.project_name}.elf"

recipe.hooks.postbuild.3.pattern="{compiler.path}teensy_post_compile" "-file={build.project_name}" "-path={build.path}" "-tools={compiler.path}" "-board={build.board}"

recipe.size.pattern="{compiler.path}{build.toolchain}{build.command.size}" -A "{build.path}/{build.project_name}.elf"

recipe.size.regex=^(?:\.text|\.text\.progmem|\.text\.itcm|\.data)\s+([0-9]+).*

recipe.size.regex.eeprom=^(?:\.eeprom)\s+([0-9]+).*

discovery.teensy.pattern="{runtime.hardware.path}/../tools/teensy_ports" -J2

tools.teensyloader.cmd.path={runtime.hardware.path}/../tools

tools.teensyloader.upload.params.quiet=

tools.teensyloader.upload.params.verbose=-verbose

tools.teensyloader.upload.pattern="{cmd.path}/teensy_post_compile" "-file={build.project_name}" "-path={build.path}" "-tools={cmd.path}" "-board={build.board}" -reboot "-port={serial.port}" "-portlabel={serial.port.label}" "-portprotocol={serial.port.protocol}"

recipe.output.tmp_file={build.project_name}.hex

recipe.output.save_file={build.project_name}.{build.board}.hex

recipe.output.tmp_file2={build.project_name}.elf

recipe.output.save_file2={build.project_name}.elf

upload.verify=

tools.vmopenocd.cmd=bin/openocd.exe

tools.vmopenocd.cmd.windows=bin/openocd.exe

tools.vmopenocd.debug.params.verbose=-d2

tools.vmopenocd.debug.params.quiet=-d0

tools.vmopenocd.debug.address=localhost:3333

tools.vmopenocd.path={runtime.tools.openocd-0.10.0.20200213.path}

tools.vmopenocd.scriptPath=-s "{path}/scripts/"

tools.vmopenocd.logging=-l "{{build.path}/{build.project_name}_DebugOpenOCD.log}"

tools.vmopenocd.boardCmd=

tools.vmopenocd.targetCmd=

tools.vmopenocd.initCmd=

tools.vmopenocd.debug.pattern="{path}/{cmd}" {debug.verbose} {logging} {scriptPath} {boardCmd} {targetCmd} {initCmd}

tools.vmopenocd.program.cmd=bin/openocd.exe

tools.vmopenocd.program.cmd.windows=bin/openocd.exe

tools.vmopenocd.program.path={runtime.tools.openocd-0.10.0.20200213.path}

tools.vmopenocd.program.address=localhost:3333

tools.vmopenocd.program.params.verbose=-d2

tools.vmopenocd.program.params.quiet=-d0

tools.vmopenocd.program.elf.message=****[vMicro]**** Uploading ELF :

tools.vmopenocd.program.pattern="{path}/{cmd}" {program.verbose} {scriptPath} {boardCmd} {targetCmd} -c "echo -n {{program.elf.message}}" {programCmd}

tools.atmelICE.protocol=

tools.atmelICE.debug.cmd=arm-none-eabi-gdb.exe

tools.atmelICE.debug.path={runtime.tools.arm-none-eabi-gcc.path}/bin

tools.atmelICE.debug.pattern="{path}/{cmd}"

tools.atmelICE.server.initCmd=-c "init; reset halt"

vs-cmd.Debug.AttachtoProcess.tools.atmelICE.server.initCmd=-c "init"

tools.atmelICE.server.boardCmd=-c "adapter driver cmsis-dap" -c "cmsis_dap_vid_pid 0x03eb 0x2141"

tools.atmelICE.server.tool=vmopenocd

tools.atmelICE.debug.server=vmopenocd

tools.atmelICE.program.scriptPath=-s "{program.path}/scripts/"

tools.atmelICE.program.boardCmd=-c "adapter driver cmsis-dap" -c "cmsis_dap_vid_pid 0x03eb 0x2141"

tools.atmelICE.program.cmd=bin/openocd.exe

tools.atmelICE.program.cmd.windows=bin/openocd.exe

tools.atmelICE.program.path={runtime.tools.openocd-0.10.0.20200213.path}

tools.atmelICE.program.address=localhost:3333

tools.atmelICE.program.params.verbose=-d2

tools.atmelICE.program.params.quiet=-d0

tools.atmelICE.program.elf.message=****[vMicro]**** Uploading ELF :

tools.atmelICE.program.pattern="{program.path}/{program.cmd}" {program.verbose} {program.scriptPath} {program.boardCmd} {program.targetCmd} -c "echo -n {{program.elf.message}}" {program.programCmd}

tools.atmelICE.program.extra_params=

tools.atmelICE.program.protocol=

tools.atmelICE.erase.params.verbose=-d3

tools.atmelICE.erase.params.quiet=-d0

tools.atmelICE.erase.pattern=

tools.jlink.cmd=arm-none-eabi-gdb.exe

tools.jlink.path={runtime.tools.arm-none-eabi-gcc.path}/bin

tools.jlink.pattern="{path}/{cmd}"

tools.jlink.server.tool=vmopenocd

tools.jlink.debug.server=vmopenocd

tools.jlink.server.boardCmd=-f "interface/jlink.cfg"

tools.jlink.server.initCmd=-c "init; reset halt"

vs-cmd.Debug.AttachtoProcess.tools.jlink.server.initCmd=-c "init"

tools.jlink.program.scriptPath=-s "{program.path}/scripts/"

tools.jlink.program.boardCmd=-f "interface/jlink.cfg"

tools.jlink.program.cmd=bin/openocd.exe

tools.jlink.program.cmd.windows=bin/openocd.exe

tools.jlink.program.path={runtime.tools.openocd-0.10.0.20200213.path}

tools.jlink.program.address=localhost:3333

tools.jlink.program.params.verbose=-d2

tools.jlink.program.params.quiet=-d0

tools.jlink.program.elf.message=****[vMicro]**** Uploading ELF :

tools.jlink.program.pattern="{program.path}/{program.cmd}" {program.verbose} {program.scriptPath} {program.boardCmd} {program.targetCmd} -c "echo -n {{program.elf.message}}" {program.programCmd}

tools.jlink.upload.scriptPath=-s "{upload.path}/scripts/"

tools.jlink.upload.boardCmd=-f "interface/jlink.cfg"

tools.jlink.upload.cmd=bin/openocd.exe

tools.jlink.upload.cmd.windows=bin/openocd.exe

tools.jlink.upload.path={runtime.tools.openocd-0.10.0.20200213.path}

tools.jlink.upload.address=localhost:3333

tools.jlink.upload.params.verbose=-d2

tools.jlink.upload.params.quiet=-d0

tools.jlink.upload.elf.message=****[vMicro]**** Uploading ELF :

tools.jlink.upload.pattern="{upload.path}/{upload.cmd}" {upload.verbose} {upload.scriptPath} {upload.boardCmd} {upload.targetCmd} -c "echo -n {{upload.elf.message}}" {upload.programCmd}

tools.bmp_upload.cmd=arm-none-eabi-gdb.exe

tools.bmp_upload.debug.path={runtime.tools.arm-none-eabi-gcc.path}/bin/

tools.bmp_upload.program.cmd=bin/arm-none-eabi-gdb.exe

tools.bmp_upload.program.cmd.windows=bin/arm-none-eabi-gdb.exe

tools.bmp_upload.program.path={runtime.tools.arm-none-eabi-gcc.path}

tools.bmp_upload.upload.cmd=bin/arm-none-eabi-gdb.exe

tools.bmp_upload.upload.cmd.windows=bin/arm-none-eabi-gdb.exe

tools.bmp_upload.upload.path={runtime.tools.arm-none-eabi-gcc.path}

tools.bmp_upload.server.initCmd=-c "init; reset halt"

vs-cmd.Debug.AttachtoProcess.tools.bmp_upload.server.initCmd=-c "init"

tools.bmp_upload.showLocalSerialPort=true

tools.bmp_upload.debug.server=

tools.stlinkv2.description=

tools.stlinkv2.cmd=arm-none-eabi-gdb.exe

tools.stlinkv2.path={runtime.tools.arm-none-eabi-gcc.path}/bin

tools.stlinkv2.pattern="{path}/{cmd}"

tools.stlinkv2.server.tool=vmopenocd

tools.stlinkv2.debug.server=vmopenocd

tools.stlinkv2.server.boardCmd=-f "interface/stlink.cfg"

tools.stlinkv2.server.initCmd=-c "init; reset halt"

vs-cmd.Debug.AttachtoProcess.tools.stlinkv2.server.initCmd=-c "init"

tools.stlinkv2.upload.scriptPath=-s "{upload.path}/scripts/"

tools.stlinkv2.upload.boardCmd=-f "interface/stlink.cfg"

tools.stlinkv2.upload.cmd=bin/openocd.exe

tools.stlinkv2.upload.cmd.windows=bin/openocd.exe

tools.stlinkv2.upload.path={runtime.tools.openocd-0.10.0.20200213.path}

tools.stlinkv2.upload.address=localhost:3333

tools.stlinkv2.upload.params.verbose=-d2

tools.stlinkv2.upload.params.quiet=-d0

tools.stlinkv2.upload.elf.message=****[vMicro]**** Uploading ELF :

tools.stlinkv2.upload.pattern="{upload.path}/{upload.cmd}" {upload.verbose} {upload.scriptPath} {upload.boardCmd} {upload.targetCmd} -c "echo -n {{upload.elf.message}}" {upload.programCmd}

tools.stlinkv2.upload.extra_params=

tools.stlinkv2.upload.protocol=

tools.stlinkv2.protocol=

tools.f2232mm.cmd=arm-none-eabi-gdb.exe

tools.f2232mm.path={runtime.tools.arm-none-eabi-gcc.path}/bin

tools.f2232mm.pattern="{path}/{cmd}" {args}

tools.f2232mm.server.tool=vmopenocd

tools.f2232mm.debug.server=vmopenocd

tools.f2232mm.server.boardCmd=-f "interface/ftdi/minimodule.cfg"

tools.f2232mm.server.initCmd=-c "init; reset halt"

vs-cmd.Debug.AttachtoProcess.tools.f2232mm.server.initCmd=-c "init"

tools.f2232mm.upload.scriptPath=-s "{upload.path}/scripts/"

tools.f2232mm.upload.boardCmd=-f "interface/ftdi/minimodule.cfg"

tools.f2232mm.upload.cmd=bin/openocd.exe

tools.f2232mm.upload.cmd.windows=bin/openocd.exe

tools.f2232mm.upload.path={runtime.tools.openocd-0.10.0.20200213.path}

tools.f2232mm.upload.address=localhost:3333

tools.f2232mm.upload.params.verbose=-d2

tools.f2232mm.upload.params.quiet=-d0

tools.f2232mm.upload.elf.message=****[vMicro]**** Uploading ELF :

tools.f2232mm.upload.pattern="{upload.path}/{upload.cmd}" {upload.verbose} {upload.scriptPath} {upload.boardCmd} {upload.targetCmd} -c "echo -n {{upload.elf.message}}" {upload.programCmd}

tools.f2232mm.upload.extra_params=

tools.f2232mm.upload.protocol=

tools.f2232mm.protocol=

tools.f2232h.server.boardCmd=-f "interface/ftdi/minimodule-lowcost.cfg"

tools.f2232h.cmd=arm-none-eabi-gdb.exe

tools.f2232h.path={runtime.tools.arm-none-eabi-gcc.path}/bin

tools.f2232h.pattern="{path}/{cmd}"

tools.f2232h.server.tool=vmopenocd

tools.f2232h.debug.server=vmopenocd

tools.f2232h.server.initCmd=-c "init; reset halt"

vs-cmd.Debug.AttachtoProcess.tools.f2232h.server.initCmd=-c "init"

tools.f2232h.upload.scriptPath=-s "{upload.path}/scripts/"

tools.f2232h.upload.boardCmd=-f "interface/ftdi/minimodule-lowcost.cfg"

tools.f2232h.upload.cmd=bin/openocd.exe

tools.f2232h.upload.cmd.windows=bin/openocd.exe

tools.f2232h.upload.path={runtime.tools.openocd-0.10.0.20200213.path}

tools.f2232h.upload.address=localhost:3333

tools.f2232h.upload.params.verbose=-d2

tools.f2232h.upload.params.quiet=-d0

tools.f2232h.upload.elf.message=****[vMicro]**** Uploading ELF :

tools.f2232h.upload.pattern="{upload.path}/{upload.cmd}" {upload.verbose} {upload.scriptPath} {upload.boardCmd} {upload.targetCmd} -c "echo -n {{upload.elf.message}}" {upload.programCmd}

tools.f2232h.upload.extra_params=

tools.f2232h.upload.protocol=

tools.f2232h.protocol=

tools.daplink.server.boardCmd=-f "interface/cmsis-dap.cfg" -c "adapter speed 1000"

tools.daplink.cmd=arm-none-eabi-gdb.exe

tools.daplink.path={runtime.tools.arm-none-eabi-gcc.path}/bin

tools.daplink.pattern="{path}/{cmd}" {args}

tools.daplink.server.tool=vmopenocd

tools.daplink.debug.server=vmopenocd

tools.daplink.server.initCmd=-c "init; reset halt"

vs-cmd.Debug.AttachtoProcess.tools.daplink.server.initCmd=-c "init"

tools.daplink.upload.scriptPath=-s "{upload.path}/scripts/"

tools.daplink.upload.boardCmd=-f "interface/cmsis-dap.cfg" -c "adapter speed 1000"

tools.daplink.upload.cmd=bin/openocd.exe

tools.daplink.upload.cmd.windows=bin/openocd.exe

tools.daplink.upload.path={runtime.tools.openocd-0.10.0.20200213.path}

tools.daplink.upload.address=localhost:3333

tools.daplink.upload.params.verbose=-d2

tools.daplink.upload.params.quiet=-d0

tools.daplink.upload.elf.message=****[vMicro]**** Uploading ELF :

tools.daplink.upload.pattern="{upload.path}/{upload.cmd}" {upload.verbose} {upload.scriptPath} {upload.boardCmd} {upload.targetCmd} -c "echo -n {{upload.elf.message}}" {upload.programCmd}

tools.daplink.upload.extra_params=

tools.daplink.upload.protocol=

tools.daplink.protocol=

vm.platform.root.path=c:\program files (x86)\microsoft visual studio\2019\community\common7\ide\extensions\53lzl3xe.1x1\Micro Platforms\arduino16x

runtime.tools.arduinoOTA.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\arduinoOTA\1.3.0

runtime.tools.arduinoOTA-1.3.0.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\arduinoOTA\1.3.0

runtime.tools.arm-none-eabi-gcc.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\arm-none-eabi-gcc\4.8.3-2014q1

runtime.tools.arm-none-eabi-gcc-4.8.3-2014q1.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\arm-none-eabi-gcc\4.8.3-2014q1

runtime.tools.avrdude.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\avrdude\6.3.0-arduino17

runtime.tools.avrdude-6.3.0-arduino17.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\avrdude\6.3.0-arduino17

runtime.tools.avr-gcc.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\avr-gcc\7.3.0-atmel3.6.1-arduino7

runtime.tools.avr-gcc-7.3.0-atmel3.6.1-arduino7.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\avr-gcc\7.3.0-atmel3.6.1-arduino7

runtime.tools.bossac.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\bossac\1.6.1-arduino

runtime.tools.bossac-1.6.1-arduino.path=C:\Users\Frank\AppData\Local\arduino15\packages\arduino\tools\bossac\1.6.1-arduino

runtime.tools.CMSIS.path=C:\Users\Frank\AppData\Local\arduino15\packages\STM32\tools\CMSIS\5.5.1

runtime.tools.CMSIS-5.5.1.path=C:\Users\Frank\AppData\Local\arduino15\packages\STM32\tools\CMSIS\5.5.1

runtime.tools.esptool_py.path=C:\Users\Frank\AppData\Local\arduino15\packages\esp32\tools\esptool_py\3.0.0

runtime.tools.esptool_py-3.0.0.path=C:\Users\Frank\AppData\Local\arduino15\packages\esp32\tools\esptool_py\3.0.0

runtime.tools.mkspiffs.path=C:\Users\Frank\AppData\Local\arduino15\packages\esp32\tools\mkspiffs\0.2.3

runtime.tools.mkspiffs-0.2.3.path=C:\Users\Frank\AppData\Local\arduino15\packages\esp32\tools\mkspiffs\0.2.3

runtime.tools.STM32Tools.path=C:\Users\Frank\AppData\Local\arduino15\packages\STM32\tools\STM32Tools\1.4.0

runtime.tools.STM32Tools-1.4.0.path=C:\Users\Frank\AppData\Local\arduino15\packages\STM32\tools\STM32Tools\1.4.0

runtime.tools.xpack-arm-none-eabi-gcc.path=C:\Users\Frank\AppData\Local\arduino15\packages\STM32\tools\xpack-arm-none-eabi-gcc\9.2.1-1.1

runtime.tools.xpack-arm-none-eabi-gcc-9.2.1-1.1.path=C:\Users\Frank\AppData\Local\arduino15\packages\STM32\tools\xpack-arm-none-eabi-gcc\9.2.1-1.1

runtime.tools.xtensa-esp32-elf-gcc.path=C:\Users\Frank\AppData\Local\arduino15\packages\esp32\tools\xtensa-esp32-elf-gcc\1.22.0-97-gc752ad5-5.2.0

runtime.tools.xtensa-esp32-elf-gcc-1.22.0-97-gc752ad5-5.2.0.path=C:\Users\Frank\AppData\Local\arduino15\packages\esp32\tools\xtensa-esp32-elf-gcc\1.22.0-97-gc752ad5-5.2.0

runtime.vm.boardinfo.id=teensy35

runtime.vm.boardinfo.name=teensy35

runtime.vm.boardinfo.desc=Teensy 3.5

runtime.vm.boardinfo.src_location=C:\Program Files (x86)\Arduino\hardware\teensy\avr

ide.hint=Use installed IDE (hardware, reference/help + libraries)

ide.location.key=Arduino16x

ide.location.ide.winreg=Arduino 1.6.x Application

ide.location.sketchbook.winreg=Arduino 1.6.x Sketchbook

ide.location.sketchbook.preferences=sketchbook.path

ide.default.revision_name=1.8.13

ide.default.version=10800

ide.default.package=arduino

ide.default.platform=avr

ide.multiplatform=true

ide.includes=Arduino.h

ide.exe_name=arduino

ide.recipe.preproc.defines.flags=-w -x c++ -E -dM

ide.platformswithoutpackage=false

ide.includes.fallback=wprogram.h

ide.extension=ino

ide.extension.fallback=pde

ide.versionGTEQ=160

ide.exe=arduino.exe

ide.builder.exe=arduinobuilder.exe

ide.builder.name=Arduino Builder

ide.hosts=atmel

ide.url=https://www.visualmicro.com/page/Download-Arduino-Or-Other-Supporting-IDEs.aspx

ide.help.reference.path=reference

ide.help.reference.path2=reference\www.arduino.cc\en\Reference

ide.help.reference.serial=reference\www.arduino.cc\en\Serial

ide.location.preferences.portable={runtime.ide.path}\portable

ide.location.preferences.arduinoData={runtime.sketchbook.path}\ArduinoData

ide.location.preferences=%VM_APPDATA_LOCAL%\arduino15\preferences.txt

ide.location.preferences_fallback=%VM_APPDATA_ROAMING%\arduino15\preferences.txt

ide.location.contributions=%VM_APPDATA_LOCAL%\arduino15

ide.location.contributions_fallback=%VM_APPDATA_ROAMING%\arduino15

ide.contributions.boards.allow=true

ide.contributions.boards.ignore_unless_rewrite_found=true

ide.contributions.libraries.allow=true

ide.contributions.boards.support.urls.wiki=https://github.com/arduino/Arduino/wiki/Unofficial-list-of-3rd-party-boards-support-urls

ide.create_platforms_from_boardsTXT.teensy=build.core

vm.debug=true

software=ARDUINO

ssh.user.name=root

ssh.user.default.password=arduino

ssh.host.wwwfiles.path=/www/sd

build.working_directory={runtime.ide.path}\java\bin

runtime.tools.vm_web_debugger.path={vm.platform.root.path}/../../Micro Debuggers/WebDebugger

recipe.hooks.vmdeploy.vm_web_debugger_postupload.1.pattern="{runtime.tools.vm_web_debugger.path}/DeployMicroWebserver.exe" "{sketch_path}" "{serial.port}" "{runtime.hardware.path}\.."

recipe.hooks.vmlaunch.vm_web_debugger_preopen.1.pattern=notepad.exe "{sketch_path}\__vm\vmWebDebugger\Start-WebServer.bat"

recipe.hooks.vmlaunch.vm_web_debugger_preopen.2.pattern={sketch_path}\__vm\vmWebDebugger\Start-WebServer.bat

ide.debug_menu.debugger_type=Debug

ide.debug_menu.debugger_type.none=Off

ide.debug_menu.none.debug.tool=no_debug

ide.debug_menu.debugger_type.universal=Serial

ide.debug_menu.universal.debug.tool=universal

ide.debug_menu.debugger_type.hwdebugger=Hardware

ide.debug_menu.hwdebugger=Debugger

ide.debug_menu.hwdebugger.custom_debugger=Manual/Custom

ide.debug_menu.hwdebugger.custom_debugger.debug.tool=dbg_external

ide.meta_custom_debugger.sentence=Provides a build that includes debug defines and will launch a custom debugger if one is provided.

ide.meta_custom_debugger.paragraph=This is option is for advanced use. It is recommended that a pre-configured debugger be selected when available in this list. Usage: Optionally add a customer debugger to the project. A 'debugger_launch.json' file shares the same command syntax that is used by the VsCode debugger. Custom debuggers can be targeted at a board and/or variant and/or configuration name. IE: [variant].[configuration_name][.]debugger_launch.json

ide.meta_custom_debugger.reference.usage.url=https://github.com/Microsoft/vscode-cpptools/blob/master/launch.md#customlaunchsetupcommands

ide.meta_custom_debugger.reference.connect.url=https://docs.microsoft.com/en-us/visualstudio/debugger/create-custom-views-of-native-objects?view=vs-2019

ide.compiler_flags_no_opt=-O0

ide.debug_menu.vm_disable_optimization=Disable Optimization

ide.debug_menu.vm_disable_optimization.vm_disable_opt_default=Default Optimization

ide.debug_menu.vm_disable_optimization.vm_disable_opt_proj=No Project Optimization

ide.debug_menu.vm_disable_opt_proj.vm_disable_opt_project={ide.compiler_flags_no_opt}

ide.debug_menu.vm_disable_optimization.vm_disable_opt_proj_libs=No Project + Libraries Optimization

ide.debug_menu.vm_disable_opt_proj_libs.vm_disable_opt_project={ide.compiler_flags_no_opt}

ide.debug_menu.vm_disable_opt_proj_libs.vm_disable_opt_libraries={ide.compiler_flags_no_opt}

ide.debug_menu.vm_disable_optimization.vm_disable_opt_all=No Optimization

ide.meta_vm_disable_opt_all.sentence=Disable compiler optimization for all sources:- Project, Library and Platform.

ide.meta_vm_disable_opt_all.comment=After switching between 'No Optimization' and other optimization values, please click "Solution Clean" or switch off (or cycle) 'vMicro>Compiler>Shared Cache For Cores'. NOTE: Changing optimization settings can cause build errors or result in overly large programs.

ide.debug_menu.vm_disable_opt_all.vm_disable_opt_project={ide.compiler_flags_no_opt}

ide.debug_menu.vm_disable_opt_all.vm_disable_opt_libraries={ide.compiler_flags_no_opt}

ide.debug_menu.vm_disable_opt_all.vm_disable_opt_core={ide.compiler_flags_no_opt}

ide.appid=arduino16x

location.sketchbook=C:\Users\Frank\Documents\Arduino

build.core.path=C:\Program Files (x86)\Arduino\hardware\teensy\avr\cores\teensy3

vm.core.include=arduino.h

vm.boardsource.path=C:\Program Files (x86)\Arduino\hardware\teensy\avr

runtime.platform.path=C:\Program Files (x86)\Arduino\hardware\teensy\avr

vm.platformname.name=teensy3

build.arch=TEENSY3

debug.tool=no_debug

build.usbtype=USB_SERIAL

build.fcpu=120000000

build.flags.ldspecs=

build.keylayout=US_ENGLISH

vm.runtime.compiler.cached_cores_path=C:\Users\Frank\AppData\Local\Temp\VMBCore\arduino16x

vm.runtime.compiler.showwarnings=false

vm.runtime.compiler.showwarnings_core=true

vm.runtime.compiler.showwarnings_library=false

vm.runtime.upload.verbose=false

vm.runtime.upload.verify=false

runtime.vm.ide.platforms.path=c:\program files (x86)\microsoft visual studio\2019\community\common7\ide\extensions\53lzl3xe.1x1\Micro Platforms

runtime.vm.ide.tools.openocd.path={runtime.tools.openocd-0.9.0.path}

runtime.vm.openocd.path={runtime.tools.openocd-0.9.0.path}

vm.runtime.build.intermediate_output_path=C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1\Release\

vm.runtime.build.final_output_path=C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1\Release\

compiler.always_include_sketchfolder=true

compiler.always_include_sharedprojectfolders=true

vm.runtime.compiler.auto_discover_includes=true

vm.runtime.compiler.auto_discover_includes_shallow=true

vm.runtime.compiler.allow_library_debugging=false

vm.sketch_ino_cpp_name=TeensySerialBridgeV1.cpp

serial.port.file=COM11

serial.port=COM11

serial.port.num=11

port.caption=COM11 - USB Serial Device

Caption=USB Serial Device (COM11)

ClassGuid={4d36e978-e325-11ce-bfc1-08002be10318}

CompatibleID.value0=USB\Class_02

ConfigManagerErrorCode=0

ConfigManagerUserConfig=False

CreationClassName=Win32_PnPEntity

Description=USB Serial Device

DeviceID=USB\VID_16C0&PID_0483\3016580

HardwareID.value0=USB\VID_16C0&PID_0483

Manufacturer=Microsoft

Name=USB Serial Device (COM11)

PNPClass=Ports

PNPDeviceID=USB\VID_16C0&PID_0483\3016580

Present=True

Service=usbser

Status=OK

SystemCreationClassName=Win32_ComputerSystem

SystemName=FRANKNEWXPS15

vid=0x16C0

pid=0x0483

vidpid=16C00483

vid_pid=0x16C0_0x0483

iserial=3016580

extra.time.local=1633459396

extra.time.utc=1633473796

extra.time.dst=-14400

extra.time.zone=14400

serial.port.caption=COM11 - USB Serial Device

serial.Caption=USB Serial Device (COM11)

serial.ClassGuid={4d36e978-e325-11ce-bfc1-08002be10318}

serial.CompatibleID.value0=USB\Class_02

serial.ConfigManagerErrorCode=0

serial.ConfigManagerUserConfig=False

serial.CreationClassName=Win32_PnPEntity

serial.Description=USB Serial Device

serial.DeviceID=USB\VID_16C0&PID_0483\3016580

serial.HardwareID.value0=USB\VID_16C0&PID_0483

serial.Manufacturer=Microsoft

serial.Name=USB Serial Device (COM11)

serial.PNPClass=Ports

serial.PNPDeviceID=USB\VID_16C0&PID_0483\3016580

serial.Present=True

serial.Service=usbser

serial.Status=OK

serial.SystemCreationClassName=Win32_ComputerSystem

serial.SystemName=FRANKNEWXPS15

serial.vid=0x16C0

serial.pid=0x0483

serial.vidpid=16C00483

serial.vid_pid=0x16C0_0x0483

serial.iserial=3016580

serial.port.iserial=3016580

build.project_name=TeensySerialBridgeV1.ino

build.project_path=C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1

sketch_path=C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1

ProjectDir=C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1\

build.path=C:\Users\Frank\AppData\Local\Temp\VMBuilds\TeensySerialBridgeV1\teensy35\Release

vm.runtime.compile.skip_library_file_if_exists_in_project=true

vm.runtime.compiler.auto_discover_includes_cache=true

build.vm.build.vmdebug=0

build.vm.build.isgdb=0

build.vm.build.optimised=1

vm.last.buildpath=C:\Users\Frank\AppData\Local\Temp\VMBuilds\TeensySerialBridgeV1\teensy35\Release

build.architecture=hardware

vmresolved.compiler.path=C:\Program Files (x86)\Arduino\hardware\tools\

vmresolved.tools.path=C:\Program Files (x86)\Arduino\hardware

Compiling 'TeensySerialBridgeV1' for 'Teensy 3.5'

Using previously compiled file: C:\Users\Frank\AppData\Local\Temp\VMBuilds\TeensySerialBridgeV1\teensy35\Release\pch\Arduino.h.gch

Program size: 50,268 bytes (used 10% of a 524,288 byte maximum) (0.84 secs)

Minimum Memory Usage: 5316 bytes (2% of a 262136 byte maximum)

I need two things from the build properties – the COM port number, and the path to the .HEX file. From the above list, it appears that I could use either of the following properties,

serial.port.caption=COM11 - USB Serial Device
serial.Name=USB Serial Device (COM11)

1 2	serial.port.caption=COM11 - USB Serial Device serial.Name=USB Serial Device (COM11)

but neither is very convenient, as the COM port number has to be extracted from a ‘known’ string. On other projects, I have seen a build property like ‘serial.port.number = 11’ which would be much more convenient, but it seems to have disappeared. For the path to the .HEX file, I should be able to use

vm.runtime.build.final_output_path=C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1\Release\

1	vm.runtime.build.final_output_path=C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1\Release\

build.path=C:\Users\Frank\AppData\Local\Temp\VMBuilds\TeensySerialBridgeV1\teensy35\Release

1	build.path=C:\Users\Frank\AppData\Local\Temp\VMBuilds\TeensySerialBridgeV1\teensy35\Release

but it appears the ‘final_output_path’ is a bit more directly related to the .HEX file location. So, to make this work using the VM post-build facility, the required ‘board.txt’ file should look like:

# Teensy Flash Demo V1 build property overrides
# 10/05/21 gfp - trying to run a post-build command
recipe.hooks.postbuild.1.pattern=cmd.exe /c "C:\Users\Frank\source\repos\FlashExecV1\bin\Release\net5.0\FlashExecV1.exe" "\"{vm.runtime.build.final_output_path}"" {serial.port.caption}

# Teensy Flash Demo V1 build property overrides

# 10/05/21 gfp - trying to run a post-build command

recipe.hooks.postbuild.1.pattern=cmd.exe /c "C:\Users\Frank\source\repos\FlashExecV1\bin\Release\net5.0\FlashExecV1.exe" "\"{vm.runtime.build.final_output_path}"" {serial.port.caption}

When the above is placed in ‘board.txt’ and the Arduino sketch is run, I got the following output:

Compiling 'TeensySerialBridgeV1' for 'Teensy 3.5'
Using previously compiled file: C:\Users\Frank\AppData\Local\Temp\VMBuilds\TeensySerialBridgeV1\teensy35\Release\pch\Arduino.h.gch
Program size: 50,268 bytes (used 10% of a 524,288 byte maximum) (0.84 secs)
Minimum Memory Usage: 5316 bytes (2% of a 262136 byte maximum)
 
C:\Program Files (x86)\Arduino\java\bin>"C:\Users\Frank\Documents\Visual Studio 2019\Projects\TeensyFlash\bin\Release\netcoreapp3.1\TeensyFlash.exe" "\"C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1\Release\"" COM3 - USB Serial Port TeensySerialBridgeV1.ino 
Teensy Flash Console
Number of arguments in args = 7
"C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1\Release"
COM3
-
USB
Serial
Port
TeensySerialBridgeV1.ino
path = C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1\Release
comport = COM3
build name = TeensySerialBridgeV1
path to HEX file = C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1\Release\TeensySerialBridgeV1.hex
C
I received: 43
Start Program Update - Send new HEX file!
buffer = 460K FLASH (0000D000 - 00080000)
waiting for hex lines...
:10000000F8FF022099010000110D0000C90C00004A
:10001000C90C0000C90C0000C90C0000C90C00008C
:10002000C90C0000C90C0000C90C0000110D000033
:10003000110D0000C90C00006129000065290000B5
:10004000110D0000110D0000110D0000110D000038
:10005000110D0000110D0000110D0000110D000028
:10006000110D0000110D0000110D0000110D000018
:10007000110D0000110D0000110D0000110D000008
:10008000110D0000110D0000110D0000110D0000F8
:10009000110D0000110D0000110D0000110D0000E8
:1000A000110D0000110D0000110D0000110D0000D8
:1000B000110D0000110D0000110D00006917000066
...
...
...
:10BFF000DCAE0000DCAE0000DCAE0000DCAE000019
:10C00000DCAE0000FFFFFFFFFFFFFFFFFFFFFFFFB2
:10C01000FFFF0000010041534349490000000000B8
:10C020000000000000000000000000000000000010
:10C030000000000000004153434949000000000097
:10C0400000000000000000000000000000000000F0
:10C0500000000000000000000000000000000000E0
:10C06000400FFF1F400FFF1F480FFF1F480FFF1F0C
:10C07000500FFF1F500FFF1F580FFF1F580FFF1FBC
:10C08000600FFF1F600FFF1F680FFF1F680FFF1F6C
:10C09000700FFF1F700FFF1F780FFF1F780FFF1F1C
:10C0A000800FFF1F800FFF1F880FFF1F880FFF1FCC
:10C0B000900FFF1F900FFF1F980FFF1F980FFF1F7C
:10C0C000A00FFF1FA00FFF1FA80FFF1FA80FFF1F2C
:10C0D000B00FFF1FB00FFF1FB80FFF1FB80FFF1FDC
:10C0E000C00FFF1FC00FFF1FC80FFF1FC80FFF1F8C
:10C0F000D00FFF1FD00FFF1FD80FFF1FD80FFF1F3C
:10C10000E00FFF1FE00FFF1FE80FFF1FE80FFF1FEB
:10C11000F00FFF1FF00FFF1FF80FFF1FF80FFF1F9B
:10C120000010FF1F0010FF1F0810FF1F0810FF1F47
:10C130001010FF1F1010FF1F1810FF1F1810FF1FF7
:10C140002010FF1F2010FF1F2810FF1F2810FF1FA7
:10C150003010FF1F3010FF1F3810FF1F3810FF1F57
:10C160004010FF1F4010FF1F4810FF1F4810FF1F07
:10C170005010FF1F5010FF1F5810FF1F5810FF1FB7
:10C180006010FF1F6010FF1F6810FF1F6810FF1F67
:10C190007010FF1F7010FF1F7810FF1F7810FF1F17
:10C1A0008010FF1F8010FF1F8810FF1F8810FF1FC7
:10C1B0009010FF1F9010FF1F9810FF1F9810FF1F77
:10C1C000A010FF1FA010FF1FA810FF1FA810FF1F27
:10C1D000B010FF1FB010FF1FB810FF1FB810FF1FD7
:10C1E000C010FF1FC010FF1FC810FF1FC810FF1F87
:10C1F000D010FF1FD010FF1FD810FF1FD810FF1F37
:10C20000E010FF1FE010FF1FE810FF1FE810FF1FE6
:10C21000F010FF1FF010FF1FF810FF1FF810FF1F96
:10C220000011FF1F0011FF1F0811FF1F0811FF1F42
:10C230001011FF1F1011FF1F1811FF1F1811FF1FF2
:10C240002011FF1F2011FF1F2811FF1F2811FF1FA2
:10C250003011FF1F3011FF1F3811FF1F3811FF1F52
:10C260004011FF1F4011FF1F4811FF1F4811FF1F02
:10C270005011FF1F5011FF1F5811FF1F5811FF1FB2
:10C280006011FF1F6011FF1F6811FF1F6811FF1F62
:10C290007011FF1F7011FF1F7811FF1F7811FF1F12
:10C2A0008011FF1F8011FF1F8811FF1F8811FF1FC2
:10C2B0009011FF1F9011FF1F9811FF1F9811FF1F72
:10C2C000A011FF1FA011FF1FA811FF1FA811FF1F22
:10C2D000B011FF1FB011FF1FB811FF1FB811FF1FD2
:10C2E000C011FF1FC011FF1FC811FF1FC811FF1F82
:10C2F000D011FF1FD011FF1FD811FF1FD811FF1F32
:10C30000E011FF1FE011FF1FE811FF1FE811FF1FE1
:10C31000F011FF1FF011FF1FF811FF1FF811FF1F91
:10C320000012FF1F0012FF1F0812FF1F0812FF1F3D
:10C330001012FF1F1012FF1F1812FF1F1812FF1FED
:10C340002012FF1F2012FF1F2812FF1F2812FF1F9D
:10C350003012FF1F3012FF1F3812FF1F3812FF1F4D
:10C360004012FF1F4012FF1F4812FF1F4812FF1FFD
:10C370005012FF1F5012FF1F5812FF1F5812FF1FAD
:10C380006012FF1F6012FF1F6812FF1F6812FF1F5D
:10C390007012FF1F7012FF1F7812FF1F7812FF1F0D
:10C3A0008012FF1F8012FF1F8812FF1F8812FF1FBD
:10C3B0009012FF1F9012FF1F9812FF1F9812FF1F6D
:10C3C000A012FF1FA012FF1FA812FF1FA812FF1F1D
:10C3D000B012FF1FB012FF1FB812FF1FB812FF1FCD
:10C3E000C012FF1FC012FF1FC812FF1FC812FF1F7D
:10C3F000D012FF1FD012FF1FD812FF1FD812FF1F2D
:10C40000E012FF1FE012FF1FE812FF1FE812FF1FDC
:10C41000F012FF1FF012FF1FF812FF1FF812FF1F8C
:10C420000013FF1F0013FF1F0813FF1F0813FF1F38
:10C430001013FF1F1013FF1F1813FF1F1813FF1FE8
:10C440002013FF1F2013FF1F2813FF1F2813FF1F98
:10C450003013FF1F3013FF1F3813FF1F3813FF1F48
:08C4600000000200FFFFFFFFD6
:00000001FF
total lines = 3146
hex file: 3146 lines 50280 bytes (00000000 - 0000C468)
new code contains correct FSEC value FFFFF9DE
new code contains correct target ID fw_teensy35
enter 3146 to flash or 0 to abort
numlines 3146 matches numTeensyLines 3146 - send confirmation

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

Compiling 'TeensySerialBridgeV1' for 'Teensy 3.5'

Using previously compiled file: C:\Users\Frank\AppData\Local\Temp\VMBuilds\TeensySerialBridgeV1\teensy35\Release\pch\Arduino.h.gch

Program size: 50,268 bytes (used 10% of a 524,288 byte maximum) (0.84 secs)

Minimum Memory Usage: 5316 bytes (2% of a 262136 byte maximum)

Teensy Flash Console

Number of arguments in args = 7

"C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1\Release"

COM3

USB

Serial

Port

TeensySerialBridgeV1.ino

path = C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1\Release

comport = COM3

build name = TeensySerialBridgeV1

path to HEX file = C:\Users\Frank\Documents\Arduino\TeensySerialBridgeV1\Release\TeensySerialBridgeV1.hex

I received: 43

Start Program Update - Send new HEX file!

buffer = 460K FLASH (0000D000 - 00080000)

waiting for hex lines...

:10000000F8FF022099010000110D0000C90C00004A

:10001000C90C0000C90C0000C90C0000C90C00008C

:10002000C90C0000C90C0000C90C0000110D000033

:10003000110D0000C90C00006129000065290000B5

:10004000110D0000110D0000110D0000110D000038

:10005000110D0000110D0000110D0000110D000028

:10006000110D0000110D0000110D0000110D000018

:10007000110D0000110D0000110D0000110D000008

:10008000110D0000110D0000110D0000110D0000F8

:10009000110D0000110D0000110D0000110D0000E8

:1000A000110D0000110D0000110D0000110D0000D8

:1000B000110D0000110D0000110D00006917000066

...

:10BFF000DCAE0000DCAE0000DCAE0000DCAE000019

:10C00000DCAE0000FFFFFFFFFFFFFFFFFFFFFFFFB2

:10C01000FFFF0000010041534349490000000000B8

:10C020000000000000000000000000000000000010

:10C030000000000000004153434949000000000097

:10C0400000000000000000000000000000000000F0

:10C0500000000000000000000000000000000000E0

:10C06000400FFF1F400FFF1F480FFF1F480FFF1F0C

:10C07000500FFF1F500FFF1F580FFF1F580FFF1FBC

:10C08000600FFF1F600FFF1F680FFF1F680FFF1F6C

:10C09000700FFF1F700FFF1F780FFF1F780FFF1F1C

:10C0A000800FFF1F800FFF1F880FFF1F880FFF1FCC

:10C0B000900FFF1F900FFF1F980FFF1F980FFF1F7C

:10C0C000A00FFF1FA00FFF1FA80FFF1FA80FFF1F2C

:10C0D000B00FFF1FB00FFF1FB80FFF1FB80FFF1FDC

:10C0E000C00FFF1FC00FFF1FC80FFF1FC80FFF1F8C

:10C0F000D00FFF1FD00FFF1FD80FFF1FD80FFF1F3C

:10C10000E00FFF1FE00FFF1FE80FFF1FE80FFF1FEB

:10C11000F00FFF1FF00FFF1FF80FFF1FF80FFF1F9B

:10C120000010FF1F0010FF1F0810FF1F0810FF1F47

:10C130001010FF1F1010FF1F1810FF1F1810FF1FF7

:10C140002010FF1F2010FF1F2810FF1F2810FF1FA7

:10C150003010FF1F3010FF1F3810FF1F3810FF1F57

:10C160004010FF1F4010FF1F4810FF1F4810FF1F07

:10C170005010FF1F5010FF1F5810FF1F5810FF1FB7

:10C180006010FF1F6010FF1F6810FF1F6810FF1F67

:10C190007010FF1F7010FF1F7810FF1F7810FF1F17

:10C1A0008010FF1F8010FF1F8810FF1F8810FF1FC7

:10C1B0009010FF1F9010FF1F9810FF1F9810FF1F77

:10C1C000A010FF1FA010FF1FA810FF1FA810FF1F27

:10C1D000B010FF1FB010FF1FB810FF1FB810FF1FD7

:10C1E000C010FF1FC010FF1FC810FF1FC810FF1F87

:10C1F000D010FF1FD010FF1FD810FF1FD810FF1F37

:10C20000E010FF1FE010FF1FE810FF1FE810FF1FE6

:10C21000F010FF1FF010FF1FF810FF1FF810FF1F96

:10C220000011FF1F0011FF1F0811FF1F0811FF1F42

:10C230001011FF1F1011FF1F1811FF1F1811FF1FF2

:10C240002011FF1F2011FF1F2811FF1F2811FF1FA2

:10C250003011FF1F3011FF1F3811FF1F3811FF1F52

:10C260004011FF1F4011FF1F4811FF1F4811FF1F02

:10C270005011FF1F5011FF1F5811FF1F5811FF1FB2

:10C280006011FF1F6011FF1F6811FF1F6811FF1F62

:10C290007011FF1F7011FF1F7811FF1F7811FF1F12

:10C2A0008011FF1F8011FF1F8811FF1F8811FF1FC2

:10C2B0009011FF1F9011FF1F9811FF1F9811FF1F72

:10C2C000A011FF1FA011FF1FA811FF1FA811FF1F22

:10C2D000B011FF1FB011FF1FB811FF1FB811FF1FD2

:10C2E000C011FF1FC011FF1FC811FF1FC811FF1F82

:10C2F000D011FF1FD011FF1FD811FF1FD811FF1F32

:10C30000E011FF1FE011FF1FE811FF1FE811FF1FE1

:10C31000F011FF1FF011FF1FF811FF1FF811FF1F91

:10C320000012FF1F0012FF1F0812FF1F0812FF1F3D

:10C330001012FF1F1012FF1F1812FF1F1812FF1FED

:10C340002012FF1F2012FF1F2812FF1F2812FF1F9D

:10C350003012FF1F3012FF1F3812FF1F3812FF1F4D

:10C360004012FF1F4012FF1F4812FF1F4812FF1FFD

:10C370005012FF1F5012FF1F5812FF1F5812FF1FAD

:10C380006012FF1F6012FF1F6812FF1F6812FF1F5D

:10C390007012FF1F7012FF1F7812FF1F7812FF1F0D

:10C3A0008012FF1F8012FF1F8812FF1F8812FF1FBD

:10C3B0009012FF1F9012FF1F9812FF1F9812FF1F6D

:10C3C000A012FF1FA012FF1FA812FF1FA812FF1F1D

:10C3D000B012FF1FB012FF1FB812FF1FB812FF1FCD

:10C3E000C012FF1FC012FF1FC812FF1FC812FF1F7D

:10C3F000D012FF1FD012FF1FD812FF1FD812FF1F2D

:10C40000E012FF1FE012FF1FE812FF1FE812FF1FDC

:10C41000F012FF1FF012FF1FF812FF1FF812FF1F8C

:10C420000013FF1F0013FF1F0813FF1F0813FF1F38

:10C430001013FF1F1013FF1F1813FF1F1813FF1FE8

:10C440002013FF1F2013FF1F2813FF1F2813FF1F98

:10C450003013FF1F3013FF1F3813FF1F3813FF1F48

:08C4600000000200FFFFFFFFD6

:00000001FF

total lines = 3146

hex file: 3146 lines 50280 bytes (00000000 - 0000C468)

new code contains correct FSEC value FFFFF9DE

new code contains correct target ID fw_teensy35

enter 3146 to flash or 0 to abort

numlines 3146 matches numTeensyLines 3146 - send confirmation

Which appears to be correct, and the Teensy was obviously updated (got the USB disconnect/connect tones, and the LED tell-tale stopped and then resumed blinking). It looks like I might actually have a working program now – woo hoo!

06 October 2021 Update:

One minor snag occurred with the build property used to pass the COM port number to the command-line program; I had been using {serial.port.caption} and it turns out that this parameter (along with many other serial.port parameters) isn’t always available – things change depending on the COM port chosen in the Arduino program and the actual device connected (or not connected) to the PC. After another round of posts in the Visual Micro forum, Tim Leek pointed out that the ‘serial.port’ parameter should always be available. I had missed this on this because it isn’t grouped in with the rest of the ‘serial.xxx.xxx’ parameters. With the benefit of hindsight, I can see why this is so; the ‘serial.port’ parameter is probably pulled from the VS2019 IDE, while the other ‘serial.port.xxx’ parameters are hardware-specific. Once I switched my ‘board.txt’ to use the ‘serial.port’ parameter vs ‘serial.port.caption’, I started getting much more consistent results. Here’s the ‘final’ (I hope) board.txt configuration:

# Teensy Flash Demo V1 build property overrides
# 10/05/21 gfp - trying to run a post-build command
recipe.hooks.postbuild.1.pattern=cmd.exe /c "C:\Users\Frank\Documents\Visual Studio 2019\Projects\TeensyFlash\bin\Release\netcoreapp3.1\TeensyFlash.exe" "\"{vm.runtime.build.final_output_path}"" {serial.port}

# Teensy Flash Demo V1 build property overrides

# 10/05/21 gfp - trying to run a post-build command

recipe.hooks.postbuild.1.pattern=cmd.exe /c "C:\Users\Frank\Documents\Visual Studio 2019\Projects\TeensyFlash\bin\Release\netcoreapp3.1\TeensyFlash.exe" "\"{vm.runtime.build.final_output_path}"" {serial.port}

One other small snag; my ‘TeensySerialBridgeV1’ program was originally intended to just pass serial data back and forth between two terminal programs (Tera Term on one side, the Teensy sketch on the other). As a result, there was a built-in assumption that both serial connections would always be available, as shown in the following code snippet:

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

    Serial1.begin(115200);
    while (!Serial1) {}

    pinMode(LED_BUILTIN, OUTPUT);
    Serial.printf("\nFlasherX OTA firmware update v1 %s %s\n", __DATE__, __TIME__);

    MsecSinceLastLEDToggle = 0;
}

void setup()

{

Serial.begin(115200);

while (!Serial) {}

Serial1.begin(115200);

while (!Serial1) {}

pinMode(LED_BUILTIN, OUTPUT);

Serial.printf("\nFlasherX OTA firmware update v1 %s %s\n", __DATE__, __TIME__);

MsecSinceLastLEDToggle = 0;

}

The first ‘while()’ statement causes the program to hang if the physical Teensy USB connection is missing. This gave me some grief when I removed the Teensy USB cable to prove I could do the entire update cycle with only the Serial1 hardware serial device connected – oops!

The final Teensy program is shown below:

/*
    Name:       TeensySerialBridgeV1.ino
    Created:	10/4/2021 5:07:47 PM
    Author:     FRANKNEWXPS15\Frank
*/

#include "FlashTxx.h"		// TLC/T3x/T4x flash primitives
#include <elapsedMillis.h>

elapsedMillis MsecSinceLastLEDToggle;

Stream* FTDIport = &Serial1;	// Serial (USB) or Serial1, Serial2, etc. (UART)
Stream* USBport = &Serial1;	// Serial (USB) or Serial1, Serial2, etc. (UART)

//******************************************************************************
// hex_info_t	struct for hex record and hex file info
//******************************************************************************
typedef struct {	// 
  char* data;		// pointer to array allocated elsewhere
  unsigned int addr;	// address in intel hex record
  unsigned int code;	// intel hex record type (0=data, etc.)
  unsigned int num;	// number of data bytes in intel hex record

  uint32_t base;	// base address to be added to intel hex 16-bit addr
  uint32_t min;		// min address in hex file
  uint32_t max;		// max address in hex file

  int eof;		// set true on intel hex EOF (code = 1)
  int lines;		// number of hex records received  
} hex_info_t;

void read_ascii_line(Stream* serial, char* line, int maxbytes);
int  parse_hex_line(const char* theline, char* bytes,
  unsigned int* addr, unsigned int* num, unsigned int* code);
int  process_hex_record(hex_info_t* hex);
void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size);

uint32_t buffer_addr, buffer_size; //09/20/21 copied from FlasherX - loop()

void setup()
{
    Serial.begin(115200);
    //while (!Serial) {} //10/06/21 infinite wait hangs pgm when USB cable removed - oops!
    delay(2000); //10/06/21 - just use fixed delay instead

    Serial1.begin(115200);
    while (!Serial1) {}

    pinMode(LED_BUILTIN, OUTPUT);
    Serial.printf("\nFlasherX OTA firmware update v1 %s %s\n", __DATE__, __TIME__);

    MsecSinceLastLEDToggle = 0;
}

void loop()
{

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

  if (Serial1.available())
  {
    //Serial.println("Got something from Serial1!");
    CheckForUserInput();
    Serial.write(Serial1.read());
  }

  if (MsecSinceLastLEDToggle >= 200)
  {
    MsecSinceLastLEDToggle -= 200;
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
    //Serial.printf(".");
  }
}
void CheckForUserInput()
{
  const int bufflen = 80;
  char buff[bufflen];
  memset(buff, 0, bufflen);
  //const char s[2] = ",";

  //if (Serial.available() > 0)
  if (Serial1.available() > 0)
  {
    // read the incoming byte:
    int incomingByte = Serial1.read();

    // say what you got:
    Serial1.print("I received: ");
    Serial1.println(incomingByte, HEX); //chg to HEX 02/18/20

    //02/18/20 experiment with multiple commands
    switch (incomingByte)
    {
    case 0x43: //ASCII 'C'
    case 0x63: //ASCII 'c'
      Serial1.println(F("Start Program Update - Send new HEX file!"));


      //09/20/21 copied from FlasherX - loop()
      if (firmware_buffer_init(&buffer_addr, &buffer_size) == 0)
      {
        Serial1.printf("unable to create buffer\n");
        Serial1.flush();
        for (;;) {}
      }

      Serial1.printf("buffer = %1luK %s (%08lX - %08lX)\n",
        buffer_size / 1024, IN_FLASH(buffer_addr) ? "FLASH" : "RAM",
        buffer_addr, buffer_addr + buffer_size);

      //09/20/21 clear the serial buffer
      while (Serial1.available())
      {
        Serial1.read();
      }

      // receive hex file via serial, write new firmware to flash, clean up, reboot
      update_firmware(&Serial1, buffer_addr, buffer_size); // no return if success

      // return from update_firmware() means error or user abort, so clean up and
      // reboot to ensure that static vars get boot-up initialized before retry
      Serial1.printf("erase FLASH buffer / free RAM buffer...\n");
      firmware_buffer_free(buffer_addr, buffer_size);
      Serial1.flush();
      REBOOT;
      break;
    }
  }
}

//09/20/21 copied from FlasherX

//******************************************************************************
// update_firmware()	read hex file and write new firmware to program flash
//******************************************************************************
void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size)
{
  static char line[96];					// buffer for hex lines
  static char data[32] __attribute__((aligned(8)));	// buffer for hex data
  hex_info_t hex = {					// intel hex info struct
    data, 0, 0, 0,					//   data,addr,num,code
    0, 0xFFFFFFFF, 0, 					//   base,min,max,
    0, 0						//   eof,lines
  };

  serial->printf("waiting for hex lines...\n");

  // read and process intel hex lines until EOF or error
  while (!hex.eof) {

    read_ascii_line(serial, line, sizeof(line));

    //10/02/21 gfp added for visual xfer confirmation
    if (hex.lines % 10 == 0)
    {
      digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN));
    }

    // reliability of transfer via USB is improved by this printf/flush
    if (serial == (Stream*)&Serial)
    {
      serial->printf("%s\n", line);
      serial->flush();
    }

    if (parse_hex_line((const char*)line, hex.data, &hex.addr, &hex.num, &hex.code) == 0) {
      serial->printf("abort - bad hex line %s\n", line);
      return;
    }
    else if (process_hex_record(&hex) != 0) { // error on bad hex code
      serial->printf("abort - invalid hex code %d\n", hex.code);
      return;
    }
    else if (hex.code == 0) { // if data record
      uint32_t addr = buffer_addr + hex.base + hex.addr - FLASH_BASE_ADDR;
      if (hex.max > (FLASH_BASE_ADDR + buffer_size)) {
        serial->printf("abort - max address %08lX too large\n", hex.max);
        return;
      }
      else if (!IN_FLASH(buffer_addr)) {
        memcpy((void*)addr, (void*)hex.data, hex.num);
      }
      else if (IN_FLASH(buffer_addr)) {
        int error = flash_write_block(addr, hex.data, hex.num);
        if (error) {
          serial->printf("abort - error %02X in flash_write_block()\n", error);
          return;
        }
      }
    }
    hex.lines++;
  }

  serial->printf("\nhex file: %1d lines %1lu bytes (%08lX - %08lX)\n",
    hex.lines, hex.max - hex.min, hex.min, hex.max);

  // check FSEC value in new code -- abort if incorrect
#if defined(KINETISK) || defined(KINETISL)
  uint32_t value = *(uint32_t*)(0x40C + buffer_addr);
  if (value == 0xfffff9de) {
    serial->printf("new code contains correct FSEC value %08lX\n", value);
  }
  else {
    serial->printf("abort - FSEC value %08lX should be FFFFF9DE\n", value);
    return;
  }
#endif

  // check FLASH_ID in new code - abort if not found
  if (check_flash_id(buffer_addr, hex.max - hex.min)) {
    serial->printf("new code contains correct target ID %s\n", FLASH_ID);
  }
  else {
    serial->printf("abort - new code missing string %s\n", FLASH_ID);
    return;
  }

  // get user input to write to flash or abort
  int user_lines = -1;
  while (user_lines != hex.lines && user_lines != 0) {
    serial->printf("enter %d to flash or 0 to abort\n", hex.lines);
    read_ascii_line(serial, line, sizeof(line));
    sscanf(line, "%d", &user_lines);
  }

  if (user_lines == 0) {
    serial->printf("abort - user entered 0 lines\n");
    return;
  }

  // move new program from buffer to flash, free buffer, and reboot
  //serial->printf("user entered %d lines\n", user_lines);
  flash_move(FLASH_BASE_ADDR, buffer_addr, hex.max - hex.min);

  // should not return from flash_move(), but put REBOOT here as reminder
  REBOOT;
}

//******************************************************************************
// read_ascii_line()	read ascii characters until '\n', '\r', or max bytes
//******************************************************************************
void read_ascii_line(Stream* serial, char* line, int maxbytes)
{
  int c = 0, nchar = 0;
  while (nchar < maxbytes && !(c == '\n' || c == '\r')) {
    if (serial->available()) {
      c = serial->read();
      line[nchar++] = c;
    }
  }
  line[nchar - 1] = 0;	// null-terminate
}

//******************************************************************************
// process_hex_record()		process record and return okay (0) or error (1)
//******************************************************************************
int process_hex_record(hex_info_t* hex)
{
  if (hex->code == 0) { // data -- update min/max address so far
    if (hex->base + hex->addr + hex->num > hex->max)
      hex->max = hex->base + hex->addr + hex->num;
    if (hex->base + hex->addr < hex->min)
      hex->min = hex->base + hex->addr;
  }
  else if (hex->code == 1) { // EOF (:flash command not received yet)
    hex->eof = 1;
  }
  else if (hex->code == 2) { // extended segment address (top 16 of 24-bit addr)
    hex->base = ((hex->data[0] << 8) | hex->data[1]) << 4;
  }
  else if (hex->code == 3) { // start segment address (80x86 real mode only)
    return 1;
  }
  else if (hex->code == 4) { // extended linear address (top 16 of 32-bit addr)
    hex->base = ((hex->data[0] << 8) | hex->data[1]) << 16;
  }
  else if (hex->code == 5) { // start linear address (32-bit big endian addr)
    hex->base = (hex->data[0] << 24) | (hex->data[1] << 16)
      | (hex->data[2] << 8) | (hex->data[3] << 0);
  }
  else {
    return 1;
  }

  return 0;
}

//******************************************************************************
// Intel Hex record foramt:
//
// Start code:  one character, ASCII colon ':'.
// Byte count:  two hex digits, number of bytes (hex digit pairs) in data field.
// Address:     four hex digits
// Record type: two hex digits, 00 to 05, defining the meaning of the data field.
// Data:        n bytes of data represented by 2n hex digits.
// Checksum:    two hex digits, computed value used to verify record has no errors.
//
// Examples:
//  :10 9D30 00 711F0000AD38000005390000F5460000 35
//  :04 9D40 00 01480000 D6
//  :00 0000 01 FF
//******************************************************************************

/* Intel HEX read/write functions, Paul Stoffregen, paul@ece.orst.edu */
/* This code is in the public domain.  Please retain my name and */
/* email address in distributed copies, and let me know about any bugs */

/* I, Paul Stoffregen, give no warranty, expressed or implied for */
/* this software and/or documentation provided, including, without */
/* limitation, warranty of merchantability and fitness for a */
/* particular purpose. */

// type modifications by Jon Zeeff

/* parses a line of intel hex code, stores the data in bytes[] */
/* and the beginning address in addr, and returns a 1 if the */
/* line was valid, or a 0 if an error occured.  The variable */
/* num gets the number of bytes that were stored into bytes[] */

#include <stdio.h>		// sscanf(), etc.
#include <string.h>		// strlen(), etc.

int parse_hex_line(const char* theline, char* bytes,
  unsigned int* addr, unsigned int* num, unsigned int* code)
{
  unsigned sum, len, cksum;
  const char* ptr;
  int temp;

  *num = 0;
  if (theline[0] != ':')
    return 0;
  if (strlen(theline) < 11)
    return 0;
  ptr = theline + 1;
  if (!sscanf(ptr, "%02x", &len))
    return 0;
  ptr += 2;
  if (strlen(theline) < (11 + (len * 2)))
    return 0;
  if (!sscanf(ptr, "%04x", (unsigned int*)addr))
    return 0;
  ptr += 4;
  /* Serial.printf("Line: length=%d Addr=%d\n", len, *addr); */
  if (!sscanf(ptr, "%02x", code))
    return 0;
  ptr += 2;
  sum = (len & 255) + ((*addr >> 8) & 255) + (*addr & 255) + (*code & 255);
  while (*num != len)
  {
    if (!sscanf(ptr, "%02x", &temp))
      return 0;
    bytes[*num] = temp;
    ptr += 2;
    sum += bytes[*num] & 255;
    (*num)++;
    if (*num >= 256)
      return 0;
  }
  if (!sscanf(ptr, "%02x", &cksum))
    return 0;

  if (((sum & 255) + (cksum & 255)) & 255)
    return 0;     /* checksum error */
  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

Name: TeensySerialBridgeV1.ino

Created: 10/4/2021 5:07:47 PM

Author: FRANKNEWXPS15\Frank

#include "FlashTxx.h" // TLC/T3x/T4x flash primitives

#include <elapsedMillis.h>

elapsedMillis MsecSinceLastLEDToggle;

Stream* FTDIport = &Serial1; // Serial (USB) or Serial1, Serial2, etc. (UART)

Stream* USBport = &Serial1; // Serial (USB) or Serial1, Serial2, etc. (UART)

//******************************************************************************

// hex_info_t struct for hex record and hex file info

//******************************************************************************

typedef struct { //

char* data; // pointer to array allocated elsewhere

unsigned int addr; // address in intel hex record

unsigned int code; // intel hex record type (0=data, etc.)

unsigned int num; // number of data bytes in intel hex record

uint32_t base; // base address to be added to intel hex 16-bit addr

uint32_t min; // min address in hex file

uint32_t max; // max address in hex file

int eof; // set true on intel hex EOF (code = 1)

int lines; // number of hex records received

} hex_info_t;

void read_ascii_line(Stream* serial, char* line, int maxbytes);

int parse_hex_line(const char* theline, char* bytes,

unsigned int* addr, unsigned int* num, unsigned int* code);

int process_hex_record(hex_info_t* hex);

void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size);

uint32_t buffer_addr, buffer_size; //09/20/21 copied from FlasherX - loop()

void setup()

{

Serial.begin(115200);

//while (!Serial) {} //10/06/21 infinite wait hangs pgm when USB cable removed - oops!

delay(2000); //10/06/21 - just use fixed delay instead

Serial1.begin(115200);

while (!Serial1) {}

pinMode(LED_BUILTIN, OUTPUT);

Serial.printf("\nFlasherX OTA firmware update v1 %s %s\n", __DATE__, __TIME__);

MsecSinceLastLEDToggle = 0;

}

void loop()

{

if (Serial.available())

{

Serial1.write(Serial.read());

}

if (Serial1.available())

{

//Serial.println("Got something from Serial1!");

CheckForUserInput();

Serial.write(Serial1.read());

}

if (MsecSinceLastLEDToggle >= 200)

{

MsecSinceLastLEDToggle -= 200;

digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));

//Serial.printf(".");

}

void CheckForUserInput()

{

const int bufflen = 80;

char buff[bufflen];

memset(buff, 0, bufflen);

//const char s[2] = ",";

//if (Serial.available() > 0)

if (Serial1.available() > 0)

{

// read the incoming byte:

int incomingByte = Serial1.read();

// say what you got:

Serial1.print("I received: ");

Serial1.println(incomingByte, HEX); //chg to HEX 02/18/20

//02/18/20 experiment with multiple commands

switch (incomingByte)

{

case 0x43: //ASCII 'C'

case 0x63: //ASCII 'c'

Serial1.println(F("Start Program Update - Send new HEX file!"));

//09/20/21 copied from FlasherX - loop()

if (firmware_buffer_init(&buffer_addr, &buffer_size) == 0)

{

Serial1.printf("unable to create buffer\n");

Serial1.flush();

for (;;) {}

}

Serial1.printf("buffer = %1luK %s (%08lX - %08lX)\n",

buffer_size / 1024, IN_FLASH(buffer_addr) ? "FLASH" : "RAM",

buffer_addr, buffer_addr + buffer_size);

//09/20/21 clear the serial buffer

while (Serial1.available())

{

Serial1.read();

}

// receive hex file via serial, write new firmware to flash, clean up, reboot

update_firmware(&Serial1, buffer_addr, buffer_size); // no return if success

// return from update_firmware() means error or user abort, so clean up and

// reboot to ensure that static vars get boot-up initialized before retry

Serial1.printf("erase FLASH buffer / free RAM buffer...\n");

firmware_buffer_free(buffer_addr, buffer_size);

Serial1.flush();

REBOOT;

break;

}

//09/20/21 copied from FlasherX

//******************************************************************************

// update_firmware() read hex file and write new firmware to program flash

//******************************************************************************

void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size)

{

static char line[96]; // buffer for hex lines

static char data[32] __attribute__((aligned(8))); // buffer for hex data

hex_info_t hex = { // intel hex info struct

data, 0, 0, 0, // data,addr,num,code

0, 0xFFFFFFFF, 0, // base,min,max,

0, 0 // eof,lines

};

serial->printf("waiting for hex lines...\n");

// read and process intel hex lines until EOF or error

while (!hex.eof) {

read_ascii_line(serial, line, sizeof(line));

//10/02/21 gfp added for visual xfer confirmation

if (hex.lines % 10 == 0)

{

digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN));

}

// reliability of transfer via USB is improved by this printf/flush

if (serial == (Stream*)&Serial)

{

serial->printf("%s\n", line);

serial->flush();

}

if (parse_hex_line((const char*)line, hex.data, &hex.addr, &hex.num, &hex.code) == 0) {

serial->printf("abort - bad hex line %s\n", line);

return;

}

else if (process_hex_record(&hex) != 0) { // error on bad hex code

serial->printf("abort - invalid hex code %d\n", hex.code);

return;

}

else if (hex.code == 0) { // if data record

uint32_t addr = buffer_addr + hex.base + hex.addr - FLASH_BASE_ADDR;

if (hex.max > (FLASH_BASE_ADDR + buffer_size)) {

serial->printf("abort - max address %08lX too large\n", hex.max);

return;

}

else if (!IN_FLASH(buffer_addr)) {

memcpy((void*)addr, (void*)hex.data, hex.num);

}

else if (IN_FLASH(buffer_addr)) {

int error = flash_write_block(addr, hex.data, hex.num);

if (error) {

serial->printf("abort - error %02X in flash_write_block()\n", error);

return;

}

hex.lines++;

}

serial->printf("\nhex file: %1d lines %1lu bytes (%08lX - %08lX)\n",

hex.lines, hex.max - hex.min, hex.min, hex.max);

// check FSEC value in new code -- abort if incorrect

#if defined(KINETISK) || defined(KINETISL)

uint32_t value = *(uint32_t*)(0x40C + buffer_addr);

if (value == 0xfffff9de) {

serial->printf("new code contains correct FSEC value %08lX\n", value);

}

else {

serial->printf("abort - FSEC value %08lX should be FFFFF9DE\n", value);

return;

}

#endif

// check FLASH_ID in new code - abort if not found

if (check_flash_id(buffer_addr, hex.max - hex.min)) {

serial->printf("new code contains correct target ID %s\n", FLASH_ID);

}

else {

serial->printf("abort - new code missing string %s\n", FLASH_ID);

return;

}

// get user input to write to flash or abort

int user_lines = -1;

while (user_lines != hex.lines && user_lines != 0) {

serial->printf("enter %d to flash or 0 to abort\n", hex.lines);

read_ascii_line(serial, line, sizeof(line));

sscanf(line, "%d", &user_lines);

}

if (user_lines == 0) {

serial->printf("abort - user entered 0 lines\n");

return;

}

// move new program from buffer to flash, free buffer, and reboot

//serial->printf("user entered %d lines\n", user_lines);

flash_move(FLASH_BASE_ADDR, buffer_addr, hex.max - hex.min);

// should not return from flash_move(), but put REBOOT here as reminder

REBOOT;

}

//******************************************************************************

// read_ascii_line() read ascii characters until '\n', '\r', or max bytes

//******************************************************************************

void read_ascii_line(Stream* serial, char* line, int maxbytes)

{

int c = 0, nchar = 0;

while (nchar < maxbytes && !(c == '\n' || c == '\r')) {

if (serial->available()) {

c = serial->read();

line[nchar++] = c;

}

line[nchar - 1] = 0; // null-terminate

}

//******************************************************************************

// process_hex_record() process record and return okay (0) or error (1)

//******************************************************************************

int process_hex_record(hex_info_t* hex)

{

if (hex->code == 0) { // data -- update min/max address so far

if (hex->base + hex->addr + hex->num > hex->max)

hex->max = hex->base + hex->addr + hex->num;

if (hex->base + hex->addr < hex->min)

hex->min = hex->base + hex->addr;

}

else if (hex->code == 1) { // EOF (:flash command not received yet)

hex->eof = 1;

}

else if (hex->code == 2) { // extended segment address (top 16 of 24-bit addr)

hex->base = ((hex->data[0] << 8) | hex->data[1]) << 4;

}

else if (hex->code == 3) { // start segment address (80x86 real mode only)

return 1;

}

else if (hex->code == 4) { // extended linear address (top 16 of 32-bit addr)

hex->base = ((hex->data[0] << 8) | hex->data[1]) << 16;

}

else if (hex->code == 5) { // start linear address (32-bit big endian addr)

hex->base = (hex->data[0] << 24) | (hex->data[1] << 16)

| (hex->data[2] << 8) | (hex->data[3] << 0);

}

else {

return 1;

}

return 0;

}

//******************************************************************************

// Intel Hex record foramt:

// Start code: one character, ASCII colon ':'.

// Byte count: two hex digits, number of bytes (hex digit pairs) in data field.

// Address: four hex digits

// Record type: two hex digits, 00 to 05, defining the meaning of the data field.

// Data: n bytes of data represented by 2n hex digits.

// Checksum: two hex digits, computed value used to verify record has no errors.

// Examples:

// :10 9D30 00 711F0000AD38000005390000F5460000 35

// :04 9D40 00 01480000 D6

// :00 0000 01 FF

//******************************************************************************

/* Intel HEX read/write functions, Paul Stoffregen, paul@ece.orst.edu */

/* This code is in the public domain. Please retain my name and */

/* email address in distributed copies, and let me know about any bugs */

/* I, Paul Stoffregen, give no warranty, expressed or implied for */

/* this software and/or documentation provided, including, without */

/* limitation, warranty of merchantability and fitness for a */

/* particular purpose. */

// type modifications by Jon Zeeff

/* parses a line of intel hex code, stores the data in bytes[] */

/* and the beginning address in addr, and returns a 1 if the */

/* line was valid, or a 0 if an error occured. The variable */

/* num gets the number of bytes that were stored into bytes[] */

#include <stdio.h> // sscanf(), etc.

#include <string.h> // strlen(), etc.

int parse_hex_line(const char* theline, char* bytes,

unsigned int* addr, unsigned int* num, unsigned int* code)

{

unsigned sum, len, cksum;

const char* ptr;

int temp;

*num = 0;

if (theline[0] != ':')

return 0;

if (strlen(theline) < 11)

return 0;

ptr = theline + 1;

if (!sscanf(ptr, "%02x", &len))

return 0;

ptr += 2;

if (strlen(theline) < (11 + (len * 2)))

return 0;

if (!sscanf(ptr, "%04x", (unsigned int*)addr))

return 0;

ptr += 4;

/* Serial.printf("Line: length=%d Addr=%d\n", len, *addr); */

if (!sscanf(ptr, "%02x", code))

return 0;

ptr += 2;

sum = (len & 255) + ((*addr >> 8) & 255) + (*addr & 255) + (*code & 255);

while (*num != len)

{

if (!sscanf(ptr, "%02x", &temp))

return 0;

bytes[*num] = temp;

ptr += 2;

sum += bytes[*num] & 255;

(*num)++;

if (*num >= 256)

return 0;

}

if (!sscanf(ptr, "%02x", &cksum))

return 0;

if (((sum & 255) + (cksum & 255)) & 255)

return 0; /* checksum error */

return 1;

}

09 October 2021 Update: The final product

After encountering and solving a few more ‘gotchas’, I think I now have a reliable Teensy OTA mechanism using the VS2019/Visual Micro IDE and Joe Pasquariello’s wonderful ‘FlasherX’ code . The ‘trick’ is using Visual Micro’s ‘board.txt’ feature to add a post-build command that runs each time the Teensy sketch is compiled, and a small C# command-line program to trigger the FlasherX update code and feed it the correct Hex file.

I created a very simple Teensy project called ‘TeensyOTADemo’ that does only two things; it flashes the built-in LED, and launches the FlasherX update code when triggered by a ‘U’ (for Update) ascii code on Serial1 (pins 0 & 1 on a T3.5). Then I created a small C# command-line program to actually send the trigger character and then transmit the .HEX file created as part of the normal compile process.

Then I created a ‘board.txt’ file containing a post-build command that launches the C# command-line program and feeds it two arguments – one containing the build path, and the other containing the COM port number to be used to connect to the Teensy’s Serial1 port.

Here’s the Teensy sketch:

/*
    Name:       TeensyOTADemo.ino
    Created:	10/9/2021 11:18:19 AM
    Author:     FRANKNEWXPS15\Frank

    This program demonstrates the use of 'board.txt' post-build instructions in
    conjunction with a small C# command-line program for seamless 'over-the-air' (OTA)
    firmware update for Teensy modules.

    Implementation of OTA update requires that Joe Pasquariello's 'FlasherX'
    code be added to the Teensy sketch as it is below, and some code to allow
    an external serial communications program to trigger the update process.
    
    In the demo sketch below, the 'FlasherX' additions are the '#include FlasherTxx.h'
    line and the addition of the FlasherX specific code at the bottom. The trigger
    mechanism is provided by the 'CheckForUserInput();' call in loop.  If the ASCII 
    code for 'U' or 'u' is present on Serial1, the update process will be launched.
    
*/

#include "FlashTxx.h"		// TLC/T3x/T4x flash primitives
#include <elapsedMillis.h>

elapsedMillis MsecSinceLastLEDToggle; //used for LED blink timer

Stream* FTDIport = &Serial1;	// Serial (USB) or Serial1, Serial2, etc. (UART)

//******************************************************************************
// hex_info_t	struct for hex record and hex file info
//******************************************************************************
typedef struct {	// 
  char* data;		// pointer to array allocated elsewhere
  unsigned int addr;	// address in intel hex record
  unsigned int code;	// intel hex record type (0=data, etc.)
  unsigned int num;	// number of data bytes in intel hex record

  uint32_t base;	// base address to be added to intel hex 16-bit addr
  uint32_t min;		// min address in hex file
  uint32_t max;		// max address in hex file

  int eof;		// set true on intel hex EOF (code = 1)
  int lines;		// number of hex records received  
} hex_info_t;

void read_ascii_line(Stream* serial, char* line, int maxbytes);
int  parse_hex_line(const char* theline, char* bytes,
  unsigned int* addr, unsigned int* num, unsigned int* code);
int  process_hex_record(hex_info_t* hex);
void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size);

uint32_t buffer_addr, buffer_size; //09/20/21 copied from FlasherX - loop()

void setup()
{
  Serial.begin(115200);
  //while (!Serial) {} //10/06/21 infinite wait hangs pgm when USB cable removed - oops!
  delay(2000); //10/06/21 - just use fixed delay instead

  Serial1.begin(115200);
  while (!Serial1) {}

  pinMode(LED_BUILTIN, OUTPUT);

  MsecSinceLastLEDToggle = 0;
}

void loop()
{
  if (Serial1.available())
  {
    CheckForUserInput();
  }

  if (MsecSinceLastLEDToggle >= 200)
  {
    MsecSinceLastLEDToggle -= 200;
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
  }
}
void CheckForUserInput()
{
  const int bufflen = 80;
  char buff[bufflen];
  memset(buff, 0, bufflen);
  //const char s[2] = ",";

  if (Serial1.available() > 0)
  {
    // read the incoming byte:
    int incomingByte = Serial1.read();

    // say what you got:
    Serial1.print("I received: ");
    Serial1.println(incomingByte, HEX); //chg to HEX 02/18/20

    //02/18/20 experiment with multiple commands
    switch (incomingByte)
    {
    case 0x55: //ASCII 'U'
    case 0x75: //ASCII 'u'
      Serial1.println(F("Start Program Update - Send new HEX file!"));


      //09/20/21 copied from FlasherX - loop()
      if (firmware_buffer_init(&buffer_addr, &buffer_size) == 0)
      {
        Serial1.printf("unable to create buffer\n");
        Serial1.flush();
        for (;;) {}
      }

      Serial1.printf("buffer = %1luK %s (%08lX - %08lX)\n",
        buffer_size / 1024, IN_FLASH(buffer_addr) ? "FLASH" : "RAM",
        buffer_addr, buffer_addr + buffer_size);

      //09/20/21 clear the serial buffer
      while (Serial1.available())
      {
        Serial1.read();
      }

      // receive hex file via serial, write new firmware to flash, clean up, reboot
      update_firmware(&Serial1, buffer_addr, buffer_size); // no return if success

      // return from update_firmware() means error or user abort, so clean up and
      // reboot to ensure that static vars get boot-up initialized before retry
      Serial1.printf("erase FLASH buffer / free RAM buffer...\n");
      firmware_buffer_free(buffer_addr, buffer_size);
      Serial1.flush();
      REBOOT;
      break;
    }
  }
}

//09/20/21 copied from FlasherX
//******************************************************************************
// update_firmware()	read hex file and write new firmware to program flash
//******************************************************************************
void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size)
{
  static char line[96];					// buffer for hex lines
  static char data[32] __attribute__((aligned(8)));	// buffer for hex data
  hex_info_t hex = {					// intel hex info struct
    data, 0, 0, 0,					//   data,addr,num,code
    0, 0xFFFFFFFF, 0, 					//   base,min,max,
    0, 0						//   eof,lines
  };

  serial->printf("waiting for hex lines...\n");

  // read and process intel hex lines until EOF or error
  while (!hex.eof) {

    read_ascii_line(serial, line, sizeof(line));

    //10/02/21 gfp added for visual xfer confirmation
    if (hex.lines % 10 == 0)
    {
      digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN));
    }

    // reliability of transfer via USB is improved by this printf/flush
    if (serial == (Stream*)&Serial)
    {
      serial->printf("%s\n", line);
      serial->flush();
    }

    if (parse_hex_line((const char*)line, hex.data, &hex.addr, &hex.num, &hex.code) == 0) {
      serial->printf("abort - bad hex line %s\n", line);
      return;
    }
    else if (process_hex_record(&hex) != 0) { // error on bad hex code
      serial->printf("abort - invalid hex code %d\n", hex.code);
      return;
    }
    else if (hex.code == 0) { // if data record
      uint32_t addr = buffer_addr + hex.base + hex.addr - FLASH_BASE_ADDR;
      if (hex.max > (FLASH_BASE_ADDR + buffer_size)) {
        serial->printf("abort - max address %08lX too large\n", hex.max);
        return;
      }
      else if (!IN_FLASH(buffer_addr)) {
        memcpy((void*)addr, (void*)hex.data, hex.num);
      }
      else if (IN_FLASH(buffer_addr)) {
        int error = flash_write_block(addr, hex.data, hex.num);
        if (error) {
          serial->printf("abort - error %02X in flash_write_block()\n", error);
          return;
        }
      }
    }
    hex.lines++;
  }

  serial->printf("\nhex file: %1d lines %1lu bytes (%08lX - %08lX)\n",
    hex.lines, hex.max - hex.min, hex.min, hex.max);

  // check FSEC value in new code -- abort if incorrect
#if defined(KINETISK) || defined(KINETISL)
  uint32_t value = *(uint32_t*)(0x40C + buffer_addr);
  if (value == 0xfffff9de) {
    serial->printf("new code contains correct FSEC value %08lX\n", value);
  }
  else {
    serial->printf("abort - FSEC value %08lX should be FFFFF9DE\n", value);
    return;
  }
#endif

  // check FLASH_ID in new code - abort if not found
  if (check_flash_id(buffer_addr, hex.max - hex.min)) {
    serial->printf("new code contains correct target ID %s\n", FLASH_ID);
  }
  else {
    serial->printf("abort - new code missing string %s\n", FLASH_ID);
    return;
  }

  // get user input to write to flash or abort
  int user_lines = -1;
  while (user_lines != hex.lines && user_lines != 0) {
    serial->printf("enter %d to flash or 0 to abort\n", hex.lines);
    read_ascii_line(serial, line, sizeof(line));
    sscanf(line, "%d", &user_lines);
  }

  if (user_lines == 0) {
    serial->printf("abort - user entered 0 lines\n");
    return;
  }

  // move new program from buffer to flash, free buffer, and reboot
  //serial->printf("user entered %d lines\n", user_lines);
  flash_move(FLASH_BASE_ADDR, buffer_addr, hex.max - hex.min);

  // should not return from flash_move(), but put REBOOT here as reminder
  REBOOT;
}

//******************************************************************************
// read_ascii_line()	read ascii characters until '\n', '\r', or max bytes
//******************************************************************************
void read_ascii_line(Stream* serial, char* line, int maxbytes)
{
  int c = 0, nchar = 0;
  while (nchar < maxbytes && !(c == '\n' || c == '\r')) {
    if (serial->available()) {
      c = serial->read();
      line[nchar++] = c;
    }
  }
  line[nchar - 1] = 0;	// null-terminate
}

//******************************************************************************
// process_hex_record()		process record and return okay (0) or error (1)
//******************************************************************************
int process_hex_record(hex_info_t* hex)
{
  if (hex->code == 0) { // data -- update min/max address so far
    if (hex->base + hex->addr + hex->num > hex->max)
      hex->max = hex->base + hex->addr + hex->num;
    if (hex->base + hex->addr < hex->min)
      hex->min = hex->base + hex->addr;
  }
  else if (hex->code == 1) { // EOF (:flash command not received yet)
    hex->eof = 1;
  }
  else if (hex->code == 2) { // extended segment address (top 16 of 24-bit addr)
    hex->base = ((hex->data[0] << 8) | hex->data[1]) << 4;
  }
  else if (hex->code == 3) { // start segment address (80x86 real mode only)
    return 1;
  }
  else if (hex->code == 4) { // extended linear address (top 16 of 32-bit addr)
    hex->base = ((hex->data[0] << 8) | hex->data[1]) << 16;
  }
  else if (hex->code == 5) { // start linear address (32-bit big endian addr)
    hex->base = (hex->data[0] << 24) | (hex->data[1] << 16)
      | (hex->data[2] << 8) | (hex->data[3] << 0);
  }
  else {
    return 1;
  }

  return 0;
}

//******************************************************************************
// Intel Hex record foramt:
//
// Start code:  one character, ASCII colon ':'.
// Byte count:  two hex digits, number of bytes (hex digit pairs) in data field.
// Address:     four hex digits
// Record type: two hex digits, 00 to 05, defining the meaning of the data field.
// Data:        n bytes of data represented by 2n hex digits.
// Checksum:    two hex digits, computed value used to verify record has no errors.
//
// Examples:
//  :10 9D30 00 711F0000AD38000005390000F5460000 35
//  :04 9D40 00 01480000 D6
//  :00 0000 01 FF
//******************************************************************************

/* Intel HEX read/write functions, Paul Stoffregen, paul@ece.orst.edu */
/* This code is in the public domain.  Please retain my name and */
/* email address in distributed copies, and let me know about any bugs */

/* I, Paul Stoffregen, give no warranty, expressed or implied for */
/* this software and/or documentation provided, including, without */
/* limitation, warranty of merchantability and fitness for a */
/* particular purpose. */

// type modifications by Jon Zeeff

/* parses a line of intel hex code, stores the data in bytes[] */
/* and the beginning address in addr, and returns a 1 if the */
/* line was valid, or a 0 if an error occured.  The variable */
/* num gets the number of bytes that were stored into bytes[] */

#include <stdio.h>		// sscanf(), etc.
#include <string.h>		// strlen(), etc.

int parse_hex_line(const char* theline, char* bytes,
  unsigned int* addr, unsigned int* num, unsigned int* code)
{
  unsigned sum, len, cksum;
  const char* ptr;
  int temp;

  *num = 0;
  if (theline[0] != ':')
    return 0;
  if (strlen(theline) < 11)
    return 0;
  ptr = theline + 1;
  if (!sscanf(ptr, "%02x", &len))
    return 0;
  ptr += 2;
  if (strlen(theline) < (11 + (len * 2)))
    return 0;
  if (!sscanf(ptr, "%04x", (unsigned int*)addr))
    return 0;
  ptr += 4;
  /* Serial.printf("Line: length=%d Addr=%d\n", len, *addr); */
  if (!sscanf(ptr, "%02x", code))
    return 0;
  ptr += 2;
  sum = (len & 255) + ((*addr >> 8) & 255) + (*addr & 255) + (*code & 255);
  while (*num != len)
  {
    if (!sscanf(ptr, "%02x", &temp))
      return 0;
    bytes[*num] = temp;
    ptr += 2;
    sum += bytes[*num] & 255;
    (*num)++;
    if (*num >= 256)
      return 0;
  }
  if (!sscanf(ptr, "%02x", &cksum))
    return 0;

  if (((sum & 255) + (cksum & 255)) & 255)
    return 0;     /* checksum error */
  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

Name: TeensyOTADemo.ino

Created: 10/9/2021 11:18:19 AM

Author: FRANKNEWXPS15\Frank

This program demonstrates the use of 'board.txt' post-build instructions in

conjunction with a small C# command-line program for seamless 'over-the-air' (OTA)

firmware update for Teensy modules.

Implementation of OTA update requires that Joe Pasquariello's 'FlasherX'

code be added to the Teensy sketch as it is below, and some code to allow

an external serial communications program to trigger the update process.

In the demo sketch below, the 'FlasherX' additions are the '#include FlasherTxx.h'

line and the addition of the FlasherX specific code at the bottom. The trigger

mechanism is provided by the 'CheckForUserInput();' call in loop. If the ASCII

code for 'U' or 'u' is present on Serial1, the update process will be launched.

#include "FlashTxx.h" // TLC/T3x/T4x flash primitives

#include <elapsedMillis.h>

elapsedMillis MsecSinceLastLEDToggle; //used for LED blink timer

Stream* FTDIport = &Serial1; // Serial (USB) or Serial1, Serial2, etc. (UART)

//******************************************************************************

// hex_info_t struct for hex record and hex file info

//******************************************************************************

typedef struct { //

char* data; // pointer to array allocated elsewhere

unsigned int addr; // address in intel hex record

unsigned int code; // intel hex record type (0=data, etc.)

unsigned int num; // number of data bytes in intel hex record

uint32_t base; // base address to be added to intel hex 16-bit addr

uint32_t min; // min address in hex file

uint32_t max; // max address in hex file

int eof; // set true on intel hex EOF (code = 1)

int lines; // number of hex records received

} hex_info_t;

void read_ascii_line(Stream* serial, char* line, int maxbytes);

int parse_hex_line(const char* theline, char* bytes,

unsigned int* addr, unsigned int* num, unsigned int* code);

int process_hex_record(hex_info_t* hex);

void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size);

uint32_t buffer_addr, buffer_size; //09/20/21 copied from FlasherX - loop()

void setup()

{

Serial.begin(115200);

//while (!Serial) {} //10/06/21 infinite wait hangs pgm when USB cable removed - oops!

delay(2000); //10/06/21 - just use fixed delay instead

Serial1.begin(115200);

while (!Serial1) {}

pinMode(LED_BUILTIN, OUTPUT);

MsecSinceLastLEDToggle = 0;

}

void loop()

{

if (Serial1.available())

{

CheckForUserInput();

}

if (MsecSinceLastLEDToggle >= 200)

{

MsecSinceLastLEDToggle -= 200;

digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));

}

void CheckForUserInput()

{

const int bufflen = 80;

char buff[bufflen];

memset(buff, 0, bufflen);

//const char s[2] = ",";

if (Serial1.available() > 0)

{

// read the incoming byte:

int incomingByte = Serial1.read();

// say what you got:

Serial1.print("I received: ");

Serial1.println(incomingByte, HEX); //chg to HEX 02/18/20

//02/18/20 experiment with multiple commands

switch (incomingByte)

{

case 0x55: //ASCII 'U'

case 0x75: //ASCII 'u'

Serial1.println(F("Start Program Update - Send new HEX file!"));

//09/20/21 copied from FlasherX - loop()

if (firmware_buffer_init(&buffer_addr, &buffer_size) == 0)

{

Serial1.printf("unable to create buffer\n");

Serial1.flush();

for (;;) {}

}

Serial1.printf("buffer = %1luK %s (%08lX - %08lX)\n",

buffer_size / 1024, IN_FLASH(buffer_addr) ? "FLASH" : "RAM",

buffer_addr, buffer_addr + buffer_size);

//09/20/21 clear the serial buffer

while (Serial1.available())

{

Serial1.read();

}

// receive hex file via serial, write new firmware to flash, clean up, reboot

update_firmware(&Serial1, buffer_addr, buffer_size); // no return if success

// return from update_firmware() means error or user abort, so clean up and

// reboot to ensure that static vars get boot-up initialized before retry

Serial1.printf("erase FLASH buffer / free RAM buffer...\n");

firmware_buffer_free(buffer_addr, buffer_size);

Serial1.flush();

REBOOT;

break;

}

//09/20/21 copied from FlasherX

//******************************************************************************

// update_firmware() read hex file and write new firmware to program flash

//******************************************************************************

void update_firmware(Stream* serial, uint32_t buffer_addr, uint32_t buffer_size)

{

static char line[96]; // buffer for hex lines

static char data[32] __attribute__((aligned(8))); // buffer for hex data

hex_info_t hex = { // intel hex info struct

data, 0, 0, 0, // data,addr,num,code

0, 0xFFFFFFFF, 0, // base,min,max,

0, 0 // eof,lines

};

serial->printf("waiting for hex lines...\n");

// read and process intel hex lines until EOF or error

while (!hex.eof) {

read_ascii_line(serial, line, sizeof(line));

//10/02/21 gfp added for visual xfer confirmation

if (hex.lines % 10 == 0)

{

digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN));

}

// reliability of transfer via USB is improved by this printf/flush

if (serial == (Stream*)&Serial)

{

serial->printf("%s\n", line);

serial->flush();

}

if (parse_hex_line((const char*)line, hex.data, &hex.addr, &hex.num, &hex.code) == 0) {

serial->printf("abort - bad hex line %s\n", line);

return;

}

else if (process_hex_record(&hex) != 0) { // error on bad hex code

serial->printf("abort - invalid hex code %d\n", hex.code);

return;

}

else if (hex.code == 0) { // if data record

uint32_t addr = buffer_addr + hex.base + hex.addr - FLASH_BASE_ADDR;

if (hex.max > (FLASH_BASE_ADDR + buffer_size)) {

serial->printf("abort - max address %08lX too large\n", hex.max);

return;

}

else if (!IN_FLASH(buffer_addr)) {

memcpy((void*)addr, (void*)hex.data, hex.num);

}

else if (IN_FLASH(buffer_addr)) {

int error = flash_write_block(addr, hex.data, hex.num);

if (error) {

serial->printf("abort - error %02X in flash_write_block()\n", error);

return;

}

hex.lines++;

}

serial->printf("\nhex file: %1d lines %1lu bytes (%08lX - %08lX)\n",

hex.lines, hex.max - hex.min, hex.min, hex.max);

// check FSEC value in new code -- abort if incorrect

#if defined(KINETISK) || defined(KINETISL)

uint32_t value = *(uint32_t*)(0x40C + buffer_addr);

if (value == 0xfffff9de) {

serial->printf("new code contains correct FSEC value %08lX\n", value);

}

else {

serial->printf("abort - FSEC value %08lX should be FFFFF9DE\n", value);

return;

}

#endif

// check FLASH_ID in new code - abort if not found

if (check_flash_id(buffer_addr, hex.max - hex.min)) {

serial->printf("new code contains correct target ID %s\n", FLASH_ID);

}

else {

serial->printf("abort - new code missing string %s\n", FLASH_ID);

return;

}

// get user input to write to flash or abort

int user_lines = -1;

while (user_lines != hex.lines && user_lines != 0) {

serial->printf("enter %d to flash or 0 to abort\n", hex.lines);

read_ascii_line(serial, line, sizeof(line));

sscanf(line, "%d", &user_lines);

}

if (user_lines == 0) {

serial->printf("abort - user entered 0 lines\n");

return;

}

// move new program from buffer to flash, free buffer, and reboot

//serial->printf("user entered %d lines\n", user_lines);

flash_move(FLASH_BASE_ADDR, buffer_addr, hex.max - hex.min);

// should not return from flash_move(), but put REBOOT here as reminder

REBOOT;

}

//******************************************************************************

// read_ascii_line() read ascii characters until '\n', '\r', or max bytes

//******************************************************************************

void read_ascii_line(Stream* serial, char* line, int maxbytes)

{

int c = 0, nchar = 0;

while (nchar < maxbytes && !(c == '\n' || c == '\r')) {

if (serial->available()) {

c = serial->read();

line[nchar++] = c;

}

line[nchar - 1] = 0; // null-terminate

}

//******************************************************************************

// process_hex_record() process record and return okay (0) or error (1)

//******************************************************************************

int process_hex_record(hex_info_t* hex)

{

if (hex->code == 0) { // data -- update min/max address so far

if (hex->base + hex->addr + hex->num > hex->max)

hex->max = hex->base + hex->addr + hex->num;

if (hex->base + hex->addr < hex->min)

hex->min = hex->base + hex->addr;

}

else if (hex->code == 1) { // EOF (:flash command not received yet)

hex->eof = 1;

}

else if (hex->code == 2) { // extended segment address (top 16 of 24-bit addr)

hex->base = ((hex->data[0] << 8) | hex->data[1]) << 4;

}

else if (hex->code == 3) { // start segment address (80x86 real mode only)

return 1;

}

else if (hex->code == 4) { // extended linear address (top 16 of 32-bit addr)

hex->base = ((hex->data[0] << 8) | hex->data[1]) << 16;

}

else if (hex->code == 5) { // start linear address (32-bit big endian addr)

hex->base = (hex->data[0] << 24) | (hex->data[1] << 16)

| (hex->data[2] << 8) | (hex->data[3] << 0);

}

else {

return 1;

}

return 0;

}

//******************************************************************************

// Intel Hex record foramt:

// Start code: one character, ASCII colon ':'.

// Byte count: two hex digits, number of bytes (hex digit pairs) in data field.

// Address: four hex digits

// Record type: two hex digits, 00 to 05, defining the meaning of the data field.

// Data: n bytes of data represented by 2n hex digits.

// Checksum: two hex digits, computed value used to verify record has no errors.

// Examples:

// :10 9D30 00 711F0000AD38000005390000F5460000 35

// :04 9D40 00 01480000 D6

// :00 0000 01 FF

//******************************************************************************

/* Intel HEX read/write functions, Paul Stoffregen, paul@ece.orst.edu */

/* This code is in the public domain. Please retain my name and */

/* email address in distributed copies, and let me know about any bugs */

/* I, Paul Stoffregen, give no warranty, expressed or implied for */

/* this software and/or documentation provided, including, without */

/* limitation, warranty of merchantability and fitness for a */

/* particular purpose. */

// type modifications by Jon Zeeff

/* parses a line of intel hex code, stores the data in bytes[] */

/* and the beginning address in addr, and returns a 1 if the */

/* line was valid, or a 0 if an error occured. The variable */

/* num gets the number of bytes that were stored into bytes[] */

#include <stdio.h> // sscanf(), etc.

#include <string.h> // strlen(), etc.

int parse_hex_line(const char* theline, char* bytes,

unsigned int* addr, unsigned int* num, unsigned int* code)

{

unsigned sum, len, cksum;

const char* ptr;

int temp;

*num = 0;

if (theline[0] != ':')

return 0;

if (strlen(theline) < 11)

return 0;

ptr = theline + 1;

if (!sscanf(ptr, "%02x", &len))

return 0;

ptr += 2;

if (strlen(theline) < (11 + (len * 2)))

return 0;

if (!sscanf(ptr, "%04x", (unsigned int*)addr))

return 0;

ptr += 4;

/* Serial.printf("Line: length=%d Addr=%d\n", len, *addr); */

if (!sscanf(ptr, "%02x", code))

return 0;

ptr += 2;

sum = (len & 255) + ((*addr >> 8) & 255) + (*addr & 255) + (*code & 255);

while (*num != len)

{

if (!sscanf(ptr, "%02x", &temp))

return 0;

bytes[*num] = temp;

ptr += 2;

sum += bytes[*num] & 255;

(*num)++;

if (*num >= 256)

return 0;

}

if (!sscanf(ptr, "%02x", &cksum))

return 0;

if (((sum & 255) + (cksum & 255)) & 255)

return 0; /* checksum error */

return 1;

}

And the C# command-line program:

using System;
using System.IO.Ports;
using System.Threading;
using System.Timers;

/*
Small console app to facilitate over-the-air (OTA) updates to a Teensy 3.x/4.x controller,
using VS2019 with the Visual Micro extension as the Arduino IDE. It is called by a post-build
'hook' statement in a file called 'board.txt' located in whatever Teensy program is 
being updated.  This app does the following:

 - Extract the project path and selected COMPORT number from the arguments to the call to Main()
 - Opens a UART serial port connection to the Teensy, typically one provided by a BT adaptor
   operating in 'pass-through' mode. The serial port COMPORT number is passed into this app
   as an argument.
 - Sends whatever command is required to put the existing Teensy firmware into 'update' mode
 - Using the path of the updating program (passed in as an argument), locates the .HEX file 
   associated with the project, and sends it's contents to the Teensy, one line at a time, counting
   lines and confirming checksums line-by-line
 - Compares the number of lines sent to the Teensy with the number of lines received by the Teensy,
   and if there is a match, allows the Teensy update process to complete; otherwise aborts
*/

namespace TeensyFlash
{  
    class Program
    {
        const string startCmdStr = "U"; //used in sketch's 'GetUserInput()' to start upload sequence
        static string rcvStr = string.Empty;
        private static System.Timers.Timer aTimer;
        private static bool bTimedOut;

        static void Main(string[] args)
        {
            //Extract the build path and selected COMPORT number from the arguments to the call to Main()
            Console.WriteLine("Teensy Flash Console");
            Console.WriteLine("Number of arguments in args = {0}\n", args.Length);
            int argindex = 0;
            string comPortStr = string.Empty;
            foreach (var item in args)
            {
                Console.WriteLine(item);
                if (item.Contains("COM"))
                {
                    comPortStr = args[argindex];
                }

                argindex++;
            }

            string build_path = args[0];
            string projectName = args[args.Length - 1];
            projectName = projectName.Substring(0, projectName.Length - 4); //remove extension
            build_path = build_path.Replace("\"", string.Empty).Trim();
            Console.WriteLine("path = {0}", build_path);
            Console.WriteLine("comport = {0}", comPortStr);
            Console.WriteLine("build name = {0}", projectName);
            Console.WriteLine("path to HEX file = {0}", build_path + "\\" + projectName + ".hex");

            //Find and open .HEX file - maybe pre-process to confirm checksums and get number of bytes.
            try
            {
                Console.WriteLine("just before file read");
                string[] lines = System.IO.File.ReadAllLines(build_path + "\\" + projectName + ".hex");
                Console.WriteLine("Read {0} lines from hex file", lines.Length);
                int numlines = 0;

                //Open UART serial port connection to the Teensy, typically one provided by a BT adaptor
                //Send whatever command is required to put the existing Teensy firmware into 'update' mode
                try
                {
                    SerialPort _serport = new SerialPort(comPortStr, 115200);
                    _serport.Open();
                    _serport.DiscardOutBuffer();
                    _serport.DiscardInBuffer();
                    Thread.Sleep(100);
                    Console.WriteLine(startCmdStr);
                    _serport.Write(startCmdStr);

                    rcvStr = string.Empty;
                    aTimer = new System.Timers.Timer();
                    aTimer.Interval = 5000;
                    aTimer.Elapsed += OnTimedEvent;

                    aTimer.Start();
                    while (!rcvStr.Contains("waiting") && !bTimedOut)
                    {
                        if (_serport.BytesToRead > 0)
                        {
                            rcvStr = _serport.ReadLine();
                        }
                    }
                    aTimer.Stop();

                    if (bTimedOut)
                    {
                        Console.WriteLine("Timed out waiting for 'waiting' response from Teensy");
                    }
                    else
                    {
                        //if we get to here, the Teensy is ready to receive HEX file contents
                        Thread.Sleep(500);
                        numlines = 0;
                        foreach (string item in lines)
                        {
                            numlines++;
                            _serport.WriteLine(item);
                        }
                        Console.WriteLine("total lines = {0}", numlines);

                        //now we wait for Teensy to emit "hex file: xx lines xx bytes..." and then "enter xx to flash..."
                        aTimer.Start();
                        while (!rcvStr.Contains("hex file:") && !bTimedOut)
                        {
                            if (_serport.BytesToRead > 0)
                            {
                                rcvStr = _serport.ReadLine();
                            }
                        }
                        aTimer.Stop();
                        aTimer.Dispose();

                        if (bTimedOut)
                        {
                            Console.WriteLine("Timed out waiting for response from Teensy");
                        }
                        else
                        {
                            //extract number of lines from Teensy string, and compare with numlines.
                            //If they match, then send the number back to Teensy to complete the update.
                            //Otherwise, send '0' to abort

                            int colonIdx = rcvStr.IndexOf(':');
                            int lineIdx = rcvStr.IndexOf("lines");
                            string compareStr = rcvStr.Substring(colonIdx+1, lineIdx - colonIdx-1);
                            compareStr = compareStr.Trim();
                            int numTeensyLines = Convert.ToInt16(compareStr);

                            Console.WriteLine("sent {0} teensy replied {1}",numlines, numTeensyLines);
                            if (numTeensyLines == numlines)
                            {
                                Console.WriteLine("numlines {0} matches numTeensyLines {1} - send confirmation",
                                    numlines, numTeensyLines);

                                _serport.WriteLine(compareStr);
                            }
                        }


                        //Send [project_name].Hex file to the Teensy, confirming checksum and counting lines
                        //If sent bytes match received bytes, allow the update to complete.
                    }
                }
                catch (Exception exc)
                {
                    Console.WriteLine(exc.Message);
                }// end CATCH portion of TRY/CATCH block
            }
            catch (Exception e)
            {
                Console.WriteLine("hex file read failed with message:" + e.Message);
            }
            aTimer.Dispose();


        }

        static string chksum(string input)
        {
            int TwosComplement(string s)
            {
                if (s.Length % 2 != 0)
                    throw new FormatException(nameof(input));

                var checksum = 0;

                for (var i = 0; i < s.Length; i += 2)
                {
                    var value = int.Parse(s.Substring(i, 2), System.Globalization.NumberStyles.AllowHexSpecifier);

                    checksum = (checksum + value) & 0xFF;
                }

                return 256 - checksum & 0xFF;
            }

            //return string.Concat(":", input, " ", TwosComplement(input).ToString("X2"));
            return TwosComplement(input).ToString("X2");
        }
        private static void SetTimer()
        {
            // Create a timer with a two second interval.
            aTimer = new System.Timers.Timer(2000);
            // Hook up the Elapsed event for the timer. 
            aTimer.Elapsed += OnTimedEvent;
            //aTimer.AutoReset = true;
            aTimer.Enabled = true;
        }

        private static void OnTimedEvent(Object source, ElapsedEventArgs e)
        {
            Console.WriteLine("The Elapsed event was raised at {0:HH:mm:ss.fff}",
                              e.SignalTime);
            bTimedOut = true;
        }
    }

}

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

using System;

using System.IO.Ports;

using System.Threading;

using System.Timers;

Small console app to facilitate over-the-air (OTA) updates to a Teensy 3.x/4.x controller,

using VS2019 with the Visual Micro extension as the Arduino IDE. It is called by a post-build

'hook' statement in a file called 'board.txt' located in whatever Teensy program is

being updated. This app does the following:

- Extract the project path and selected COMPORT number from the arguments to the call to Main()

- Opens a UART serial port connection to the Teensy, typically one provided by a BT adaptor

operating in 'pass-through' mode. The serial port COMPORT number is passed into this app

as an argument.

- Sends whatever command is required to put the existing Teensy firmware into 'update' mode

- Using the path of the updating program (passed in as an argument), locates the .HEX file

associated with the project, and sends it's contents to the Teensy, one line at a time, counting

lines and confirming checksums line-by-line

- Compares the number of lines sent to the Teensy with the number of lines received by the Teensy,

and if there is a match, allows the Teensy update process to complete; otherwise aborts

namespace TeensyFlash

{

class Program

{

const string startCmdStr = "U"; //used in sketch's 'GetUserInput()' to start upload sequence

static string rcvStr = string.Empty;

private static System.Timers.Timer aTimer;

private static bool bTimedOut;

static void Main(string[] args)

{

//Extract the build path and selected COMPORT number from the arguments to the call to Main()

Console.WriteLine("Teensy Flash Console");

Console.WriteLine("Number of arguments in args = {0}\n", args.Length);

int argindex = 0;

string comPortStr = string.Empty;

foreach (var item in args)

{

Console.WriteLine(item);

if (item.Contains("COM"))

{

comPortStr = args[argindex];

}

argindex++;

}

string build_path = args[0];

string projectName = args[args.Length - 1];

projectName = projectName.Substring(0, projectName.Length - 4); //remove extension

build_path = build_path.Replace("\"", string.Empty).Trim();

Console.WriteLine("path = {0}", build_path);

Console.WriteLine("comport = {0}", comPortStr);

Console.WriteLine("build name = {0}", projectName);

Console.WriteLine("path to HEX file = {0}", build_path + "\\" + projectName + ".hex");

//Find and open .HEX file - maybe pre-process to confirm checksums and get number of bytes.

try

{

Console.WriteLine("just before file read");

string[] lines = System.IO.File.ReadAllLines(build_path + "\\" + projectName + ".hex");

Console.WriteLine("Read {0} lines from hex file", lines.Length);

int numlines = 0;

//Open UART serial port connection to the Teensy, typically one provided by a BT adaptor

//Send whatever command is required to put the existing Teensy firmware into 'update' mode

try

{

SerialPort _serport = new SerialPort(comPortStr, 115200);

_serport.Open();

_serport.DiscardOutBuffer();

_serport.DiscardInBuffer();

Thread.Sleep(100);

Console.WriteLine(startCmdStr);

_serport.Write(startCmdStr);

rcvStr = string.Empty;

aTimer = new System.Timers.Timer();

aTimer.Interval = 5000;

aTimer.Elapsed += OnTimedEvent;

aTimer.Start();

while (!rcvStr.Contains("waiting") && !bTimedOut)

{

if (_serport.BytesToRead > 0)

{

rcvStr = _serport.ReadLine();

}

aTimer.Stop();

if (bTimedOut)

{

Console.WriteLine("Timed out waiting for 'waiting' response from Teensy");

}

else

{

//if we get to here, the Teensy is ready to receive HEX file contents

Thread.Sleep(500);

numlines = 0;

foreach (string item in lines)

{

numlines++;

_serport.WriteLine(item);

}

Console.WriteLine("total lines = {0}", numlines);

//now we wait for Teensy to emit "hex file: xx lines xx bytes..." and then "enter xx to flash..."

aTimer.Start();

while (!rcvStr.Contains("hex file:") && !bTimedOut)

{

if (_serport.BytesToRead > 0)

{

rcvStr = _serport.ReadLine();

}

aTimer.Stop();

aTimer.Dispose();

if (bTimedOut)

{

Console.WriteLine("Timed out waiting for response from Teensy");

}

else

{

//extract number of lines from Teensy string, and compare with numlines.

//If they match, then send the number back to Teensy to complete the update.

//Otherwise, send '0' to abort

int colonIdx = rcvStr.IndexOf(':');

int lineIdx = rcvStr.IndexOf("lines");

string compareStr = rcvStr.Substring(colonIdx+1, lineIdx - colonIdx-1);

compareStr = compareStr.Trim();

int numTeensyLines = Convert.ToInt16(compareStr);

Console.WriteLine("sent {0} teensy replied {1}",numlines, numTeensyLines);

if (numTeensyLines == numlines)

{

Console.WriteLine("numlines {0} matches numTeensyLines {1} - send confirmation",

numlines, numTeensyLines);

_serport.WriteLine(compareStr);

}

//Send [project_name].Hex file to the Teensy, confirming checksum and counting lines

//If sent bytes match received bytes, allow the update to complete.

}

catch (Exception exc)

{

Console.WriteLine(exc.Message);

}// end CATCH portion of TRY/CATCH block

}

catch (Exception e)

{

Console.WriteLine("hex file read failed with message:" + e.Message);

}

aTimer.Dispose();

}

static string chksum(string input)

{

int TwosComplement(string s)

{

if (s.Length % 2 != 0)

throw new FormatException(nameof(input));

var checksum = 0;

for (var i = 0; i < s.Length; i += 2)

{

var value = int.Parse(s.Substring(i, 2), System.Globalization.NumberStyles.AllowHexSpecifier);

checksum = (checksum + value) & 0xFF;

}

return 256 - checksum & 0xFF;

}

//return string.Concat(":", input, " ", TwosComplement(input).ToString("X2"));

return TwosComplement(input).ToString("X2");

}

private static void SetTimer()

{

// Create a timer with a two second interval.

aTimer = new System.Timers.Timer(2000);

// Hook up the Elapsed event for the timer.

aTimer.Elapsed += OnTimedEvent;

//aTimer.AutoReset = true;

aTimer.Enabled = true;

}

private static void OnTimedEvent(Object source, ElapsedEventArgs e)

{

Console.WriteLine("The Elapsed event was raised at {0:HH:mm:ss.fff}",

e.SignalTime);

bTimedOut = true;

}

And last, the ‘board.txt’ file contents that launches the C# command-line program:

# Teensy OTA Demo build property overrides
# 10/05/21 gfp - trying to run a post-build command
recipe.hooks.postbuild.1.pattern=cmd.exe /c "C:\Users\Frank\Documents\Visual Studio 2019\Projects\TeensyFlash\bin\Release\netcoreapp3.1\TeensyFlash.exe" "\"{vm.runtime.build.final_output_path}"" {serial.port} {build.project_name}

# Teensy OTA Demo build property overrides

# 10/05/21 gfp - trying to run a post-build command

Here’s a short video showing the update process. The clip starts with the ascii ‘U’ trigger code arriving at the Teensy Serial1 port, and ends with the update finished and the Teensy rebooted back into the ‘blink’ code.

09 October 2021 Update: HC-05 Bluetooth link:

The next step is to replace the FTDI module with an HC-05 Bluetooth link. I had some HC-05 modules from previous work, and I had done a similar project with an Arduino some time back – so how hard could it be?

I hooked up a HC-05 to the Teensy as shown in the following photo, using a bench power supply to power both the HC-05 and the Teensy 3.5

HC-05 and Teensy both powered by lap power supply

Then I paired the HC-05 with my laptop; this took a bit of fumbling around, as the laptop thought it was still paired with an HC-05 even though it’s been over two years since I last used it, and I had since forgotten that the default password was ‘1234’. In any case, I eventually got it paired, as shown, with an automatically generated COM port on COM4.

Next I fired up Tera Term and created a connection to COM4, as shown:

And then tried sending some ascii text through to the Teensy. This appeared to work fine, but when I tried a program update via the HC-05 link I got an error that indicated the FlasherX code didn’t like something I was sending it.

The ‘abort – bad hex line’ output happens before I try to send it the .HEX file contents, so it clearly isn’t choking on that; maybe some extra characters getting sent instead of just the “U” character?

Looking at the ‘FlasherX’ code, it appears that the offending characters/line is supposed to be printed out with the lines

    if (parse_hex_line((const char*)line, hex.data, &hex.addr, &hex.num, &hex.code) == 0) {
      serial->printf("abort - bad hex line %s\n", line);
      return;
    }

if (parse_hex_line((const char*)line, hex.data, &hex.addr, &hex.num, &hex.code) == 0) {

serial->printf("abort - bad hex line %s\n", line);

return;

}

which implies whatever caused the problem is non-printable – maybe an extra CR/LF? So, I added some debug code to update_firmware() to print out each line as it is read into the ‘line’ character array, so maybe I can see the problem.

Hmm, more mysteries. I reconnected the regular USB connection, and uploaded the new version of the sketch. Then I disconnected the USB connector, and used Tera Term to send the update command (“U”). However, this time the OTA Update code didn’t choke, and AFAICT performed a completely successful update via BT and the HC-05 – yay! Of course, I now have no idea what caused the problem to start with, and whether or not my addition of a few lines of debugging code made the difference.

So, I undid the changes to the update code and tried again. And, as shown below, the OTA update worked perfectly – double Yay!!

The printed out lines from the .hex file are from the previous run.

So now to try an OTA update using my command-line program instead of Tera Term. I disconnected TT from COM4, and then, after selecting COM4 in the VS2019 IDE, pressed F7 to start the process. This worked as well, but it appeared the transfer rate was considerably slower – no idea why.

C:\Program Files (x86)\Arduino\java\bin>"C:\Users\Frank\Documents\Visual Studio 2019\Projects\TeensyFlash\bin\Release\netcoreapp3.1\TeensyFlash.exe" "\"C:\Users\Frank\Documents\Arduino\Teensy Projects\TeensyOTADemo\Release\"" COM4 TeensyOTADemo.ino 
Teensy Flash Console
Number of arguments in args = 3
"C:\Users\Frank\Documents\Arduino\Teensy Projects\TeensyOTADemo\Release"
COM4
TeensyOTADemo.ino
path = C:\Users\Frank\Documents\Arduino\Teensy Projects\TeensyOTADemo\Release
comport = COM4
build name = TeensyOTADemo
path to HEX file = C:\Users\Frank\Documents\Arduino\Teensy Projects\TeensyOTADemo\Release\TeensyOTADemo.hex
just before file read
Read 3142 lines from hex file
U
total lines = 3142
sent 3142 teensy replied 3142
numlines 3142 matches numTeensyLines 3142 - send confirmation

Teensy Flash Console

Number of arguments in args = 3

"C:\Users\Frank\Documents\Arduino\Teensy Projects\TeensyOTADemo\Release"

COM4

TeensyOTADemo.ino

path = C:\Users\Frank\Documents\Arduino\Teensy Projects\TeensyOTADemo\Release

comport = COM4

build name = TeensyOTADemo

path to HEX file = C:\Users\Frank\Documents\Arduino\Teensy Projects\TeensyOTADemo\Release\TeensyOTADemo.hex

just before file read

Read 3142 lines from hex file

total lines = 3142

sent 3142 teensy replied 3142

numlines 3142 matches numTeensyLines 3142 - send confirmation

Here’s a short video showing the OTA update using the command-line program and BT OTA.

Teensy OTA update using command-line program and HC-05 BT link

Just comparing the overall times from the two videos above the one using the command-line program runs approximately twice as long. It’s hard to believe it is only the use of the command-line program vs Tera Term that is causing the delay – but it is possible that TT was simply running at a higher baud rate – more study required.

In summary, however, slow rate or no, it is clear that we now can implement completely automated, seamless OTA update processes using VS2019 and Visual Micro. Now that the groundwork has been laid, I would assume that this same strategy could be implemented for other IDE’s as well.

I have started GitHub repositories for the Teensy demo sketch TeensyOTADemo and my TeensyFlash C# command-line program on my GitHub site, and I would welcome suggestions/improvements.

10 October 2021 Update:

I’m trying to determine what caused the slow update when using my command-line program and the HC-05 when doing an OTA update relative to the situation when using Tera Term to manually transfer the .HEX file to the Teensy. In both cases, the OTA link is through the HC-05, so that module shouldn’t be the cause. However, just to check I went back and checked the HC-05 settings using the ‘AT Command Mode’ trick discussed in this post. AFAICT, the HC-05 was set to 115200 baud rate. I also checked to see if I had somehow misconfigured the serial port created in my command-line program, but it is set to create a port at 115,200 BPS as well. So, I’m officially baffled.

To investigate the problem, did an OTA update via the HC-05 BT link, but using Tera Term to trigger the update process and send the .HEX file. Using this method, it took approximately 14 sec to transfer the entire 3142-line .HEX file. Then I did an OTA update using my command-line program, using the same HC-05 BT link. With this setup, the transfer took approximately 35 seconds – over twice the time. Watching with my scope, it is clear that the transfer takes place at a much slower rate when using the command-line program, even though (at least AFAICT) the programmed baud rates are identical in both cases. The two photos below show the transfer rate for both cases, using the same time scale for both.

File Transfer using Command-line Program and HC-05 BT Link

File Transfer using Tera Term and HC-05 BT Link

After a bit of web research on C# .NET serial port programming, I came across this post, which indicates that using .NET for this task was not a very wise move – bummer!

Stay tuned,

Frank

Arduino Remote Programming Using A HC-05 Bluetooth Module

7 Replies

Posted 10 June 2019

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

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

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

Overall Approach:

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

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

The Wireless Link

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

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

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

A way of resetting the Arduino to accept firmware uploads

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

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

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

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

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

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

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

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

AT+INIT // Initialize SPP Profile.

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

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

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

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

AT+INIT // Initialize SPP Profile.

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

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

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

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

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

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

Wiring Layout for HC-05 Configuration via AT commands

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

HC-05 wired for initial configuration using AT commands

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

Initial AT Configuration Arduino Sketch

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

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

void setup()

{

Serial.begin(115200);

Serial1.begin(38400);

}

void loop()

{

if (Serial1.available())

{

Serial.write(Serial1.read());

}

if (Serial.available())

{

Serial1.write(Serial.read());

}

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

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

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

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

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

Testing

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

Pairing dialog on my Dell XPS15 9570 laptop

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

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

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

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

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

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

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

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

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

13 Aug 2019 Update:

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

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

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

Stay tuned!

Frank

25 October 2021 Update:

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

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

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