From Waveshare Wiki
Jump to: navigation, search

USB Type-C





PICO-CAM-A is a high-performance microcontroller camera development board designed by Waveshare. With an HM01B0 grayscale camera and a 1.14-inch IPS display screen, it also has onboard 13 GPIO pin headers and a Debug interface, making it easy for users to develop with better integration into applications.


  • RP2040 microcontroller chip designed by Raspberry Pi in the United Kingdom.
  • Dual-core Arm Cortex M0+ processor, flexible clock running up to 133 MHz.
  • 264KB of SRAM, and 16MB of onboard Flash memory.
  • Type-C connector, keeps it up to date, easier to use.
  • On-board HM01B0 grayscale camera.
  • Onboard 1.14inch 240×135 pixels 65K colorful IPS LCD for clear color pictures.
  • USB 1.1 with device and host support.
  • Low-power sleep and dormant modes.
  • Drag-and-drop programming using mass storage over USB.
  • 13 × multi-function GPIO pins.
  • 2 × SPI, 2 × I2C, 2 × UART, 4 × 12-bit ADC, 13 × controlled PWM channel
  • Accurate clock and timer on-chip.
  • Temperature sensor.
  • Accelerated floating-point libraries on-chip.
  • 8 × Programmable I/O (PIO) state machines for custom peripheral support.


LCD Specifications
Controller ST7789V Resolution 135(H)RGB x 240(V)
Communication Interface SPI Display Dimensions 14.864(H)x 24.912(V)mm
Display Panel IPS Pixel Size 0.1101(H)x 0.1035(V)mm





Get Started with Pico


C/C++ Series

Open-source Demo

Sample Demo

C Demo

Burning Firmware

Mode 1: Hold down the BOOT key and connect to the computer, release the BOOT key, a removable disk will appear on the computer, copy the firmware library with suffix.uf2 into it.
Mode 2: After connecting the computer, press the BOOT key and RESET key at the same time, release the RESET key and then release the BOOT key, the computer will appear a removable disk, copy the firmware library with the suffix.uf2 into it.

Code Analysis

Example Explanation
This example primarily involves capturing images through the camera and displaying them on a 1.14-inch LCD. The demo utilizes multi-core processing, with Core 1 responsible for acquiring image data and image processing, while Core 0 handles the image display.
Core 1 Code Explanation

  • Data Pushing
    multicore_fifo_push_blocking() is a function provided by Pico SDK for pushing data to the FIFO (First In, First Out) queue of the multi-core system. Here, Core 1 will push the FLAG_VALUE to FIFO, and Core 0 will block to wait for the FLAG_VALUE data from Core 1 in the flow of execution.
  • Wait for Data
    Core 1 blocks and waits for the data from Core 0.
uint32_t ack = multicore_fifo_pop_blocking();
  • LCD Initialization
    Call DEV_Module_Init() to initialize the pins and buttons related to the LCD, and call LCD_1IN14_V2_Init() to initialize the LCD.
UDOUBLE Imagesize = LCD_1IN14_V2_HEIGHT * LCD_1IN14_V2_WIDTH * 2;
UWORD *BlackImage;
if ((BlackImage = (UWORD *)malloc(Imagesize)) == NULL)
    printf("Failed to apply for black memory...\r\n");
  • Display Image
    Call Paint_DrawImage() to draw images, and call LCD_1IN14_V2_Display() to display the images on the LCD.
Paint_NewImage((UBYTE *)BlackImage, LCD_1IN14_V2.WIDTH, LCD_1IN14_V2.HEIGHT, 0, WHITE);
Paint_DrawImage(gImage_waveshare, 0, 0, 240, 135);
  • Camera Initialization
    This code segment calls cam_config_struct() to initialize the camera configuration structure "config" and then proceeds to initialize the camera by calling cam_init().
struct cam_config config;
  • Image Processing
    This code segment is a loop where the camera captures a frame in each iteration, processes the image, and ultimately stores the processed image data in "displayBuf". The "imageReady" flag is then set to 1, indicating that the image is ready for display.
while (true) {

    uint16_t index = 0;
    for (int y = 134; y > 0; y--) {
        for (int x = 0; x < 240; x++) {
            uint16_t c = image_buf[(y)*324+(x)];
            uint16_t imageRGB = (((c & 0xF8) << 8) | ((c & 0xFC) << 3) | ((c & 0xF8) >> 3));
            displayBuf[index++] = (uint16_t)(imageRGB >> 8) & 0xFF;
            displayBuf[index++] = (uint16_t)(imageRGB) & 0xFF;

    imageReady = 1;

Core 0 Code Explanation

  • Boots Core1
    multicore_launch_core1 is the function provided by Pico SDK for booting Core 1 on the Raspberry Pi Pico. This code start Core 1 to execute the specified function through calling multicore_launch_core1().
  • Wait for data
    Core 0 blocks and waits for data from Core 1, if data FLAG_VALUE is successfully received then send data to Core 1.
uint32_t ack = multicore_fifo_pop_blocking();
if (ack != FLAG_VALUE)
    printf("Error: Core 0 failed to receive acknowledgment from core 1!\n");
else {
    printf("Success: Core 0 Received acknowledgment from core 1!\n");
  • Main Loop
    Continuously checks the "imageReady" flag in the main loop. Once the flag is detected as 1, indicating that the image is ready for display, it calls LCD_1IN14_V2_Display() to show the image. After the display, it resets the "imageReady" flag to 0.
while (1) {
    if (imageReady == 1) {
        // Reset the imageReady flag after displaying the image
        imageReady = 0;

Run the Demo

  • After programming the firmware and powering up, the PICO-Cam-A displays the boot-up screen and then shows the camera's captured images in real-time.





Official Resources

Raspberry Pi Official Datasheet

Raspberry Pi Open-source Demo

Development Software


Technical Support

If you need technical support or have any feedback/review, please click the Submit Now button to submit a ticket, Our support team will check and reply to you within 1 to 2 working days. Please be patient as we make every effort to help you to resolve the issue.
Working Time: 9 AM - 6 PM GMT+8 (Monday to Friday)