WebSocket for live updates in Raspberry Pi - Step-by-Step Execution

Concept Flow - WebSocket for live updates

Client opens WebSocket connection

↓

Server accepts connection

↓

Client and Server send messages

↓

Client receives live updates

↓

Server sends live data

↓

Connection stays open for real-time

↓

Client or Server closes connection

The client opens a WebSocket connection to the server, which stays open to send and receive live updates in real time.

Execution Sample

Raspberry Pi

import asyncio
import websockets

async def listen():
    async with websockets.connect('ws://localhost:8765') as ws:
        while True:
            msg = await ws.recv()
            print(f'Received: {msg}')

This code connects to a WebSocket server and continuously receives and prints live messages.

Execution Table

Step	Action	Evaluation	Result
1	Client calls websockets.connect()	Connection attempt to ws://localhost:8765	Connection established
2	Client awaits ws.recv()	Waiting for server message	No message yet, waiting...
3	Server sends 'Hello from server!'	Message sent over WebSocket	Client receives message
4	Client prints message	Prints 'Received: Hello from server!'	Output shown on screen
5	Connection remains open	Ready for more messages	Live updates possible
6	Client or server closes connection	Connection closed	WebSocket session ends

💡 Connection closes when client or server ends session

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
ws	None	WebSocket connection object	Same connection object	Closed or None after close
msg	None	'Hello from server!'	'Hello from server!'	No new message after close

Key Moments - 3 Insights

Why does the client wait at ws.recv()?

At step 2 in the execution_table, the client pauses at ws.recv() because it waits for the server to send a message before continuing.

What keeps the connection open for live updates?

Step 5 shows the connection remains open, allowing continuous sending and receiving of messages without reconnecting.

What happens when the connection closes?

At step 6, either client or server closes the connection, ending the live update session and stopping message exchange.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'msg' after step 3?

A 'Received: Hello from server!'

B None

C 'Hello from server!'

D WebSocket connection object

💡 Hint

Check variable_tracker row for 'msg' after Step 3

At which step does the client print the received message?

A Step 2

B Step 4

C Step 5

D Step 6

💡 Hint

Look at execution_table row describing printing action

If the server never sends a message, what happens at step 2?

A Client waits indefinitely at ws.recv()

B Client connection closes

C Client prints a message immediately

D Client throws an error

💡 Hint

Refer to execution_table step 2 where client waits for server message

Concept Snapshot

WebSocket for live updates:
- Client opens a WebSocket connection to server
- Connection stays open for two-way live data
- Client waits for messages with ws.recv()
- Server sends live updates anytime
- Connection closes when either side ends
- Enables real-time communication without reconnects

Full Transcript

This example shows how a Raspberry Pi client uses WebSocket to get live updates from a server. First, the client opens a connection to the server. Then it waits to receive messages using ws.recv(). When the server sends a message, the client receives and prints it. The connection stays open to allow continuous live updates. Finally, the connection closes when either the client or server decides to end it. This method is useful for real-time data like sensor readings or notifications.