By the end of working through this post, you will be able to write simple MicroPython programs. In addition, you will be able to control the ESP32’s GPIOs with the counterparts of It’s a lot of knowledge in a small space that I’m trying to impart here. In programming books, this would fill dozens of pages. So try things out and vary the examples, although many things may be boring at first. But only by practicing can you learn the language.<\/p>\r\n Helpful, but not absolutely necessary, is previous experience with the ESP32. Here<\/a> you can find more information on the ESP32.<\/p>\r\n\n Python is an object-oriented high-level language that is comparatively easy to learn. Python code is easy to read and very compact. The language is quite young – it was developed in the early 90s by Guido van Rossum. He is apparently a Monty Python fan because that’s where the name comes from. Among hobby electronics engineers, Python has spread mainly through its use on the Raspberry Pi.<\/p>\r\n But Python also has disadvantages: the programs are interpreted and not compiled. This is very noticeable in the speed. Python is much slower than C++. In addition, it is more difficult to find bugs. Syntax errors are detected only when the interpreter encounters the corresponding line. <\/p>\r\n You could say that in terms of Python, MicroPython is what the “Arduino language” is for C++, namely an adaptation for microcontrollers. Since the programs you create always require the MicroPython interpreter, this language is only suitable for microcontrollers with correspondingly large memory and sufficient computing power. MicroPython is available for the ESP32 and the ESP8266 among others.<\/p>\r\n On https:\/\/docs.micropython.org\/en\/latest\/index.html<\/a> you will find the excellently structured documentation for MicroPython.<\/p>\r\n\n You have to install Python first, because MicroPython is based on it.<\/p>\r\n If you are using Windows, you can download uPyCraft here<\/a>. There is no installation file, but you get the executable program directly as an “.exe” file. Copy it to the folder you want to work from.<\/p>\r\n When you start uPyCraft for the first time, you will probably be prompted to install SourceCodePro. After that, you will find a file called SourceCodePro.ttf on your computer. This contains the required character sets. To prevent you from being asked for it again every time you start the program, right-click on the file and select “Install for all users” (or similar – my Windows is in German).<\/p>\r\n You will also be asked if you want to install a newer version of uPyCraft. Click OK. Now you will find another file called uPyCraft_Vx.y.exe. You can now delete the original uPyCraft.exe file.<\/p>\r\n In order for MicroPython to run on the ESP32, you now have to download the firmware for the ESP32. To do this, go to https:\/\/micropython.org\/download\/esp32\/<\/a> and choose the latest, stable “GENERIC” version:<\/p>\r\n\n It is best to store the firmware file in your uPyCraft folder.<\/p>\r\n\n The user interface of uPyCraft consists of five sections:<\/p>\r\n\n Explanations will follow – I just want to make sure at this point that you know what I’m talking about when I refer to these sections.<\/p>\r\n\n Connect the ESP32 to your computer. Go to the menu bar \u2192 Tools \u2192 Serial, select the port to which your ESP32 is connected. Click on it. If the port does not appear, you may be missing a driver for the USB-to-UART adapter on the ESP32. In this case you can find the driver here<\/a>. <\/p>\r\n\n Now you have to burn the firmware on your ESP32. To do this, go to Tools \u2192 BurnFirmware. Select the firmware file you downloaded earlier. The correct settings look like this (your port must of course be adjusted):<\/p>\r\n\n If the burning process does not work, you may have to press the boot button first. This depends on your board.<\/p>\r\n If everything went well, the prompt “>>>” appears. You may need to reset the ESP32 or disconnect it from power briefly. When you plug it back in, you have to select the serial port again. uPyCraft is not particularly smart in this regard.<\/p>\r\n With that, you have made it and can finally get started.<\/p>\r\n\n Python allows you to enter and test code directly in the shell (input\/output window). This is called REPL for “Read-Evaluate-Print Loop”. REPL is a great thing that wouldn’t be possible with a compiler-based language in this form.<\/p>\r\n Try it out by typing You’ve already learned a lot about Python:<\/p>\r\n If you want to prevent the line break, enter Conveniently, you can use the “up\/down” arrow keys to scroll to your previous entries.<\/p>\r\n\n Typing code directly into the shell is nice for trying things out, but usually you will write your programs as files. We come to that now. In addition, you certainly want to learn how to control the GPIOs with MicroPython.<\/p>\r\n Connect an LED with resistor (remember the 3.3 volts) to a GPIO of the ESP32. I chose GPIO18. Then go to File \u2192 New in the menu bar. Alternatively, click on the top icon in the toolbar. The title “untitled” and the line numbering appear in the program editor. Enter the following program “blink.py”:<\/p>\r\n\n Save the program via the menu bar (File \u2192 Save) or via the floppy disk icon. In the pop-up window you enter a file name (Input File). Then you will be asked once where the workspace of uPyCraft should be created. In the selected directory (preferably your uPyCraft folder) uPyCraft creates the directory “workSpace” and the subdirectory “user_lib”. Your Python programs are stored in the workspace.<\/p>\r\n\n Now go to Tools \u2192 DownloadAndRun or press F5 or you click on the triangle in the toolbar. The program is then uploaded to the ESP32 and executed. The LED should now flash every second.<\/p>\r\n\n Now click on Files \u2192 Reflush Directory. This will update the file directory. Then click on the triangles next to “device” and next to “workSpace”. As you will see, the file blink.py is now located both in the workspace and on the ESP32 (= device). Both files can be edited independently. Before you can open the version on the ESP32, however, you have to exit the running program with “Stop” (via toolbar or menu bar).<\/p>\r\n You can tell which version you have opened by the icon next to the file name in the program editor. I recommend to work with the version from the workspace.<\/p>\r\n\n If you create more programs and upload them to the ESP32 (download in the uPyCraft language), they will additionally<\/em> be stored on the ESP32. If you want to delete a file on the ESP32, right-click on the file in the device directory and choose “delete”.<\/p>\r\n\n When you leave uPyCraft, the execution of blink.py also stops. To get blink.py running again, you have to restart uPyCraft, choose the serial port, call blink.py and start DownloadAndRun. You also cannot start blink.py automatically by resetting the ESP32 or briefly disconnecting it from the power supply. This makes sense, since you can have several programs on the ESP32.<\/p>\r\n For a Python program to start automatically on the ESP32, it must be named “main.py”. Unfortunately, there is a problem with this. Because when main.py is running, you cannot connect via the serial port. And consequently you cannot stop main.py. I couldn’t find any other option with uPyCraft than to re-burn the firmware. Therefore, wait until you have finished your project before renaming it to main.py. Alternatively, you can use Thonny (see appendix). With this program, you can stop the running main.py with control \/ c. <\/p>\r\n\n Let’s go back to the code. With The statement<\/p>\r\n corresponds to the Arduino code:<\/p>\r\n However, with the difference that “led” in MicroPython is an object of the class Pin. Accordingly, the pin is switched to HIGH or LOW state using a method of the pin class:<\/p>\r\n Alternatively, you can also use:<\/p>\r\n You can pass more arguments to If you want to set a pin to input and need a pull-up or pull-down resistor (e.g. to read a key), it looks like this:<\/p>\r\n Here you also learned that you mark comments with a “#” instead of “\/\/”.<\/p>\r\n The condition for the while loop is not enclosed in parentheses, nor are the statements within the loop. The indentation alone indicates what belongs to the loop. With Arduino \/ C++ the indentation is only for readability, but with MicroPython it has a real meaning.<\/p>\r\n The last point I want to make is that as an alternative to The arithmetic operators As logical operators The bit and shift operators You find an overview of mathematical functions such as sine, root, etc. here<\/a>.<\/p>\r\n\n As in C++, binary, octal, and hexadecimal numbers are represented as In addition, MicroPython can also handle complex numbers.<\/p>\r\n\n MicroPython offers a wide range of different data collections. These include lists, arrays, bytearrays, tuples, sets, dictionaries, and others. They differ, among other things, in:<\/p>\r\n Lists are very flexible and are used very often. They are framed by square brackets and their elements are separated by commas. Here is an example:<\/p>\r\n Lists are mutable, they can be expanded and sorted. You can access individual elements. Lists can be concatenated (appended to each other). Lists are also allowed as elements of lists. The following inputs and outputs are – I think – self-explanatory.<\/p>\r\n\n I have forgotten an important function for lists: Arrays are basically lists that allow only one data type. Otherwise, you can apply the same methods to them. Arrays work more efficiently than lists, which can become relevant for large amounts of data. Here’s an example of how to create an array:<\/p>\r\n The “i” stands for Integer. Here, exceptionally, a data type must be specified in MicroPython. For an array of floats, you must specify “f”. It’s best to play around with lists and arrays a bit to get familiar with them.<\/p>\r\n\n The following lines are not surprising:<\/p>\r\n\n However, this could be the case here:<\/p>\r\n\n In (Micro)Python, everything is an object. And variables are names that reference these objects. We can also say that the names are bound to the objects. MicroPython distinguishes between mutable and immutable objects. For example, a “1” is an object of the class “int” and is immutable<\/em>. Sounds weird, but it is. Lists and arrays, on the other hand, are mutable.<\/p>\r\n In the first example, a and b first refer to the same object, namely “1”. With The next example does change the binding:<\/p>\r\n\n Each object in MicroPython has its individual ID, which you can query with As you can see, the ID of a changes. If you are still motivated, enter If you internalize this, you will be able to better understand various things in MicroPython. Among other things, the topic becomes important when you pass lists, arrays or other mutable objects to functions and modify them there. Because only the references are passed, and the functions work with the originals. It’s like passing references in C++.<\/p>\r\n\n I had already mentioned tuples and byte arrays above. I need to go into more detail about these data types, as you are very likely to encounter them. It’s a bit confusing at first to distinguish lists, arrays, bytearrays and tuples. And it’s pretty boring at first. The good news is that the methods you can apply to them are repetitive.<\/p>\r\n\n Basically, tuples are just immutable lists. You can add data of any type to tuples. Unlike the lists, tuples are defined in parentheses. However, you can also omit the brackets. Personally, I find it easier to read with parentheses.<\/p>\r\n\n As you can see, tuple_2[4] = 43 does not work. Tuples are not mutable.<\/p>\r\n\n Not surprisingly, bytearrays are arrays that contain only bytes. Like the other arrays, they are mutable. The best way to define bytearrays is to pass a list to the function The somewhat cryptic output is noticeable when you output the byte array as a whole. If the value of an element corresponds to a printable ASCII character, the character is printed. If this is not the case, the element is output in the format \\xyy, where yy is the value in hexadecimal notation. <\/p>\r\n\n I don’t even dare to say it: There’s more!<\/p>\r\n There is little to say about In addition, you learn from this example:<\/p>\r\n Enter the following in the shell:<\/p>\r\n You can see that MicroPython is smart and expects more input after the colon. You will receive:<\/p>\r\n\n Or you only pass one parameter, namely the upper limit. These statements also work:<\/p>\r\n\n You can see that MicroPython allows you to write fairly compact code.<\/p>\r\n\n The use of functions is also not significantly different from C++. Here is a small example:<\/p>\r\n\n The output is:<\/p>\r\n\n What you learn from it:<\/p>\r\n In Python or MicroPython, there are many ways to output numbers and strings formatted. First, here is a non-formatted example: <\/p>\r\n\ndigitalWrite()<\/code> and digitalRead()<\/code>. In the next post I will show you how to use other functions of the ESP32 like PWM, A\/D converter, timer, etc. with MicroPython.<\/p>\r\nPython and MicroPython<\/h2>\n\n
Preparation: Installing Python<\/h2>\n\n
\r\n
Installing uPyCraft and setting up the ESP32<\/h2>\n\n
Installation<\/h3>\n\n
![\"MicroPython](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/uPyCraft_select_firmware-1024x232.png\")
<\/a>The uPyCraft user interface<\/h3>\n\n
![\"uPyCraft](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/uPyCraft__surface-1024x702.png\")
<\/a>\r\n
Setting up the ESP32<\/h3>\n\n
Burning the Firmware<\/h4>\n\n
![\"Burning](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/upycraft_burn_fw.png\")
<\/a>Getting Started<\/h2>\n\n
a = 42<\/code> (or your favorite number) first and confirming with Enter. The next statement is print(\"a =\", a)<\/code>. As output you get a = 42<\/code>. Use type(a)<\/code> to query the variable type of a<\/code>. Now, enter a *= 1.0<\/code>, then a<\/code> and finally again type(a)<\/code>:<\/p>\r\n\n![\"Get](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/upycraft_first_test.png\")
\r\n
\r\n
a = 42.0<\/code> would be a float.<\/li>\r\na = \"42\"<\/code> a would be a string. a = '42'<\/code> is equivalent.<\/li>\r\n<\/ul>\r\n<\/li>\r\nprint()<\/code> creates a line break in the output.<\/li>\r\na *= 1.0<\/code> would not have triggered a conversion in C++.\r\n\r\n
float(variable)<\/code>, int(variable)<\/code> orstr(variable)<\/code> are also possible.<\/li>\r\n<\/ul>\r\n<\/li>\r\nprint()<\/code> statement, each separated by a comma.\r\n\r\n
end = \"\"<\/code> as last argument, for example print(\"a =\", a, end=\"\")<\/code>.<\/p>\r\nThe first program<\/h3>\n\n
from machine import Pin\r\nfrom time import sleep\r\nled = Pin(18, Pin.OUT)\r\nwhile True:\r\n led.value(1) \r\n sleep(1)\r\n led.value(0)\r\n sleep(1)<\/pre>\r\n
File Handling<\/h4>\n\n
![\"blink.py](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/uPyCraft_device_vs_workspace.png\")
<\/a>Automatic program start<\/h4>\n\n
Explanations about blink.py<\/h4>\n\n
from module import class\/method<\/code> classes or methods are imported from modules that are not part of the basic configuration. This is similar to the #include<\/code> preprocessor directive in C++. In blink.py, the class “Pin” is imported from the module “machine” and the function “sleep” is imported from the module “time”. An overview of the different ESP32-specific modules, classes and their methods can be found in the Quick Reference Guide<\/a>.<\/p>\r\nled = Pin(18, Pin.OUT)<\/code><\/p>\r\nint led = 18;\r\n<\/code><\/p>\r\npinMode(led, OUTPUT);<\/code><\/p>\r\nled.value(1)<\/code> or led.value(0)<\/code><\/p>\r\nled.on()<\/code> or led.off()<\/code><\/p>\r\nPin()<\/code>, e.g. the pin state:<\/p>\r\nled = Pin(18, PIN.OUT, value=1)<\/code> or in short: led = Pin(18, PIN.OUT, 1)<\/code><\/p>\r\nbuttonPin = Pin(18, Pin.IN, PIN.PULL_DOWN) # or: PULL_UP<\/code><\/p>\r\nsleep()<\/code> corresponds to delay()<\/code>, but you pass seconds to function. With sleep_ms()<\/code> you pass milliseconds and sleep_us()<\/code> corresponds to delayMicroseconds()<\/code>.<\/p>\r\nloop()<\/code> is replaced by while True:<\/code> in MicroPython. Everything before and in setup()<\/code> is placed before the while loop in MicroPython.<\/p>\r\nfrom ... import ...<\/code>, simply import ...<\/code> is also allowed. However, you have to prefix the classes and methods with the module names:<\/p>\r\n\nimport machine\r\nimport time\r\nled = machine.Pin(18, machine.Pin.OUT)\r\nwhile True:\r\n led.on()\r\n time.sleep(1)\r\n led.off()\r\n time.sleep(1)<\/pre>\r\n\n
Other general MicroPython elements<\/h2>\n\n
Operators<\/h3>\n\n
+<\/code>, -<\/code>, *<\/code>, \/<\/code> are identical to those in Arduino \/ C++ and the same applies to the modulo %<\/code>. Exponential functions can be realized with **<\/code>, e.g. 2**4<\/code> for “2 to the 4”. The operator for integer division is \/\/<\/code>.<\/p>\r\nand<\/code>, or<\/code> and not<\/code> are available. Just written out, so not like the C++ operators ||,<\/code> &&<\/code> and !<\/code>.<\/p>\r\n&<\/code>, |<\/code>, ^<\/code>, ~<\/code>, <<<\/code>, >><\/code> are again identical to the Arduino \/ C++ spelling. The same applies to the comparison operators: <<\/code>, ><\/code>, <=<\/code>, >=<\/code>, ==<\/code>, !=<\/code>.<\/p>\r\nNumber systems<\/h3>\n\n
0b...<\/code>, 0o...<\/code> and 0x...<\/code>. If you want to output a number in a certain format, then use bin()<\/code>, oct()<\/code> or hex()<\/code>. For example: print(bin(a))<\/code>.<\/p>\r\nLists and arrays<\/h3>\n\n
\r\n
l = [42, True, \"abc\", 66.6]<\/code><\/p>\r\n![\"Operations](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/list_options.png\")
<\/a>len(l)<\/code> returns the number of items in the list l.<\/p>\r\nimport array as arr\r\na = arr.array(\"i\", [3,7,9,25])<\/pre>\r\n
Mutable and immutable objects<\/h4>\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/var.png\")
<\/a><\/figure>\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/var2.png\")
<\/a><\/figure>\nb = 2<\/code> b refers to a new object, namely “2”. “a” remains unaffected. In the second example, however, b[0] = 2<\/code> does not change the binding to the object (namely the list), but changes the object because it is mutable.<\/p>\r\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/var3.png\")
<\/a><\/figure>\nid(object)<\/code>. Try this:<\/p>\r\na = 1<\/code>,<\/p>\r\nid(a)<\/code>,<\/p>\r\na += 1<\/code> and finally this:<\/p>\r\nid(a)<\/code><\/p>\r\nid(2)<\/code>. Consequently, id(a)<\/code> is equal to id(2)<\/code>. <\/p>\r\nTuples and bytearrays<\/h3>\n\n
Tuple<\/h4>\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/09\/tuple_test.png\")
<\/a>Bytearrays<\/h4>\n\n
bytearray()<\/code>. Here are a few examples:<\/p>\r\n\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/09\/bytearray.png\")
\r\n
bytes()<\/code> instead of bytearray()<\/code>. Otherwise, everything is the same.<\/li>\r\nOther loops and conditions<\/h3>\n\n
if – else – elif statements<\/h4>\n\n
if<\/code> and else<\/code>. else if<\/code> is called elif<\/code> in MicroPython. Here’s an example, which admittedly is pretty pointless in itself:<\/p>\r\n\nfrom time import sleep\r\nfrom random import randint \r\nwhile True:\r\n n = randint(-10, 30) # random integer between -10 and +30\r\n print(\"Random number =\", n)\r\n if n > 0:\r\n if n > 20:\r\n print(\"Number is bigger than 20\")\r\n elif n > 10:\r\n print(\"Number is bigger than 10\")\r\n else:\r\n print(\"Number is bigger than 0\")\r\n elif n <= 0:\r\n print(\"Number <= 0\")\r\n print(\"...........\")\r\n sleep(1.5)<\/pre>\r\n\n
\r\n
randint(x,y)<\/code>.<\/li>\r\nrandint()<\/code> must be imported.<\/li>\r\nsleep()<\/code> also works with floats.<\/li>\r\n<\/ul>\r\n\nFor – statements<\/h4>\n\n
for i in range(1,4):\r\n print(i)\r\n<\/pre>\r\n
![\""for"-loop](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/simple_for.png\")
<\/a>for i in range(1,4)<\/code> is therefore equivalent to the Arduino\/C++ expression: for(int i=1; i<4; i++)<\/code>. You can pass a third parameter to range()<\/code> and change the increment this way. Try range(1,10,2)<\/code> and range(4,1,-1)<\/code> see what happens.<\/p>\r\nrange(x)<\/code> corresponds to range(0,x)<\/code>.<\/p>\r\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/further_range_options.png\")
<\/a>Functions<\/h2>\n\n
def double_it(i):\r\n result = i * 2\r\n return result\r\n \r\nn = 5\r\nprint(\"5 * 2 =\", double_it(n))\r\nn = 5.0\r\nprint(\"5.0 * 2 =\", double_it(n))\r\nn = \"Hello\"\r\nprint(\"Hello * 2 =\", double_it(n))<\/pre>\r\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/output_simple_function.png\")
<\/a><\/figure>\n\r\n
def function_name(parameter):<\/code>.\r\n\r\n
Formatted output<\/h2>\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/format_unformatiert.png\")
<\/a><\/figure>\n
![](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/08\/format_formatiert.png\"){kind=link}