├── imagenes ├── ldr.png ├── pwm.png ├── button.png ├── checkfw.png ├── hcsr04.png ├── putty.jpg ├── webrepl.png ├── coolTerm.png ├── holamundo.png ├── blinknodemcu.png ├── puttyserial.png ├── upythonmac.png ├── analogentrada.png ├── nodemcudigital.png ├── optioncoolTerm.png ├── Thonny_flashing1.png ├── Thonny_flashing2.png ├── Thonny_flashing3.png ├── Thonny_flashing4.png ├── Thonny_flashing5.png ├── Thonny_flashing6.png ├── Thonny_stop_restart.png ├── Thonny_error_inicial.png ├── Thonny_opcion_flashear.png ├── Thonny_primer_inicio.png ├── Thonny_tools_options.png ├── Thonny_repl_funcionando.png ├── Thonny_seleccion_puerto.png ├── Thonny_seleccionar_esp32.png └── Thonny_seleccionar_imagen_bin.png ├── ejercicios ├── blink.py └── buttons.py ├── ejemplos ├── timers.py ├── interrupciones.py ├── polling.py └── polling_cronometros.py ├── ultrasonic.py └── README.md /imagenes/ldr.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/ldr.png -------------------------------------------------------------------------------- /imagenes/pwm.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/pwm.png -------------------------------------------------------------------------------- /imagenes/button.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/button.png -------------------------------------------------------------------------------- /imagenes/checkfw.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/checkfw.png -------------------------------------------------------------------------------- /imagenes/hcsr04.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/hcsr04.png -------------------------------------------------------------------------------- /imagenes/putty.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/putty.jpg -------------------------------------------------------------------------------- /imagenes/webrepl.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/webrepl.png -------------------------------------------------------------------------------- /imagenes/coolTerm.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/coolTerm.png -------------------------------------------------------------------------------- /imagenes/holamundo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/holamundo.png -------------------------------------------------------------------------------- /imagenes/blinknodemcu.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/blinknodemcu.png -------------------------------------------------------------------------------- /imagenes/puttyserial.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/puttyserial.png -------------------------------------------------------------------------------- /imagenes/upythonmac.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/upythonmac.png -------------------------------------------------------------------------------- /imagenes/analogentrada.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/analogentrada.png -------------------------------------------------------------------------------- /imagenes/nodemcudigital.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/nodemcudigital.png -------------------------------------------------------------------------------- /imagenes/optioncoolTerm.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/optioncoolTerm.png -------------------------------------------------------------------------------- /imagenes/Thonny_flashing1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/Thonny_flashing1.png -------------------------------------------------------------------------------- /imagenes/Thonny_flashing2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/Thonny_flashing2.png -------------------------------------------------------------------------------- /imagenes/Thonny_flashing3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/Thonny_flashing3.png -------------------------------------------------------------------------------- /imagenes/Thonny_flashing4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/Thonny_flashing4.png -------------------------------------------------------------------------------- /imagenes/Thonny_flashing5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/Thonny_flashing5.png -------------------------------------------------------------------------------- /imagenes/Thonny_flashing6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/Thonny_flashing6.png -------------------------------------------------------------------------------- /imagenes/Thonny_stop_restart.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/Thonny_stop_restart.png -------------------------------------------------------------------------------- /imagenes/Thonny_error_inicial.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/Thonny_error_inicial.png -------------------------------------------------------------------------------- /imagenes/Thonny_opcion_flashear.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/Thonny_opcion_flashear.png -------------------------------------------------------------------------------- /imagenes/Thonny_primer_inicio.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/Thonny_primer_inicio.png -------------------------------------------------------------------------------- /imagenes/Thonny_tools_options.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/Thonny_tools_options.png -------------------------------------------------------------------------------- /imagenes/Thonny_repl_funcionando.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/Thonny_repl_funcionando.png -------------------------------------------------------------------------------- /imagenes/Thonny_seleccion_puerto.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/Thonny_seleccion_puerto.png -------------------------------------------------------------------------------- /imagenes/Thonny_seleccionar_esp32.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/Thonny_seleccionar_esp32.png -------------------------------------------------------------------------------- /imagenes/Thonny_seleccionar_imagen_bin.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pythoncanarias/upython/HEAD/imagenes/Thonny_seleccionar_imagen_bin.png -------------------------------------------------------------------------------- /ejercicios/blink.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | import time 3 | 4 | led = Pin(16, Pin.OUT) 5 | 6 | while True: 7 | led.on() 8 | time.sleep(0.5) 9 | led.off() 10 | time.sleep(0.5) 11 | -------------------------------------------------------------------------------- /ejercicios/buttons.py: -------------------------------------------------------------------------------- 1 | from machine import Pin 2 | import time 3 | 4 | button = Pin(2, Pin.IN) 5 | led = Pin(16, Pin.OUT) 6 | 7 | while True: 8 | state = button.value() 9 | led.value(state) 10 | time.sleep(0.5) 11 | -------------------------------------------------------------------------------- /ejemplos/timers.py: -------------------------------------------------------------------------------- 1 | from machine import Timer 2 | 3 | 4 | tim = Timer(0) 5 | tim2 = Timer(1) 6 | tim.init(period=5000, mode=Timer.ONE_SHOT, callback=lambda t: print(1)) 7 | tim2.init(period=2000, mode=Timer.PERIODIC, callback=lambda t: print(2)) 8 | -------------------------------------------------------------------------------- /ejemplos/interrupciones.py: -------------------------------------------------------------------------------- 1 | import machine 2 | 3 | 4 | interruptCounter = 0 5 | totalInterruptsCounter = 0 6 | 7 | 8 | def callback(pin): 9 | global interruptCounter 10 | interruptCounter = interruptCounter+1 11 | led.value(not led.value()) 12 | 13 | 14 | p0 = machine.Pin(0, machine.Pin.IN, machine.Pin.PULL_UP) 15 | p0.irq(trigger=machine.Pin.IRQ_FALLING, handler=callback) 16 | 17 | PIN_LED = 5 # puede cambiar en cada placa 18 | led = machine.Pin(PIN_LED, machine.Pin.OUT) 19 | 20 | while True: 21 | if interruptCounter > 0: 22 | state = machine.disable_irq() 23 | interruptCounter = interruptCounter-1 24 | machine.enable_irq(state) 25 | 26 | totalInterruptsCounter = totalInterruptsCounter+1 27 | print("Interrupt has occurred: " + str(totalInterruptsCounter)) 28 | -------------------------------------------------------------------------------- /ejemplos/polling.py: -------------------------------------------------------------------------------- 1 | import time 2 | import machine 3 | """ dejamos el espacio de nombres sin "aplanar" 4 | es decir, NO hacemos: 5 | from machine import * """ 6 | 7 | 8 | class CuentaMs(): 9 | def __init__(self, ms): 10 | self.ms = ms 11 | self.reset() 12 | 13 | def reset(self): 14 | self.proximo = time.ticks_ms() + self.ms 15 | 16 | def comprueba(self): 17 | if self.proximo <= time.ticks_ms(): 18 | self.reset() 19 | return True 20 | else: 21 | return False 22 | 23 | 24 | PIN_LED = 16 # puede cambiar en cada placa 25 | led = machine.Pin(PIN_LED, machine.Pin.OUT) 26 | contador_ms = CuentaMs(500) 27 | 28 | while True: 29 | # hacemos el resto de tareas 30 | # ¿las insertamos aquí, o despues del if? 31 | if contador_ms.comprueba(): 32 | led.value(not led.value()) 33 | -------------------------------------------------------------------------------- /ejemplos/polling_cronometros.py: -------------------------------------------------------------------------------- 1 | import time 2 | import machine 3 | 4 | 5 | class CuentaMs(): 6 | def __init__(self, ms): 7 | self.ms = ms 8 | self.reset() 9 | 10 | def reset(self): 11 | self.proximo = time.ticks_ms() + self.ms 12 | 13 | def comprueba(self): 14 | if self.proximo <= time.ticks_ms(): 15 | self.reset() 16 | return True 17 | else: 18 | return False 19 | 20 | 21 | pin = [machine.Pin(14, machine.Pin.OUT), 22 | machine.Pin(12, machine.Pin.OUT), 23 | machine.Pin(13, machine.Pin.OUT)] 24 | 25 | contador_ms = [CuentaMs(1000), CuentaMs(2333), CuentaMs(1698)] 26 | 27 | while True: 28 | time.sleep(0.1) 29 | for i, e in enumerate(contador_ms): 30 | if e.comprueba(): 31 | pin[i].value(not pin[i].value()) 32 | print(" " * i, i, "ha pasado su tiempo") 33 | -------------------------------------------------------------------------------- /ultrasonic.py: -------------------------------------------------------------------------------- 1 | ## 2 | # Ultrasonic library for MicroPython's machineoard. 3 | # Compatible with HC-SR04 and SRF04. 4 | # 5 | # Copyright 2014 - Sergio Conde Gómez 6 | # Copyright 2017 - Lucas Grillo 7 | # - Víctor Suárez García 8 | # 9 | # This program is free software: you can redistribute it and/or modify 10 | # it under the terms of the GNU General Public License as published by 11 | # the Free Software Foundation, either version 3 of the License, or 12 | # (at your option) any later version. 13 | # 14 | # This program is distributed in the hope that it will be useful, 15 | # but WITHOUT ANY WARRANTY; without even the implied warranty of 16 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 | # GNU General Public License for more details. 18 | # 19 | # You should have received a copy of the GNU General Public License 20 | # along with this program. If not, see . 21 | # 22 | # Improved to ESP8266 with MicroPython 23 | ## 24 | 25 | import machine 26 | import time 27 | 28 | # Pin configuration. 29 | # WARNING: Do not use PA4-X5 or PA5-X6 as the echo pin without a 1k resistor. 30 | 31 | 32 | class Ultrasonic: 33 | def __init__(self, tPin, ePin): 34 | self.triggerPin = tPin 35 | self.echoPin = ePin 36 | 37 | # Init trigger pin (out) 38 | self.trigger = machine.Pin(self.triggerPin) 39 | self.trigger.init(machine.Pin.OUT) 40 | self.trigger.off() 41 | 42 | # Init echo pin (in) 43 | self.echo = machine.Pin(self.echoPin) 44 | self.echo.init(machine.Pin.IN) 45 | 46 | def distance_in_inches(self): 47 | return (self.distance_in_cm() * 0.3937) 48 | 49 | def distance_in_cm(self): 50 | start = 0 51 | end = 0 52 | 53 | # Create a microseconds counter. 54 | start = time.ticks_us() 55 | 56 | # Send a 10us pulse. 57 | self.trigger.on() 58 | time.sleep_us(20) 59 | self.trigger.off() 60 | 61 | # Wait 'till whe pulse starts. 62 | while self.echo.value() == 0: 63 | start = time.ticks_us() 64 | 65 | # Wait 'till the pulse is gone. 66 | while self.echo.value() == 1: 67 | end = time.ticks_us() 68 | 69 | # Calc the duration of the recieved pulse, divide the result by 70 | # 2 (round-trip) and divide it by 29 (the speed of sound is 71 | # 340 m/s and that is 29 us/cm). 72 | dist_in_cm = ((end - start) / 2) / 29 73 | 74 | return dist_in_cm 75 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # upython 2 | 3 | Curso sobre _MicroPython_ del día 26 de mayo 2019. 4 | 5 | ## Contenidos del curso 6 | 7 | * [Qué es MicroPython](#qué-es-micropython) 8 | * [Pasos Previos](#pasos-previos) 9 | * [Primeros pasos con MicroPython](#primeros-pasos) 10 | * [Ejemplos del curso de Gran Canaria](#ejemplos-del-curso-de-gc) 11 | * [Entrada/Salida Digital](#entradasalida-digital) 12 | * [Entrada/Salida Analógica](#entradasalida-analogica) 13 | * [Sensores](#sensores) 14 | * [ESP8266](#esp8266) 15 | * [Proyecto Final](#proyecto-final) 16 | * [Pinout de NodeMCU](#pinout-del-nodemcu) 17 | 18 | ## Qué es Micropython 19 | 20 | _MicroPython_ es una implementación software del lenguaje de programación Python 3, escrita en C, y que está optimizada para poder ejecutarse en un microcontrolador. _MicroPython_ es un compilador completo del lenguaje Python y un motor e intérprete en tiempo de ejecución, que funciona en el hardware del microcontrolador. 21 | 22 | Al usuario se le presenta una línea de órdenes interactiva (el REPL) que soporta la ejecución inmediata de órdenes. Se incluye una selección de bibliotecas fundamentales de Python: _MicroPython_ incluye módulos que permiten al programador el acceso al hardware en bajo nivel. 23 | 24 | _MicroPython_ permite ser ejecutado en distintas placas con diferentes microcontroladores. En nuestro caso, utilizaremos la placa NodeMCU con el microcontrolador ESP32. Puedes usar de manera muy parecida la placa más económica ESP8266, igualmente válida para apredizaje y proyectos de pequeña envergadura. 25 | 26 | Para saber qué placas son compatibles, consulta la [documentación oficial](http://docs.micropython.org). 27 | 28 | ## Pasos Previos 29 | 30 | Antes de poder instalar _MicroPython_, necesitaremos tener instalado Python 3.6 o superior. 31 | 32 | ### Instalación 33 | 34 | #### Linux y MacOS 35 | 36 | Utilizando la herramienta _pip_ instalamos todo lo necesario en un solo paso. Esto es posible porque el editor de aprendizaje _Thonny_ realiza en un solo paso todo lo necesario para empezar, resolviendo por nosotros los problemas iniciales. Frente a todas estas ventajas, como inconveniente el editor _Thonny_ sólo está en idioma inglés, pero Python Canaria está en proceso de traducirlo para toda la comunidad hispanohablante, así que cuando leas esto gran parte del editor podría estar ya en castellano. 37 | 38 | Cuando tengamos más soltura, podemos pasar a nuestro editor habitual sin problema, pero habremos ahorrado mucho tiempo en el proceso, para la curva de aprendizaje inicial. 39 | 40 | Para instalar el editor _Thonny_, debemos comprobar que la versión de python que estamos ejecutando es la 3: 41 | 42 | ```bash 43 | $ python --version 44 | Python 2.7.15rc1 45 | 46 | ``` 47 | Si no lo es, actuaremos en consecuencia. Por ejemplo: 48 | ```bash 49 | $ python3 --version 50 | Python 3.6.7 51 | 52 | ``` 53 | 54 | Y procederemos a la instalación: 55 | 56 | ```bash 57 | $ python3 -m pip install thonny-esp 58 | 59 | ``` 60 | 61 | Alternativamente, y si *python3* no es una orden reconocida por el sistema, pero nuestra versión de python es la 3, podemos probar: 62 | 63 | ```bash 64 | $ python -m pip install thonny-esp 65 | 66 | ``` 67 | 68 | Ahora tenemos dos posibilidades: o bien ejecutamos directamente el editor mediante la orden "thonny" o bien, si este procedimiento falla, mediante python. 69 | 70 | ```bash 71 | $ thonny & 72 | 73 | ``` 74 | 75 | o alternativamente: 76 | 77 | ```bash 78 | $ python -m thonny & 79 | 80 | ``` 81 | 82 | #### MacOs 83 | 84 | En MacOs la operación es la misma. Sin embargo, en caso de no tener el chip de comunicación CP2102, debemos instalar los drivers del chip alternativo USB CH340/CH341. Los podemos descargar [aquí](http://www.mblock.cc/docs/run-makeblock-ch340-ch341-on-mac-os-sierra/). 85 | 86 | Una vez instalado, ya podremos ver el puerto serie en nuestro sistema. 87 | 88 | El resto de pasos se realizan de igual forma que para Linux. 89 | 90 | ![upythonlinux](imagenes/Thonny_primer_inicio.png) 91 | 92 | #### Windows 93 | 94 | Para windows, en caso de no tener el chip de comunicación CP2102, también debemos instalar los drivers CH340/CH341; los podemos encontrar en la web del [fabricante](http://www.wch.cn/download/CH341SER_EXE.html). 95 | 96 | Luego hay que ejecutar el Windows Power Shell (o su equivalente en las nuevas versiones) y dentro de él las órdenes conocidas para las otras plataformas. Primero comprobamos que tenemos Python 3: 97 | 98 | ```bash 99 | $ python --version 100 | Python 3.6.7 101 | 102 | ``` 103 | De no ser así, tomaremos las medidas necesarias para conseguir tener instalado Python 3 y en condiciones de ejecutarse. Luego procederemos a instalar todo el sistema de aprendizaje en una sola orden: 104 | 105 | ```bash 106 | $ python -m pip install thonny-esp 107 | 108 | ``` 109 | Una vez instalado el entorno de aprendizaje, seguiremos los mismos pasos que con Linux, especificando el puerto COM correspondiente dentro del editor _Thonny_, como veremos posteriormente. 110 | 111 | En el caso de Windows, ejecutaremos el editor _Thonny_ indirectamente mediante python: 112 | 113 | ```bash 114 | $ python -m thonny 115 | 116 | ``` 117 | 118 | ### Obtención del firmware de MicroPython 119 | 120 | Para poder instalar _MicroPython_, descargaremos el firmware de la [Página oficial](http://micropython.org/download#esp32) (Descargar el firmware para el chip correspondiente al ESP32). Una vez descargado, instalaremos las herramientas necesarias para _flashear_ el chip con el firmware de _MicroPython_. Lo instalaremos desde dentro del editor _Thonny_. 121 | 122 | ### Instalación del firmware 123 | 124 | Tanto en Windows como en Linux/MacOs, seguiremos este procedimiento. 125 | 126 | Antes de comenzar, conectamos la placa al PC por un puerto USB, abrimos un terminal y ejecutamos: 127 | 128 | ```bash 129 | $ thonny & 130 | 131 | ``` 132 | 133 | o alternativamente: 134 | 135 | ```bash 136 | $ python -m thonny & 137 | 138 | ``` 139 | 140 | Nos aparecerá una primera instancia del editor _Thonny_ con el intérprete de órdenes de Python que tengamos por defecto de nuestro sistema, en la parte inferior: 141 | 142 | ![thonnyinicio](imagenes/Thonny_tools_options.png) 143 | 144 | Podemos utilizar este editor para todas las operaciones básicas sin salirnos de él hasta que no cobremos más confianza, reduciendo de este modo los tiempos de instalación y la curva de aprendizaje inicial. Recuerde que es conveniente ejecutar Thonny con la placa ya conectada. 145 | 146 | En primer lugar seleccionaremos la opción _Options_ del menú _Tools_, y una vez dentro de ella, podremos en primer plano la pestaña _Interpreter_. 147 | Gracias a la orden única de instalación que hemos ejecutado, todos los programas y módulos necesarios para la comunicación se han instalado automáticamente. Tan sólo es necesario seleccionar aquí la placa ESP32, o en su defecto la ESP8266, ya que el procedimiento esra el mismo: 148 | 149 | ![thonnyseleccionesp](imagenes/Thonny_seleccionar_esp32.png) 150 | 151 | 152 | Una vez hecho esto, y sin salirnos de esta pestaña, tenemos un segundo menú desplegable más abajo, que nos permite seleccionar el puerto. Si observamos con detenimiento, veremos que una de las opciones es parecida a `CP2104 USB to UART Bridge Controller (/dev/ttyUSB0)`, es decir, que debido a que ya hemos conectado la placa antes de ejecutar _Thonny_, debería aparecernos una opción semejante: 153 | 154 | ![thonnyseleccionpuerto](imagenes/Thonny_seleccion_puerto.png) 155 | 156 | Ahora ya podemos pulsar OK y salirnos al programa principal. Observaremos que si nuestra placa no tiene ya el firmware de MicroPython, aparecerá un mensaje de error: 157 | 158 | ![thonnyerrorinicial](imagenes/Thonny_error_inicial.png) 159 | 160 | Debido a que ya tenemos seleccionado el puerto, podemos proceder a subir a la placa ESP32 el firmware de _MicroPython_. Para poder instalar _MicroPython_, descargaremos el firmware de la [Página oficial](http://micropython.org/download#esp32) (Descargar el firmware para el chip correspondiente al ESP32). 161 | En el momento de realizar este tutorial, la última versión se podía obtener del [siguiente enlace](http://micropython.org/resources/firmware/esp32-ppp-fix.bin). 162 | 163 | La guardamos en un lugar conocido (por ejemplo, el directorio estándar de descargas para el navegador) y, con la placa conectada y detectada, seleccionamos la opción de subir el firmware a la placa desde dentro de _Thonny_. Para ello debemos elegir el menú _Device_ y dentro de él la opción _Install MicroPython to ESP8266/ESP32_: 164 | 165 | ![thonnyelegirflashear](imagenes/Thonny_opcion_flashear.png) 166 | 167 | Y buscamos el lugar donde está disponible el firmware que nos hemos bajado. Elegimos el fichero, que tendrá la extensión `.bin`, y pulsamos aceptar: 168 | 169 | ![thonnyelegirbin](imagenes/Thonny_seleccionar_imagen_bin.png) 170 | 171 | Automáticamente comenzará el proceso de flasheo de la placa, si ésta está conectada. En algunos casos puede ser necesario pulsar un botón en la placa: 172 | 173 | ![thonnyflashing1](imagenes/Thonny_flashing1.png) 174 | 175 | 176 | ![thonnyflashing4](imagenes/Thonny_flashing4.png) 177 | 178 | 179 | ![thonnyflashing5](imagenes/Thonny_flashing5.png) 180 | 181 | Pulsamos el botón "`OK`" y en el menú _Run_ seleccionamos _Stop/Restart Backend_: 182 | 183 | ![thonnystoprestart](imagenes/Thonny_stop_restart.png) 184 | 185 | Y mágicamente tenemos una interfaz REPL Python (si falla, tendrás que reiniciar _Thonny_), pero lo más normal es que obtengamos directamente control sobre la placa a través del teclado en la ventana inferior: 186 | 187 | ![thonnyreplfuncionando](imagenes/Thonny_repl_funcionando.png) 188 | 189 | Ahora llevamos el cursor a donde está el signo `>>>` de intérprete de ordenes de _MicroPython_ en la ventana inferior de _Thonny_, y escribimos algunas órdenes: 190 | 191 | ```bash 192 | >>> import sys 193 | >>> sys.version 194 | '3.4.0' 195 | 196 | ``` 197 | ¡Enhorabuena! Hemos terminado nuestra instalación y primeros pasos de _MicroPython_. 198 | 199 | ### Avanzado: herramientas de terminal 200 | 201 | Puede ignorar este apartado, ya que haremos la conexión desde dentro de _Thonny_. Sin embargo, para usuarios avanzados, explicaremos brevemente las opciones de que disponen. 202 | 203 | #### Linux 204 | 205 | * picocom 206 | * minicom 207 | 208 | ##### Usando *picocom* 209 | 210 | ```bash 211 | picocom /dev/ttyUSB0 -b 115200 212 | ``` 213 | * Control-a Control-x SALIR 214 | * Control-a Control-c LOCAL ECHO 215 | * Control-d NODEMCU SOFT REBOOT 216 | 217 | 218 | #### MacOS 219 | 220 | Para conectarnos a la placa, usaremos _coolTerm_. 221 | 222 | ##### CoolTerm 223 | 224 | Para descargar CoolTerm Puede hacerse desde el siguiente [enlace](http://freeware.the-meiers.org/CoolTermMac.zip) 225 | 226 | Una vez descargado e instalado, se configurará el puerto a utilizar; pulsando en el botón _Options_. 227 | 228 | ![opcionesCoolTerm](imagenes/optioncoolTerm.png) 229 | 230 | Una vez configurado el puerto (con el que nos aparece en nuestro MAC) y configurado el baudrate a _115200_. Pulsaremos OK y al botón _connect_. Apareciendo el promt de Python. 231 | 232 | ![coolTerm](imagenes/coolTerm.png) 233 | 234 | #### Windows 235 | 236 | Para poder conectarnos via serial a nuestra placa NodeMCU, utilizaremos el famoso programa Putty; el cual podemos descargarnos [aquí](http://www.putty.org) 237 | 238 | Una vez descargado el programa lo abriremos y seleccionaremos la conexion por serial. 239 | 240 | ![putty](imagenes/putty.jpg) 241 | 242 | En la dirección escribiremos el puerto al que nos conectaremos (COMX) y en la velocidad pondremos 11520. 243 | 244 | Si requeririeramos una configuración mayor podemos ir al apartado serial y configurar nuestra placa. 245 | 246 | ![puttyserial](imagenes/puttyserial.png) 247 | 248 | Una vez hecho esto, ya podemos continuar trabajando con nuestra placa. 249 | 250 | ### Otros IDES 251 | 252 | Además de utilizar estas herramientas para conectarnos, podemos usar algunos IDES como _Thonny_ (el que usamos en esta documentación) o _Pycharm_: 253 | 254 | **Pycharm Plugin de MicroPython** 255 | 256 | Podemos usar un plugin para _pycharm_ para conectar con nuestra placa ESP y trabajar con _MicroPython_. 257 | 258 | Puede verse más información en este [enlace](https://blog.jetbrains.com/pycharm/2018/01/micropython-plugin-for-pycharm/) 259 | 260 | ![pycharmupython](https://d3nmt5vlzunoa1.cloudfront.net/pycharm/files/2018/01/image6.png) 261 | 262 | 263 | ## Primeros Pasos 264 | 265 | Una vez tengamos ya _MicroPython_, usaremos la consola serie integrada en el editor _Thonny_ para mandar las instrucciones Python; de forma que podremos ejecutar nuestro código python en el ESP32. 266 | 267 | ![holamundo](imagenes/holamundo.png) 268 | 269 | Podemos comprobar la version y el estado de nuestro firmware con el siguiente código. 270 | 271 | ```python 272 | 273 | import esp 274 | esp.check_fw() 275 | 276 | ``` 277 | 278 | ![checkfw](imagenes/checkfw.png) 279 | 280 | ## Ejemplos del curso de GC 281 | 282 | 283 | ### Control del tiempo por polling 284 | ```python 285 | import time, machine 286 | # dejamos el espacio de nombres sin "aplanar" 287 | # es decir, NO hacemos: 288 | # from machine import * 289 | class CuentaMs(): 290 | def __init__(self, ms): 291 | self.ms = ms 292 | self.reset() 293 | def reset(self): 294 | self.proximo = time.ticks_ms() + self.ms 295 | def comprueba(self): 296 | if self.proximo <= time.ticks_ms(): 297 | self.reset() 298 | return True 299 | else: 300 | return False 301 | 302 | PIN_LED = 16 # puede cambiar en cada placa 303 | led = machine.Pin(PIN_LED, machine.Pin.OUT) 304 | contador_ms = CuentaMs(500) 305 | 306 | while True: 307 | # hacemos el resto de tareas 308 | # las insertamos aquí, o despues del if? 309 | if contador_ms.comprueba(): 310 | led.value(not led.value()) 311 | ``` 312 | 313 | ### Control del tiempo por polling, 3 cronómetros diferentes 314 | 315 | ```python 316 | import time, machine 317 | class CuentaMs(): 318 | def __init__(self, ms): 319 | self.ms = ms 320 | self.reset() 321 | def reset(self): 322 | self.proximo = time.ticks_ms() + self.ms 323 | def comprueba(self): 324 | if self.proximo <= time.ticks_ms(): 325 | self.reset() 326 | return True 327 | else: 328 | return False 329 | 330 | pin = [machine.Pin(14, machine.Pin.OUT), machine.Pin(12, machine.Pin.OUT), machine.Pin(13, machine.Pin.OUT)] 331 | 332 | contador_ms = [CuentaMs(1000), CuentaMs(2333), CuentaMs(1698)] 333 | 334 | while True: 335 | time.sleep(0.1) 336 | for i, e in enumerate(contador_ms): 337 | if e.comprueba(): 338 | pin[i].value(not pin[i].value()) 339 | print(" "* i, i, "ha pasado su tiempo") 340 | ``` 341 | ### Funcionamiento de dos timers, uno repetido y otro momentáneo 342 | 343 | ```python 344 | from machine import Timer 345 | 346 | tim = Timer(0) 347 | tim2 = Timer(1) 348 | tim.init(period=5000, mode=Timer.ONE_SHOT, callback=lambda t:print(1)) 349 | tim2.init(period=2000, mode=Timer.PERIODIC, callback=lambda t:print(2)) 350 | ``` 351 | 352 | ### Control de las tareas por interrupciones 353 | ```python 354 | import machine 355 | 356 | interruptCounter = 0 357 | totalInterruptsCounter = 0 358 | 359 | def callback(pin): 360 | global interruptCounter 361 | interruptCounter = interruptCounter+1 362 | led.value(not led.value()) 363 | 364 | p0 = machine.Pin(0, machine.Pin.IN, machine.Pin.PULL_UP) 365 | p0.irq(trigger=machine.Pin.IRQ_FALLING, handler=callback) 366 | 367 | PIN_LED = 5 # puede cambiar en cada placa 368 | led = machine.Pin(PIN_LED, machine.Pin.OUT) 369 | 370 | while True: 371 | 372 | if interruptCounter>0: 373 | 374 | state = machine.disable_irq() 375 | interruptCounter = interruptCounter-1 376 | machine.enable_irq(state) 377 | 378 | totalInterruptsCounter = totalInterruptsCounter+1 379 | print("Interrupt has occurred: " + str(totalInterruptsCounter)) 380 | ``` 381 | 382 | ## Entrada/salida Digital 383 | 384 | Lo principal a la hora de trabajar con electrónica, es poder utilizar las entradas/salidas digitales que nos proveen los distintos microcontroladores; es por esto que micropython permite trabajar con entradas/salidas digitales. 385 | 386 | Una entrada/salida digital, permite mandar o recibir un pulso binario es decir, un 0 o un 1, apagado o encendido. 387 | 388 | Otros aspecto importante es saber que es una entrada o una salida con respecto a electrónica. 389 | 390 | * Una entrada es un puerto que permite recibir una señal. 391 | 392 | * Una salida es un puerto que permite lanzar una señal. 393 | 394 | En la placa NodeMCU que utilizamos en este curso, podemos ver que tiene una serie de salidas digitales que van desde el 0 al 8; que son las cuales tienen una D al lado. 395 | 396 | ![nodeMCUdigital](imagenes/nodemcudigital.png) 397 | 398 | **NOTA**: A parte de estas entradas/salidas MicroPython permite utilizar otras entradas/salidas como digitales. 399 | 400 | Para poder realizar esto, tenemos que saber la configuración de nuestra placa. En nuestro caso la NodeMCU; ya que micropython, no utiliza la misma nomenclatura que nuestra placa. 401 | 402 | Micropython utiliza los GPIO de la placa para poder saber a qué puerto utilizar. 403 | 404 | Para saber que puerto utilizar consultar el [Pinout de la NodeMCU](#pinout-del-nodemcu) 405 | 406 | Por ejemplo, para usar el puerto D0, tenemos que usar el GPIO16. 407 | 408 | Para poder usar los distintos puertos, tenemos que instanciar un objeto de la clase _Pin_. 409 | 410 | ```python 411 | import machine 412 | 413 | pin = machine.Pin(16) 414 | ``` 415 | 416 | Otro aspecto a tener en cuenta es definir si el puerto será de entrada o de salida. 417 | 418 | * Si es de salida, utilizaremos la constante _OUT_. 419 | * Si es de entrada, utilizaremos la constante _IN_, seguido de la constante _PULL_UP_; la cual activa una resistencia interna para evitar cortocirtuitos. 420 | 421 | **NOTA**: Una resistencia PULL_UP, permite evitar falsos positivos ya que permite dar un valor erroneo a la hora de utilizar las entradas o salidas. 422 | 423 | ```python 424 | from machine import Pin 425 | 426 | pout= Pin(16,Pin.OUT) 427 | pin= Pin(4,Pin.IN,Pin.PULL_UP) 428 | ``` 429 | Sabiendo esto, ya podemos crear nuestro primer montaje, comunmente conocido como Blink u Hola Mundo. 430 | 431 | ### Primer Ejercicio: El Blink 432 | 433 | Este primer montaje hará que un led parpadee. 434 | 435 | Para este montaje necesitaremos: 436 | 437 | * 1 NodeMCU 438 | * 1 Led 439 | * 1 resistencia 220 Ohmios 440 | * cable de conexion. 441 | * cable MicroUsb. 442 | 443 | **Ejemplo del Blink** 444 | 445 | 446 | ![blink](imagenes/blinknodemcu.png) 447 | 448 | Código: 449 | 450 | ```python 451 | from machine import Pin 452 | import time 453 | led=Pin(16,Pin.OUT) 454 | 455 | while True: 456 | led.on() 457 | time.sleep(0.5) 458 | led.off() 459 | time.sleep(0.5) 460 | ``` 461 | En el ejemplo anterior, vemos que creamos un objeto de la clase Pin que asignamos al GPIO16, correspondiente al puerto D0 en modo salida. 462 | 463 | Usando la función ```on()``` u ```off()``` podemos apagar o encender el led. 464 | 465 | Este es un ejemplo de salida digital; seguidamente mostraremos un ejemplo de entrada digital. En este caso, el uso de pulsadores. 466 | 467 | **NOTA:** La función ```sleep()``` del módulo ```time``` hace que se espere el tiempo pasado por parámetro en segundos. 468 | 469 | ### Segundo Ejercicio: Pulsadores 470 | 471 | Un pulsador es un ejemplo de entrada digital; ya que permite mandar un pulso (1) o ausencia de él (0); a partir de pulsarlo o no. 472 | 473 | Para este montaje necesitaremos: 474 | 475 | * 1 NodeMCU 476 | * 1 pulsador 477 | * 2 Resistencias 220 Ohmios 478 | * 1 led 479 | * cables de conexión 480 | * cable microUsb. 481 | 482 | **Ejemplo de Pulsadores** 483 | 484 | 485 | ![pulsadores](imagenes/button.png) 486 | 487 | Código: 488 | 489 | ```python 490 | from machine import Pin 491 | import time 492 | 493 | button=Pin(2,Pin.IN) 494 | led=Pin(16,Pin.OUT) 495 | 496 | while True: 497 | state=button.value() 498 | led.value(state) 499 | time.sleep(0.5) 500 | 501 | 502 | ``` 503 | En este ejemplo, definimos 2 Pines de forma que uno es de entrada y otro de salida. En función del valor del primer led, encendemos o no el segundo. 504 | 505 | 506 | ## Entrada/Salida Analogica 507 | 508 | Una vez vistos las entrada y salidas digitales, pasaremos a ver las analógicas; de forma que podamos mandar un valor distintos de 0 o 1. 509 | 510 | En el caso del ESP8266, como otros tantos MicroControladores, nos permite mandar o recibir valores analógicos. 511 | 512 | ### Tercer Ejecicio: Entradas Analógicas 513 | 514 | La NodeMCU, permite recibir datos analógicos a través de un ADC (Analog DIgital Converter); de manera que toma el valor analógico y lo trasnforma a digital de forma que obtiene una serie de niveles de voltaje en función del valor obtenido. 515 | 516 | Por eso utilizaremos la clase _ADC_; que nos permite leer de una de las entradas analógicas. 517 | 518 | ```python 519 | from machine import ADC 520 | 521 | adc= ADC(0) 522 | 523 | adc.read() 524 | ``` 525 | 526 | Con este código, podemos leer de una entrada analógica; en este caso la 0(la NodeMCU solo tiene una entrada analógica). 527 | 528 | En el caso de la NodeMCU tiene un ADC de manera que tiene una precisión de 10 bits. Esto quiere decir, que podemos detectar cambios de valores de entre 0 y 1023. 529 | 530 | Para realizar este montaje: 531 | 532 | * 1 NodeMCU 533 | * 1 Potenciometro 534 | * Cables de Conexión 535 | * Cable MicroUSB. 536 | 537 | **Ejemplo de lectura Analógica** 538 | 539 | ![analogentrada](imagenes/analogentrada.png) 540 | 541 | Código 542 | 543 | ```python 544 | 545 | from machine import ADC 546 | 547 | adc = ADC(0) 548 | 549 | while True: 550 | print(adc.read()) 551 | 552 | ``` 553 | 554 | **NOTA:** Para parar la ejecución, pulsaremos control+c. 555 | 556 | ### Cuarto Ejercicio: PWM 557 | 558 | A la hora de utilizar las salidas analógicas, tenemos que saber que en la NodeMCU utiliza el llamado PWM. 559 | 560 | El _PWM_(Pulse Width Modulation) es una ténica en la que se modifica el ciclo de trabajo de una señal periodica para transimitir información a través de un canal de comunicaciones o enviar una cantidad de energia. 561 | 562 | Esto nos permite simular una salida analogica a través de un sistema digital. Modificando el ciclo de trabajo en un determinado tiempo para poder medir la cantidad de energía enviada. 563 | 564 | ![graficopwm](https://upload.wikimedia.org/wikipedia/commons/thumb/8/8e/PWM%2C_3-level.svg/350px-PWM%2C_3-level.svg.png) 565 | 566 | En la NodeMCU tenemos 10 bits de precision por lo que podremos sacar un valor de 0 a 1023. Esto nos permitira por ejemplo, cambiar la intensidad del brillo de un led; cambiando el nivel de voltaje de este. 567 | 568 | Seguidamente veremos un ejemplo de como cambiar la intensidad de un led. 569 | 570 | Para este ejercicio necesitaremos: 571 | 572 | * 1 NodeMCU 573 | * 1 led 574 | * 1 resistencia de 220Ohmios 575 | 576 | ![pwm](imagenes/pwm.png) 577 | 578 | ```python 579 | import machine 580 | 581 | pwm=machine.PWM(machine.Pin(5)) 582 | pwm.freq(60) 583 | 584 | while True: 585 | for i in range(1024): 586 | pwm.duty(i) 587 | 588 | ``` 589 | 590 | **NOTA**: No se puede utilizar como PWM la salida digital 0 (GPIO16). 591 | 592 | ### Quinto Ejercicio: Entrada y salida Analógica 593 | 594 | Una vez hemos visto como se utiliza por un lado la entrada analógica y por otro la salida analógica vamos a combinarlos para cambiar la intensidad de un led con una resistencia LDR o fotoresistencia. 595 | 596 | Una fotoresistencia o LDR, es una resistencia que cambia de valor con respecto a la luz que reciba. 597 | 598 | 599 | Para este ejercicio necesitaremos: 600 | 601 | * 1 NodeMCU 602 | * 2 Resistencias de 220Ohmios 603 | * 1 Fotoresistencia 604 | * cables de conexión 605 | 606 | ![ldr](imagenes/ldr.png) 607 | 608 | 609 | ```python 610 | 611 | from machine import Pin,PWM,ADC 612 | led=Pin(2) 613 | led.on() 614 | adc=ADC(0) 615 | pwm=PWM(led) 616 | pwm.freq(60) 617 | while True: 618 | pwm.duty(adc.read()) 619 | 620 | ``` 621 | 622 | ## Sexto Ejercicio: Sensores 623 | 624 | MicroPython permite trabajar con distintos tipos de sensores los cuales podemos utilizar tanto por librerias propias, como utilizando distintos protocolos como el I2C o en SPI. 625 | 626 | En nuestro caso, vamos a usar un sensor HC-SR04 de ultrasonidos el cual permite medir distancias utilizando pulsos de ultrasonidos. 627 | 628 | Para poder utilizar este sensor usaremos la librería modificada para el ESP8266 [ultrasonic](ultrasonic.py) 629 | 630 | Por lo que en primer lugar nos descargaremos la librería. 631 | 632 | Una vez decargada, necesitaremos subirlo al microcontrolador por lo que utilizaremos el programa mpfshell para poder subir a la placa. 633 | 634 | ### Subida de ficheros con [mpfshell](#referencias) 635 | 636 | Para subir ficheros con mpfshell en primer lugar lo instalaremos usando pip. 637 | 638 | ```bash 639 | $pip install mpfshell 640 | ``` 641 | 642 | Una vez instalado, usaremos este programa para subir el fichero de la librería. 643 | 644 | ```bash 645 | mpfshell tty.USB0 -c "put ultrasonic.py" 646 | ``` 647 | 648 | 649 | ![hcsr04](imagenes/hcsr04.png) 650 | 651 | ```python 652 | from ultrasonic import Ultrasonic 653 | 654 | ultra = Ultrasonic(4,0) 655 | 656 | while True: 657 | print(ultra.distance_in_cm()) 658 | 659 | ``` 660 | 661 | ## ESP8266 662 | 663 | Como hemos mencionado anteriormente, en la placa NodeMCU está presente un Chip ESP8266 que tiene unas cracterísticas especificas de las que carecen otros microcontroladores, como por ejemplo el poder unirnos a una red Wifi o crear un punto de acceso. 664 | 665 | ### Conectarse a una Wifi 666 | 667 | El ESP8266 permite tanto conectarse a una wifi, como crear una wifi y tener un punto de acceso. 668 | 669 | Para conectar a un punto de acceso podemos usar el módulo ```network```: 670 | 671 | ```python 672 | import network 673 | 674 | sta_if = network.WLAN(network.STA_IF) 675 | sta_if.active(True) 676 | sta_if.connect("SSID","PASSWORD") 677 | sta_if.isconnected() 678 | ``` 679 | 680 | **Ejemplo conexion externa** 681 | 682 | ```python 683 | import network 684 | import socket 685 | 686 | 687 | sta_if = network.WLAN(network.STA_IF) 688 | sta_if.active(True) 689 | sta_if.connect("SSID","PASSWORD") 690 | sta_if.isconnected() 691 | 692 | addr_info = socket.getaddrinfo("towel.blinkenlights.nl", 23) 693 | 694 | addr = addr_info[0][-1] 695 | 696 | s = socket.socket() 697 | s.connect(addr) 698 | 699 | while True: 700 | data = s.recv(500) 701 | print(str(data, 'utf8'), end='') 702 | ``` 703 | 704 | [Más info](https://docs.micropython.org/en/latest/esp8266/esp8266/tutorial/network_tcp.html#star-wars-asciimation) 705 | 706 | 707 | 708 | ### Crear un punto de acceso 709 | 710 | Al igual que para conectarnos a un punto de acceso, podemos crear uno. Para ello usaremos el siguiente fragmento. 711 | 712 | ```python 713 | 714 | import network 715 | 716 | ap_if = network.WLAN(network.AP_IF) 717 | ap_if.active(True) 718 | ``` 719 | 720 | ### Crear un servidor Web 721 | 722 | Usando Un socket podemos crear un servidor web. 723 | 724 | ```python 725 | import machine 726 | pins = [machine.Pin(i, machine.Pin.IN) for i in (0, 2, 4, 5, 12, 13, 14, 15)] 727 | 728 | html = """ 729 | 730 | ESP8266 Pins 731 |

ESP8266 Pins

732 | %s
PinValue
733 | 734 | 735 | """ 736 | 737 | import socket 738 | addr = socket.getaddrinfo('0.0.0.0', 80)[0][-1] 739 | 740 | s = socket.socket() 741 | s.bind(addr) 742 | s.listen(1) 743 | 744 | print('listening on', addr) 745 | 746 | while True: 747 | cl, addr = s.accept() 748 | print('client connected from', addr) 749 | cl_file = cl.makefile('rwb', 0) 750 | while True: 751 | line = cl_file.readline() 752 | if not line or line == b'\r\n': 753 | break 754 | rows = ['%s%d' % (str(p), p.value()) for p in pins] 755 | response = html % '\n'.join(rows) 756 | cl.send(response) 757 | cl.close() 758 | ``` 759 | 760 | ### Funciones especificas del ESP8266 761 | 762 | El ESP8266 tiene funciones especificas que podemos utilizar. 763 | 764 | módulo ```esp```: 765 | 766 | ```esp.sleep_type([sleep_type])``` 767 | 768 | Obtiene o establece el modo ahorro de energia. 769 | 770 | * ```SLEEP_NONE``` - No establece el modo ahorro de energia. 771 | * ```SLEEP_MODEM``` - desactiva la wifi. 772 | * ```SLEEP_LIGHT``` - desactiva la wifi y el procesador. 773 | 774 | 775 | ```esp.deepsleep(time)``` 776 | 777 | Pone el circuito en modo ahorro de energia parando todos los circuitos incluido el procesador y temporizadores. Solo volvera al estado normal si se manda una señal por el GPIO16 (D0). 778 | 779 | 780 | 781 | ## WebREPL 782 | 783 | Hasta ahora, hemos estado trabajando usando la consola serial. Sin embargo, podemos usar una consola web que nos permitirá trabajar con el microcontrolador via wifi. 784 | 785 | Para esto, es necesario configurar el acceso a la consola WebREPL, activandolo y además configurando una contraseña. 786 | 787 | Para configurar el WebREPL, nos conectaremos a la placa por consola Serial, e introduciremos la siguiente instrucción: 788 | 789 | ```python 790 | import webrepl_setup 791 | ``` 792 | 793 | Tras esto, se nos preguntara si queremos activar el WebREPL, pulsando E (enable) para activarlo. 794 | 795 | Si por el contrario una vez conectado queremos iniciarla tendremos que introducir el siguiente codigo. 796 | 797 | ```python 798 | import webrepl 799 | 800 | webrepl.start() 801 | ``` 802 | 803 | Seguidamente nos preguntará por la contraseña que pondremos para entrar en la consola WebREPL. La cual introduciremos dos veces. 804 | 805 | Una vez finalizado, la placa se reiniciara y podremos entrar en la consola web. 806 | 807 | Si no hemos modificado nada por defecto la NodeMCU estará en modo AP(Acces Point) por lo que podremos conectarnos a una wifi llamada MicroPython-XXX. Esta wifi nos permitira conectarnos a la consola. 808 | 809 | Pero antes de conectarnos, debemos entrar en la siguiente dirección: 810 | 811 | http://micropython.org/webrepl/ 812 | 813 | Una vez conectados, ya podremos conectar a la wifi de MicroPython (La contraseña por defecto es "micropythoN"). 814 | 815 | Tras esto ya podemos conectar usando la webREPL introducimos la dirección IP y puerto para conectar y pulsamos el boton conectar. Nos preguntara la contraseña que pusimos al configurar el WebREPL y una vez introducida veremos la consola Python. 816 | 817 | ![webrepl](imagenes/webrepl.png) 818 | 819 | ## Proyecto final 820 | 821 | Una vez hemos visto todo lo necesario para crear el proyecto final de este curso. En este caso, vamos a crear un pequeño instrumento musica que en función de la distancia medida con el sensor de ultrasonidos, usaremos el buzzer para crear distintas notas. 822 | 823 | Además podemos crear iluminacion con los leds conectados e iluminando estos en función de la distancia medida con el sensor. 824 | 825 | **Recursos** 826 | 827 | * [Buzzer con micropython](https://pypi.python.org/pypi/micropython-buzzer/1.0.0) 828 | * [Ultrasonic](ultrasonic.py) 829 | 830 | **NOTA**: para instalar este paquete, tenemos que ejecutar upip. 831 | 832 | ```bash 833 | $ micropython -m upip install micropython-pystone 834 | ``` 835 | 836 | * [upip instalación](https://pypi.python.org/pypi/micropython-upip/) 837 | 838 | También puede ejecutarse dentro del propio microcontrolador. 839 | 840 | ``` 841 | import upip 842 | 843 | upip.install('https://github.com/fruch/micropython-buzzer') 844 | ``` 845 | 846 | ## Ejercicios opcionales 847 | 848 | * Micropython trae un modulo especifico para el DHT11 que permite medir temperatura y humedad del aire. Se pide poder mostrar por consola el valor de la temperatura y humedad usando este [módulo](http://docs.micropython.org/en/latest/esp8266/esp8266/quickref.html?highlight=dht#dht-driver). 849 | 850 | * Micropython tiene un modulo especifico llamado neopixel, este modulo permite controlar los leds de una tira. Se pide cambiar los colores de una tira de leds con el tiempo. para ello usar el siguiente [módulo](http://docs.micropython.org/en/latest/esp8266/esp8266/quickref.html?highlight=dht#neopixel-driverhttp://docs.micropython.org/en/latest/esp8266/esp8266/quickref.html?highlight=dht#neopixel-driver). 851 | 852 | 853 | ## Pinout del NodeMCU 854 | 855 | ![alt text](https://docs.bsfrance.fr/documentation/10663_NODEMCU_V3_CH340/Pinout.png "Esquema de pines para la NodeMCU") 856 | 857 | ## Pinout del Wemos D1 Mini 858 | 859 | ![D1 mini](https://camo.githubusercontent.com/253e71b8ffdb3b3402f90315b0493622daec82b5/687474703a2f2f65736361706571756f7465732e6e65742f77702d636f6e74656e742f75706c6f6164732f323031362f30322f657370383236362d77656d6f732d64312d6d696e692d70696e6f75742e706e67) 860 | 861 | ## Referencias 862 | 863 | * [MicroPython Documentacion Oficial](https://docs.micropython.org/en/latest/esp8266/index.html) 864 | * [AdaFruit MicroPython Tutorial](https://learn.adafruit.com/building-and-running-micropython-on-the-esp8266/overview) 865 | * [Awesome Micropython](https://github.com/makersgc/awesome-micropython) 866 | * [mpfshell](https://github.com/wendlers/mpfshell) 867 | * [Anaconda](https://anaconda.org/anaconda/python) 868 | * [upip](https://github.com/micropython/micropython-lib) 869 | --------------------------------------------------------------------------------