WebSocket for live updates in Raspberry Pi - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the WebSocket client library.

Raspberry Pi

import [1]

Drag options to blanks, or click blank then click option'

Arequests

Bsocket

Chttp

Dwebsocket

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'socket' instead of 'websocket' will not provide WebSocket client features.

Using 'requests' is for HTTP, not WebSocket.

We use the websocket library to create WebSocket clients in Python on Raspberry Pi.

2fill in blank

medium

Complete the code to create a WebSocket connection to the server URL.

Raspberry Pi

ws = websocket.WebSocket()
ws.[1]("ws://example.com/live")

Drag options to blanks, or click blank then click option'

Acreate

Bconnect

Copen

Dstart

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'open' or 'start' will cause an AttributeError.

Using 'create' is not a valid method for WebSocket client.

The connect method establishes a WebSocket connection to the given URL.

3fill in blank

hard

Fix the error in the code to receive a message from the WebSocket.

Raspberry Pi

message = ws.[1]()

Drag options to blanks, or click blank then click option'

Arecv

Bsend

Creceive

Dread

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'send' tries to send data instead of receiving.

Using 'receive' or 'read' are not valid methods in this library.

The recv() method receives a message from the WebSocket server.

4fill in blank

hard

Fill both blanks to send a JSON message with a type and data.

Raspberry Pi

import json

msg = json.dumps({"type": [1], "data": [2])
ws.send(msg)

Drag options to blanks, or click blank then click option'

A"update"

B"live"

C"sensor"

D"value"

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'live' as type is incorrect here.

Using 'sensor' as data key is not expected.

The message type is 'update' and the data key is 'value' to send live sensor data.

5fill in blank

hard

Fill both blanks to create a dictionary comprehension filtering live data with values above 50.

Raspberry Pi

live_data = {k: v for k, v in data.items() if v {BLANK_1}} {{BLANK_2}}
filtered = {k: v for k, v in live_data.items()}

Drag options to blanks, or click blank then click option'

A>

B50

C:

D=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '=' instead of ':' in dictionary comprehension causes syntax error.

Using '<' instead of '>' changes the filter logic.

The comprehension filters values greater than 50 and creates a dictionary with key-value pairs separated by a colon.

Practice

1. What is the main advantage of using WebSocket on a Raspberry Pi for live updates?

easy

A. It keeps a connection open for instant two-way data flow.

B. It sends data only once when the page loads.

C. It requires no network connection to work.

D. It stores data locally on the Raspberry Pi.

Solution

1. Step 1: Understand WebSocket connection behavior

   WebSocket keeps a connection open between the Raspberry Pi and the web page, allowing data to flow instantly both ways.

2. Step 2: Compare options with WebSocket features

   Options A, B, and C do not describe WebSocket's live, continuous connection feature.

3. Final Answer:

   It keeps a connection open for instant two-way data flow. -> Option A

4. Quick Check:

   WebSocket = open two-way connection [OK]

Hint: Remember: WebSocket keeps connection open for live updates [OK]

Common Mistakes:

• Thinking WebSocket sends data only once
• Confusing WebSocket with HTTP request-response
• Assuming WebSocket works offline

2. Which of the following is the correct way to create a WebSocket client connection in JavaScript on a Raspberry Pi web page?

easy

A. const socket = new Socket('ws://localhost:8080');

B. const socket = WebSocket.connect('http://localhost:8080');

C. const socket = WebSocket('https://localhost:8080');

D. const socket = new WebSocket('ws://localhost:8080');

Solution

1. Step 1: Recall correct WebSocket syntax in JavaScript

   The correct syntax to create a WebSocket client is using the WebSocket constructor with the URL starting with 'ws://' or 'wss://'.

2. Step 2: Check each option's syntax

   const socket = new WebSocket('ws://localhost:8080'); uses 'new WebSocket' with 'ws://' which is correct. Options A, B, and D use incorrect methods or protocols.

3. Final Answer:

   const socket = new WebSocket('ws://localhost:8080'); -> Option D

4. Quick Check:

   WebSocket client = new WebSocket('ws://...') [OK]

Hint: Use 'new WebSocket("ws://...")' to create connection [OK]

Common Mistakes:

• Using 'http://' instead of 'ws://'
• Calling WebSocket as a function without 'new'
• Using undefined methods like WebSocket.connect

3. Given this Python code running on a Raspberry Pi using the 'websockets' library, what will be printed when a client connects and sends 'Hello'?

import asyncio
import websockets

async def handler(websocket):
    message = await websocket.recv()
    print(f'Received: {message}')

async def main():
    async with websockets.serve(handler, 'localhost', 8765):
        await asyncio.Future()

asyncio.run(main())

medium

A. Received: Hello

B. Received: websocket

C. Error: No client connected

D. Received: None

Solution

1. Step 1: Understand the handler function

   The handler waits to receive a message from the client and then prints it with 'Received: ' prefix.

2. Step 2: Analyze what happens when client sends 'Hello'

   The message 'Hello' is received and printed as 'Received: Hello'.

3. Final Answer:

   Received: Hello -> Option A

4. Quick Check:

   Received message = 'Hello' [OK]

Hint: Handler prints whatever client sends prefixed by 'Received:' [OK]

Common Mistakes:

• Assuming it prints 'websocket' instead of message
• Expecting an error without client connection
• Thinking it prints None if message missing

4. Identify the error in this Raspberry Pi WebSocket server code snippet:

import asyncio
import websockets

async def handler(websocket):
    while True:
        message = websocket.recv()
        print(message)

async def main():
    async with websockets.serve(handler, 'localhost', 8765):
        await asyncio.Future()

asyncio.run(main())

medium

A. The server address 'localhost' is invalid.

B. The while loop should be outside the handler function.

C. Missing 'await' before websocket.recv() call.

D. The 'asyncio.run(main())' should be 'asyncio.start(main())'.

Solution

1. Step 1: Check asynchronous calls in handler

   The 'websocket.recv()' is a coroutine and must be awaited to get the message.

2. Step 2: Verify other parts of the code

   Address 'localhost' is valid, the loop inside handler is correct for continuous receiving, and 'asyncio.run' is the proper way to start.

3. Final Answer:

   Missing 'await' before websocket.recv() call. -> Option C

4. Quick Check:

   Await async calls like websocket.recv() [OK]

Hint: Always await async functions like websocket.recv() [OK]

Common Mistakes:

• Forgetting 'await' on async calls
• Misplacing the while loop
• Using wrong asyncio start function

5. You want your Raspberry Pi to send live temperature updates to a web page using WebSocket. Which approach best ensures the web page updates instantly when the sensor value changes?

hard

A. Open a new WebSocket connection every time the temperature changes.

B. Open a WebSocket connection once, then send new temperature data whenever it changes.

C. Send temperature data only when the web page reloads.

D. Use HTTP GET requests repeatedly to fetch temperature data.

Solution

1. Step 1: Understand WebSocket usage for live updates

   WebSocket keeps a connection open, so sending data only when it changes over the same connection is efficient and instant.

2. Step 2: Evaluate other options

   Opening new connections repeatedly (B) wastes resources. Sending data only on reload (C) or using HTTP polling (D) is slower and less real-time.

3. Final Answer:

   Open a WebSocket connection once, then send new temperature data whenever it changes. -> Option B

4. Quick Check:

   One open connection + send updates = instant live data [OK]

Hint: Keep one connection open; send updates as they happen [OK]

Common Mistakes:

• Opening multiple connections unnecessarily
• Relying on page reloads for updates
• Using HTTP polling instead of WebSocket