I see pins on most components labelled with "VCC" but found in their specifications different volatages related to it, in one case 5V, another "VCC" indicates a range 1,65..3,6V with 'Absolute Maximum Ratings' of -,5..4,6V (note the negative value for "Absolute Maximum"). Thus 5V would be inappropriate.

Question: when I piece a circuitry together, are there systems apt to check my sketch (computerised sketch of course) for such faults? Which is the best way to prevent wrong voltage mishaps?

This post is a side stage of my debut project. The goal of this intermediate step is to get used on how to prepare programs for ESP32 systems or similar. This "apprenticeship" should be possible using simulators like those suggested in this clip. These are:

• Wokwi: https://wokwi.com/
  Its pricing plan for 0,- monthly is, to generate a personal 30-day license for Wokwi VS Code. So I should change my identity every month to continue testing?
  
  
• Cirkit Designer: https://www.cirkitstudio.com/
  "Cirkit AI designs circuits, writes firmware, debugs projects, and researches solutions" (end of quote). So 'Cirkit' is primarily an AI front end? That could work due to the restricted focus, nevertheless I'm reluctant regarding AI, take me for too prudent -- so what.
  
  
• Velxio: https://velxio.dev/
  Near the bottom of its 'Pricing' section some common questions are answered. One of them is "Can I self-host Velxio for free? -- Yes." Plus a link to GitHub. In contrast to the '.msi Download for Windows' with the hint "30-day free trial" I didn't find (yet) a similar restriction on GitHub.

Since it's not a 'no installation, runs in your browser'-thing a. m. clip does not mention the simulation offered by Espressif. Alas, it's a bit puzzling, because one description lists considerable restrictions, while another reference does not show similar limitations (or I've overlooked it).

I'll give a try at Espressif's QEMU and Velxio. As first experiment I take HP41Kernel.cpp of V41 (what emulates an HP-41 but the Voyager's CPU is functionally the same) and interpret with it the f/w of an HP11C (see attached ROM copy). A trace log (if possible) should be the same as with another "emulator", at least it should end quite qick with the simulated CPU clocks stopped and virtual display on. (I will run this test w/o display, I'll check only the display's on/off bit.)

Don't expect me to report success tomorrow, it will take several weeks I guess. Until then, don't hesitate to post expedient comments.

• ESP32-S3.  All tests are run entirely in Core 1 either in the loop() method or interrupts also in Core 1. 
• MPU6050 is using I2C running at 400kHz.  This is the fastest speed recommended for I2C on it.  
• LSM6DSV can be used with either I2C or SPI.  To get its max rate, SPI was used at 1MHz.  This is well below the maximum rate of SPI.
• Both sensors are on the same breadboard but are configured to be used either independently or together depending on the test.
• I wrote both software drivers to use minimalist (fastest) access to retrieve raw data and to know exactly what is in the code versus using Arduino hosted libraries.

1. In this first sub test, the ESP32-S3 was not asked to do anything with the data.    The MPU6050 had the higher rate of sampling IN the IMU at just over 8 kHz (124 ns/sample).  The LSM6DSV was not that far behind at just over 7.5 kHz (132 ns/sample).  Although higher, the ability to retrieve this data is significantly hampered in the MPU6050 by its use of I2C.  

2. In the second test, the ESP32-S3 also processed the data as if it will be run in an Inference for the robot.  I tested it at two different sizes.  The first I expect to be somewhat larger than I'll need for the self-balancing robot, and the second one is 25x larger than I expect to ever need.  With the smaller use case, the LSM6DSV still had extra available CPU time to process the Inference.  The MPU6050 lost about 1.5%.  With the larger use case, they lost 29% and 24% repectively.

Only you can judge for your use case which sensor is good enough for your project.  Although a lot faster, and a lot less noisy, it still indeterminant whether the LSM6DSV will result in noticeably better performance in the self-balancing robot project.

Inq

Program is pretty fugly coding due it being just a test app with multiple independently coded tests, but it also contain comments of the raw result for those as anal retentive as Inq.

// To run tests set test to 1.  Only do ONE AT A TIME!

#define TEST1 0	// RAW SPEED
// To get maximum rates that we can use the sensors.
// * USE_LSM6DSV (or) USE_MPU6050 set to 1.  You can
//   do both, but they slow things down for both.
// * Use WITH_INFERENCE 1 to have some processing
// 	 of the data (simulates ANN Inference) for 
//   self-balancing robot, etc.

#define TEST2 0 // NOISE
// * USE_LSM6DSV (or) USE_MPU6050 set to 1.  
//   Don't do both, data is mis-match.
// * Use WITH_INFERENCE 0 to get highest rate.
// * Set VAL to component to evaluate 
//	 (aX, aY, aZ, gX, gY, gZ)

#define TEST3 1 // DRIFT
// As the chips warm up they will supposedly drift
// * USE_LSM6DSV (and) USE_MPU6050 set to 1.  
// * Use WITH_INFERENCE 0 to get highest rate.

#define USE_LSM6DSV	1
#define USE_MPU6050 1

#define WITH_INFERENCE 0

#define INFERENCE_SIZE 50
#define VAL aZ

#include <Arduino.h>
#include <InqLSM6DSV.h>
#include <InqMPU6050.h>
#include <InqMatrix.h>

/* RESULTS

TEST1 RAW SPEED ---------------------------------------------------------------

(A) Using LSM6DSV w/o Inference
(A) Sensor rate 7536.4 Hz, Use rate 7536.0
(A) g(14, -96, -68), a(-103, 1538, 16592)
(A) Sensor rate 7535.8 Hz, Use rate 7536.0
(A) g(87, -71, -19), a(-96, 1553, 16515)
(A) Sensor rate 7535.8 Hz, Use rate 7535.8
(A) g(63, -150, -53), a(-74, 1663, 16596)

(B) Using MPU-6050 w/o Inference
(B) Sensor rate 8044.3 Hz, Use rate 2098.0
(B) g(439, 781, -108), a(-208, 1252, 16084)
(B) Sensor rate 8044.4 Hz, Use rate 2098.5
(B) g(440, 756, -96), a(-76, 1032, 15992)
(B) Sensor rate 8044.1 Hz, Use rate 2098.4
(B) g(413, 771, -103), a(-140, 1132, 16160)

(A) Using LSM6DSV w/ INFERENCE_SIZE = 10
(A) Sensor rate 7536.2 Hz, Use rate 7535.8
(A) g(29, -7, -32), a(-129, 1592, 16530)
(A) Sensor rate 7535.8 Hz, Use rate 7536.0
(A) g(21, -37, -87), a(-87, 1621, 16473)
(A) Sensor rate 7535.6 Hz, Use rate 7535.8
(A) g(14, -44, -19), a(-140, 1546, 16533)

(B) Using MPU-6050 w/ INFERENCE_SIZE = 10
(B) Sensor rate 8042.8 Hz, Use rate 2062.3
(B) g(404, 758, -99), a(-152, 1076, 15976)
(B) Sensor rate 8042.6 Hz, Use rate 2062.5
(B) g(425, 784, -88), a(-180, 1124, 16096)
(B) Sensor rate 8042.3 Hz, Use rate 2062.6
(B) g(407, 757, -91), a(-200, 1144, 15984)

(A) Using LSM6DSV w/ INFERENCE_SIZE = 50
(A) Sensor rate 7538.1 Hz, Use rate 5333.3
(A) g(60, -70, -35), a(-134, 1578, 16487)
(A) Sensor rate 7535.8 Hz, Use rate 5333.3
(A) g(34, -38, -65), a(-89, 1687, 16466)
(A) Sensor rate 7535.7 Hz, Use rate 5333.3
(A) g(30, -86, -47), a(-129, 1621, 16497)

(B) Using MPU-6050 w/ INFERENCE_SIZE = 50
(B) Sensor rate 8045.9 Hz, Use rate 1576.7
(B) g(422, 778, -106), a(-236, 1088, 16072)
(B) Sensor rate 8044.8 Hz, Use rate 1576.9
(B) g(403, 773, -105), a(-248, 1260, 16060)
(B) Sensor rate 8044.8 Hz, Use rate 1576.0
(B) g(423, 794, -101), a(-136, 1180, 16048)

TEST2 NOISE -------------------------------------------------------------------
GYROSCOPE

Using MPU-6050 gX
(B) 8058.2 Hz
t=59  Avg=773.01  Delta=16.99  MaxDelta=1031.01 over200=604  over1000=247  Stdev=64.97
(B) 8057.8 Hz
t=59  Avg=770.93  Delta=19.07  MaxDelta=1285.93 over200=813  over1000=369  Stdev=75.76
(B) 8058.7 Hz
t=59  Avg=771.43  Delta=18.31  MaxDelta=1029.43 over200=748  over1000=313  Stdev=72.03

Using LSM6DSV gX
(A) 7535.6 Hz
t=15  Avg=58.03  Delta=18.72  MaxDelta=1978.97 over200=86  over1000=6  Stdev=27.58
(A) 7542.1 Hz
t=15  Avg=58.12  Delta=17.32  MaxDelta=95.12 over200=0  over1000=0  Stdev=21.74
(A) 7542.1 Hz
t=15  Avg=58.52  Delta=17.22  MaxDelta=88.52 over200=0  over1000=0  Stdev=21.60

Using MPU-6050 gY
(B) 8055.1 Hz
t=59  Avg=417.41  Delta=20.47  MaxDelta=675.41 over200=838  over1000=0  Stdev=49.44
(B) 8057.3 Hz
t=59  Avg=417.60  Delta=20.74  MaxDelta=675.60 over200=929  over1000=0  Stdev=50.58
(B) 8057.6 Hz
t=59  Avg=417.78  Delta=20.54  MaxDelta=932.78 over200=905  over1000=0  Stdev=49.73

Using LSM6DSV gY
(A) 7542.1 Hz
t=15  Avg=-85.65  Delta=18.29  MaxDelta=107.35 over200=0  over1000=0  Stdev=22.89
(A) 7542.1 Hz
t=15  Avg=-85.25  Delta=18.02  MaxDelta=100.25 over200=0  over1000=0  Stdev=22.60
(A) 7542.1 Hz
t=15  Avg=-85.99  Delta=18.23  MaxDelta=100.99 over200=0  over1000=0  Stdev=22.80

Using MPU-6050 gZ
(B) 8053.8 Hz
t=59  Avg=-100.01  Delta=11.24  MaxDelta=414.99 over200=1  over1000=0  Stdev=17.47
(B) 8056.8 Hz
t=59  Avg=-99.96  Delta=11.26  MaxDelta=415.04 over200=1  over1000=0  Stdev=17.59
(B) 8056.7 Hz
t=59  Avg=-99.97  Delta=11.21  MaxDelta=415.03 over200=1  over1000=0  Stdev=17.39

Using LSM6DSV gZ
(A) 7535.6 Hz
t=15  Avg=-44.47  Delta=11.30  MaxDelta=1655.47 over200=102  over1000=5  Stdev=21.94
(A) 7542.1 Hz
t=15  Avg=-44.19  Delta=10.94  MaxDelta=60.81 over200=0  over1000=0  Stdev=13.71
(A) 7542.1 Hz
t=15  Avg=-44.49  Delta=10.91  MaxDelta=62.51 over200=0  over1000=0  Stdev=13.65

ACCELEROMETER

6DoF Sensor Test LSM6DSV vs IMU6050
Using MPU-6050 aX
(B) 8056.7 Hz
t=59  Avg=-209.19  Delta=41.23  MaxDelta=304.81 over200=130  over1000=0  Stdev=52.03
(B) 8057.2 Hz
t=59  Avg=-209.22  Delta=42.18  MaxDelta=366.78 over200=202  over1000=0  Stdev=53.53
(B) 8058.6 Hz
t=59  Avg=-206.20  Delta=43.94  MaxDelta=569.80 over200=679  over1000=0  Stdev=58.00

6DoF Sensor Test LSM6DSV vs IMU6050
Using LSM6DSV aX
(A) 7535.6 Hz
t=15  Avg=-87.15  Delta=33.90  MaxDelta=199.85 over200=0  over1000=0  Stdev=42.41
(A) 7542.1 Hz
t=15  Avg=-87.18  Delta=33.84  MaxDelta=198.82 over200=0  over1000=0  Stdev=42.41
(A) 7542.1 Hz
t=15  Avg=-86.28  Delta=33.87  MaxDelta=190.72 over200=0  over1000=0  Stdev=42.39
(A) 7542.1 Hz

6DoF Sensor Test LSM6DSV vs IMU6050
Using MPU-6050 aX
(B) 8055.2 Hz
t=59  Avg=1095.15  Delta=40.80  MaxDelta=228.85 over200=10  over1000=0  Stdev=51.07
(B) 8057.3 Hz
t=59  Avg=1089.29  Delta=40.59  MaxDelta=225.29 over200=12  over1000=0  Stdev=50.87
(B) 8057.8 Hz
t=59  Avg=1093.67  Delta=41.14  MaxDelta=221.67 over200=14  over1000=0  Stdev=51.55

6DoF Sensor Test LSM6DSV vs IMU6050
Using LSM6DSV aX
(A) 7535.6 Hz
t=15  Avg=1578.79  Delta=35.65  MaxDelta=850.79 over200=218  over1000=0  Stdev=46.89
(A) 7542.1 Hz
t=15  Avg=1572.33  Delta=32.36  MaxDelta=179.33 over200=0  over1000=0  Stdev=40.59
(A) 7542.1 Hz
t=15  Avg=1572.76  Delta=33.90  MaxDelta=223.24 over200=4  over1000=0  Stdev=42.81

6DoF Sensor Test LSM6DSV vs IMU6050
Using MPU-6050 aZ
(B) 8056.0 Hz
t=59  Avg=16041.72  Delta=80.37  MaxDelta=16724.28 over200=631  over1000=186  Stdev=639.30
(B) 8058.5 Hz
t=59  Avg=16032.75  Delta=82.52  MaxDelta=16733.25 over200=1476  over1000=178  Stdev=625.25
(B) 8057.8 Hz
t=59  Avg=16035.85  Delta=79.20  MaxDelta=16730.15 over200=909  over1000=171  Stdev=612.43

6DoF Sensor Test LSM6DSV vs IMU6050
Using LSM6DSV aZ
(A) 7535.6 Hz
t=15  Avg=16491.22  Delta=36.21  MaxDelta=6378.22 over200=5  over1000=1  Stdev=49.17
(A) 7541.6 Hz
t=15  Avg=16494.97  Delta=36.40  MaxDelta=212.97 over200=2  over1000=0  Stdev=45.69
(A) 7541.6 Hz
t=15  Avg=16493.84  Delta=36.61  MaxDelta=327.16 over200=35  over1000=0  Stdev=46.19

This one is running I2C for 6050 at 1MHz
6DoF Sensor Test LSM6DSV vs IMU6050
Using MPU-6050
(B) 8044.9 Hz
t=39  Avg=16000.12  Delta=85.05  MaxDelta=16258.12 over200=943  over1000=193  Stdev=651.62
(B) 8047.5 Hz
t=39  Avg=16001.19  Delta=82.11  MaxDelta=16259.19 over200=978  over1000=176  Stdev=622.28
(B) 8047.4 Hz
t=39  Avg=16002.78  Delta=82.28  MaxDelta=16260.78 over200=1484  over1000=166  Stdev=605.35

TEST3 CREEP -------------------------------------------------------------------
This is sample output.  Run as long as you want.  Topic data shown was overnight.
It plots the chosen "VAL" once every second for both sensors.  We should seekdir
a trend as the chips warm up.
(A) Using LSM6DSV
(B) Using MPU-6050
   -46    -94
   -57   -102
   -50    -97
   -37   -107
   -71    -96
   -46    -83
   -26    -99
   -47   -105
   -46    -84
   -47    -97
   -45    -86
   -48   -102
   -60   -103
   -15   -105
   -37    -89
   -69   -104
   -57    -97
   -28   -107
   -55    -86
   -28    -94
   -39    -88
   -33    -87
*/

#if USE_LSM6DSV
	#define PIN_MISO 15
	#define PIN_CS   16
	#define PIN_MOSI 17
	#define PIN_SCLK 18
	#define PIN_INT1 3

	InqLSM6DSV imuLSM6(PIN_MISO, PIN_CS, PIN_MOSI, PIN_SCLK);
#endif

#if USE_MPU6050
	#define I2C_SDA 8
	#define I2C_SCL 9
	#define PIN_INT 10 
	
	InqMPU6050 imu6050(I2C_SDA, I2C_SCL);
#endif

// Interrupt

volatile bool aReady = false;
volatile bool bReady = false;
volatile uint32_t aCntSample = 1;
volatile uint32_t bCntSample = 1;

void IRAM_ATTR isrLSM6() { aReady=true; aCntSample++; }
void IRAM_ATTR isr6050() { bReady=true; bCntSample++; }

InqMatrix<float> m1, v1, v2;

// ============================================================
// Setup
// ============================================================

void setup()
{
    Serial.begin(115200);
    delay(1000);
    Serial.println("\n6DoF Sensor Test LSM6DSV vs IMU6050");

#if USE_LSM6DSV
	Serial.println("(A) Using LSM6DSV");
	if (!imuLSM6.begin())
	{
		Serial.println("Sensor Failure\n");
		while(true) delay(1000);
	}		
	pinMode(PIN_INT1, INPUT_PULLUP);
	attachInterrupt(digitalPinToInterrupt(PIN_INT1), 
		isrLSM6, RISING);
#endif

#if USE_MPU6050
	Serial.println("(B) Using MPU-6050");
	imu6050.begin();
	
	pinMode(PIN_INT, INPUT_PULLUP);
	attachInterrupt(digitalPinToInterrupt(PIN_INT), 
		isr6050, RISING);
#endif

	m1.size(INFERENCE_SIZE, INFERENCE_SIZE);
	m1.randomize();
	v1.size(INFERENCE_SIZE);  
	v2.size(INFERENCE_SIZE);
}

// ============================================================
// Main loop
// ============================================================
#define ONE_MEG 1000000.0f
#define MAX 120000
int16_t store;
uint32_t cntStore = 0;

Raw6050 bRawData;
uint32_t bCntUse = 0;

RawLSM6DSV aRawData;
uint32_t aCntUse = 0;

void loop()
{
	static uint32_t ts = micros();
	
	#if TEST1
	uint32_t t = micros() - ts;
	if (t > 5000000)
	{
		#if USE_LSM6DSV
		Serial.printf("(A) Sensor rate %0.1f Hz, Use rate %0.1f\n",
			aCntSample * ONE_MEG / t, aCntUse * ONE_MEG / t);
		aCntSample = 0;
		aCntUse = 0;
		Serial.printf("(A) g(%d, %d, %d), a(%d, %d, %d)\n", 
			aRawData.gX, aRawData.gY, aRawData.gZ, aRawData.aX, aRawData.aY, aRawData.aZ);
		#endif

		#if USE_MPU6050
		Serial.printf("(B) Sensor rate %0.1f Hz, Use rate %0.1f\n",
			bCntSample * ONE_MEG / t, bCntUse * ONE_MEG / t);
		bCntSample = 0;
		bCntUse = 0;
		// Reoriented to match LSM6DSV coordinate frame.
		Serial.printf("(B) g(%d, %d, %d), a(%d, %d, %d)\n", 
			bRawData.gY, bRawData.gX, bRawData.gZ, bRawData.aY, bRawData.aX, bRawData.aZ);
		#endif
		Serial.println("");

		ts = micros();
	}
	
	#endif // TEST1

	#if USE_LSM6DSV
	if (aReady)
	{
		aReady = false;
		aCntUse++;
		aRawData = imuLSM6.readLSM6DSV();
		store = aRawData.VAL;
		cntStore++;
		#if WITH_INFERENCE		
		v1(0) = aRawData.gX;	
		v1(1) = aRawData.gY;	
		v1(2) = aRawData.gZ;	
		v1(3) = aRawData.aX;	
		v1(4) = aRawData.aY;	
		v1(5) = aRawData.aZ;	
		fakeInference(m1, v1, v2);
		#endif
	}
	#endif // USE_LSM6DSV
	
	#if USE_MPU6050
	if (bReady)
	{
		bReady = false;
		bCntUse++;
		bRawData = imu6050.read6050();
		store = bRawData.VAL;
		cntStore++;
		#if WITH_INFERENCE		
		v1(0) = aRawData.gX;	
		v1(1) = aRawData.gY;	
		v1(2) = aRawData.gZ;	
		v1(3) = aRawData.aX;	
		v1(4) = aRawData.aY;	
		v1(5) = aRawData.aZ;	
		fakeInference(m1, v1, v2);
		#endif
	}
	#endif // USE_MPU6050

	#if TEST2
	
	if (cntStore == MAX)
	{
		uint32_t t = micros() - ts;
		Serial.print("");
		#if USE_LSM6DSV
		Serial.printf("(A) %0.1f Hz", aCntSample * 1000000.0f / t);
		aCntSample = 0;
		aCntUse = 0;
		#endif
		#if USE_MPU6050
		Serial.printf("(B) %0.1f Hz", bCntSample * 1000000.0f / t);
		bCntSample = 0;
		bCntUse = 0;
		#endif
		Serial.println("");
		
		float total = 0;
		for (uint32_t i=0; i<MAX; i++)
			total += store;
		float avg = total / MAX;
		float stddv = 0.0f;
		float delta = 0.0f;
		float maxdelta = 0;
		uint32_t over200 = 0;
		uint32_t over1000 = 0;
		for (uint32_t i=0; i<MAX; i++)
		{
			float pt = (float)store - avg;
			stddv += pt * pt;
			
			float d = abs(pt);
			delta += d;
			if (d > maxdelta) maxdelta = d;
			if (d > 200.0f) over200++;
			if (d > 1000.0f) over1000++;
		}
		stddv /= (float)(MAX - 1);
		stddv = sqrt(stddv);
		delta /= (float)MAX;
		Serial.printf("t=%u  Avg=%0.2f  Delta=%0.2f  MaxDelta=%0.2f over200=%u  over1000=%u  Stdev=%0.2f\n",
			t / 1000000, avg, delta, maxdelta, over200, over1000, stddv);

		ts = micros();
		cntStore = 0;
	}
	#endif // TEST2
	
	#if TEST3
	// Creep Test	
	uint32_t t = micros();
	if (t - ts > 1000000)
	{
	    Serial.printf("%6d %6d\n", aRawData.gZ, bRawData.gZ);
		ts = t;
	}
	#endif // TEST3
}

void fakeInference(InqMatrix<float>& m1, InqMatrix<float>& v1, InqMatrix<float>& v2)
{
	v2.productOf(m1, v1);
}	

I've found the ESP32 Selection Guide and the Product Selector, alas, there are criteria I don't grasp (yet): Flash, SRAM, ROM, PSRAM, ... well, I found SRAM explained in Wikipedia, but my question is -- how much of it will my project need? I surmise my software and its data must fit completely in the available SRAM. How may I estimate the size of the future s/w? What I plan to run exists already as a PC program, NutEm/PC written in ooREXX, I must migrate its core to the SoC, no idea yet how to do that and how "resource demanding" the result will be.

Next theoretical question is, do I need a general-purpose experimenter board? I don't like the trial-and-error way, I favour know-why rather know-how only. I'm used to work with virtual systems (once VM/ESA, today with virtual calculators) and hope I could push my project to a mature state using simulations only. Is that realistic?

But the major question is -- would an ESP32 be the best choice to achieve my goal?

I'm totally new to the hardware side of SBC/HMI boards etc...

I'm looking for a board/device with any MCU (a 2KHz 6502 would be fast enough for my application), a display around 4 to 5 inches (just for user interface in LVGL), and a DAC.

It is the DAC that is giving me problems.

The HMI kits I can find all use the ESP32-S3 - which does not have a DAC (the S2 does).

So I'm looking for any recommendations for a dev. kit, that does have a DAC.

OR - I would look at using a PWM output to make a DAC via a low pass filter.

Any comments/thoughts on that method, also welcome.

I'll only looking at very low frequency output, 1 to 100 Hz.

Thanks.

I'm sure this is a dumb question but I am new to Arduino.

The question is once I have a breadboard working correctly with the correct sketch in the Arduino Uno, How do I transition to a in the real world implementation?

I know how to wire up the hardware, but with the Uno once it is disconnected from the USB on the computer and powered down, does it retain the program so when power is applied it keeps running the script?

Does it keep doing this after it is powered down and up again?

Sorry I'm not clear on the process.

However,

Here's my question: I cannot get the Nano's 15x2 array of header pins to insert into the Mill-Max IC Socket with any form of "reasonable" force. I'm afraid to push or prod any harder than I am. I note male DuPont wires insert into the IC Socket receptacles with a satisfying click, but the header pins are so far a no go.

I'm obviously doing something wrong. Please advise and help me get back on track.