Introduction
In this project, you’ll learn how to use blynk 2.0 with raspberry pi pico W board Using micropython code. Blynk is a service that allows you to control your devices from a phone or tablet.
We have already shown how to use Blynk with Arduino and also with ESP32, and it has proved to be an efficient device to control your task from a distance. Today we are going to guide you on how this can also be done with Raspberry Pi Pico W using Blynk. Check also Raspberry Pi Pico W Relay Module Web Server Using Thonny IDE
Required Materials
To get started, you will require a few things:
- Raspberry Pi Pico W board
- LED
- Breadboard
- Jumper wires
- Blynk app
What is Blynk?
Blynk is a smart platform that allows users to create their Internet of Things applications without the need for coding or electronics knowledge. It is based on the idea of physical programming & provides a platform to create and control devices where users can connect physical devices to the Internet and control them using a mobile app.
Schematic Diagram
To create the circuit, you will need only one LED and one resistor to limit the current. led pi will be connected to pin 2 according to the diagram below:
Setting up the Blynk 2.0 app
The LED is controlled using Blynk and Raspberry Pi Pico W. You need to create a Blynk project and set up a dashboard on the mobile or web app. To set up the dashboard, visit blynk.cloud, Create a Blynk account if you don’t already have one. Then create a new project and get the authentication token.
After logging in, click on the “+New Template” button.
Give your project a name and select the hardware device you will be using. Choose Hardware Type as Other and Connection Type as WiFi.
After creating the project, you will be taken to the project dashboard. Click on the “Settings” button and copy the authentication token. You will need this token later when you write your MicroPython script.
So a template will be created now.
Now we need to add a new device.
Choose a new device from the ‘template’.
Select a template device the add a name to create a new device.
When you successfully create your project, you will navigate directly to the project dashboard. you will find the Blynk Authentication Token Here. You will need this token once you write your MicroPython Code.
Click on the ‘Dashboard’ tab, and select the option ‘Demo Dashboards‘.
Add widgets to the project click on the “Widget Box” button to add widgets to your project.
There are many different widgets to choose from, such as buttons, sliders, graphs, and displays. You can drag and drop widgets onto the canvas and configure them to interact with your hardware.
Select a switch from the widget box and place it on the dashboard screen.
On the switchboard, click Settings. In the Settings window, set up the switch. Give it a title, and “Create Datastream” as Virtual Pin.
configure the switch settings as per the image below and click on create. Configure your switch settings to match the image below. Click on create to finish.
With this Blynk dashboard setup, you are now well set to program the Raspberry Pi Pico W to control the LED.
Setup Switches in Android Phone
Install the Blynk app on your smartphone The Blynk app is available for iOS and Android. Download and install the app on your smartphone. then need to set up both the Mobile App and the Mobile Dashboard in order to control the LED with a mobile device. The process is explained above.
- Open Google Play Store App on an android phone
- Open Blynk.App
- Log In to your account (using the same email and password)
- Switch to Developer Mode
- Find the “Pico W IoT Projects Using Blynk” template we created on the web and tap on it
- Tap on the “Pico W IoT Projects Using Blynk” template (this template automatically comes because we created it on our dashboard).
- tap on plus icon on the left-right side of the window
- Add one button Switch
- Now We Successfully Created an android template
- it will work similarly to a web dashboard template
Installation BlynkLib library and Python program
The code is divided into two parts BlynkLib.py and main.py requires Blynk Library for MicroPython.
BlynkLib.py
BlynkLib.py is a Python library for connecting hardware devices to the Blynk IoT platform. It provides a simple-to-use interface for sending and receiving data between a hardware device and the Blynk server.
The library is compatible with Python 2 and 3, and it supports a wide range of hardware platforms. It supports Arduino, Raspberry Pi Pico, and ESP32. check out LED Control using Blynk 2.0 & Raspberry Pi Pico W
Copy and Paste the following code and save it to your Raspberry Pi Pico W board with ‘BlynkLib.py‘ as the file name.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 |
# Copyright (c) 2015-2019 Volodymyr Shymanskyy. See the file LICENSE for copying permission. __version__ = "1.0.0" import struct import time import sys import os try: import machine gettime = lambda: time.ticks_ms() SOCK_TIMEOUT = 0 except ImportError: const = lambda x: x gettime = lambda: int(time.time() * 1000) SOCK_TIMEOUT = 0.05 def dummy(*args): pass MSG_RSP = const(0) MSG_LOGIN = const(2) MSG_PING = const(6) MSG_TWEET = const(12) MSG_NOTIFY = const(14) MSG_BRIDGE = const(15) MSG_HW_SYNC = const(16) MSG_INTERNAL = const(17) MSG_PROPERTY = const(19) MSG_HW = const(20) MSG_HW_LOGIN = const(29) MSG_EVENT_LOG = const(64) MSG_REDIRECT = const(41) # TODO: not implemented MSG_DBG_PRINT = const(55) # TODO: not implemented STA_SUCCESS = const(200) STA_INVALID_TOKEN = const(9) DISCONNECTED = const(0) CONNECTING = const(1) CONNECTED = const(2) print(""" ___ __ __ / _ )/ /_ _____ / /__ / _ / / // / _ \\/ '_/ /____/_/\\_, /_//_/_/\\_\\ /___/ for Python v""" + __version__ + " (" + sys.platform + ")\n") class EventEmitter: def __init__(self): self._cbks = {} def on(self, evt, f=None): if f: self._cbks[evt] = f else: def D(f): self._cbks[evt] = f return f return D def emit(self, evt, *a, **kv): if evt in self._cbks: self._cbks[evt](*a, **kv) class BlynkProtocol(EventEmitter): def __init__(self, auth, tmpl_id=None, fw_ver=None, heartbeat=50, buffin=1024, log=None): EventEmitter.__init__(self) self.heartbeat = heartbeat*1000 self.buffin = buffin self.log = log or dummy self.auth = auth self.tmpl_id = tmpl_id self.fw_ver = fw_ver self.state = DISCONNECTED self.connect() def virtual_write(self, pin, *val): self._send(MSG_HW, 'vw', pin, *val) def send_internal(self, pin, *val): self._send(MSG_INTERNAL, pin, *val) def set_property(self, pin, prop, *val): self._send(MSG_PROPERTY, pin, prop, *val) def sync_virtual(self, *pins): self._send(MSG_HW_SYNC, 'vr', *pins) def log_event(self, *val): self._send(MSG_EVENT_LOG, *val) def _send(self, cmd, *args, **kwargs): if 'id' in kwargs: id = kwargs.get('id') else: id = self.msg_id self.msg_id += 1 if self.msg_id > 0xFFFF: self.msg_id = 1 if cmd == MSG_RSP: data = b'' dlen = args[0] else: data = ('\0'.join(map(str, args))).encode('utf8') dlen = len(data) self.log('<', cmd, id, '|', *args) msg = struct.pack("!BHH", cmd, id, dlen) + data self.lastSend = gettime() self._write(msg) def connect(self): if self.state != DISCONNECTED: return self.msg_id = 1 (self.lastRecv, self.lastSend, self.lastPing) = (gettime(), 0, 0) self.bin = b"" self.state = CONNECTING self._send(MSG_HW_LOGIN, self.auth) def disconnect(self): if self.state == DISCONNECTED: return self.bin = b"" self.state = DISCONNECTED self.emit('disconnected') def process(self, data=None): if not (self.state == CONNECTING or self.state == CONNECTED): return now = gettime() if now - self.lastRecv > self.heartbeat+(self.heartbeat//2): return self.disconnect() if (now - self.lastPing > self.heartbeat//10 and (now - self.lastSend > self.heartbeat or now - self.lastRecv > self.heartbeat)): self._send(MSG_PING) self.lastPing = now if data != None and len(data): self.bin += data while True: if len(self.bin) < 5: break cmd, i, dlen = struct.unpack("!BHH", self.bin[:5]) if i == 0: return self.disconnect() self.lastRecv = now if cmd == MSG_RSP: self.bin = self.bin[5:] self.log('>', cmd, i, '|', dlen) if self.state == CONNECTING and i == 1: if dlen == STA_SUCCESS: self.state = CONNECTED dt = now - self.lastSend info = ['ver', __version__, 'h-beat', self.heartbeat//1000, 'buff-in', self.buffin, 'dev', sys.platform+'-py'] if self.tmpl_id: info.extend(['tmpl', self.tmpl_id]) info.extend(['fw-type', self.tmpl_id]) if self.fw_ver: info.extend(['fw', self.fw_ver]) self._send(MSG_INTERNAL, *info) try: self.emit('connected', ping=dt) except TypeError: self.emit('connected') else: if dlen == STA_INVALID_TOKEN: self.emit("invalid_auth") print("Invalid auth token") return self.disconnect() else: if dlen >= self.buffin: print("Cmd too big: ", dlen) return self.disconnect() if len(self.bin) < 5+dlen: break data = self.bin[5:5+dlen] self.bin = self.bin[5+dlen:] args = list(map(lambda x: x.decode('utf8'), data.split(b'\0'))) self.log('>', cmd, i, '|', ','.join(args)) if cmd == MSG_PING: self._send(MSG_RSP, STA_SUCCESS, id=i) elif cmd == MSG_HW or cmd == MSG_BRIDGE: if args[0] == 'vw': self.emit("V"+args[1], args[2:]) self.emit("V*", args[1], args[2:]) elif cmd == MSG_INTERNAL: self.emit("internal:"+args[0], args[1:]) elif cmd == MSG_REDIRECT: self.emit("redirect", args[0], int(args[1])) else: print("Unexpected command: ", cmd) return self.disconnect() import socket class Blynk(BlynkProtocol): def __init__(self, auth, **kwargs): self.insecure = kwargs.pop('insecure', False) self.server = kwargs.pop('server', 'blynk.cloud') self.port = kwargs.pop('port', 80 if self.insecure else 443) BlynkProtocol.__init__(self, auth, **kwargs) self.on('redirect', self.redirect) def redirect(self, server, port): self.server = server self.port = port self.disconnect() self.connect() def connect(self): print('Connecting to %s:%d...' % (self.server, self.port)) s = socket.socket() s.connect(socket.getaddrinfo(self.server, self.port)[0][-1]) try: s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) except: pass if self.insecure: self.conn = s else: try: import ussl ssl_context = ussl except ImportError: import ssl ssl_context = ssl.create_default_context() self.conn = ssl_context.wrap_socket(s, server_hostname=self.server) try: self.conn.settimeout(SOCK_TIMEOUT) except: s.settimeout(SOCK_TIMEOUT) BlynkProtocol.connect(self) def _write(self, data): #print('<', data) self.conn.write(data) # TODO: handle disconnect def run(self): data = b'' try: data = self.conn.read(self.buffin) #print('>', data) except KeyboardInterrupt: raise except socket.timeout: # No data received, call process to send ping messages when needed pass except: # TODO: handle disconnect return self.process(data) |
main.py
Here’s a Final code for controlling an LED using Blynk Using MicroPython: Copy the following code and save it to the “Pico W“ with the name ‘main.py’.
Replace the WIFI_SSID
, WIFI_PASSWORD
, and BLYNK_AUTH_TOKEN
with your Wi-Fi SSID and password, and the authentication token for your Blynk project.
The code above defines a virtual pin handler for virtual pin V0. When the value of the virtual pin changes, it toggles an LED connected to Pin GP02.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
import time import network from machine import Pin import BlynkLib led=machine.Pin(2, machine.Pin.OUT) led.on() wlan = network.WLAN(network.STA_IF) wlan.active(True) wlan.connect("Shiva","77777777") BLYNK_AUTH = '8-cDtuBBCTM1SPjbNo8Hi1Wr3rzcENzf' # connect the network wait = 10 while wait > 0: if wlan.status() < 0 or wlan.status() >= 3: break wait -= 1 print('waiting for connection...') time.sleep(1) # Handle connection error if wlan.status() != 3: raise RuntimeError('network connection failed') else: print('connected') ip=wlan.ifconfig()[0] print('IP: ', ip) "Connection to Blynk" # Initialize Blynk blynk = BlynkLib.Blynk(BLYNK_AUTH) # Register virtual pin handler @blynk.on("V1") #virtual pin V0 def v0_write_handler(value): #read the value if int(value[0]) == 1: led.value(1) #turn the led on else: led.value(0) #turn the led off while True: blynk.run() |
Upload the code to Pico W Connect your Raspberry Pi Pico W to your computer using a USB cable. Copy the MicroPython code to the Pico W. You can use a tool like ampy or rshell to do this.
The script should start running and connect to your Wi-Fi and Blynk project. You can control the LED by sending values to virtual pin V0 from the Blynk app on your smartphone.
Use Blynk 2.0 With Raspberry Pi Pico W to Control LED
Check the Latest Raspberry Pi Pico Projects
- How To Make Raspberry Pi Pico W Web Server – MicroPython
- Controlling RGB LED From Raspberry Pi Pico W Web Server with MicroPython
- Raspberry Pi Pico W Web Server with BME280 – Mini Weather Station
- BME280 With Raspberry Pi Pico W Using MicroPython
- How to Control WS2812 LED w/ Raspberry Pi Pico W & Adafruit IO
- Raspberry Pi Pico W Remote Controlled Car Robot Web Server