0-ESP32-MicroPython ESP32 ESP8266 MicroPython Project Tech

MicroPython Programming Basics with ESP32 and ESP8266

MicroPython Programming Basics with ESP32 and ESP8266

MicroPython is a re-implementation of Python programming language focused for microcontrollers and embedded techniques just like the ESP32 or ESP8266.

Programming in MicroPython is similar to programming in Python: all the language options of Python are additionally in MicroPython, aside from a couple of exceptions. As a result of microcontrollers and embedded techniques are far more restricted than our computer systems, MicroPython doesn’t include the complete commonplace library by default.

When you already know how you can program in Python, programming in MicroPython is identical. You simply want to remember that MicroPython is used for constrained units. So, you should hold your code so simple as attainable.

This text explains the fundamentals of Python programming language syntax that additionally apply to MicroPython, like:

  • Mathematical operators
  • Relational operators
  • Knowledge varieties
  • print() perform
  • Conditional statements
  • Whereas and for loops
  • Consumer outlined features
  • Courses and objects
  • Modules


On this tutorial we’re going to make use of uPyCraft IDE as a improvement setting, however you should use some other program. To put in and get began with uPyCraft IDE, comply with these subsequent tutorials:

Mathematical Operators

Micropython can carry out mathematical operations. The next desk exhibits the mathematical operators supported:

Operator Mathematical Operation
+ Addition
* Multiplication
/ Division
// Division, discarding the decimal level
% The rest after division

Within the shell, attempt a number of operations to see the way it works. For instance:

>>> 2+2*9-Three
>>> 28594/2312
>>> 214522236/7.5
>>> 23//2
>>> 25%Three

You possibly can carry out different mathematical operations in the event you import the maths module, like sq. root, trigonometric features, logarithm, exponentiation, and so on..

Relational Operators

You can also make comparisons utilizing relational operators. These examine the values on both sides and present the relation between them.

Operator Description
== Equal to
!= Not equal to
> Larger than
< Lower than
>= Larger than or equal to
<= Lower than or equal to

Attempt a number of comparisons and see what you get:

>>> 2 == Three
>>> four == four
>>> Three > 2
>>> 489808234 != 2223
>>> four.5 >= four.5

Assigning Values to Variables

In Python you don’t have to declare what sort every variable is. For those who’re used to program your boards utilizing Arduino IDE, you understand that you could declare the kind of a variable when creating a brand new variable. There isn’t such factor in Python.

Variables are merely a storage placeholder for values: quantity or textual content. To assign a worth to a variable you employ the equal signal (=), with the variable identify on the left and the worth on the proper.

For instance, to create a variable to carry the GPIO quantity the place an LED is related to, you’ll be able to merely sort the next:

led_pin = 23

Within the Arduino IDE, you’d have one thing like:

const int led_pin = 23;

As you’ll be able to see, Python is far easier than programming in C (in Arduino IDE).

Word: the names you give variables can’t have areas and are case delicate, so led_pin is totally different from LED_PIN or Led_Pin.

Knowledge Varieties

Variables can retailer a number of forms of values, not simply entire numbers. That’s the place knowledge varieties are available. A knowledge sort is a classification of a worth that tells what operations may be completed with the worth and the way it ought to be saved.

The next desk exhibits the info varieties we’ll use most frequently in our tasks.

Knowledge sort Description
int (Int) Integer (entire quantity)
float (Float) Quantity with a decimal level
str (String) Set of characters between citation marks
bool (Boolean) True or False

Let’s create variables with totally different knowledge varieties:

>>> a = 6
>>> b = 95.32
>>> c = ‘Howdy World!’
>>> d = True

  • The primary worth assigned to a, is an integer, which is an entire quantity.
  • The b variable accommodates a float worth, which is a quantity with a decimal.
  • The third worth, ‘Howdy World!’, is a string, which is a collection of characters. A string have to be put inside single (‘Howdy World!’) or double citation (“Howdy World!”) marks.
  • Lastly, d is a Boolean, which is a kind that may solely take both True or False.

There’s a perform to examine the info sort of a variable: the sort() perform. This perform accepts as argument the variable you need to verify the info sort.


For instance, after declaring the variables within the earlier instance a, b, c, and d, you’ll be able to verify its knowledge sort. For instance, when you sort:

>>> sort(a)

It returns:

This tells that a is an int (integer). Experiment with the opposite variables and you need to get:

>>> sort(b)

>>> sort(c)

>>> sort(d)

print() Perform

The print() perform prints the message between parentheses into the shell. That is specifically helpful in our tasks to debug the code and maintain monitor of what’s happening. For instance:

>>> print(‘LED is on’)
LED is on


Feedback in Python begin with the hash character, # ,and proceed to the top of the road. A remark is beneficial so as to add “notes” in your program or to tells anybody who reads this system what the script does. This doesn’t add any performance to your program. For instance:

# That is only a remark

As a result of in MicroPython we’re working underneath constrained circumstances, there are events during which you must keep away from including feedback to save lots of area on the flash reminiscence.

Conditional Statements

To put in writing helpful packages, you’ll in all probability have to carry out totally different actions relying on whether or not a sure situation is True or False. We’re speaking about conditional statements. They’ve the next construction:

if :

elif :

elif :


is a Boolean expression and it may be both True or False. Whether it is True, the proper after it’s executed. The must be indented in order that Python is aware of what assertion belongs to every expression.

The elif assertion stands for else if and runs provided that the primary if situation shouldn’t be True.

The else assertion solely runs if not one of the different expressions are True.

There’s no restrict to the variety of elif statements in a program. It’s additionally not mandatory to incorporate an else clause, but when there’s one, it should come on the finish.

Within the Arduino IDE, we use curly brackets to outline code blocks. With MicroPython, we use indentation. Moreover, you have to use a colon : after every expression. Opposite to the Arduino IDE, the expression doesn’t have to be inside parentheses.

Necessary: Python’s normal indentation is four areas. In MicroPython indentation ought to be solely 2 areas to suit extra code into the flash reminiscence.

Whereas and For loops

Loops can help you execute a block of code a number of occasions for so long as a situation is met. There are two sorts of loops: whereas and for loops. For instance, you possibly can print all numbers from 1 to 10 with some time loop:

quantity = 1
whereas quantity <= 10:
quantity = quantity + 1

The code that belongs to the whereas loop, indicated by the indentation, is executed so long as the worth within the variable quantity is lower than or equal to (<=) 10. In each loop, the present quantity is printed after which 1 is added to it.

You can even print numbers from 1 to 10 utilizing a for loop, like this:

quantity = 1
for quantity in vary(1, 11):

The for loop is executed so long as the worth within the variable quantity is inside the vary of 1 and 11. The vary() perform mechanically assigns the subsequent worth to the quantity variable, till 1 under the ultimate quantity you specify.

It is best to use a for loop if you need to repeat a block of code a sure variety of occasions. Use some time loop if you need to repeat code till a sure situation is not met. In some conditions, you need to use both one, oftentimes one is extra appropriate than the opposite.

Just like the conditional statements, the for and whereas Boolean expressions ought to have a colon : proper after them, and the expressions to be executed ought to be indented.

Consumer-defined Features

To outline a brand new perform, you employ the phrase def adopted by the identify you need to give the perform and a set of parentheses (and arguments inside, if vital). After the parentheses you add a colon : after which inform the perform what directions to carry out. The statements must be indented with 2 areas (in MicroPython). For instance:

def my_function(…):


For instance, a perform that converts the temperature in Celsius to Fahrenheit could possibly be the next:

def celsius_to_fahrenheit(temp_celsius):
temp_fahrenheit = temp_celsius * (9/5) + 32
return temp_fahrenheit

The celsius_to_fahrenheit() perform accepts as argument a temperature in Celsius (temp_celsius). Then, it does the calculation to transform the temperature. Lastly, it returns the temperature in Fahrenheit (temp_fahrenheit).

Word: features don’t essentially have to return one thing. They might simply carry out some work with out the necessity to return something.

Courses and Objects

Python is an object-oriented programming language (OOP). There are two essential ideas it’s essential perceive about OOP: courses and objects.

A category is a blueprint for objects. It defines a set of attributes (knowledge and features) that characterize an object. The features inside a category are referred to as strategies. Courses are outlined by the key phrase class adopted by the identify of the category. For instance:

class MyClass:

Word: by conference, courses’ names in Python must be CapWords. Nevertheless, you may give no matter identify you need.

An object is an occasion of a category. It’s merely a set of knowledge and strategies right into a single entity. Via the item, you need to use all functionalities of its class. Confused? Let’s check out a easy instance.

If we want to outline a number of individuals in a Python program utilizing the identical attributes, we will consider the time period individual as a category. We might need to outline an individual utilizing attributes like identify, age, nation, and so forth.

So, we will create a category referred to as Individual. Our class may have the next attributes: identify, age, and nation. You possibly can add as many attributes as you need. We’ll additionally create a perform (technique) that prints an outline of the individual based mostly on its attributes:

class Individual:
identify = “”
age = zero
nation = “”
def description(self):
print(“%s is %d years previous and he’s from %s.” %(self.identify, self.age, self.nation))

As you possibly can see, we outline a brand new class through the use of the key phrase class, adopted by the identify we need to give to the category.

Contained in the Individual class, we outline a number of variables to carry values. By default the identify and nation are empty strings, and the age is zero. Then, we additionally outline a perform (technique) that prints all of the variables values into the shell.

All features inside a category ought to have the self parameter as argument and different arguments, if wanted.

The self  parameter refers back to the object itself. It’s used to entry variables that belong to the category. For instance, to entry the identify variable inside the category, we should always use self.identify.

Now that we’ve create a category, we will create as many Individual objects as we would like through the use of that class. The Individual object could have a reputation, age, and nation. We’ll additionally have the ability to print its description utilizing the outline() technique.

For instance, to create a brand new Individual object referred to as person1:

>>> person1 = Individual()

Set the item’s properties

To set the identify, age, and nation of the person1 object. You are able to do it as follows:

>>> person1.identify = “Rui”
>>> person1.age = 25
>>> person1.nation = “Portugal”

Calling strategies

Later in your code you should use the created description() technique on any Individual object. To name the outline() technique on the person1 object:

>>> person1.description()

This could print the next:

Rui is 25 years previous and he’s from Portugal.

You must now perceive that you would be able to create as many objects as you need utilizing the identical class and you’ll be able to use the obtainable strategies with all of the objects of that class.

The constructor technique

As an alternative of getting to outline a category, after which set the item’s properties, which might be time consuming, you need to use the constructor technique inside your class.

The constructor technique is used to provoke knowledge as quickly as an object of a category is instantiated. The constructor technique is also referred to as __init__ technique.  Utilizing the __init__ technique, the category Individual() seems to be as follows:

class Individual():
def __init__(self, identify, age, nation):
self.identify = identify
self.age = age
self.nation = nation
def description(self):
print(“%s is %d years previous and he’s from %s.” %(self.identify, self.age, self.nation))

Then, to instantiate a Individual object with the identical attributes we’ve outlined earlier, we simply have to do the next:

>>> person1 = Individual(“Rui”, 25, “Portugal”)

For those who name the outline() on the person1 object, you’ll get the identical outcome:

>>> person1.description()
Rui is 25 years previous and he’s from Portugal.


A module is a file that accommodates a set of courses and features you need to use in your code – you may also name it library. To entry the courses and features inside that code, you simply have to import that module into your code.

You possibly can create your personal modules, or use already created modules from the usual Python library. On the subject of MicroPython, it solely comes with a small subset of the usual Python library, however it does include a set of modules to regulate GPIOs, make networks connections and far more.

Importing modules/libraries is so simple as utilizing:

import module_name

For instance, to import the machine library that accommodates courses to regulate GPIOs, sort the next:

import machine

In most packages you gained’t want all of the courses from one module. You might simply need to import a single class. For instance, to import solely the Pin class from the machine module:

from machine import module

Wrapping Up

On this tutorial we’ve simply scratched the floor of Python fundamentals that additionally apply to MicroPython. In case you are used to program electronics utilizing the Arduino IDE, you’ll discover that MicroPython has a a lot easier and user-friendly syntax. Let’s simply summarize a few of the primary variations between your Arduino sketches and packages in MicroPython:

  • You don’t use semicolon ; on the finish of a press release
  • After Boolean expressions in conditional statements and loops, you employ a colon :
  • To outline code blocks use indentation as an alternative of curly brackets
  • When making a variable, you don’t have to outline which knowledge sort it’s – you don’t have to declare a variable
  • Indentation in MicroPython is 2 areas

Advocate studying: Getting Began with MicroPython on ESP32 and ESP8266.

We hope you’ve discovered this text concerning the MicroPython fundamentals syntax helpful. We’ll be including tutorials about programming the ESP32 and ESP8266 utilizing MicroPython very quickly. So, keep tuned and subscribe the RNT weblog!

Thanks for studying.