The Pico In MicroPython: HTTP Client
Written by Harry Fairhead & Mike James   
Monday, 02 January 2023
Article Index
The Pico In MicroPython: HTTP Client
A Custom Server
A Temperature Sensor Client

A Temperature Sensor Client

The standard approach to implementing a sensor device that makes its readings available to other devices is to implement a web server or a custom protocol that allows other devices to connect. A simpler solution is to implement an HTTP client and allow the sensor device to send data to a server which other devices can then connect to as required.

As we have already seen in Chapter 15, it is very easy to use the DS18B20 to collect data about ambient temperature. All we have to do is take a reading every so often, convert the floating-point value to a byte object and send it to the server using a PUT:

from machine import Pin, Timer
import network
import rp2
import onewire
import ds18x20
from time import sleep_ms
import urequests
wifi = setup("country", "ssid", "key")
url = "http://192.168.253.45:8080"
ow = onewire.OneWire(Pin(22))
presence = ow.reset()
if presence:
    print("Device present")
else:
    print("No device")
DS = ds18x20.DS18X20(ow)
roms = DS.scan()
while True:
    DS.convert_temp()
    temp = DS.read_temp(roms[0])
    buf = str(temp).encode("utf-8")
    try:
        r = urequests.put(url, data=buf)
        r.close()
    except:
        print("Server Not Online")
    sleep_ms(500)

The setup function given earlier which makes the WiFi connection has been omitted.

The server simply has to respond to the PUT request and convert the bytes to a string and then a float:

from http.server import HTTPServer, 
BaseHTTPRequestHandler
from io import BytesIO
class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
def log_message(self,*args, **kwargs): pass
def do_PUT(self): content_length =
int(self.headers['Content-Length']) body = self.rfile.read(content_length) bodyString= body.decode(encoding="utf-8") temp=float(bodyString) print(temp) self.send_response(200) self.end_headers()
httpd = HTTPServer(('', 8080), SimpleHTTPRequestHandler) httpd.serve_forever()

As before, it is simple enough to convert the server to HTTPS. The overriding of the log_message method is to suppress the regular printing of status messages. The do_PUT handler method simply prints the temperature. It could, of course, do much more.

You can appreciate that this architecture works well if you can allocate a simple device to act as a server. If the sensor supplies more data than a single measurement then using a JSON encoding makes things easier. For example, if you want to send a timestamp along with the temperature you could change the while loop to read:

while True:
    DS.convert_temp()
    temp = DS.read_temp(roms[0])
    jsonData={"temp":temp,"time":time()}
      
    try:
        r = urequests.put(url,json=jsonData)
        r.close()
    except:
        print("Server Not Online")
    sleep_ms(500)

You can see that the only difference is that now we make up a dictionary with key/value pairs corresponding to the data we want to send to the server. The only other difference is that we now set json=jsonData rather than setting it to data and the urequests module converts the dictionary into a JSON string.

To process the JSON string the server’s do_PUT method now has to use the json module to convert the received JSON string back into a dictionary object:

    def do_PUT(self):
        content_length = 
int(self.headers['Content-Length']) body = self.rfile.read(content_length) bodyString= body.decode(encoding="utf-8") jsonData=json.loads(bodyString) print(jsonData) self.send_response(200) self.end_headers()

If you run the client and the server with these changes you will see something like:

{'time': 1609459985, 'temp': 14.4375}
{'time': 1609459986, 'temp': 14.5}
{'time': 1609459987, 'temp': 14.4375}

You can unpack the data from the dictionary and use it as you would any other data.

In chapter but not in this extract

  • Sockets
  • Socket Address
  • Client Sockets
  • A Socket Web Client
  • SSL Socket Based HTTPS Client
  • Socket Server
  • A Socket Temperature Server
  • An SSL HTTPS Server
  • Non-Blocking Sockets
  • The Connection Queue

Summary

  • The Pico W’s new WiFi hardware is connected via an SPI bus and this makes use of several GPIO lines that are used in the Pico for different things. In particular, GP25 is no longer used to control the internal LED. The internal LED is now controlled by a GPIO line on the WiFi chip.

  • Connecting to a WiFi network is a matter of using the WLAN class.

  • Implementing error handling for a WiFi connection can be challenging.

  • The simplest way of implementing an HTTP client is to use urequests.

  • An HTTP client can both send and receive data. The only thing it cannot do is accept an incoming connection, which is what a server does.

  • If you want to do anything beyond HTTP, or you want to implement an HTTP server, then you need to make use of sockets.

  • Sockets are completely general and you can use them to implement an HTTP client.

  • Implementing a socket server is easy, but it can be difficult to ensure that both clients and internal services are both attended to.

  • The simplest solution to the server problem is to implement a polling loop and to do this you need to make use of non-blocking sockets.

 

Programming the Raspberry Pi Pico/W In MicroPython Second Edition

By Harry Fairhead & Mike James

picopython2e360

Buy from Amazon.

Contents

  • Preface
  • Chapter 1 The Raspberry Pi Pico – Before We Begin
  • Chapter 2 Getting Started
  • Chapter 3 Getting Started With The GPIO
  • Chapter 4 Simple Output
  • Chapter 5 Some Electronics
  • Chapter 6 Simple Input
             Extract: Simple Input 
  • Chapter 7 Advanced Input – Events and Interrupts
  • Chapter 8 Pulse Width Modulation
             Extract: PWM 
  • Chapter 9 Controlling Motors And Servos
             Extract: DC Motors
  • Chapter 10 Getting Started With The SPI Bus
  • Chapter 11 A-To-D and The SPI Bus ***NEW!
  • Chapter 12 Using The I2C Bus
  • Chapter 13 Using The PIO   
  • Chapter 14 The DHT22 Sensor Implementing A Custom Protocol
             Extract: A PIO Driver For The DHT22  
  • Chapter 15 The 1‑Wire Bus And The DS1820
  • Chapter 16 The Serial Port
  • Chapter 17 Using The Pico W - WiFi
             Extract: HTTP Client 
  • Chapter 18 Asyncio And Servers
  • Chapter 19 Direct To The Hardware
             Extract: Direct To The Hardware

Also of interest:

Raspberry Pico File System

<ASIN:1871962803>

<ASIN:B0BR8LWYMZ>

<ASIN:187196279X>

<ASIN:B0BL1HS3QD>

 

To be informed about new articles on I Programmer, sign up for our weekly newsletter, subscribe to the RSS feed and follow us on Twitter, Facebook or Linkedin.

Banner


JConference January 2024 Sessions Now Online
23/02/2024

The talks presented at the 4th JChampions Conference which took place between Jan 25 to Jan 30, are now available for free on YouTube. Topics ranged from Code and Tech to Career Advice.



Copilot Research Asks Who Will Clean Up The Mess
31/01/2024

A whitepaper from GitClear sets out to investigate the quality and maintainability of AI-assisted code compared to what would have been written by a human. It highlights a worrying increase in "code c [ ... ]


More News

raspberry pi books

 

Comments




or email your comment to: comments@i-programmer.info

 

 



Last Updated ( Monday, 02 January 2023 )