MicroPython Reference

Copy
1from machine import Pin
2
3output_pin = Pin(5, Pin.OUT) #define pin
4input_pin = Pin(6, Pin.IN, Pin.PULL_UP) #define pin as an input pullup

Copy
1from machine import Pin
2
3pin = Pin(5, Pin.PULL_UP) #define pin
4reading = pin.value() #read pin
5
6print(reading) #print state of pin to REPL

Copy
1from machine import Pin
2
3pin = Pin(5, Pin.PULL_UP) #define pin
4pin.value(1) #set pin to high state

Copy
1import machine
2import time
3
4adc_pin = machine.Pin("PC4") 
5adc = machine.ADC(adc_pin)
6
7while True:
8    reading = adc.read_u16()    
9    print("ADC: ",reading)
10
11    time.sleep_ms(1000)

Copy
1# right-shifts the bits and discards the 6 most significant bits
2# effectively changing the value range from 0-65535 to 0-1023
3result = (reading >> 6) & 0x3FF

Copy
1from machine import Pin, PWM, ADC
2
3pwm = PWM(Pin(15))
4duty = 30000 #between 0-65535
5
6pwm.freq(1000)
7
8while True:
9    pwm.duty_u16(duty)

Copy
1import pyb
2import time
3from pyb import Pin, Timer
4
5pin1 = Pin("PC6", Pin.OUT_PP, Pin.PULL_NONE)
6timer1 = Timer(3, freq=1000)
7channel1 = timer1.channel(1, Timer.PWM, pin=pin1, pulse_width=0)
8
9channel1.pulse_width(50) #duty cycle at 50%

Copy
1import time
2
3time.sleep(1) #freeze program for 1 seconds

Copy
1'''
2"Blink Without Delay" script.
3Blinks an LED attached to pin 5 every second,
4without freezing the program.
5'''
6
7import time
8from machine import Pin
9
10ledPin = Pin(5, Pin.OUT) 
11
12interval = 1
13previousTime = 0
14switch = False
15
16while True:
17    currentTime = time.time()
18    
19    if currentTime - previousTime >= interval:
20        previousTime = currentTime
21        
22        switch = not switch
23        ledPin.value(switch)

Copy
1'''
2This example prints out each bit of an 8-bit variable
3It stops after 255 (the max value an 8-bit variable can hold)
4'''
5import time
6counter = 0
7
8bit_length = 8 # 8 bits
9while True:
10    bits = []
11    for bit_index in range(bit_length - 1, -1, -1):
12        bit_value = (counter >> bit_index) & 1
13        bits.append(bit_value)
14    print("Binary: ", bits, " DEC: ", counter)
15
16    counter += 1
17    time.sleep(0.01)
18    if counter > 255:
19        break

Copy
1# Example variable
2variable = 12345
3
4# Set the third bit
5bit_index = 2
6
7print()
8print("Before setting a bit: ",bin(variable))
9print("Before setting a bit: ",variable)
10variable = variable | (1 << bit_index)
11
12# Print the result
13print("After setting a bit: ",bin(variable))
14print("After setting a bit: ",variable)

Copy
1# Example variable
2variable = 255
3
4bit_length = 8
5# Extract the leftmost bit
6leftmost_bit_index = bit_length - 1
7leftmost_bit = (variable >> leftmost_bit_index) & 1
8
9# Print the result
10print("Leftmost bit: ", leftmost_bit)

Copy
1# Example variable
2variable = 255
3
4# Extract the rightmost bit
5rightmost_bit = variable & 1
6
7# Print the result
8print("Rigthmost bit: ", rightmost_bit)

Copy
1from machine import Pin, PWM
2import time
3    
4def tone(pin,frequency,volume,duration=None):
5    speaker = PWM(Pin(pin))
6    speaker.freq(frequency)
7    speaker.duty_u16(volume)
8    if duration is not None:
9        time.sleep(duration)
10
11def noTone(pin,duration=None):
12    speaker = PWM(Pin(pin))
13    speaker.deinit()
14    if duration is not None:
15        time.sleep(duration)
16
17while True:
18    tone(5,500,1000,1)
19    noTone(5,1)

Copy
1result = abs(-5)
2print(result)

Copy
1def constrain(value, lower, upper):
2    return max(min(value, upper), lower)
3
4result = constrain(10, 0, 5)  # Result will be 5
5print(result)

Copy
1def map(value, in_min, in_max, out_min, out_max):
2    return (value - in_min) * (out_max - out_min) / (in_max - in_min) + out_min
3
4result = map(50, 0, 100, 0, 255) # Result is 127.5
5print(result)

Copy
1result = max(5, 10, 3)  # Result will be 10
2print(result)

Copy
1result = min(5, 10, 3)  # Result will be 3
2print(result)

Copy
1result = pow(2, 3)  # Result will be 8
2print(result)

Copy
1result = sq(4)  # Result will be 16
2print(result)

Copy
1import math
2
3result = math.sqrt(16)  # Result will be 4.0
4print(result)

Copy
1import math
2
3# Specify the angle in radians
4angle_in_radians = math.radians(45)
5
6# Calculate the cosine of the angle
7cos_value = math.cos(angle_in_radians)
8
9# Print the result
10print(f"The cosine of {angle_in_radians} radians is: {cosine_value}")

Copy
1import math
2
3# Specify the angle in radians
4angle_in_radians = math.radians(30)
5
6# Calculate the sine of the angle
7sine_value = math.sin(angle_in_radians)
8
9# Print the result
10print(f"The sine of {angle_in_radians} radians is: {sine_value}")

Copy
1import math
2
3# Specify the angle in radians
4angle_in_radians = math.radians(60)
5
6# Calculate the tangent of the angle
7tangent_value = math.tan(angle_in_radians)
8
9# Print the result
10print(f"The tangent of {angle_in_radians} radians is: {tangent_value}")

Copy
1char = 'a'
2if char.isalpha():
3    print(f"{char} is alphabetic.")
4else:
5    print(f"{char} is not alphabetic.")

Copy
1# Function to check if a character is alphanumeric
2def is_alphanumeric(char):
3    return char.isalpha() or char.isdigit()
4
5# Example usage
6test_char = 'a'
7
8if is_alphanumeric(test_char):
9    print(f"{test_char} is alphanumeric.")
10else:
11    print(f"{test_char} is not alphanumeric.")

Copy
1char = 'Ö'
2
3if 0 <= ord(char) < 128:
4    print(f"{char} is an ASCII character.")
5else:
6    print(f"{char} is not an ASCII character.")

Copy
1char = '\t'  # Example: Tab character
2
3if 0 <= ord(char) < 32 or ord(char) == 127:
4    print(f"{char} is a control character.")
5else:
6    print(f"{char} is not a control character.")

Copy
1char = '5'
2if char.isdigit():
3    print(f"{char} is a digit.")
4else:
5    print(f"{char} is not a digit.")

Copy
1char = 'A'
2
3if char.isprintable() and not char.isspace():
4    print(f"{char} is a graph character.")
5else:
6    print(f"{char} is not a graph character.")

Copy
1char = 'a'
2
3if char.islower():
4    print("Is lower case.")
5else:
6    print("Is not lower case.")

Copy
1char = '\t'
2
3if char.isprintable():
4    print("Is printable.")
5else:
6    print("Is not printable.")

Copy
1def isPunct(char):
2    punctuation_chars = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
3    return char in punctuation_chars
4
5print(isPunct("."))

Copy
1char = ' '
2
3if char.isspace():
4    print(f"{char} is a space character.")
5else:
6    print(f"{char} is not a space character.")

Copy
1char = 'A'
2
3if char.isupper():
4    print(f"{char} is an uppercase letter.")
5else:
6    print(f"{char} is not an uppercase letter.")

Copy
1import random
2
3random_integer = random.randint(1, 10)
4print("Random integer between 1 and 10:", random_integer)

Copy
1import random
2import time
3
4# Seed the random number generator with the current time
5seed_value = int(time.time())
6random.seed(seed_value)
7
8# Generate random numbers using the seeded generator
9random_number = random.randint(1,100)
10print(random_number)

Copy
1from machine import Pin
2import time
3
4# Define a callback function to be called when the interrupt occurs
5def interrupt_callback(pin):
6    print("Interrupt occurred on pin", pin_name)
7
8# Pin name
9pin_name = "PA3"
10
11# Define the pin to which you want to attach the interrupt
12interrupt_pin = Pin(pin_name, Pin.IN, Pin.PULL_UP)  # Replace 2 with the actual pin number you are using
13
14# Attach the interrupt to the pin, specifying the callback function and trigger type
15interrupt_pin.irq(trigger=Pin.IRQ_FALLING, handler=interrupt_callback)
16
17while True:
18    print("hello world")
19    time.sleep(1)

Copy
1from machine import Pin
2import time
3
4# Define a callback function to be called when the interrupt occurs
5def interrupt_callback(pin):
6    print("Interrupt occurred on pin", pin_name)
7    # Detaches the interrupt from the pin
8    interrupt_pin.irq(handler=None) 
9
10# Pin name
11pin_name = "PA3"
12
13# Define the pin to which you want to attach the interrupt
14interrupt_pin = Pin(pin_name, Pin.IN, Pin.PULL_UP)  # Replace 2 with the actual pin number you are using
15
16# Attach the interrupt to the pin, specifying the callback function and trigger type
17interrupt_pin.irq(trigger=Pin.IRQ_FALLING, handler=interrupt_callback)
18
19while True:
20    print("hello world")
21    time.sleep(1)

Copy
1variable = 5
2
3print("I am a string!") # prints a string
4print(variable) # prints value of variable
5print(58) # prints a numeric value
6print(f"The value is {variable}") # prints a string with a value inserted

Copy
1import machine
2import time
3
4uart = machine.UART(1, baudrate=57600)

Copy
1import machine
2import time
3
4uart = machine.UART(1, baudrate=57600)
5
6while True:
7    if uart.any():
8        print("data available")

Copy
1import machine
2import time
3
4
5uart = machine.UART(1, baudrate=57600) 
6received_data = ""
7
8while True:
9    if uart.any():
10        data = uart.read(1)
11        received_data += data
12    
13    if received_data and received_data[-1] == '\n':
14        print("Received:", received_data[:-1])  # Print the accumulated data (excluding the newline character)
15        received_data = ""  # Reset the string after printing
16    
17    time.sleep(0.1)

Copy
1import machine
2import time
3
4
5uart = machine.UART(1, baudrate=57600)  
6
7while True:
8    data_to_send = "Hello World!\n"
9    uart.write(data_to_send)
10    
11    time.sleep(1)

Copy
1import machine
2
3spi = machine.SPI(0, baudrate=1000000, polarity=0, phase=0)

Copy
1import machine
2import time
3
4spi = machine.SPI(0, baudrate=1000000, polarity=0, phase=0)
5data_in = bytearray(3)
6
7spi.readinto(data_in)
8
9print("Received Data:", data_in)

Copy
1import machine
2import time
3
4spi = machine.SPI(0, baudrate=1000000, polarity=0, phase=0) 
5data_out = b'\x01\x02\x03'
6
7spi.write(data_out)

Copy
1import machine
2import time
3
4spi = machine.SPI(0, baudrate=1000000, polarity=0, phase=0)
5
6data_to_send = b'\x01\x02\x03'
7
8data_received = bytearray(len(data_to_send))
9
10spi.write_readinto(data_to_send, data_received)
11
12print("Received Data:", data_received)
13
14spi.deinit()

Copy
1spi.bits = 8

Copy
1from machine import I2C
2
3i2c = I2C(0, scl=Pin(SCL_PIN), sda=Pin(SDA_PIN), freq=100000)

Copy
1available_bytes = i2c.in_waiting()
2
3print("Available bytes to read: ", available_bytes)

Copy
1data_in = i2c.readfrom(address, num_bytes)
2
3print("I2C data: ", data_in)

Copy
1from machine import I2C, Pin
2
3# Initialize I2C anc configure device & reg addresses
4i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=100000)  # Adjust pins and frequency as needed
5device_address = 0x68
6register_address = 0x00
7
8# The array of bytes to be send out
9# This buffer simply stores 1,2,3,4
10data_out = bytearray([0x01, 0x02, 0x03, 0x04])
11
12# Send the device address with the write bit to indicate a write operation
13i2c.writeto(device_address, bytearray([register_address]))
14
15# Finally, send data to the device
16i2c.writeto(device_address, data_out)

Copy
1var_array = [1, 2, 3]
2var_bool = True/False
3var_unsigned_byte = 255
4var_signed_byte = -128
5var_char = 'A'
6var_double = 3.14
7var_float = 29.231232
8var_int = 2147483647
9var_long = 2147483647
10var_short = 32767
11var_string = "This is a string"
12var_unsigned_int = 4294967295
13var_unsigned_long = 4294967295

Copy
1my_array = [1,2,3,4,5]
2
3array_size = len(my_array)
4
5print("Size of array is: ", array_size)

Copy
1def my_function():
2    print("Function executed, nothing returned though!")

Copy
1my_byte = bytes([255])
2print(my_byte) # prints \xff which in hex is 255

Copy
1value = 65  # 65 is "A" in ASCII code
2char_value = chr(value) # converts a value to char (65 to "A")
3print("Char value:", char_value) # prints "A"

Copy
1value = 25
2float_value = float(value)
3print("Float value:", float_value) # prints 25.0

Copy
1value = "3.14"
2float_value = float(value)
3print("Float value:", float_value) #prints 3.14

Copy
1value = 42.232
2int_value = int(value)
3print("Int value:", int_value)

Copy
1value = "42"
2int_value = int(value)
3print("Int value:", int_value)

Copy
1global_var = 0 #initial value
2
3def my_function():
4    local_var = 10 # declare local variable
5    print()
6    print("(inside function) local_var is: ", local_var)
7
8    global_var = local_var + 25
9    print("(inside function) global_var is updated to: ", global_var)
10
11    return global_var
12
13global_var = my_function() + 25
14print("(outside function) global_var is finally: ", global_var)
15
16'''
17The line below will cause the script to fail
18because it is not declared globally.
19'''
20#print(local_var)

Copy
1print("Hello World!")

Copy
1import time
2value = 0
3
4while True:
5    value += 1
6    print(value)
7    time.sleep(1)

Copy
1from machine import Pin
2
3output_pin = Pin(5, Pin.OUT)
4
5while True:
6    #loops forever

Copy
1x = 10
2if x > 5:
3    print("x is greater than 5")

Copy
1x = 5
2y = 10
3
4if x > y:
5    print("x is greater")
6else:
7    print("y is greater")

Copy
1for number in range(5):
2    print(number)

Copy
1my_list = [10, 20, 30, 40, 50]
2for item in my_list:
3    print(item)

Copy
1my_string = "Hello World!"
2for char in my_string:
3    print(char)

Copy
1i = 0
2while i < 5:
3    print(i)
4    i += 1

Copy
1while True:
2    # your program

Copy
1for i in range(5):
2    if i == 3:
3        break
4    print(i)

Copy
1my_list = [0, -5, -3, 8, 9 , 11]
2for num in my_list:
3    if num < 0:
4        continue
5    print(num)

Copy
1def add_numbers(a, b):
2    result = a + b
3    return result
4
5print(add_numbers(5,5))

Copy
1my_variable = 5 # the value of my_variable is now 5

Copy
1remainder = 5 % 10 # remainder is 5
2multiplication = 10 * 5 # result of multiplication is 50
3addition = 10 + 5 # result of addition is 15
4subtraction = 10 - 5 # result of subtraction is 5
5division = 10 / 5 # result of division is 2
6exponentiation = 10 ** 5 # result of exponentiation is 10000 (10*10*10*10*10)
7
8print("remainder:", remainder)
9print("multiplication:", multiplication)
10print("addition:", addition)
11print("subtraction:", subtraction)
12print("division:", division)
13print("exponentiation:", exponentiation)

Copy
1x = 10
2y = 5
3
4if x == y:
5    print("x is equal to y")
6else:
7    print("x is not equal to y")

Copy
1x = 10
2y = 5
3
4if x != y:
5    print("x is not equal to y")
6else: 
7    print("x is equal to y")

Copy
1x = 10
2y = 5
3
4if x <  y:
5    print("x is smaller than x")
6else:
7    print("x is not smaller than y")

Copy
1x = 10
2y = 5
3
4if x <= y:
5    print("x is smaller or equal to y")
6else:    
7    print("x is not smaller or equal to y")

Copy
1x = 10
2y = 5
3
4if x >  y:
5    print("x is greater than y")
6else:
7    print("x is not greater than y")

Copy
1x = 10
2y = 5
3
4if x >= y:
5    print("x is greater than or equal to y")
6else:
7    print("x is not greater than or equal to y")

Copy
1x = True
2
3if not x:
4    print("False")
5else:
6    print("True")

Copy
1x = 7
2
3if x > 5 and x < 10:
4    print("x is greater than 5 AND smaller than 10")