树莓派Zero上While循环中Spotipy请求速度优化及代码问询

Hey there! Let's break down how to optimize your Spotify track-fetching loop and troubleshoot common issues on the Pi Zero—since that little board has limited CPU and network resources, we need to work smarter, not harder.

Core Optimizations for Request Speed #

1. Reduce API Request Frequency (Critical!) #

Your original code hits the Spotify API 20 times per second—way more than necessary. Spotify tracks don't switch that fast, and you're risking hitting API rate limits (which will block your requests) while wasting precious Pi Zero CPU cycles.

Instead, add a time-based throttle to only request updates every 2-5 seconds (adjust based on how quickly you want to catch track changes):

import time

count = 0
previous_track = ""
last_request_time = time.time()
API_INTERVAL = 2  # Check for new tracks every 2 seconds

while True:
    current_time = time.time()
    # Only fetch track data when the interval has passed
    if current_time - last_request_time >= API_INTERVAL:
        current_track = spotify.current_user_playing_track()
        last_request_time = current_time  # Reset the timer
        
        if current_track is None:
            display_string = ""
        else:
            display_string = f"{current_track['item']['name']} - {current_track['item']['artists'][0]['name']} | "
        
        # Update display ONLY if the track actually changed
        if display_string != previous_track:
            sphd.clear()
            sphd.write_string(display_string, brightness=0.1)
            previous_track = display_string[:]
            count = 0  # Reset scroll position for new track

    # Handle display scrolling (keep this smooth but light)
    if display_string:
        sphd.show()
        sphd.scroll(1)
        count += 1
        if count > 20:
            count = 0
    else:
        sphd.clear()
        sphd.show()
    
    time.sleep(0.05)

2. Track Changes by ID (More Reliable) #

Comparing full display strings can lead to false positives (e.g., minor API response changes). Instead, track the unique id of the current track to only update when the actual song changes:

previous_track_id = None
# ... inside the API request block ...
if current_track is None:
    display_string = ""
    current_track_id = None
else:
    current_track_id = current_track['item']['id']
    display_string = f"{current_track['item']['name']} - {current_track['item']['artists'][0]['name']} | "

# Only update display if track ID differs
if current_track_id != previous_track_id:
    sphd.clear()
    sphd.write_string(display_string, brightness=0.1)
    previous_track_id = current_track_id
    count = 0

3. Offload API Requests to a Separate Thread #

The Pi Zero's single core can get blocked waiting for API responses, making your display stutter. Use a thread to handle Spotify requests in the background, so your scrolling stays smooth:

import threading
from queue import Queue

# Queue to pass track data between threads
track_queue = Queue(maxsize=1)

def spotify_fetcher():
    previous_track_id = None
    while True:
        try:
            current_track = spotify.current_user_playing_track()
            if current_track is None:
                track_queue.put(("", None))
            else:
                track_id = current_track['item']['id']
                if track_id != previous_track_id:
                    track_str = f"{current_track['item']['name']} - {current_track['item']['artists'][0]['name']} | "
                    track_queue.put((track_str, track_id))
                    previous_track_id = track_id
            time.sleep(2)
        except Exception as e:
            print(f"Fetch error: {e}")
            time.sleep(5)  # Wait longer if something goes wrong

# Start the fetcher thread (daemon mode lets it exit with the main program)
threading.Thread(target=spotify_fetcher, daemon=True).start()

# Main thread handles display
count = 0
current_display = ""
while True:
    # Check for new track data
    if not track_queue.empty():
        new_display, new_id = track_queue.get()
        if new_display != current_display:
            sphd.clear()
            sphd.write_string(new_display, brightness=0.1)
            current_display = new_display
            count = 0
    
    # Handle scrolling
    if current_display:
        sphd.show()
        sphd.scroll(1)
        count += 1
        if count > 20:
            count = 0
    else:
        sphd.clear()
        sphd.show()
    
    time.sleep(0.05)

Troubleshooting Common Issues #

1. API Rate Limits (429 Errors) #

Spotify restricts how often you can call their API. If you see 429 Too Many Requests errors:

• Increase your API_INTERVAL to 3-5 seconds.
• Add error handling to respect the Retry-After header Spotify sends:

  import requests
  
  try:
      current_track = spotify.current_user_playing_track()
  except requests.exceptions.HTTPError as e:
      if e.response.status_code == 429:
          retry_time = int(e.response.headers.get('Retry-After', 5))
          print(f"Rate limited! Waiting {retry_time}s")
          time.sleep(retry_time)
          last_request_time = time.time()  # Reset timer after waiting
      else:
          print(f"API Error: {e}")
          # Handle other issues like expired tokens here
  

2. Slow/Unreliable Network #

The Pi Zero's WiFi can be flaky. Test your connection:

• Run ping api.spotify.com in the terminal to check latency. If ping is consistently >100ms, try moving the Pi closer to your router or using a USB Ethernet adapter.
• Use curl -w "%{time_total}s\n" https://api.spotify.com/v1/me/player/currently-playing to measure actual request time. If it's >1s, increase your API interval to avoid blocking the loop.

3. High CPU Usage #

If your Pi's CPU is maxed out:

• Check top in the terminal to see if your Python process is using too much CPU.
• Increase the time.sleep(0.05) value to 0.1—this reduces scroll frequency but lowers CPU load (test to find a balance between smoothness and performance).
• Ensure you're only updating the display when the track changes, not every loop iteration.

4. Display Stuttering #

If the scroll is choppy:

• Make sure the API request thread isn't blocking the main thread (using the separate thread approach fixes this).
• Reduce the length of your display_string (e.g., shorten artist names or remove extra characters) to cut down on the work the display has to do.

内容的提问来源于stack exchange，提问作者dhjtricks