Docs Review Update

Docs update for release. Adjusting format to separate software sections & final review updates/edits.

Author: SFEMark

docs/assets/img/Qwiic-registered-updated.png

@@ -0,0 +1,18 @@
+---
+icon: material/tools
+---
+
+Getting started with the Pro Micro - RP2350 is as easy as plugging it in over USB. The board ships with simple code that cycles the WS2812 RGB LED through a rainbow so on initial power up you should see that cycle.
+
+<figure markdown>
+[![Simple USB-C assembly](./assets/img/Pro_Micro_USB_Assembly.jpg){ width="400"}](./assets/img/Pro_Micro_USB_Assembly.jpg "Click to enlarge")
+</figure>
+
+From here, you can quickly get started programming the board with either the Pico SDK or MicroPython. If you'd like to quickly get started with a variety of I<sup>2</sup>C devices, SparkFun carries a variety of Qwiic boards with MicroPython support such as the [Optical Tracking Odometry Sensor](https://www.sparkfun.com/products/24904) as shown in the assembly photo below:
+
+<figure markdown>
+[![Qwiic assembly with the Optical Odometry sensor](./assets/img/Pro_Micro_USB_Qwiic_Assembly.jpg){ width="400"}](./assets/img/Pro_Micro_USB_Qwiic_Assembly.jpg)
+</figure>
+
+
+

docs/assets/img/arducam_image1.png

@@ -1,24 +1,11 @@
----
-icon: material/tools
----
 
-## Basic Assembly
 
-Getting started with the Pro Micro - RP2350 is as easy as plugging it in over USB. The board ships with simple code that cycles the WS2812 RGB LED through a rainbow so on initial power up you should see that cycle.
 
-<figure markdown>
-[![Simple USB-C assembly](./assets/img/Pro_Micro_USB_Assembly.jpg){ width="400"}](./assets/img/Pro_Micro_USB_Assembly.jpg "Click to enlarge")
-</figure>
-
-From here, you can quickly get started programming the board. If you'd like to quickly get started with a variety of I<sup>2</sup>C devices, SparkFun carries a variety of Qwiic boards with MicroPython support such as the [Optical Odometry Sensor]() as shown in the assembly photo below:
-
-<figure markdown>
-[![Qwiic assembly with the Optical Odometry sensor](./assets/img/Pro_Micro_USB_Qwiic_Assembly.jpg){ width="400"}](./assets/img/Pro_Micro_USB_Qwiic_Assembly.jpg)
-</figure>
 
-## Camera Example Assembly
+!!! attention "Important!"
+    This is an advanced example that assumes users are familiar with using the [Pico SDK](https://www.raspberrypi.com/documentation/pico-sdk/) to build and run projects. If you have not previously used the Pico SDK we strongly encourage going through Raspberry Pi's tutorials on getting started with it before continuing with this example.
 
-If you'd like to follow along with the Camera Example in this guide, you'll need to connect the Arducam M5 camera module to the Pro Micro over both SPI and I<sup>2</sup>C as well as connections for input voltage and ground. We recommend soldering male headers to the Pro Micro as the photo below shows and then plugging it into a breadboard for easy prototyping.
+If you'd like to follow along with the Arducam PRSAM Demo in this guide, you'll need to connect the Arducam M5 camera module to the Pro Micro over both SPI and I<sup>2</sup>C as well as connections for input voltage and ground. We recommend soldering male headers to the Pro Micro as the photo below shows and then plugging it into a breadboard for easy prototyping.
 
 <figure markdown>
 [![Male headers soldered to the Pro Micro.](./assets/img/Pro_Micro_Headers.jpg){ width="400"}](./assets/img/Pro_Micro_Headers.jpg "Click to enlarge")
@@ -54,11 +41,11 @@ Next, connect the Arducam wire harness to the camera assembly if you have not al
         <td>CS</td>
     </tr>
     <tr>
-        <td>4</td>
+        <td>3</td>
         <td>MOSI/COPI</td>
     </tr>
     <tr>
-        <td>3</td>
+        <td>4</td>
         <td>MISO/CIPO</td>
     </tr>
     <tr>
@@ -83,12 +70,10 @@ Next, connect the Arducam wire harness to the camera assembly if you have not al
     </tr>
 </table> 
 
-??? note "Pull-Down Jumper"
-    Not listed in the table above is the pull-down jumper between A3 and Ground. This jumper switches the example between "Standard" and "High Contrast" modes.
+Finally, you'll want to connect a jumper wire between <b>A3</b> and <b>GND</b>. The code refers to the state of A3/GPIO29 (called 29 in the code) to run the image processing algorithm. The code sets A3/GPIO29 as an input with an internal pull-up resistor enabled. When the pin is pulled LOW through the jumper wire there is no image processing and the image should appear as a normal greyscale. When the jumper is removed, the code enables the processing algorithm to apply image thresholding. 
 
 With the wiring completed, it should look similar to the photo below
 
 <figure markdown>
 [![Close up shot of completed camera wiring](./assets/img/Pro_Micro_Camera_Wiring.jpg){ width="400"}](./assets/img/Pro_Micro_Camera_Wiring.jpg "Click to enlarge")
-</figure>
-
+</figure>

docs/assets/img/arducam_image2.png

@@ -0,0 +1,110 @@
+
+
+
+
+!!! attention "Important!"
+    This is an advanced example that assumes users are familiar with using the [Pico SDK](https://www.raspberrypi.com/documentation/pico-sdk/) to build and run projects. If you have not previously used the Pico SDK we strongly encourage going through Raspberry Pi's tutorials on getting started with it before continuing with this example.
+
+The Arducam PSRAM Example is a modified version of [Arducam's Videostreaming example](https://github.com/ArduCAM/PICO_SPI_CAM/tree/master/C/Examples/Arducam_MINI_5MP_Plus_Videostreaming) that uses the Arducam to take still images and send them to the RP2350 and then process and transmit the images over USB to be displayed using a [Processing](https://processing.org/) sketch. The primary goal of this example is to demonstrate how to set up and use PSRAM on the Pro Micro - RP2350 using the Pico SDK and the cool images are a neat bonus!
+
+## Software Requirements
+
+Along with the Pico SDK, you'll need to install the following items for this demo to run properly.
+
+### Pico SDK Cam Driver
+
+This example uses the Pico SDK, Arducam's Pico Cam driver for the SDK. The example files include the necessary Arducam driver installation but if you'd like to install it separately you can find it in the ArduCAM GitHub repo [here](https://github.com/ArduCAM/PICO_SPI_CAM).
+
+### Processing Software
+
+You'll also need to download and install the [Processing](https://processing.org/) software. You can download the program by clicking the button below:
+
+<center>
+    [Processing Downloads Page](https://processing.org/download){ .md-button .md-button--primary}
+</center>
+
+### Arducam Demo Files
+
+We've included pretty much everything you'll need to run the example in the Pro Micro - RP2350 GitHub repository [here](https://github.com/sparkfun/SparkFun_Pro_Micro_RP2350/tree/main/Examples/Arducam_Demo). If you'd like to download a compressed (ZIP) copy of the repository, click the button below:
+
+<center>
+    [SparkFun Pro Micro - RP2350 Github Repository (ZIP)](https://github.com/sparkfun/SparkFun_Pro_Micro_RP2350/archive/refs/heads/main.zip){ .md-button .md-button--primary}
+</center>
+
+The C++, .uf2, and cmake.txt files for the example can be found in the "<b>/Examples/Arducam_Demo</b>" folder. Take note of where these are as we'll need them later on.
+
+## Uploading and Running Demo
+
+With the Pico SDK set up on your computer, use the following command from the example directory to build the project:
+
+``` c++
+mkdir build
+cd build
+cmake .. -DPICO_PLATFORM=rp2350 -DPICO_BOARD=sparkfun_promicro_rp2350
+make
+```
+
+Next, set the Pro Micro in boot mode and upload the .uf2 file to the board.
+
+### Processing Sketch
+
+Now that the Pro Micro - RP2350 is running the demo code, open the Processing sketch included in the GitHub repository download. Finally, click the "Run" button in the top left of the Processing window and it should open a new window to display the images the camera is taking. We've done our best to speed up the time between the Arducam capturing an image and displaying it on the computer but it can take a few seconds in between shots. With the camera steady, you should start to see greyscale images like this fancy photo of the ceiling in the SparkFun engineering department:
+
+<figure markdown>
+[![Greyscale screenshot for Arducam demo.](./assets/img/arducam_image1.png){ width="400"}](./assets/img/arducam_image1.png "Click to enlarge")
+</figure>
+
+Now try unplugging the jumper wire between A3 and GND and the next images should be in purely black and white (thresholded) like the screenshot below:
+
+<figure markdown>
+[![Black and white screenshot for Arducam demo.](./assets/img/arducam_image2.png){ width="400"}](./assets/img/arducam_image2.png "Click to enlarge")
+</figure>
+
+## PSRAM Code to Note
+
+!!! note "Pico SDK PSRAM Support"
+    The Pico SDK may include official PSRAM support for the Pro Micro - RP2350 in the future. This is simply a demo to get users started while that support is being implemented.
+
+The primary goal of this demo is to show how to implement and use PSRAM in your own projects. It's fairly involved and requires overriding the default PSRAM allocations to work with the Pro Micro.
+
+### CMakeLists.txt
+
+The CMakeLists.txt file includes the commands to override the default allocation to use a custom allocation created in the "sfe_pico_alloc" folder.
+
+```
+# use our own allocator
+set(SKIP_PICO_MALLOC 1)
+```
+
+It then adds a subdirectory called "sfe_pico_alloc" to import the custom PSRAM memory allocation for the Pro Micro - RP2350.
+
+```
+add_subdirectory(sfe_pico_alloc)
+
+# pull in common dependencies and additional spi hardware support
+target_link_libraries(arducam_demo 
+	pico_stdlib
+	hardware_dma
+	hardware_i2c
+	hardware_pwm
+	ArduCAM
+	sfe_pico_alloc
+)
+```
+
+### C++ PSRAM
+
+The code snippet below shows how to configure and use PSRAM with <code>malloc()</code>.
+
+``` c++
+// Create buffer to store image. In this demo, malloc() has been configure to
+// use the PSRAM of the SparkFun Pro Micro RP2350, so you don't need to do
+// anything else to use the PSRAM!
+imageBuf = (uint8_t*) malloc(nRows * nCols);
+if (!imageBuf)
+{
+    // Always good practice to verify that malloc() worked
+    printf("Malloc failed! Exiting example\n");
+    return 1;
+}
+```

docs/basic_assembly.md

@@ -12,9 +12,9 @@ The RP2350 from Raspberry Pi packs a whole lot of computing punch in a tiny pack
 [![Photo highlighting RP2350.](./assets/img/Pro_Micro_RP2350-RP2350.jpg){ width="400"}](./assets/img/Pro_Micro_RP2350-RP2350.jpg "Click to enlarge")
 </figure>
 
-This internal configuration allows users to customize the chip to their preferred architecture or to use one of each! The RP2350 includes 520kB of on-chip SRAM in ten independent banks and 8kB of one-time-programmable (OTP) storage. It also has an impressive set of security features including optional boot signing with protected OTP storage for the boot decryption key, global bus filtering (based on either Arm or RISC-V security and privilege levels) and more.
+This internal configuration allows users to customize the chip to their preferred architecture or to use one of each! The RP2350 includes 520kB of on-chip SRAM in ten independent banks and 8kB of one-time-programmable (OTP) storage. It also has an impressive set of security features including optional boot signing with protected OTP storage for the boot decryption key, global bus filtering (based on either Arm or RISC-V security and privilege levels) and more. For a complete overview of the RP2350, refer to the [datasheet]().
 
-The Pro Micro - RP2350 uses the "A" version of the microcontroller which has 30 5V-tolerant GPIO with 4 analog inputs and also includes the following peripheral options:
+The Pro Micro - RP2350 uses the "A" version of the microcontroller which has 30 3.3V-tolerant GPIO with 4 analog inputs and also includes the following peripheral options:
 
 * 2x UART
 * 2x SPI

docs/bootloader.md

@@ -2,12 +2,6 @@
 icon: material/book-open-page-variant
 ---
 
-# Hookup Guide
-
-
-## Introduction
-<!-- Single Product Card -->
-
 <div class="grid cards desc" markdown>
 
 -    <a href="https://www.sparkfun.com/products/24870">
@@ -28,6 +22,8 @@ icon: material/book-open-page-variant
 
 -    The SparkFun Pro Micro - RP2350 provides a powerful development platform in SparkFun's compact Pro Micro form factor built around the RP2350 from the Raspberry Pi Foundation. This board uses the updated Pro Micro form factor and includes a USB-C connector, Qwiic connector, WS2812B addressable RGB LED, Boot and Reset buttons, resettable PTC fuse as well as PTH and castellated solder pads. This board also includes external memory for the RP2350 with 16MB Flash and 8MB PSRAM both tied to the RP2350's QSPI controller.
 
+    The RP3250 is a unique dual-core microcontroller with two ARM<sup>&reg;</sup> Cortex<sup>&reg;</sup> M33 processors and two Hazard3 RISC-V processors, all running at up to 150 MHz! Now, this doesn't mean the RP2350 is a quad-core microcontroller. Instead, users can select which two processors to run on boot instead. You can run two processors of the same type or one of each. The RP2350 also features 520kB SRAM in ten banks, a host of peripherals including two UARTs, two SPI and two I<sup>2</sup>C controllers, and a USB 1.1 controller for host and device support.
+
     <center>
     [Purchase from SparkFun :fontawesome-solid-cart-plus:{ .heart }](https://www.sparkfun.com/products/24870){ .md-button .md-button--primary }
     </center>

docs/hardware_assembly.md renamed to docs/camera_assembly.md

@@ -0,0 +1,39 @@
+---
+icon simple/micropython
+---
+
+## Verify MicroPython Firmware & Hardware
+
+First, to make sure everything is running properly, use the <code>sys</code> module to verify the firmware version and machine/board running. Open your preferred interface and enter the following prompts and you should see something similar to the printout below:
+
+``` py
+>>> import sys
+>>> sys.implementation
+(name='micropython', version=(1, 24, 0, 'preview'), _machine='SparkFun Pro Micro RP2350 with RP2350', _mpy=7942)
+```
+
+## Verify Memory (Internal and PSRAM)
+
+Next, we can verify the total free memory on the Pro Micro which includes the built-in memory on the RP2350 as well as the 8MB PSRAM. We'll use the <code>gc</code> module for this so type in the prompt below and you should see a response close to the value below:
+
+``` py
+>>> import gc
+>>> gc.mem_free()
+8640352
+```
+
+
+
+## WS2812 LED Control
+
+Finally, we'll make sure we can properly control the WS2812 LED on the Pro Micro using the <code>machine</code> and <code>neopixel</code> classes. The WS2812 Data In pin connects to I/O 25 on the RP2350 so we'll create a pin for it as an OUTPUT and assign it to the LED object. Next, we'll set the color to red and finally write the color values to the LED. The code below goes through all these steps so try copying it on your machine and you should see the WS2812 LED turn red.
+
+``` py
+>>> import machine, neopixel
+>>> pin = machine.Pin(25, machine.Pin.OUT)
+>>> led = neopixel.NeoPixel(pin, 1)
+>>> n[0] = (255, 0, 0)
+>>> n.write()
+```
+
+Try playing around with other values between 0 and 255 for the three colors (R, G, B) and then writing the changes to switch the LED's displayed color.

docs/camera_demo.md

@@ -0,0 +1,21 @@
+
+
+
+
+## Setup
+
+MicroPython is an application of the Python 3 language that runs on microcontrollers like the Pro Micro - RP2350 that allows you to easily interact with the board directly over a USB serial interface through either a command line interface or your preferred Python IDE such as [Thonny](https://thonny.org/). We'll do a quick overview of how to download MicroPython firmware on to the Pro Micro - RP2350 but for a complete overview of using MicroPython with this and other RP2350 boards, head over to Raspberry Pi's documentation by clicking the button below:
+
+<center>
+    [Raspberry Pi MicroPython Docs](https://www.raspberrypi.com/documentation/microcontrollers/micropython.html){ .md-button .md-button--primary}
+</center>
+
+## UF2 Firmware
+
+As of this writing, we're waiting on the next release of MicroPython to include UF2 files for the Pro Micro - RP2350 so to get users started before then, you can download the "early release" of the UF2 firmware file by clicking the button below.
+
+<center>
+    [Pro Micro - RP2350 UF2 Firmware](https://cdn.sparkfun.com/assets/6/3/c/f/d/firmware_pro_micro_rp2350.uf2){ .md-button .md-button--primary}
+</center>
+
+Once downloaded, put the Pro Micro - RP2350 into UF2 bootloader mode and open the location the board appeared as a USB storage device (it should appear as "RP2350"). Next, simply drag and drop the UF2 file into the RP2350 folder and the board should reboot. Next, open up your preferred MicroPython IDE (or command line interface) and you can start interacting with your Pro Micro. Read on to the MicroPython examples section for a few quick examples to make sure everything is working properly.

docs/examples.md

@@ -0,0 +1,15 @@
+
+
+
+
+## Raspberry Pi Pico SDK
+
+The Pico C SDK is a C/C++ development kit for Raspberry Pi microcontrollers including the RP2350. Click on the links below for complete documentation on installing and using the SDK.
+
+<center>
+    [Pico C SDK Documentation](https://www.raspberrypi.com/documentation/pico-sdk/){ .md-button .md-button--primary }
+</center>
+
+<center>
+    [Pico C SDK GitHub Repository](https://github.com/raspberrypi/pico-sdk){ .md-button .md-button--primary }
+</center>