![\"\"](\"https:\/\/i0.wp.com\/randomnerdtutorials.com\/wp-content\/uploads\/2018\/10\/programming-micropython-esp32-esp8266.jpg?resize=1200%2C675&quality=100&strip=all&ssl=1\")
<\/p>\nMicroPython is a re-implementation of Python programming language targeted for microcontrollers and embedded systems like the ESP32 or ESP8266.<\/p>\n
Programming in MicroPython is very similar to programming in Python: all of the language features of Python are also in MicroPython, apart from a few exceptions. Because microcontrollers and embedded systems are much more limited than our computers, MicroPython does not come with the full standard library by default.<\/p>\n
<\/p>\n
If you already know how to program in Python, programming in MicroPython is the same. You just need to bear in mind that MicroPython is used for constrained devices. So, you must keep your code as simple as possible.<\/p>\n
This article explains the basics of Python programming language syntax that also apply to MicroPython, like:<\/p>\n
In this tutorial we\u2019re going to use uPyCraft IDE as a development environment, but you can use any other program. To install and get started with uPyCraft IDE, follow these next tutorials:<\/p>\n
Micropython can perform mathematical operations. The following table shows the mathematical operators supported:<\/p>\n
Operator<\/strong><\/td>\n| Mathematical Operation<\/strong><\/td>\n<\/tr>\n | +<\/td>\n | Addition<\/td>\n<\/tr>\n | –<\/td>\n | Subtraction<\/td>\n<\/tr>\n | *<\/td>\n | Multiplication<\/td>\n<\/tr>\n | \/<\/td>\n | Division<\/td>\n<\/tr>\n | \/\/<\/td>\n | Division, discarding the decimal point<\/td>\n<\/tr>\n | %<\/td>\n | Remainder after division<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n | In the Shell, try several operations to see how it works. For example:<\/span><\/p>\n You can perform other mathematical operations if you import the math<\/em> module, like square root, trigonometric functions, logarithm, exponentiation, etc..<\/p>\n You can make comparisons using relational operators. These compare the values on either sides and show the relation between them.<\/p>\n Try several comparisons and test the result:<\/span><\/p>\n In Python you don\u2019t need to declare what type each variable is. If you’re used to program your boards using Arduino IDE, you know that you need to declare the type of a variable when creating a new variable.\u00a0There isn\u2019t such thing in Python.<\/p>\n Variables are simply a storage placeholder for values: number or text. To assign a value to a variable you use the equal sign (=), with the variable name on the left and the value on the right.<\/p>\n For example, to create a variable to hold the GPIO number where an LED is connected to, you can simply type the following:<\/p>\n In the Arduino IDE, you would have something like:<\/p>\n As you can see, Python is much simpler than programming in C (in Arduino IDE).<\/p>\n Note:<\/strong> the names you give variables can\u2019t have spaces and are case sensitive, so led_pin<\/em> is different from LED_PIN<\/em> or Led_Pin.<\/em><\/p>\n Variables can store several types of values, not just whole numbers. That\u2019s where data types<\/em> come in. A data type is a classification of a value that tells what operations can be done with the value and how it should be stored.<\/p>\n The following table shows the data types we\u2019ll use most often in our projects.<\/p>\n Let\u2019s create variables with different data types:<\/span><\/p>\n There is a function to check the data type of a variable: the type()<\/strong> <\/em>function. This function accepts as argument the variable you want to check the data type.<\/p>\n For example, after declaring the variables in the previous example a<\/em>, b<\/em>, c<\/em>, and d<\/em>, you can check its data type. For example, if you type:<\/span><\/p>\n It returns:<\/p>\n This tells that a<\/em> is an int (integer). Experiment with the other variables and you should get:<\/p>\n The print()<\/em> function prints the message between parentheses into the Shell. This is specially useful in our projects to debug the code and keep track of what’s going on. For example:<\/p>\n Comments in Python start with the hash character (#) and continue to the end of the line. A comment is useful to add “notes” in your program or to\u00a0tell anyone who reads the program what the script does. This doesn’t add any functionality to your program. For example:<\/p>\n Because in MicroPython we are working under constrained conditions, there are occasions in which you should avoid adding comments to save space on the ESP memory.<\/p>\n To write useful programs, you’ll probably need to perform different actions depending on whether a certain condition is True or False. We’re talking about conditional statements. They have the following structure:<\/p>\n <expr> is a Boolean expression and it can be either True<\/strong> or False<\/strong>. If it is True, the <statement> right after it is executed. The <statement> should be indented so that Python knows what statement belongs to each expression.<\/p>\n The elif<\/em> statement stands for else if and runs only if the first if\u00a0<\/em>condition is not True.<\/p>\n The else<\/em> statement only runs if none of the other expressions are True.<\/p>\n There’s no limit to the number of elif<\/em> statements in a program. It\u2019s also not necessary to include an else<\/em> clause, but if there is one, it must come at the end.<\/p>\n In the Arduino IDE, we use {} curly brackets to define code blocks. With MicroPython, we use indentation. Additionally, you need to use a colon :<\/strong> after each expression. Contrary to the Arduino IDE, the expression doesn\u2019t need to be inside parentheses.<\/p>\n Important<\/strong>:<\/span>\u00a0Python\u2019s standard indentation is 4 spaces. In MicroPython indentation should be only 2 spaces<\/strong> to fit more code into the microcontroller memory.<\/p>\n Loops allow you to execute a block of code multiple times for as long as a condition is met. There are two kinds of loops: while<\/em> and for<\/em> loops. For example, you can print all numbers from 1 to 10 with a while<\/em> loop:<\/p>\n The code that belongs to the while loop, indicated by the indentation, is executed as long as the value in the\u00a0number<\/em> variable is less than or equal to (<=) 10. In every loop, the current number<\/em> is printed and then 1 is added to it.<\/p>\n You can also print numbers from 1 to 10 using a for<\/em> loop, like this:<\/p>\n The for<\/em> loop is executed as long as the value in the\u00a0number<\/em> variable is within the range of 1 and 11. The range()<\/em> function automatically assigns the next value to the number<\/em> variable, until 1 below the final number you specify.<\/p>\n You should use a for loop when you want to repeat a block of code a certain number of times. Use a while loop when you want to repeat code until a certain condition is no longer met. In some situations, you can use either one,\u00a0oftentimes one is more suitable than the other.<\/p>\n Similar to the conditional statements, the for<\/em> and while<\/em> Boolean expressions should have a colon :<\/strong> right after them, and the expressions to be executed should be indented.<\/p>\n To define a new function, you use the word def<\/em> followed by the name you want to give the function and a set of parentheses (and arguments inside, if necessary). After the parentheses you add a colon :<\/strong> and then tell the function what instructions to perform. The statements should be indented with 2 spaces (in MicroPython). For example:<\/p>\n For example, a function that converts the temperature in Celsius to Fahrenheit could be the following:<\/p>\n The celsius_to_fahrenheit()<\/em> function accepts as argument a temperature in Celsius (temp_celsius<\/em>). Then, it does the calculation to convert the temperature. Finally, it returns the temperature in Fahrenheit (temp_fahrenheit<\/em>).<\/p>\n Note<\/strong>: functions don’t necessarily need to return something. They could just perform some work without the need to return anything.<\/p>\n Python is an Object-Oriented Programming (OOP) language. There are two important concepts you need to understand about OOP: classes and objects.<\/p>\n A class is a blueprint for objects. It defines a set of attributes (data and functions) that characterize an object. The functions inside of a class are called methods. Classes are defined by the keyword class<\/em> <\/strong>followed by the name of the class. For example:<\/p>\n Note:<\/strong> by convention, classes’ names in Python should be CapWords. However, you can give whatever name you want.<\/p>\n An object is an instance of a class. It’s simply a collection of data and methods into a single entity. Through the object, you can use all functionalities of its class. Confused? Let\u2019s take a look at a simple example.<\/span><\/p>\n If we would like to define several persons in a Python program using the same attributes, we can think of the term person as a class. We may want to define a person using attributes like name, age, country, etc.<\/p>\n So, we can create a class called Person<\/em>. Our class will have the following attributes: name<\/em>, age<\/em>, and country<\/em>. You can add as many attributes as you want. We\u2019ll also create a function (method) that prints a description of the person based on its attributes:<\/p>\n As you can see, we define a new class by using the keyword class<\/em>, followed by the name we want to give to the class.<\/p>\n Inside the Person<\/em>\u00a0class, we define several variables to hold values. By default the name<\/em> and country<\/em> are empty strings, and the age<\/em> is 0. Then, we also define a function (method) that prints all the variables values into the Shell.<\/p>\n All functions inside a class should have the self<\/em>\u00a0parameter as argument and other arguments, if needed.<\/p>\n The\u00a0self\u00a0<\/em> parameter refers to the object itself. It is used to access variables that belong to the class. For example, to access the name<\/em> variable inside the class, we should use self.name<\/em>.<\/p>\n Now that we\u2019ve create a class, we can create as many Person<\/em> objects as we want by using that class. The Person<\/em> object will have a name, age, and country. We\u2019ll also be able to print its description using the description()<\/em> method.<\/p>\n For example, to create a new Person<\/em> object called person1<\/em>:<\/p>\n Set the object’s properties<\/strong><\/p>\n To set the name<\/em>, age<\/em>, and country<\/em> of the person1<\/em> object. You can do it as follows:<\/p>\n Calling methods<\/strong><\/p>\n Later in your code you can use the created description() <\/em>method\u00a0on any\u00a0Person<\/em> object. To call the description()<\/em> method on the person1<\/em> object:<\/p>\n This should print the following:<\/p>\n You should now understand that you can create as many objects as you want using the same class and you are able to use the available methods with all the objects of that class.<\/p>\n The constructor method<\/strong><\/p>\n Instead of having to define a class, and then set the object’s properties, which can be time consuming, you can use the constructor method inside your class.<\/p>\n The constructor method is used to initiate data as soon as an object of a class is instantiated. The constructor method is also known as __init__ method.\u00a0 Using the __init__ method, the Person()<\/em>\u00a0class looks as follows:<\/p>\n Then, to instantiate a Person<\/em> object with the same attributes we’ve defined earlier, we just need to do the following:<\/p>\n If you call the description()<\/em> on the person1<\/em> object, you’ll get the same result:<\/p>\n A module is a file that contains a set of classes and functions you can use in your code – you can also call it library. To access the classes and functions inside that code, you just need to import that module into your code.<\/p>\n You can create your own modules, or use already created modules from the standard Python library. When it comes to MicroPython, it only comes with a small subset of the standard Python library, but it does come with a set of modules to control GPIOs, make networks connections and much more.<\/p>\n Importing modules\/libraries is as simple as using:<\/p>\n For example, to import the machine<\/em> library that contains classes to control GPIOs, type the following:<\/p>\n In most programs you won’t need all the classes from one module. You may just want to import a single class. For example, to import only the Pin<\/em> class from the machine<\/em> module:<\/p>\n In this tutorial we’ve just scratched the surface of Python basics that also apply to MicroPython. If you are used to program electronics using the Arduino IDE, you’ll find that MicroPython has a much simpler and user-friendly syntax. Let’s just summarize some of the main differences between your Arduino sketches and programs in MicroPython:<\/p>\n Recommend reading: <\/strong>MicroPython Programming with ESP32 and ESP8266 eBook<\/a><\/p>\n |
![\"\"](\"https:\/\/i0.wp.com\/randomnerdtutorials.com\/wp-content\/uploads\/2018\/10\/objects-class.png?resize=455%2C323&quality=100&strip=all&ssl=1\")
<\/p>\n![\"\"](\"https:\/\/i0.wp.com\/randomnerdtutorials.com\/wp-content\/uploads\/2018\/10\/creating-objects.png?resize=750%2C422&quality=100&strip=all&ssl=1\")
<\/a><\/p>\n![\"\"](\"https:\/\/i0.wp.com\/randomnerdtutorials.com\/wp-content\/uploads\/2018\/10\/from-machine-import-pin-Copy.png?resize=750%2C347&quality=100&strip=all&ssl=1\")
<\/h2>\n