Merge pull request #3096 from madeline-underwood/ard

Ard

Author: jasonrandrews

content/learning-paths/embedded-and-microcontrollers/arduino-pico/_index.md

@@ -3,6 +3,7 @@ title: Embedded programming with Arduino on the Raspberry Pi Pico
 
 who_is_this_for: This is an introductory topic for software developers interested in embedded programming.
 minutes_to_complete: 60
+description: Learn how to build a motion-detection device with Raspberry Pi Pico (RP2040 Cortex-M0+) using Arduino IDE, PIR sensors, and interrupt-driven programming on baremetal.
 
 learning_objectives: 
     - Understand the basics of embedded programming

content/learning-paths/embedded-and-microcontrollers/arduino-pico/app_stack.md

@@ -12,7 +12,7 @@ layout: "learningpathall"
 
 Application developers will be familiar with this traditional computing stack, whether their target devices are desktops, mobile phones, or the cloud, it would be the same. 
 
-![Traditional stack](_images/traditional_stack.png)
+![Diagram showing the traditional application computing stack with four layers from bottom to top: hardware, firmware/BIOS, operating system, and application. The firmware layer provides hardware abstraction that allows a single OS image to run on different hardware configurations, a key difference from embedded systems.#center](_images/traditional_stack.png)
 
 ## Hardware
 

content/learning-paths/embedded-and-microcontrollers/arduino-pico/arduino_sketch.md

@@ -246,7 +246,7 @@ If successful, you should see the LED on your board light up. If you wave your h
 
 You can further check that your code is running properly by opening the `Serial Monitor` from the `Tools` menu of the Arduino IDE. There you should see all of the output messages, including count of detected motion events, coming from your sketch.
 
-![Debug output](_images/output.webp)
+![Screenshot of the Arduino IDE Serial Monitor window displaying debug messages from the motion detection sketch. The output shows repeated "Motion detected" messages followed by motion event counts, confirming that the PIR sensor is triggering correctly and the sketch is processing the interrupts.#center](_images/output.webp)
 
 Congratulations! You have successfully programmed your microcontroller and built a working, if simple, smart device. 
 

content/learning-paths/embedded-and-microcontrollers/arduino-pico/arm_embedded.md

@@ -12,7 +12,7 @@ layout: "learningpathall"
 
 Now that you know the differences between application and embedded programming, as well as the differences in the hardware and software stack, it's time to take your first steps into embedded software development!
 
-![Arm Embedded stack](_images/embedded_arm_stack.png)
+![Diagram showing the typical Arm embedded software stack with three layers: Cortex-M CPU at the bottom hardware layer, Mbed OS RTOS in the middle, and C application code with supporting libraries at the top. This illustrates the standard architecture for Arm microcontroller projects where the RTOS sits directly on hardware without a firmware abstraction layer.#center](_images/embedded_arm_stack.png)
 
 A typical embedded project for Arm devices looks like this. For microcontrollers, you'll have a CPU in the Cortex-M family and, as your RTOS, you'll use something like Mbed OS, which is provided by Arm and used by default in Arm Developer Studio and Keil MDK.
 
@@ -26,7 +26,7 @@ As you know, these small, cheap, development prototyping boards have been around
 
 But they're so much more than just a toy for making lights flash. They're a really great way to get started with embedded programming!
 
-![Arduino stack](_images/embedded_arduino_stack.png)
+![Diagram showing Arduino's simplified embedded stack with Cortex-M0+ CPU at the hardware layer, Arduino core package in the middle providing hardware abstraction, and Arduino sketch written in C++ at the application layer. This shows how Arduino makes embedded development more accessible by hiding low-level hardware details behind the core package.#center](_images/embedded_arduino_stack.png)
 
 The latest generations of Arduino use Arm Cortex-M microprocessors, such as the Cortex-M0+ in the Arduino Nano RP2040, making that more powerful and capable than before, while still providing a very simple and straightforward programming experience.
 

content/learning-paths/embedded-and-microcontrollers/arduino-pico/embedded_stack.md

@@ -12,7 +12,7 @@ layout: "learningpathall"
 
 While the embedded computing stack looks similar to an application stack, there are some important differences.
 
-![Embedded stack](_images/embedded_stack.png)
+![Diagram showing the embedded computing stack with hardware at the bottom, RTOS in the middle, and application at the top. Unlike traditional application stacks, there is no firmware layer abstracting the hardware, meaning embedded software must be built specifically for the target hardware and include all necessary drivers.#center](_images/embedded_stack.png)
 
 ## Hardware
 

content/learning-paths/embedded-and-microcontrollers/arduino-pico/raspberrypi_pico.md

@@ -12,24 +12,24 @@ layout: "learningpathall"
 
 To get started on your first embedded project, you can use a cheap and widely available device: the [Raspberry Pi Pico](https://www.raspberrypi.com/products/raspberry-pi-pico/).
 
-![RaspberryPi Pico](_images/raspberry_pi_pico.jpg)
+![Photo of a Raspberry Pi Pico development board showing its compact rectangular shape with dual rows of GPIO pins along both edges and a micro-USB port. The board features an RP2040 microcontroller with dual Cortex-M0+ cores, the same chip used in Arduino Nano RP2040, making it compatible with Arduino core packages.#center](_images/raspberry_pi_pico.jpg)
 
 You were probably expecting an Arduino board, rather than a Raspberry Pi board but it turns out that the Arduino core package that supports the Arduino Nano RP2040 will also support the Raspberry Pi Pico, because they use the exact same RP2040 microprocessor. Plus the Pico is less expensive, currently retailing for less than $5 USD (you can also use the Raspberry Pi Pico with other programming environments, such as MicroPython).
 
 ## Accessories
 
 For interacting with the physical world you can use two cheap commodity components. 
 
-![PIR Sensor](_images/pir-sensor-pinout.png)
+![Diagram showing PIR motion sensor pinout with three pins labeled from left to right: VCC for power input, OUT for data signal output that goes high when motion is detected, and GND for ground. Understanding this pinout is essential for wiring the sensor correctly to the Pico's 3.3V power, ground, and GPIO pins.#center](_images/pir-sensor-pinout.png)
 
 First a PIR motion sensor. This sensor reacts to infrared photons emitted by a warm moving object, like a person or animal. The interface is simple, it has one pin for input voltage, one pin for ground to complete the circuit, and a third pin that will have the same voltage as the input pin when motion is detected, and the same voltage as the ground pin when it isn't.
 
 
-![Electric Buzzer](_images/buzzer-pin-diagram.png.webp)
+![Diagram showing piezo-electric buzzer pinout with two terminals: a positive terminal marked with a plus sign that connects to a GPIO pin for signal input, and a negative terminal that connects to ground. When voltage is applied to the positive terminal, the buzzer emits a high-pitched beep to signal motion detection.#center](_images/buzzer-pin-diagram.png.webp)
 
 Second, a very simple electric buzzer. You could get fancy with one of these and make it play different sounds with something called Pulse Width Modulation (PWM) but, for simplicity, you can give it a constant voltage which will result in a high-pitched beeping noise.
 
-![Breadboard](_images/breadboard.jpeg)
+![Diagram showing standard solderless breadboard layout with color-coded connection patterns. Holes in each column are connected vertically, while the center divider isolates left and right sides. Power rails along the edges run horizontally for distributing voltage and ground. This layout allows you to connect multiple components to the same Pico pins by plugging wires into holes on the same connected column.#center](_images/breadboard.jpeg)
 
 Finally, you can use a breadboard to connect the components together without having to do any soldering.
 
@@ -39,39 +39,39 @@ If you're not familiar with a breadboard, the image above shows you how all of t
 
 ### Step 1: Seat your Raspberry Pi
 
-![RaspberryPi Pico](_images/pico_on_breadboard.webp)
+![Photo showing Raspberry Pi Pico seated on a breadboard with its dual rows of GPIO pins straddling the center divider. This placement ensures that each pin has its own column of connected holes on either side, allowing you to wire components to the Pico's GPIOs without creating short circuits across pins.#center](_images/pico_on_breadboard.webp)
 
 Seat your Raspberry Pi Pico on the breadboard so that its rows of pins sit on either side of the center divider. Make sure that it's firmly pressed all the way down but be careful not to bend any of the pins.
 
 ### Step 2: PIR ground
 
-![PIR ground](_images/pir_sensor_1.webp)
+![Photo showing a black jumper wire connecting the PIR sensor's ground pin to physical pin 38 on the Raspberry Pi Pico. Pin 38 is one of the Pico's ground pins that completes the circuit for powering the PIR sensor. Using black wire for ground connections is a common convention that makes circuits easier to troubleshoot.#center](_images/pir_sensor_1.webp)
 
 Using a black jumper wire, connect the ground pin of your PIR sensor to pin #38 on your Pico. This pin is a ground voltage pin on the Pico.
 
 ### Step 3: PIR input voltage
 
-![PIR voltage](_images/pir_sensor_2.webp)
+![Photo showing a red jumper wire connecting the PIR sensor's VCC power pin to physical pin 36 on the Raspberry Pi Pico. Pin 36 provides 3.3V output to power the PIR sensor. Using red wire for voltage connections follows standard wiring conventions and helps distinguish power connections from ground and signal lines.#center](_images/pir_sensor_2.webp)
 
 Using a red wire, connect the input voltage pin of your PIR sensor to pin #36 on your Pico. This pin is a 3.3 volt pin on the Pico and will supply power to your PIR sensor.
 
 ### Step 4: PIR data
 
-![PIR data](_images/pir_sensor_3.webp)
+![Photo showing a jumper wire connecting the PIR sensor's data output pin to physical pin 34 on the Raspberry Pi Pico. This pin corresponds to GPIO 28, which your code will monitor to detect when the PIR sensor signals motion. Note the distinction between physical pin numbering and GPIO numbering, which is important when writing your Arduino sketch.#center](_images/pir_sensor_3.webp)
 
 The last step to connecting the PIR sensor is to connect the middle data pin to pin #34 on your Pico. This is a GPIO pin that you can use to either read or write data. 
 
 Note that this is GPIO #28, even though it's physical pin #34. Physical pin number and GPIO numbers are not the same.
 
 ### Step 5: Buzzer ground
 
-![Buzzer ground](_images/piezo_1.webp)
+![Photo showing a jumper wire connecting the piezo-electric buzzer's negative terminal to physical pin 23 on the Raspberry Pi Pico. Pin 23 is a ground pin that completes the buzzer circuit. With both ground and power connections in place, the buzzer will emit a tone when the GPIO pin provides voltage to signal detected motion.#center](_images/piezo_1.webp)
 
 Next, it's time to connect the buzzer. Start by connecting the buzzer's ground pin to pin #23 on your Pico. This is another ground pin that is build into your board.
 
 ### Step 6: Buzzer input
 
-![Buzzer input](_images/piezo_2.webp)
+![Photo showing a jumper wire connecting the piezo-electric buzzer's positive terminal to physical pin 25 on the Raspberry Pi Pico. This pin corresponds to GPIO 19, which your Arduino code will control to trigger the buzzer when motion is detected. By setting this GPIO pin high, you provide voltage that causes the piezo element to vibrate and emit a beep.#center](_images/piezo_2.webp)
 
 Then, connect the buzzer's input pin to pin #25 on your Pico. This is another GPIO pin, this time GPIO #19.