AI says "For Macs with Apple silicon (M1, M2, etc.), you'll need to use virtualization software like Parallels Desktop, VMware Fusion, or UTM to run Windows in a virtual machine."
How does the VM debugging work with Teensys? Does it use that TeensyDebug library or something?
I don't know. I use VisualMicro all the time but have never tried the built-in debugging, couldn't work out whether it used Usb Serial or hardware Serial, so never tried. The instructions are not too clear to me. They seem to be written by someone who knows how it works for someone who also knows how it works!
Thanks for the suggestion, though. Appreciate the thought. I'll have to be more resourceful.
Serial.write(buf, len) : https://docs.arduino.cc/language-reference/en/functions/communication/serial/write/
Thanks, that's the easy part of the question...
. You’d probably want to use some framing protocol so that you know where data frames start. Two examples are SLIP and COBS. CRC’s are also useful to validate frame data. For data recovery upon error, there’s a bunch of ways to do error correction, but I have a feeling that with a reliable transport (eg. serial or USB), you probably only need to worry about framing and synchronization.Thanks, that's the easy part of the question...
Really was wondering about the parsing of binary command bytes with a method to recover from an error (garbled command?). Is there a simple way to recover? I mean, if all goes well, everything just works, but if there's a hiccup, then how does one recover/resync to the binary data? This binary data logging will be in the presence of a 1 HP motor being driven by a Variable Frequency Drive controller.
/*
T4.1 Take readings from UART (from ESP32C3) in text and save to SD card and show on screen.
Modified to detect SD Card present, or NOT.
SoftwareId: S.0004.0004.002
SoftwareId: S.0004.0004.003 Added MTP support
*/
#define softwareId "S.0004.0004.003 - Added MTP support"
#include <SD.h>
#include <timelib.h>
//#include <MTP_Teensy.h>
#define numTargets 4
#define CS_SD BUILTIN_SDCARD // Works on T_3.6 and T_4.1
#define ledPin 13
const uint32_t identifier = 57767959;
union identifierUnion {
uint32_t Identifier;
char identTxt[sizeof(uint32_t)];
};
identifierUnion identMatch;
struct msgType { // <<---- Format of message for sending and receiving
uint32_t ident;
uint8_t id;
uint16_t temp;
uint16_t humidity;
};
struct uniMsgType {
union {
msgType d;
char txt[sizeof(msgType)];
};
};
uniMsgType recvMsg;
const uint8_t maxArr = numTargets;
typedef struct msgArrType {
msgType data[maxArr];
bool gotData[maxArr];
uint8_t hour;
uint8_t min;
} msgArrType;
msgArrType recvMsgArr;
File dataFile;
String GenerateDateStr(char c) {
String s = "";
int n = day();
if (n < 10) s.concat( "0");
s.concat(n);
s.concat('/');
n = month();
if (n < 10) s.concat("0");
s.concat(n);
s.concat('/');
n = year();
if (n < 10) s.concat("0");
s.concat(n);
if (c != 0x0) s.concat(c);
return s;
}
String GenerateTimeStr(bool andSeconds, char c ) {
String s = "";
int n = hour();
if (n < 10) s.concat("0");
s.concat(n);
s.concat(':');
n = minute();
if (n < 10) s.concat("0");
s.concat(n);
if (andSeconds) {
s.concat(':');
n = second();
if (n < 10) s.concat("0");
s.concat(n);
}
if (c != 0x0) s.concat(c);
return s;
}
time_t getTeensy3Time(){
return Teensy3Clock.get();
}
void send(const msgType* msg)
{
Serial1.write((const char*)msg, sizeof(msgType)); // 2 bytes.
}
bool receive(uniMsgType* msg)
{
return (Serial1.readBytes((char*)msg, sizeof(uniMsgType)) == sizeof(uniMsgType));
}
//String t = "";
bool sdSetup = true;
void setup()
{
identMatch.Identifier = identifier;
setSyncProvider(getTeensy3Time);
Serial.begin(115200);
while (!Serial && millis() < 5000);
Serial1.begin(115200);
Serial.print("SoftwareId: "); Serial.println(softwareId);
Serial.print("Initializing SD card...");
pinMode(ledPin, OUTPUT);
// see if the card is present and can be initialized:
if (SD.begin(CS_SD)) {
MTP.addFilesystem(SD, "SD Card");
Serial.println("card initialized.");
}
else {
Serial.println("Card failed, or not present");
sdSetup = false;
// No SD card, so don't do anything more - stay stuck here
}
if (timeStatus() != timeSet) {
Serial.println("Unable to sync with the RTC");
} else Serial.println("RTC has set the system time");
// mandatory to begin the MTP session.
MTP.begin();
Serial.println(GenerateDateStr(0x0));
}
void PrintDec(uint8_t n) {
if (n < 10) Serial.print("0");
Serial.print(n);
};
void PrintN(uint16_t n) {
uint16_t q;
Serial.print(n / 100);
Serial.print(".");
q = n % 100;
PrintDec(q);
}
void PrintNN(uint16_t n) {
uint16_t q;
dataFile.print(n / 100);
dataFile.print(".");
q = n % 100;
if (q < 10) dataFile.print("0");
dataFile.print(q);
}
void PrintData() {
String where;
uint8_t n;
uint8_t p;
n = 0;
PrintDec(recvMsgArr.hour);
Serial.print(":");
PrintDec(recvMsgArr.min);
Serial.print(" ");
while (n < maxArr) {
p = recvMsgArr.data[n].id - 1;
if (recvMsgArr.gotData[n]) {
switch (p) {
case 0:
where = "GBrm:";
break;
case 1:
where = "Lnge:";
break;
case 2:
where = "BBrm:";
break;
case 3:
where = "CBrm:";
break;
}
Serial.print(where);
PrintN(recvMsgArr.data[n].temp);
recvMsgArr.data[n].temp = 0;
Serial.print(" ");
PrintN(recvMsgArr.data[n].humidity); recvMsgArr.data[n].humidity = 0;
Serial.print(" ");
}
else Serial.print("----------------- ");
recvMsgArr.gotData[n] = false;
n = n + 1;
}
Serial.println();
}
String tim;
String date;
uint8_t lastMin = 99;
uint8_t currMin = 98;
uint8_t p;
// Add the main program code into the continuous loop() function
void loop()
{
MTP.loop(); //This is mandatory to be placed in the loop code.
while (Serial1.available() >= (int)sizeof(msgType)) {
digitalWrite(ledPin, HIGH);
if (receive(&recvMsg)) {
if (recvMsg.d.ident == identifier) {
currMin = minute();
if (currMin != lastMin) {
if (lastMin != 99) {
PrintData();
}
lastMin = currMin;
}
p = recvMsg.d.id - 1; // Serial.print(p); Serial.println(" ");
recvMsgArr.data[p] = recvMsg.d;
recvMsgArr.gotData[p] = true;
recvMsgArr.hour = hour();
recvMsgArr.min = minute();
//Serial.print("sdSetup:"); Serial.print(sdSetup); Serial.print(" SD.mediaPresent:"); Serial.print(SD.mediaPresent());
if (sdSetup && SD.mediaPresent()) {
dataFile = SD.open("datalog.csv", FILE_WRITE);
//Serial.print(" dataFile:"); Serial.println(dataFile);
// if the file is available, write to it:
if (dataFile) {
for (int q = 0; q < (recvMsg.d.id-1) * 5; q++) {
dataFile.print(',');
}
date = GenerateDateStr(' ');
tim = GenerateTimeStr(true, ',');
dataFile.print(date);
dataFile.print(tim);
dataFile.print(recvMsg.d.id); dataFile.print(",");
PrintNN(recvMsg.d.temp); dataFile.print(",");
PrintNN(recvMsg.d.humidity); dataFile.println();
dataFile.close();
}
else Serial.println("error opening datalog.csv");
}
else Serial.println("No SD Card (Media) present");
}
else {
Serial.println("Bad data, getting back into synch");
for (uint n = 0; n < sizeof(msgType); n++) {
Serial.print(recvMsg.txt[n]);
}
bool insynch = false;
elapsedMillis outOfSynchTime;
while (!insynch && outOfSynchTime < 5000) { // after 5 seconds of no serial1 data should be back in synch
while (Serial1.available() && (Serial1.peek() != identMatch.identTxt[0])) {
Serial.print((char)Serial1.read());
outOfSynchTime = 0;
}
if (Serial1.available()) insynch = (Serial1.peek() == identMatch.identTxt[0]);
}
Serial.println("Back in synch");
}
} else Serial.println("Unable to Receive Data");
digitalWrite(ledPin, LOW);
}
delay(1);
}Thanks.
You don't have to use MTP. If you don't want it just delete all the MTP references. I originally wrote it to log to SD disk and to the screen. It was only latterly that I added the MTP. It sometimes makes it easier to look at the results on a PC but does have drawbacks in that new data does not automatically appear on the PC unless you close the directory on the PC and then open the directory again. At least I think that is the way it works. It's been a while since I have used it.
But I'd like to get MTP to work, as it might be easier in the end... However, MTP is not native to a Mac. I'm going to try openmtp installed via homebrew. I don't know if it will actually work on a Teensy, as it was written primarily for Android phone to Mac file transfer. But first I need to study the basic message comms stuff. MTP is just something new for me to pick up.
Rather not go there. If it was $10, sure, over $100, hard no. I still have a Win10 anemic laptop, maybe it will boot... It was a cheap laptop, never again. It had the slowest HDD I've ever experienced. Replaced it with an SSD and things were slightly better, but still slow. It was a matched system - all devices were slow... What a waste of money that was.
It only fails to sync during thread to stop mode. All other modes work flawlessly, (normal thread, normal feed, and feed to stop) and have for three years.
Maybe, maybe not. Can't tell. Premature to speculate.
No. I am using EncoderTool, which interrupts on both A and B. Encoder library doesn't seem to have a method that I can use for this. I built my code around EncoderTool, which has an entirely different API from Encoder library.
Yes.
No. I added print statements during sync time, and first step time. They had selected variable values. I did not send out encoder counts, as they occur rapidly, roughly every 33us.
I could log to SD, but the T4.1 is not very accessible in the shop, since it need to be in an enclosure. MTP is not supported by Apple, and I have a Mac. I'm willing to try openmtp, it's installed, but have yet to test it. That's why I was asking about example code for mtp-teensy. Need something simple, so I can do a test read back of a file on an SD card.
Yes. There's no way to stop it from globally disabling (blocking) all interrupts for somewhat lengthy times, at it's whim. It's in the source. If my encoder interrupts are blanked for more than 33 us (at only 400 RPM) then I've lost sync.
Yes, I'm setting up a HWSerial channel. If I'm careful, it might be ok. I'm starting out at 3Mbps. The wire will be about 8-12" long.
It's kind of complicated, but simple at the same time. When you cut a threads on a lathe, they are usually cut in multiple passes, since most (99% of them!) lathes are not massive and rigid enough to do it in a single pass. This creates a requirement to have successive helices to overlay the same path as the original cut, but be a little deeper every time. So sync is in effect to the original cut. It's actually a rotational error.
Unknown really. I suspect it's angle related, as the angle changes quickly. Z changes, relatively slowly. Logging of z shows linear movement down to the micron level. If I want to, I can watch it change micron by micron. I rarely do, save for initial investigations. Z has been boring...
Using different instances of EncoderTool for z and theta. Z occurs at 100 Hz rates, theta is more like 10's of KHz. Z encoder routine is quite fast, there's not much going on. Z = countvalue * conversion_factor; That's it. Z is relative, so I can set the zero point (in the main loop). I also have an X encoder, but it doesn't move during an active pass of cutting. X executes quickly too, same as Z. X is the cross dimension, typically the cutter displacement. Z is the axis coaxial with the spindle axis. Theta is the rotation angle about the spindle axis. It's the lathe chuck angle.
Some good ideas. For these tests I have to use a coarse thread, simply because it's easy to see if there's a phase error, the cutter tip is obviously not in the groove. With a fine thread, it's impossible to see. But coarse threads advance VERY quickly, so it's hard to follow by eye. So much so, that I need to have the tip of the cutter 0.005" from the rod, and have to stare watching this very quick event. A 4 TPI thread, advances 1/4" in 150 ms, at 400 RPM. Believe me, I was scared doing this initial testing. But my stopping control loop seems to work ok. (Based on Z.)
