Thanks for that, Bruce, nice to hear from you.

Well, the good news, Russ, is that although you might think you have forgotten things they will quickly resurface once prompted. So you are ahead of the game!

Awesome, thank you! I can't believe Andreas even knows I exist but I do occasionally watch his excellent content too.

Thanks Gord, if your students understand this then my work is complete!

Awesome! Thank you!

Awesome! Thank you! And thank your teacher for pointing you in this direction!

Thank you for your feedback, Stephen Thompson, noted and appreciated!

Glad you liked this one, Robin, that ESP32 is a most powerful device indeed and it makes sense to know how to program it properly. Thanks for posting.

Glad you liked it James!

You are most welcome george kon, I'm glad you like the video. Nice to hear from you.

Welcome aboard! I'm looking at doing more ESP32 stuff, Vince, as it happens. Such a powerful chip. Keep tuned!

You are most welcome NLab ™, I'm glad you like the video. Nice to hear from you.

Glad it was helpful! I tend to use the ESP32 for most projects unless it's trivial and doesn't ever need Wi-Fi connectivity.

Thanks, will do!

Glad you liked it Annacer Med, great to hear from someone in Algeria, warmer than the UK, that's for sure.

Thank you for your feedback, David Lambert, noted and appreciated!

Thanks for that, Mike Lopez, nice to hear from you.

I'm glad it helped, and thank you for your good wishes. There will be a pause in my videos soon as I move house. After Christmas, in early 2021.

Wow, thanks!

Excellent! I am so glad this video helped you. I can never cover all aspects of a topic but enough to get you going in the right direction. Thanks for the feedback, David.

Glad it was helpful!

Welcome aboard! You only have around 233 more videos to watch, then! Oh, and the quiz to take (latest video). Good luck!

@@RalphBacon Ahahhahahah will do

Glad it was helpful!

I probably had too many coffees before this video, but inside I'm always enthusiastic! Good to hear from you, thanks for posting.

You're very welcome!

Glad you liked it!

Great to hear! From one C# developer to another it's all quite different in the embedded C++ world without the .NET safety net!

I'm very glad you think so, Dale, you're very welcome.

That's fine, Andy, repeat views are apparently a Good Thing as far as UKposts go! But it is worth understanding this correctly to avoid problems down the line.

@@RalphBacon ​ Nice one Ralph and Happy Birthday! may you have many more and keep your tutorials coming ...I love 'em!

You are most welcome Tom Watzek, I'm glad you like the video. Nice to hear from you.

Glad it was helpful!

Thanks for your post, Asger Vestbjerg, good to hear from you.

Thanks Chris!

I wasn't subscribed now i subscribed...Thank u

And thank you back, welcome to my channel!

Well said! I'm using a task and a global variable in my ESP32 Web Radio project and it works very well.

Thanks for your post, Norm Caissie, good to hear from you.

$2,500 in 1979 is worth about $11,356 today! Wow! Expensive computer. See: www.in2013dollars.com/us/inflation/1978?amount=2500 Yes, the ESP32 is a powerful beast for sure. One reason why I like it!

Thanks for the supportive feedback, good to hear from you, thanks for posting.

That's very interesting, and plausible; if you can give me a citation where this info can be found, it would be even better. I searched high and low and could not find it). But for now, I'll use your explanation!

Sounds like you have an interesting project ahead.

I'm glad you found it useful, thanks for posting.

Ha Ha! You're being cruel to the Arduino IDE now, Arjan! But, would you believe it, I'm also running *Visual Studio Code* and *Platformio* at the moment, mainly for ESP32 development but it also works for the Arduino and supports hundreds of other boards too. So maybe, that might become my IDE of choice in the future, you never know. Thanks for your enthusiasm for a 'proper' development IDE, keep tuned.

@@RalphBacon I've also found myself using vs code with platformio for the esp32. Had been a wonderful experience thus far. Thank for this explanation, cleared some things up for me.

If you write one function to control one servo you could run that function many times (once per servo) in different tasks. Just pass in the parameter which servo it is that you are wishing to control from your main sketch and Bob's your uncle.

Great tip! Sounds like it would be a good use for the loop.

Nothing special about loop0 and loop1 at all; these are arbitrary names and, as I mentioned, I would call them something very different in a real program. They are started the instant the setup() creates them. Which means that if you have several tasks to start the first one will be running long before the last one gets scheduled. Thanks for posting Tom, always good to hear from you.

Ah okay, so xTaskCreatePinnedToCore() doesn’t only define the properties of the task, it also runs it. Thanks again Ralph!

Yes, you can indeed, hmx, and that is indeed the way to do it, but I knew if I did that I would confuse my audience. I tend to use sprintf on my ESP8266 for my HomeAlone project as it's easy to use and is "proper" C! I mentioned in the previous video that users can continue to use Arduino-friendly speak or slowly migrate to the underlying language constructs; maybe I need to expand on this?

Oh, and I _never_ use String (capital S) as it can fragment the Heap space, so std::string it is, but then we have to convert that back... the list goes on!

Glad to hear that you are aware of sprintf. I go crosseyed every time I see example code and there are 5+ Serial.print() statements in a row just to output a single line of text. I am enjoying that you are encouraging people to use more standard functions. Can't wait to see what you have for us next.

To really master FreeRTOS (especially in ESP32 terms and perhaps Due too) you need to work through the book "Free-RTOS for ESP32 Arduino" by Warren Gay. If you learn 1/10th of what's in there you will be head and shoulders above everyone else. Well, except me, of course 😉

I'm glad it's opened your eyes to new possibilities, Stuart! But when you say "ditch the Arduino framework", just hold your horses! When you program for the ESP32, you still use what is effectively an Arduino-like framework (ported from Espressif's IDF development system). Whilst there will be new syntax to learn for the ESP32, you can still use just _most_ of the Arduino-speak you currently use which should speed up development. If you really want to embrace a better way of working (and cut the apron strings of Arduino) think about using PlatformIO (built on top of Visual Studio Code). It is far less hand-holding but ultimately leads to a better programming experience. I now use it all the time unless I'm doing a video! It still uses an Arduino-like framework (supports Arduino-speak C++) but gives you much greater freedom and control when developing. Just a thought!

@@RalphBacon I've been using PlatformIO since I started down this path back in November last year. I normally develop on non-embedded systems using TDD, so the opportunity to use an IDE that integrated with the Unity test framework swung it for me to use PlatformIO over the Arduino IDE. My understanding was that the ESP32 port of the Arduino framework was a wrapper layer on top of the Espressif IDF, am I correct in that? I'm wondering if that's why the String implementation you'd mentioned wasn't stable hadn't given you any problems on your ESP32.

The PlatformIO (and Arduino) implementation of the Espressif ESP32 platform are not wrappers for the IDF (which we would only use if we were developing software professionally, I guess). Espressif release these platforms (port them) regularly and although Arduino and PlatformIO might be at different versions I think they are basically the same thing. That allows the use of Arduino-speak C++ for all the millions of users out there. I haven't had any issues with string handling in the PlatformIO environment but maybe Espressif's implementation of String (capital S) doesn't turn your heap memory into Swiss cheese. That said, I tend to use std::string as a more standard way of using strings in C++.

Using shared (volatile) global variables is always tricky; using a semaphore before reading a shared variable will be much safer. BTW I would not put the two tasks on different cores; run them at the same priority on Core 1 and it will be safer for all the Espressif stuff (BT/WiFI etc) running on Core 0.

I currently use Visual Studio Code (free) with the PlatformIO add-in. After an initial learning curve (plenty of helpful videos out there, but not by me!) it was bliss (as I have used Visual Studio for decades in my day job!)

Yes, putting small delay in the loop is one way to prevent the panic message, but what I do is delete the unwanted task as a first step, then the OS doesn't expect it to run. I demo this somewhere in my code, search my GitHubs for all things ESP32 and you will doubtless find it.

@@RalphBacon Hi Ralph, in my particular app I needed core 0 to continuously monitor time sensitive sensors while core 1 handled other asynchronous stuff. There is no issue with using either core in an infinite loop as long as the watchdog is refreshed periodically or disabled. The vTaskDelay() refreshes the watchdog kinda like time.sleep() does in Python but there may be more elegant ways to do this.

​@@johnhoeppner1569 Hey john, i have the same error as you, can you please help me fix it?

Thanks Chris for your kind words. Now, if you're not using Wi-Fi or BT there is still the OS running on Core 0 but I would use it, with caution. If you upset it you will soon find out with a PANIC or similar on Core 0. Don't forget to yield tasks when there is no more work to do and to keep the priority of _your_ tasks to the default of 1 so that others in Core 0 continue to run.

Thank you Emmanuel, glad you found it interesting.

RTOS is pretty well hidden from users of the ESP32; but now you have discovered a whole new world of possibilities! Keep away from Core 0, that is for WiFi, BT and RTOS. Use tasks on Core 1.

You're welcome!

I'll have a look to see how the prices compare to Chinese outlets, thanks for letting me know.

I'm glad you found this useful. Regarding your question, I'm not totally clear what you mean by "is the ram on the board you have used". The ESP32 has 4Mb of SRAM built into the chip, shared by both processors and is used just like any other memory would be. You know this. so what was your question, exactly?

It's pretty much a fallacy, IMHO, to think that you will save power by reducing the clock rate. If your microController is mostly asleep then that is where your power savings come from. Then, upon waking, you want to get things done pretty much as quickly as possible so you can get back to sleep as quickly as possible. Whilst slightly less power is consumed whilst on a lower clock frequency it does not make up for the fact that you will be awake for longer. That's my take on it, anyway. Of course, if you are dependent on a reliable clock (eg serial transmissions) then a slower internal one _may_ be better regulated but then you should really use a crystal anyway!

I use 'static' variables mainly to reduce the scope; that is, ensure they are not global. Within a function they are removed from the function by the compiler (so they are not re-initialised on each loop) but are not visible to other functions. Even so-called global variables (within a sketch) would benefit from being static to prevent the compiler exporting the name and potentially clashing with a name in another library (happened to me, only once or twice). I'd be very wary of declaring variables as static within a class as they are, as you say, shared between instances of the class. Might be what you want but probably not! I don't expect they are thread-safe on an ESP32 either, but I'm just guessing. Yes, we could protect the variable with semaphores, but that's beyond most beginner coding ability (although I did do a video on that, which everyone seemed to understand) 😜 Thanks for the feedback, Tim, some good points you raise there 👍

Espressif, the designers of the ESP32, have taken note of the popularity of the Arduino IDE, Mariano, and you can continue programming right there if you wish. Just install the ESP32 boards from the Tools, Boards Manager, ESP32 once you have added in the following entry into your Tools, Preferences, Additional Boards URL Manager: dl.espressif.com/dl/package_esp32_index.json That said, I would take the plunge and either use the new Arduino PRO IDE that is still in alpha (based on Eclipse) or use the open source and well-respected PlatformIO with Visual Studio Code (which I am currently using). Anything new will require a degree of familiarisation (aka a steep initial learning curve) but the PlatformIO community is mature with a wealth of documentation and videos. I decided to build my ESP32 Web Radio project using Platformio & VS Code (so I became familiar with it) and whilst at times it was quite frustrating, it eventually became a joy to use. No turning back for me now although I will keep trying the Arduino PRO IDE (it didn't compile my ESP32 project though!)

@@RalphBacon Great, thanks a lot. I'll study PlatformIO. So far Arduino has shown to be sufficient, but sometimes I fill it's not enough, specielly when debuging. Have a nice week-end : )

The _vparameters_ parameter type is just a void pointer (to a variable), so I guess you could point it to a struct or even a class instance (object)! I have some faint bells ringing but no definitive answer, this time. Strange about Serial.print but maybe a native C++ call might work better. Or output a char array rather than a String (with capital S).

@@RalphBacon Thanks Ralph. I've been able to pass both arrays and structs with no issues. Interesting was that the number of arrays or structs put on the queue works just like a normal variable in the xQueueCreate statement, as the sizeof () is just set to the array or struct variable. If you set to 1 then task0 just waits until it can put the next whole set of array data to the queue.

I haven't even covered task priority yet (except in passing) but you are correct that the serial port most certainly does get corrupted (well, interleaved) with data from more than one task if the data is written in different statements. Perhaps the Serial library uses secret mutexes to ensure atomic operation?

I'm glad you found the video interesting, Leon. However... However, although I might have used Core 0 and Core 1 to make a point about moving values between tasks, you really should not use Core 0 at all; it's for the RTOS and Wi-Fi and BT... all the stuff Espressif have put in there. Core 1 is for us developers. So, the best approach is not to use Core 0, just to create a new task, at the same priority as all other tasks (=1) pinned to Core 1. That's what I do with my ESP32 Web Radio: a separate task to handle the transfer of data from an audio buffer to an audio module. Before I did this it was very jittery due to other functions in Core 1 blocking (mostly waiting for) some Wi-Fi procedure to return. Now it runs like a dream. Tasks get a time-slice of about 1mS unless they "yield" their time slot. If the task has run out of work to do, or is itself blocked, you yield the remainder of its 1mS time-slice to other tasks of the same priority (which, counter-intuitively then only can use the remaining time left in that 1mS slice) but it all works amazingly well. I do this with the above-mentioned Web Radio task; if it runs out of data I just "yield" - no point in hogging a time-slice to do nothing in! You've listed several functions that you feel need a dedicated time-slot; set up new tasks for each, but do this slowly. Keep everything in the loop initially, which, of course, must be non-blocking in any way (no delay(x) calls) and move each function to a new task, one by one, ensuring the whole thing functions. Ensure you have enough debugging (monitoring) in each task but remove that (or switch it off) as soon as you feel it's running, as Serial prints are slow. The other thing I do, is to call each of the functions from the main loop() every few milliseconds, rather than doing all tasks all the time. So, for example, I update the screen every X milliseconds (given that it's mostly static). This then gives more time to other functions in the main loop( ). You may find you need fewer tasks than you think! Anyway, this is not the work of a few hours, it will take some design and experimentation - good luck and go slow!

Short answer: yes, Paul. Longer answer: Yes. If you use two independent cores then each core can support X tasks before you see a noticeable slow-down. But even if you do not use WiFi or BT you might have to take further steps to kill (suspend?) the tasks that _are_ running on Core 0 as otherwise you may get a Core Panic and the ESP32 will reboot. That said, if you code well, that is don't hog all the CPU cycles in a tight loop, for example, it will all work anyway (as my demo from the previous video showed). Good luck!

@@RalphBacon Thanks Ralph. Just a supplementary (and probably unnecessary) question, your excellent demo showed tasks sharing data via queues but on one core only. Can I assume that this technique will work between tasks running on different cores? All the best.

The use of the Arduino "String" with a capital S is known to cause heap fragmentation (and eventually a crash). However, heap management is allegedly better on the ESPxxxx processors and your heap space doesn't turn into Swiss cheese. That said, I've used std::string in my ESP8266 work and that runs 24x7 for months on end with no issues. Regarding a "catch" for heap fragmentation problems, I'm not sure you _can_ correct it - I mean what is your code going to do if your request for heap space fails?

Arduino boards (perhaps, as you say, Jedan, in Nano format) are useful in simple projects but even Arduino.cc have just released a whole new set of Nanos to get the interest back. But when you look at this chip, which is cheaper than the Nano (official version) there is no comparison in capabilities, it is true.

In a word (or two) there is _no relationship_ between a semaphore and what you are then doing. The fact that we are updating a variable is just coincidence. The semaphore prevents _concurrent_ updating by two tasks that are otherwise unaware that another task is in the process of updating the variable. By using the semaphore, we are just saying to any other task, "Sorry, you will have to wait a while to get that semaphore and continue whatever it is you were doing." That's why we need to be quick about handing back semaphore when we have carried out the critical process.

You're welcome!

Yes, the main flow of the code (the loop) will be interrupted by, well, an interrupt! In an ESP32 environment, each task gets a 1mS slice of time to do its thing. Very fair!

I showed you how to change the CPU frequency, Henrik, (assuming you watched to the end) so a quick 5-line sketch should prove it one way or the other. As for deadlocks, I sort of mentioned that if you cannot get a semaphore in the allotted time it will return a response indicating this. It's something I must expand upon as they are, as you say, somewhat problematic.

I have tried that now, but I do not have the functions to get/set CPU frequency. Searching the library code I found this: uint8_t getCpuFreqMHz(){ return CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ; } In the ESP class and it return 240 The timeout on semaphores are not always available and it is mostly meaningless in some content anyway.

Yes, 240Mhz is the default speed (and that used by the Arduino IDE). But if you have installed the recent boards from Espressif then you should have access to those function I show, to set and get the speed of the chip.

I have not really worried about updates, but hoped that the Arduino IDE handled that, but that may not be true. I use this link for ESP32 in the board manager: dl.espressif.com/dl/package_esp32_index.json I do not know how to force a update. Maybe remove the link and add it again after a restart.

Now, Henrik, I did a detailed, step-by-step demo on how to add _or update_ the board definitions so you obviously skipped ahead! Go to Tools, Boards, Boards Manager then type in ESP32 in the search box and you will see ESP32 version 1.02 (or even later). Upgrade to the latest if you haven't already. That should give you all the (new) commands you seem to be missing. Let me know how it goes!

The ESP32 community is vibrant, Joey, as is the documentation and support (including the forums) from Espressif themselves, IMHO. You can use the Arduino libraries although I've only used a few so far. After all, if you're writing commands to the I2C bus then it makes no difference what hardware platform you're running on. For the sake of a few dollars it's well worthwhile just getting one and playing with it (also IMHO).

@@RalphBacon Thanks Ralph

You are most welcome Elie Wardini, I'm glad you like the video. Nice to hear from you.

Certainly having two tasks update the same variable, Stephen, is just asking for trouble - unless the developer has ensured the entire read/update operation is atomic, which you most certainly can do. Volatile alone may not do this (it's usually used to ensure register copies of memory values are not used). The question is why you might want the headache of doing this! Certainly not for beginners (which you show you are not, so you probably appreciate the coding complexity this would entail). You could use semaphores or queues, of course, but you always risk a deadlock. When using tasks I'd try and ensure the entire task was doing something independently (single responsibility principle) to avoid huge amounts of testing and debugging.

@@RalphBacon I may have gotten a little carried away! You're right, it's definitely better to keep tasks independent when possible. After looking around, It appears that std::atomic is available, if we need it. I haven't even gotten one of these chips yet, so maybe it's too soon for me to be trying to push the things limits ;)

Indeed, start slow and build on what you learn. Great chip the ESP32 and the RTOS is very good too, pity it's not a FULL implementation (ie certain functions are just not available).

This: eclipse.baeyens.it/ but don't forget Arduino is developing a new IDE based on the Eclipse Thea framework, probably for later this year, Trevor. But you can use that Sloeber version in the meantime to get familiar with the way it works (expect to devote several dozen hours to getting your head around it).

@@RalphBacon Great video as always, thanks! How do you find the Arduino Pro IDE compares to it?

@@RalphBacon That's the first I've heard of an alternative IDE from Arduino! That's really exiting! Another option I'd just put out there is visual studio code (free, lightweight, multi-OS), which has an unofficial but decently supported Arduino plugin. It relies on Arduino IDE for part of the toolchain though, so it has the same crippling problems. (Weirdness involving header files and multiple source files in a project.) It CAN parse the source though, and provide code completion and suggestions, etc. Overall it's a very nice editor, but it can't overcome the issues inherent in the underlying build process. I've never had a good time with Eclipse, though I know it has come a long way, and literally anything is better than the plain Arduino IDE! So both this Sloeber thing and that new Arduino IDE are hugely good news, to me! Thanks for sharing!

One other advantage of having the ESP32 in the same form factor as the Arduino UNO is ability to simply transfer the shields from one to the other. Just a couple of days ago I was doing a presentation to a javascript group about Espruino and part of it was a comparison of how code would look like if written for the Arduino. It really helped hammer home the fact that the hardware being controlled is the same, but the language being used to program is different. Just wanted to mention that one quickly :) The queueing discussion was really interesting and it's something I'd like to experiment on in the future.

Normally it can work, but it depends on the shield. 3.3v is still seen as a logic high to a 5v input. And if you feed the shield only 3.3v it will return only 3.3v logic levels. You have to look at them case by case.

So what we need, Tristan, is an ESP32-compatible shield format! Someone has probably created one already!

Glad you like the queuing discussion; it can be a bit long-winded but once understood it's pretty straightforward.

I think the most successful shields were the ones by Wemos (which you've covered quite thoroughly in the past) but that was for the ESP8266; and there were some that tried to ride on the form factor, but I haven't seen anything that really took off. One would think that it would be easy to design a pcb which would take the usual devkit-c boards and adapt it to the UNO form factor (much like the nano adapter boards you've also shown in the past) but again, I haven't seen anyone build that (yet).

Yes, I put a number of things in there that I new would be computationally hard work for all the processors (although the ESP32, being 32-bit with a floating point unit, found it no trouble at all).

Glad you like the format of the videos; and the content too! That "for{;;}" construct is just what has been always used. I don't think anyone would ever use a GOTO in C... would they? But the compiler probably compiles it to that anyway. Yes, C can be OK but C++ (object oriented) is better, of course.

Indeed you have to create the semaphore, as I show in my setup() routine. Did you miss it or I have misunderstood your question, Jose?

@@RalphBacon Yes, I missed it :-). Sorry.

Indeed. I guess it depends on how atomic each operation is, but semaphores is what I would go with anyway if I decide to use a task to read the circular buffer.

Great point! Ok for this demo but in general you are spot on.

Often true, John, but it's lucky for us the AVR 8-bit chips do have hardware multiplication. According to the datasheet, it allows 8- and 16-bit implementations, signed and unsigned routines, and fractional signed and unsigned multiply. Here's some bedtime reading: ww1.microchip.com/downloads/en/AppNotes/Atmel-1631-Using-the-AVR-Hardware-Multiplier_ApplicationNote_AVR201.pdf

You sure you want to use two tasks for this? You could certainly use a separate, self-contained task to get input from the keyboard and display that on an LCD, but how about using the standard loop() to move the stepper motor? Why? I can hear you asking. Well, if the keyboard task updates a volatile, global variable then the main loop just reads that (you might get away with no semaphores if you ensure the read is atomic, that is, it reads the entire two-byte integer) and drives the motor the required amount. If you can use a single byte for the value then it will work without any semaphores or worrying about atomicity. And the stepper motor is only moved if that global variable changes value. Incidentally, the processor is so quick there will be no "delay" in the stepper motor just because you have to read a variable, whichever way you design your code.

@@RalphBacon Thank you so much for your time in replying. I know you didn't have to but that is what makes you a great person. I appreciate the input and I would love to avoid having to do multiple tasks. I just didn't want having to take input from a keypad, update a display and run a stepper motor at the same time to stop the smooth flow of the stepper motor. Based on what you have said, maybe I should try and get it working the basic way first and then look at improving my code if it doesn't work rather than giving myself hurdles I haven't even encountered yet. Thanks again, you rock!

Because we have our own task(s) running we don't need the "loop" any more so we can delete it in this manner; keeps things tidy and reduces resources.

Others have asked the same, Andrew, and Espressif indicate that 80Mhz should be considered a safe, minimum frequency to use. But, yes, you can adjust the frequency on the fly, dynamically as my demo shows. Have a go!

Yes, it can cause issues with one message mixed up with another!

@@RalphBacon interesting, ill remember this when i come to making something. Thank you!

The best way (and now advocated by Espressif, the makers of the ESP32) is to use LittleFS instead of SPIFFS. I did an entire video on this, and used it in my ESP32 Web Radio project. ukposts.info/have/v-deo/bKJnjZCjg5x8x6s.html

ESP32 does indeed have Bluetooth (the more recent chips support Low Energy BT, BLE). So the ESP32 can act as server or client for BLE.

I would be using the Eclipse Sloeber IDE, now deprecated, but remember that the new Arduino IDE is based on Eclipse too. See eclipse.baeyens.it/

Yes, the queue can take any number of variables (structs, objects etc).

Firstly, don't share strings they take far too much space up. Use a value that means the same as a string. Eg 1=error, 2=too hot, 3= too cold... You get the idea. Push the value onto a queue as I described in this and other esp32 videos and the other task will detect the presence and continue.

The two cores should be treated as two independent chips; that said, steer clear of Core 0 as it's used by the WiFi and BT tasks. Tasks within the _same_ core probably don't need the _volatile_ keyword if you're passing variables back and forth, but you can try it out in a simple loop to see if it changes correctly. Adding in that keyword won't cause issues, though.

@@RalphBacon thanks Ralph. I'll give it a bash. Chances are that I also missed a semaphore somewhere.

So after getting depressed about not being able to run my MPU6050 as a separate task, went back to running it as a normal function in the main loop. Worked fine. But as I'm a very bad loser, tried again, but this time was very meticulous about the semaphore give and take, and declared all the necessary variables as volatile. It now appears to run perfectly. I'm updating the i2c device from within the task. At first this seemed to have issues. Then created a semaphore to sort of isolate each i2c device. No idea if that's how you're supposed to do it, but it worked :) I'm using xCreateSemaphoreMutex() for all cases. Again, no idea if that's the correct way. Anyway, just thought I'd let you know seeing as your video was my initial inspiration for trying tasks in the first place. More vids on the ESP32 and various RTOS magic certainly wouldn't be a bad thing. Good day to you Sir!

Experience never comes cheap, does it? But I'm delighted that my video at least made you try this (and then refine it). Your knowledge has now increased. So I'm more than happy!

Ralph, experience is a bit lacking on my side, but with guys like your good self sharing your vast experience with us incompetent fools makes learning these thing so much fun.

I suspect that the Wi-Fi, Bluetooth and other protocols/services are too delayed with a slow frequency. The question I'm asking myself is why you would want to reduce the frequency of an ESP32 _at all_ let along to below 80MHz? Let me know!

I2C (and, indeed, any other hardware device) can be used in any task. You just have to be careful not to conflict their use from multiple tasks. However, back to your question. If you have initialised the I2C device, either in the "setup" of your sketch, or the task itself, you should be able to determine it is present (perhaps using the "standard" ESP32 GPIO pins 21/22 but you can actually assign most GPIO pins as you see fit). Look at the ubiquitous I2C "scanner" sketch to ensure you have discovered the device, it's only about 6 lines long! Then, in your task's infinite loop (tasks must never end, except by deleting them) just use the I2C functionality as you need. It all works just as you would expect. Tip: Keep all your task on Core 1, leaving Core 0 for the ESP32's system processes (such as Wi-Fi, BT and so on). You can expose the data the task reads on the I2C bus by updating a shared variable (if you want to consume the data in another task, you will probably need to use semaphores so each task doesn't fight over - and corrupt - the data values).

Quite so. If the count is not atomic then the use of a semaphore is _essential_ but we can't be sure at which point the task handler switches contexts. But the semaphore ensures consistency.

If you are (still) using delays you need to learn how not to do that. Blocking code is wasteful in microcontroller cycles. At the very least you could YIELD that part of the timeslice it has been given, but better still is suspending the task for a particular period (either relative or absolute). Or just suspend the task until it is un-suspended (resumed) by another bit of code. Options, options! OK, enough wrist slapping! If you delay one task you will not affect the operation of other tasks (they all get an equal share of the time, usually 1mS each). (But if you do YIELD a task, the next task gets the remainder of its timeslice). BTW I've covered how not to use delay statements in more than video, good hunting (a searchable and linked pdf of all my videos in each video description).

@@RalphBacon I really appreciate your help, since I learned to use millis on class objects, I no longer use delay. I hope to show you the progress of my project. Thank you!!!

Yes, when you run out of memory (each task requires a stack in memory). It's probably documented somewhere but it must also depend on what your task is doing, how many variables it uses, wifi, bluetooth etc.

You cannot directly. Each processor is independent. But you could pass a value between tasks (running on different processors) that then generates an interrupt on that processor, I suppose.

No, Alexander, volatile variables are not thread-safe. You would have to use semaphores or use another signalling system to ensure you did not stomp all over a variable as it was being updated by another thread. Remember that *volatile variables* are simply those flagged to the compiler that they are unsafe to be referenced by a register where the compiler might have put a _copy_ of the variable's value; it will _always_ be retrieved from its memory location. But that doesn't help across threads at all!

@@RalphBacon Hm actually after some research and reading, looks like in some case i can use that. Depending on controller "bits" so in arduino it is safe to use byte size variables, and it case of ESP i could safely use up to 32bits variable. But if some structure to read is more than 32bits in this case could be problems

Well, OK, a single byte is OK, because the operation is _atomic_ - that is, it completes in its entirety or not at all. But updating an integer (2-bytes) can go very wrong, as one task updates the low-byte then before it has a chance to update the high-byte the other task stomps all over the low-byte value (or reads a now corrupt value). Personally, I think it would be foolhardy to _hope_ it will work when semaphores are very easy to use and are designed to avoid this exact situation of clashes. Just sayin'! 😜

You need to pass it as a (void *) &reference (pointer) and then de-reference it in the task back to the correct variable type. I'll post some very simple code tomorrow for you; I do this in my project. What are you passing to the task?

@@RalphBacon can i send you my code so to show how i can modify please

@@RalphBacon thanks Ralph much appreciated im passing a float variable that is being used elsewhere and changing i need to track its value it is declared in a structure in .h file and used by .c files i think 2 i passed a constant float variable and that worked but the varying one is not giving me the right values

This is how I do it: 1. When you create the (pinned) task, I pass the parameter like this: (void *)&myVariable, /* Task input parameter */ 2. In the task I dereference it (to get to the actual value) likes this: int myVariable = *((int *)parameter); You need to do this action whenever you want to get to the new (updated) values. I was wondering whether there was another way I could do this but as I am using a struct in an array it's the best way for me. One word of warning: floats are not a good variable type to pass around as they get rounding errors very easily. Better to use an integer (2 bytes) or a long integer (4 bytes) and then divide down to the float when you need to _display_ it. It's what I do. Example: float value of 10.45 received from some sensor. Multiply by 100 to get 1045 as the _integer_ value that you can then use without worries of rounding errors. When you need to display the value just do (float) myInteger / 100.00

@@RalphBacon Hi Ralph thanks for your reply this is my code in the task its running outside void loop() void task1(void *parameters){ //contl.LutOut=34.0f; //volatile control_output_t contl; digitalWrite(2,HIGH); delay(5000); digitalWrite(2,LOW); delay(5000); for(;;){ //volatile control_output_t contl; if(contl.LutOut>33.0f) {digitalWrite(2,HIGH); } else if (contl.LutOut

Yes, that PSRAM caused them no end of problems, from I hear (and read)! You raise an important note there, Gavin, that these modules are NOT 5v tolerant (although some have experimented) but I would always use a level shifter). Thanks for posting, good to hear from you.