You can determine how much space we have available on the Pico flash after programming an ELF or UF2 file. For example, if we have an ELF file that's 1 MB and we were to program via openocd, then where should we offset my user data in flash? (i.e. XIP_BASE + OFFSET)

With an elf or uf2 file, using ```picotool info -a``` on it will show the start and end of the binary (the start is usually 0x10000000 unless you did something to change it).

Inside your code, you can use the symbols defined by the linker script __flash_binary_start (defined here) and __flash_binary_end (defined here) like this:

extern char __flash_binary_start; // defined in linker script

extern char __flash_binary_end; // defined in linker script

uintptr_t start = (uintptr_t) &__flash_binary_start;

uintptr_t end = (uintptr_t) &__flash_binary_end;

printf("Binary starts at %08x and ends at %08x, size is %08x\n", start, end, end-start);

from machine import Pin

import ssd1306

WIDTH = 128

HEIGHT = 64

clock=Pin(2) #SCL

data=Pin(3) #SDA

RES = machine.Pin(4)

DC = machine.Pin(5)

CS = machine.Pin(6)

spi=machine.SPI(0, sck=clock, mosi=data)

display = ssd1306.SSD1306_SPI(WIDTH, HEIGHT, spi, DC, RES, CS)

display.fill(0)

display.line(0, 0, WIDTH, HEIGHT, 1)

To test that the signal is coming into the ADC (Analog-to-Digital Converter) on the Raspberry Pi Pico via GPIO26, and to display the audio signal on your SSD1306 OLED, you can use the following MicroPython script. This script will read the analog values from the microphone connected to GPIO26 and plot these values in real-time on the OLED display, creating a simple waveform visualization.

Note: Before running this script, ensure you have properly initialized and connected your microphone to GPIO26 (ADC0), and the OLED display is correctly wired for SPI communication as per your provided initialization.

import machine

import utime

from machine import Pin, ADC, SPI

import ssd1306

WIDTH = 128

HEIGHT = 64

clock = Pin(2) # SCL

data = Pin(3) # SDA

RES = Pin(4)

DC = Pin(5)

CS = Pin(6)

spi = SPI(0, sck=clock, mosi=data)

display = ssd1306.SSD1306_SPI(WIDTH, HEIGHT, spi, DC, RES, CS)

adc = ADC(Pin(26))

def plot_signal():

display.fill(0) # Clear the display

old_x = 0

old_y = HEIGHT // 2

# For simplicity, we're plotting every other pixel

for x in range(0, WIDTH, 2):

# Read from ADC (values will be from 0 to 4095)

val = adc.read_u16()

# Scale the ADC value to fit the OLED height

y = int((val / 65535) * HEIGHT)

# Invert y to plot correctly on the OLED

y = HEIGHT - y

# Draw a line from the last point to the new point

display.line(old_x, old_y, x, y, 1)

old_x, old_y = x, y

display.show() # Update the display with the new data

while True:

plot_signal()

utime.sleep(0.1) # Small delay to reduce flickering

This script continuously reads the analog signal from the microphone and plots a simplified version of the waveform across the OLED display. Here's a breakdown of the plotting part:

- The screen is cleared at the beginning of each frame with `display.fill(0)`.

- We read a value from the ADC and scale it to fit the OLED's screen height.

- We draw a line from the previous point to the current point to create a continuous waveform.

- The display is updated with `display.show()` to visualize the waveform.

This example provides a basic way to visualize audio signals. The resolution and quality of the visualization can be further enhanced or adjusted according to your requirements.

The signal is very low on the display. I have added a Potentiometer on ADC1 which is on GPIO PIN 27. Can you please regenerate the entire program with sound on ADC0 and gain on ADC1. sound = ADC(Pin(26)) gain = ADC(Pin(27))

Certainly! To adjust the signal's amplitude on the display based on the gain from a potentiometer connected to ADC1 (GPIO PIN 27), you can modify the program as follows. This updated script will use the value from the potentiometer to scale the audio signal from the microphone, making the waveform larger or smaller on the OLED display according to the potentiometer's position.

import machine

import utime

from machine import Pin, ADC, SPI

import ssd1306

WIDTH = 128

HEIGHT = 64

clock = Pin(2) # SCL

data = Pin(3) # SDA

RES = Pin(4)

DC = Pin(5)

CS = Pin(6)

spi = SPI(0, sck=clock, mosi=data)

display = ssd1306.SSD1306_SPI(WIDTH, HEIGHT, spi, DC, RES, CS)

sound = ADC(Pin(26))

gain = ADC(Pin(27))

def plot_signal_with_gain():

display.fill(0) # Clear the display

old_x = 0

old_y = HEIGHT // 2

# Read gain control (potentiometer) value

gain_value = gain.read_u16() + 1 # Adding 1 to avoid division by zero

for x in range(0, WIDTH, 2):

# Read from ADC (sound input)

val = sound.read_u16()

# Adjust the sound value based on the gain

# Note: This scaling might need adjustment depending on your specific potentiometer and desired sensitivity

adjusted_val = min(((val * gain_value) >> 16), 65535) # Ensure the adjusted value does not exceed ADC's max value

# Scale the adjusted value to fit the OLED height

y = int((adjusted_val / 65535) * HEIGHT)

# Invert y to plot correctly on the OLED

y = HEIGHT - y

# Draw a line from the last point to the new point

display.line(old_x, old_y, x, y, 1)

old_x, old_y = x, y

display.show() # Update the display with the new data

while True:

plot_signal_with_gain()

utime.sleep(0.1) # Small delay to reduce flickering

In this script, the gain control (potentiometer) reading is used to adjust the amplitude of the sound signal before plotting it. The `gain_value` is read from ADC1 and is used to scale the audio signal from the microphone connected to ADC0. The line `adjusted_val = min(((val * gain_value) >> 16), 65535)` scales the microphone input based on the potentiometer's position, and the bit shift `>> 16` is used to keep the value within the 16-bit range of the ADC's output.

This method should help make the displayed signal more responsive to the potentiometer's adjustments, allowing you to visually enhance or reduce the waveform amplitude on the OLED display.

To make the display update faster and to create a scrolling effect that moves the waveform to the left by one pixel, you can modify the `plot_signal_with_gain` function to use the `scroll()` method of the SSD1306 library. This will shift the entire display content to the left by one pixel, and then you can plot the new data point at the right edge of the display. Here's how you can implement this:

def plot_signal_with_gain():

# Scroll the display content to the left by one pixel

display.scroll(-1, 0)

# Read gain control (potentiometer) value

gain_value = gain.read_u16() + 1 # Adding 1 to avoid division by zero

# Read from ADC (sound input)

val = sound.read_u16()

# Adjust the sound value based on the gain

adjusted_val = min(((val * gain_value) >> 16), 65535) # Ensure the adjusted value does not exceed ADC's max value

# Scale the adjusted value to fit the OLED height

y = int((adjusted_val / 65535) * HEIGHT)

# Invert y to plot correctly on the OLED

y = HEIGHT - y

# Since we've scrolled, we only need to update the last column (x = WIDTH - 1)

# Clear the last column first (optional, depending on the desired visual effect)

for clear_y in range(HEIGHT):

display.pixel(WIDTH - 1, clear_y, 0)

# Draw the new data point at the right edge of the display

display.pixel(WIDTH - 1, y, 1)

# Update the display with the new data

display.show()

In this updated function, the display is scrolled left by one pixel at the beginning of each update cycle using `display.scroll(-1, 0)`. This creates room to draw the new data point at the far right edge (`WIDTH - 1`) of the display. The loop that clears the last column before drawing the new point is optional and can be adjusted or removed depending on the visual effect you're aiming for.

Remember, while `scroll()` improves the visual fluidity by creating a continuous scrolling effect, the update rate can still be limited by the display's physical refresh rate and the speed at which your MicroPython script can run. Experiment with the `utime.sleep(0.1)` delay at the end of the main loop to find a balance between smoothness and speed that works for your specific application.

Creating an audio spectrum analyzer with a Raspberry Pi Pico and a 128x64 OLED display using MicroPython is a fascinating project that combines hardware interfacing with digital signal processing. Below is a step-by-step guide to help you get started on this project.

1. **Raspberry Pi Pico**: A microcontroller board based on the RP2040 microcontroller chip.

2. **128x64 OLED Display**: This will be used for visualizing the audio spectrum. Ensure it's compatible with the Pi Pico, ideally one that communicates over I2C or SPI.

3. **Electret Microphone Amplifier**: This captures the audio signals. A module like the MAX4466 or a similar one would be suitable.

4. **Jump Wires**: For connecting the components.

5. **Breadboard**: Useful for prototyping without soldering.

6. **USB Cable**: For programming the Raspberry Pi Pico.

1. **Install MicroPython**: Download and flash MicroPython onto the Raspberry Pi Pico. The Raspberry Pi Pico documentation provides clear instructions for this process.

2. **Prepare Your Development Environment**: Install any necessary drivers and a code editor that supports MicroPython, such as Thonny or Visual Studio Code with the appropriate extensions.

1. **Microphone to Pi Pico**: Connect the output of the electret microphone amplifier to one of the analog input pins of the Pi Pico. Also, connect the ground and Vcc pins accordingly.

2. **OLED Display to Pi Pico**: Connect the OLED display to the Pi Pico using I2C or SPI, depending on your display module. For I2C, you'll need to connect SDA, SCL, Vcc, and GND. For SPI, the connections will include SCK, MOSI, RES, DC, CS, Vcc, and GND.

1. **Initialize the OLED Display**: Write or adapt a MicroPython script to initialize the OLED display using the appropriate library. There are libraries available for both I2C and SPI OLED displays in MicroPython.

2. **Capture Audio Data**: Write a script to capture audio data from the microphone using the ADC (Analog to Digital Converter) of the Pi Pico. The data capture should be done in real-time, and you may need to experiment with sampling rates.

3. **Process Audio Data**: Implement a Fast Fourier Transform (FFT) algorithm to convert the time-domain audio signals into the frequency domain. This step is crucial for creating the spectrum analysis.

4. **Visualize the Spectrum**: Map the frequency domain data to the OLED display. You will likely need to scale the data to fit nicely on the 128x64 display, representing different frequencies and their intensities.

1. **Run Your Script**: Test the entire system by running your script. You may need to adjust the audio capture settings or the way the data is visualized on the OLED display.

2. **Troubleshoot**: If you encounter issues, use serial print statements to debug and understand where things might be going wrong.

1. **Refine the Display**: You can refine how the audio spectrum is displayed, perhaps by adjusting the resolution, colors (if your OLED supports it), or adding additional visual elements like peak hold.

2. **Experiment with Features**: Consider adding features such as different modes for the spectrum analyzer, audio input from different sources, or even a GUI for interacting with the device.

- **MicroPython Documentation**: Essential for understanding how to program the Raspberry Pi Pico.

- **FFT Libraries**: Look for MicroPython libraries or examples of FFT implementations suitable for the Raspberry Pi Pico.

- **OLED Libraries**: Find libraries specific to your OLED display model for easier programming.

This project involves a mix of hardware setup, digital signal processing, and real-time data visualization. Take it step by step, and don't hesitate to seek out community forums and resources if you encounter challenges.

In this lesson, we will use a 4-digit LED display to create a clock that displays the time of day.

These clocks will use [Mike Causer's **tm1637**](https://github.com/mcauser/micropython-tm1637) library to communicate

1. Ground (GND)

3. Data (DIO)

4. Clock (CLK)

programs first starts up and then we just update the time after the sleep() functions run for a second.

This also can updates the colon between the hours

* [Sam Altman on Coding](https://www.youtube.com/shorts/OK0YhF3NMpQ)

* [Raspberry Pi Pico W LESSON 1: Write Your First Program for Absolute Beginners](https://www.youtube.com/watch?v=SL4_oU9t8Ss) by Paul McWhorter. A nice gentle introduction to getting started with Thonny on the Raspberry Pi Pico.

[Micropython Snake Game](https://github.com/hwiguna/HariFun_203_PicoSnake)

- Spectrum Analyzer:

- Introduction: advanced-labs/30-spectrum-analyzer/index.md

- Test Incomming: advanced-labs/30-spectrum-analyzer/01-test-incoming-sound.md

- Gain Pot: advanced-labs/30-spectrum-analyzer/02-gain-pot.md

- Display Scroll: advanced-labs/30-spectrum-analyzer/display-scroll.md