在 Windows 下控制 RP2040

Intel J4125 与 RP2040 和 40-PIN GPIO 的关系介绍

在 Radxa X4 上集成了一块 Intel N100 的 CPU 和一块 RP2040 MCU，两者通过 USB 或 UART 进行通信。 40-PIN 是从 RP2040 拉出来的 IO 扩展口，CPU 通过与 RP2040 通信来控制 40-PIN. 其中 RP2040 通过 PICO SDK 来操作 40-PIN。

安装必要工具

Git for Windows

该工具主要方便用户使用 git 命令，以及为用户提供一些 Linux 命令，我们可以在该工具下进行编译
Vscode for Windows
CMAKE
Pico Setup Windows
Ninja

下载后解压即可，
Python3 for Windows

设置环境变量

在搜索栏搜索 "编辑系统环境"
点击 "环境变量"
添加系统变量或者用户变量
- 添加变量 PICO_INSTALL_PATH 和 PICO-SDK_PATH
添加 PATH

构建编译

打开 git bash，进入到 pico-examples/build 目录下，执行以下命令进行构建编译

cmake -G "Ninja" ..

ninja

烧录

按下 BOOTSEL 键后，会弹出一个 USB 设备。将编译后产生的 .uf2 文件拷贝到 RP2040 的 USB 设备中，待该 USB 设备消失后，程序开始执行。

示例

RP2040 控制 40-PIN

GPIO
I2C
PWM
PoE FAN
UART

GPIO

1. 准备

一块 Radxa X4
一个 LED

2. 连接

Radxa X4	<-->	LED
PIN_5	<-->	LED
PIN_1	<-->	VCC
PIN_9	<-->	GND

提示

这里的 PIN_5 对应下面代码中的 GPIO29, 详细请参考 GPIO 定义

3. 测试

将以下代码替换 pico-examples/blink/blink.c

blink.c

#include "pico/stdlib.h"
#define BLINK_PIN 29 // GPIO29

int main() {

    gpio_init(BLINK_PIN);
    gpio_set_dir(BLINK_PIN, GPIO_OUT);

    while (true) {
        gpio_put(BLINK_PIN, 1);
        sleep_ms(250);
        gpio_put(BLINK_PIN, 0);
        sleep_ms(250);
    }
}

编译
```
cd pico-examples/build/
rm -rf *
cmake -G "Ninja" ..
ninja
```
成功编译后，在 pico-examples/build/blink/ 目录下会产生一个名为 blink.uf2 的文件
烧录
- 重启 RP2040
- 将 blink.uf2 文件拖入到 RP2040 中，待 RP2040 消失后， LED 会开始闪烁

I2C

1. 准备

一块 Radxa X4
一个 I2C OLED 1306

2. 连接

Radxa X4	<-->	OLED
PIN_5	<-->	SCL
PIN_3	<-->	SDA
PIN_1	<-->	VCC
PIN_9	<-->	GND

提示

这里的 PIN_5 对应下面代码中的 GPIO29 的复用属性 I2C0 SDA, PIN_3 对应下面代码中的 GPIO28 的复用属性 I2C0 SCL, 详细请参考 GPIO 定义

3. 测试

将以下代码替换 pico-examples/i2c/lcd_1602_i2c/lcd_1602_i2c.c

lcd_1602_i2c.c

    #include <stdio.h>
    #include <string.h>
    #include "pico/stdlib.h"
    #include "hardware/i2c.h"
    #include "pico/binary_info.h"

    #define I2C_ID i2c0
    #define I2C_SDA_PIN 28
    #define I2C_SCL_PIN 29

    // commands
    const int LCD_CLEARDISPLAY = 0x01;
    const int LCD_RETURNHOME = 0x02;
    const int LCD_ENTRYMODESET = 0x04;
    const int LCD_DISPLAYCONTROL = 0x08;
    const int LCD_CURSORSHIFT = 0x10;
    const int LCD_FUNCTIONSET = 0x20;
    const int LCD_SETCGRAMADDR = 0x40;
    const int LCD_SETDDRAMADDR = 0x80;

    // flags for display entry mode
    const int LCD_ENTRYSHIFTINCREMENT = 0x01;
    const int LCD_ENTRYLEFT = 0x02;

    // flags for display and cursor control
    const int LCD_BLINKON = 0x01;
    const int LCD_CURSORON = 0x02;
    const int LCD_DISPLAYON = 0x04;

    // flags for display and cursor shift
    const int LCD_MOVERIGHT = 0x04;
    const int LCD_DISPLAYMOVE = 0x08;

    // flags for function set
    const int LCD_5x10DOTS = 0x04;
    const int LCD_2LINE = 0x08;
    const int LCD_8BITMODE = 0x10;

    // flag for backlight control
    const int LCD_BACKLIGHT = 0x08;

    const int LCD_ENABLE_BIT = 0x04;

    // By default these LCD display drivers are on bus address 0x27
    static int addr = 0x27;

    // Modes for lcd_send_byte
    #define LCD_CHARACTER  1
    #define LCD_COMMAND	0

    #define MAX_LINES	  2
    #define MAX_CHARS	  16

    /* Quick helper function for single byte transfers */
    void i2c_write_byte(uint8_t val) {
        i2c_write_blocking(I2C_ID, addr, &val, 1, false);
    }

    void lcd_toggle_enable(uint8_t val) {
        // Toggle enable pin on LCD display
        // We cannot do this too quickly or things don't work
    #define DELAY_US 600
        sleep_us(DELAY_US);
        i2c_write_byte(val | LCD_ENABLE_BIT);
        sleep_us(DELAY_US);
        i2c_write_byte(val & ~LCD_ENABLE_BIT);
        sleep_us(DELAY_US);
    }

    // The display is sent a byte as two separate nibble transfers
    void lcd_send_byte(uint8_t val, int mode) {
        uint8_t high = mode | (val & 0xF0) | LCD_BACKLIGHT;
        uint8_t low = mode | ((val << 4) & 0xF0) | LCD_BACKLIGHT;

        i2c_write_byte(high);
        lcd_toggle_enable(high);
        i2c_write_byte(low);
        lcd_toggle_enable(low);
    }

    void lcd_clear(void) {
        lcd_send_byte(LCD_CLEARDISPLAY, LCD_COMMAND);
    }

    // go to location on LCD
    void lcd_set_cursor(int line, int position) {
        int val = (line == 0) ? 0x80 + position : 0xC0 + position;
        lcd_send_byte(val, LCD_COMMAND);
    }

    static void inline lcd_char(char val) {
        lcd_send_byte(val, LCD_CHARACTER);
    }

    void lcd_string(const char *s) {
        while (*s) {
            lcd_char(*s++);
        }
    }

    void lcd- _init() {
        lcd_send_byte(0x03, LCD_COMMAND);
        lcd_send_byte(0x03, LCD_COMMAND);
        lcd_send_byte(0x03, LCD_COMMAND);
        lcd_send_byte(0x02, LCD_COMMAND);

        lcd_send_byte(LCD_ENTRYMODESET | LCD_ENTRYLEFT, LCD_COMMAND);
        lcd_send_byte(LCD_FUNCTIONSET | LCD_2LINE, LCD_COMMAND);
        lcd_send_byte(LCD_DISPLAYCONTROL | LCD_DISPLAYON, LCD_COMMAND);
        lcd_clear();
    }

    int main() {
        i2c_init(I2C_ID, 100 * 1000);
        gpio_set_function(I2C_SDA_PIN, GPIO_FUNC_I2C);
        gpio_set_function(I2C_SCL_PIN, GPIO_FUNC_I2C);
        gpio_pull_up(I2C_SDA_PIN);
        gpio_pull_up(I2C_SCL_PIN);
        // Make the I2C pins available to picotool
        bi_decl(bi_2pins_with_func(I2C_SDA_PIN, I2C_SCL_PIN, GPIO_FUNC_I2C));

        lcd_init();

        static char *message[] =
                {
                        "RP2040 by", "Raspberry Pi",
                        "A brand new", "microcontroller",
                        "Twin core M0", "Full C SDK",
                        "More power in", "your product",
                        "More beans", "than Heinz!"
                };

        while (1) {
            for (int m = 0; m < sizeof(message) / sizeof(message[0]); m += MAX_LINES) {
                for (int line = 0; line < MAX_LINES; line++) {
                    lcd_set_cursor(line, (MAX_CHARS / 2) - strlen(message[m + line]) / 2);
                    lcd_string(message[m + line]);
                }
                sleep_ms(2000);
                lcd_clear();
            }
        }
    }

编译

cd pico-examples/build/
rm -rf *
cmake -G "Ninja" ..
ninja

成功编译后，在 pico-examples/build/i2c/lcd_1602_i2c/ 目录下会产生一个名为 lcd_1602_i2c.uf2 的文件

烧录
重启 RP2040
将 lcd_1602_i2c.uf2 文件拖入到 RP2040 中，待 RP2040 消失后， OLED 会一段文本

PWM

1. 准备

一块 Radxa X4
一个 LED

2. 连接

Radxa X4	<-->	LED
PIN_5	<-->	LED
PIN_1	<-->	VCC
PIN_9	<-->	GND

提示

这里的 PIN_5 对应下面代码中的 GPIO29, 详细请参考 GPIO 定义

3. 测试

将以下代码替换 pico-examples/pwm/led_fade/pwm_led_fade.c

pwm_led_fade.c

#include "pico/stdlib.h"
#include <stdio.h>
#include "pico/time.h"
#include "hardware/irq.h"
#include "hardware/pwm.h"

#define PWD_FADE_LED_PIN 29

void on_pwm_wrap() {
    static int fade = 0;
    static bool going_up = true;

    pwm_clear_irq(pwm_gpio_to_slice_num(PWD_FADE_LED_PIN));

    if (going_up) {
        ++fade;
        if (fade > 255) {
            fade = 255;
            going_up = false;
        }
    } else {
        --fade;
        if (fade < 0) {
            fade = 0;
            going_up = true;
        }
    }

    pwm_set_gpio_level(PWD_FADE_LED_PIN, fade * fade);
}

int main() {

    gpio_set_function(PWD_FADE_LED_PIN, GPIO_FUNC_PWM);

    uint slice_num = pwm_gpio_to_slice_num(PWD_FADE_LED_PIN);

    pwm_clear_irq(slice_num);
    pwm_set_irq_enabled(slice_num, true);
    irq_set_exclusive_handler(PWM_IRQ_WRAP, on_pwm_wrap);
    irq_set_enabled(PWM_IRQ_WRAP, true);

    pwm_config config = pwm_get_default_config();
    pwm_config_set_clkdiv(&config, 4.f);
    pwm_init(slice_num, &config, true);

    while (1)
        tight_loop_contents();
}

编译

cd pico-examples/build/
rm -rf *
cmake -G "Ninja" ..
ninja

编译成功后，在 pico-examples/build/pwm/led_fade/ 目录下会产生一个名为 pwm_led_fade.uf2 的文件

烧录
- 重启 RP2040
- 将 pwm_led_fade.uf2 文件拖入到 RP2040 中，待 RP2040 消失后， LED 会由暗到亮/由亮到暗渐变

PoE FAN

1. 准备

一块 Radxa X4
一个瑞莎 25W PoE+ HAT X4 专用款

2. 连接

如图所示，将瑞莎 25W PoE+ HAT X4 专用款安装在 Radxa X4 上：

3. 测试

将以下代码替换 pico-examples/pio/onewire/onewire.c

onewire.c

#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/binary_info.h"

#include "onewire_library.h"    // onewire library functions
#include "ow_rom.h"             // onewire ROM command codes
#include "ds18b20.h"            // ds18b20 function codes

#define FAN_PIN 13
#define TEMP_THRESHOLD 45.0
#define CONVERSION_DELAY_MS 750 // DS18B20 conversion time is about 750ms
#define SLEEP_BETWEEN_READS_MS 1000 // Delay between consecutive temperature reads

int main() {
    stdio_init_all();

    PIO pio = pio0;
    uint gpio = 4;

    // configure PIN 13
    gpio_init(FAN_PIN);
    gpio_set_dir(FAN_PIN, GPIO_OUT);

    OW ow;
    uint offset;
    if (pio_can_add_program(pio, &onewire_program)) {
        offset = pio_add_program(pio, &onewire_program);
        if (ow_init(&ow, pio, offset, gpio)) {
            int maxdevs = 10;
            uint64_t romcode[maxdevs];
            int num_devs = ow_romsearch(&ow, romcode, maxdevs, OW_SEARCH_ROM);

            printf("Found %d devices\n", num_devs);
            for (int i = 0; i < num_devs; i++) {
                printf("\t%d: 0x%llx\n", i, romcode[i]);
            }

            while (true) {
                // start temperature conversion in parallel on all devices
                ow_reset(&ow);
                ow_send(&ow, OW_SKIP_ROM);
                ow_send(&ow, DS18B20_CONVERT_T);

                // wait for the conversion to finish
                sleep_ms(CONVERSION_DELAY_MS);

                for (int i = 0; i < num_devs; i++) {
                    ow_reset(&ow);
                    ow_send(&ow, OW_MATCH_ROM);
                    for (int b = 0; b < 64; b += 8) {
                        ow_send(&ow, romcode[i] >> b);
                    }
                    ow_send(&ow, DS18B20_READ_SCRATCHPAD);
                    int16_t temp = ow_read(&ow) | (ow_read(&ow) << 8);

                    float temperature = temp / 16.0;
                    // set fan speed to max
                    if (temperature >= TEMP_THRESHOLD) {
                        printf("\tTemperature >= 45, Device %d: temp: %.2f\n", i, temperature);
                        gpio_put(FAN_PIN, 0);
                    } else {
                        // set fan speed to min
                        printf("\tTemperature < 45, Device %d: temp: %.2f\n", i, temperature);
                        gpio_put(FAN_PIN, 1);
                    }
                }

                // sleep between consecutive reads
                sleep_ms(SLEEP_BETWEEN_READS_MS);
            }
        } else {
            puts("could not initialise the driver");
        }
    } else {
        puts("could not add the program");
    }

    return 0;
}

编译

cd pico-examples/build/
rm -rf *
cmake -G "Ninja" ..
ninja

成功编译后，在 pico-examples/build/pio/onewire/ 目录下会产生一个名为 pio_onwire.uf2 的文件

烧录
重启 RP2040
将 pio_onwire.uf2 文件拖入到 RP2040 中，待 RP2040 消失后，程序开始执行，如果 PoE 温度大于等于 45 摄氏度，风扇会全速转，否则风扇会停下

UART

将以下代码替换 pico-examples/uart/hello_uart/hello_uart.c

hello_uart.c

/**
 * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */


#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/uart.h"

/// \tag::hello_uart[]

#define UART_ID uart0
#define BAUD_RATE 115200

// We are using pins 0 and 1, but see the GPIO function select table in the
// datasheet for information on which other pins can be used.
#define UART_TX_PIN 0
#define UART_RX_PIN 1

int main() {
    // Set up our UART with the required speed.
    uart_init(UART_ID, BAUD_RATE);

    // Set the TX and RX pins by using the function select on the GPIO
    // Set datasheet for more information on function select
    gpio_set_function(UART_TX_PIN, GPIO_FUNC_UART);
    gpio_set_function(UART_RX_PIN, GPIO_FUNC_UART);

    // Use some the various UART functions to send out data
    // In a default system, printf will also output via the default UART

    // Send out a character without any conversions
    uart_putc_raw(UART_ID, 'A');

    // Send out a character but do CR/LF conversions
    uart_putc(UART_ID, 'B');

    // Send out a string, with CR/LF conversions
    while(1) {
        uart_puts(UART_ID, "Hello, UART!\r\n");
        sleep_ms(1000);
    }

}

/// \end::hello_uart[]

将以下代码替换 pico-examples/uart/hello_uart/CMakeLists.txt

CMakeLists.txt

add_executable(hello_uart
        hello_uart.c
        )

# pull in common dependencies
target_link_libraries(hello_uart pico_stdlib)

# create map/bin/hex file etc.
pico_add_extra_outputs(hello_uart)

# add url via pico_set_program_url
example_auto_set_url(hello_uart)

pico_enable_stdio_usb(hello_uart 1)
pico_enable_stdio_uart(hello_uart 1)

编译

cd pico-examples/build/
rm -rf *
cmake -G "Ninja" ..
ninja

编译成功后，在 pico-examples/build/uart/hello_uart/ 目录下会产生一个名为 hello_uart.uf2 的文件

烧录
- 重启 RP2040
- 将 hello_uart.uf2 文件拖入到 RP2040 中，待 RP2040 消失后，程序开始执行
终端输入以下命令，查看串口输出

sudo minicom -D /dev/ttyS4 -b 115200

验证

在 minicom 中，你将看到终端每隔一秒输出一行 "Hello, UART!"

在 Windows 下控制 RP2040

Intel J4125 与 RP2040 和 40-PIN GPIO 的关系介绍​

安装必要工具​

设置环境变量​

构建编译​

烧录​

示例​

RP2040 控制 40-PIN​

GPIO​

1. 准备​

2. 连接​

3. 测试​

I2C​

1. 准备​

2. 连接​

3. 测试​

PWM​

1. 准备​

2. 连接​

3. 测试​

PoE FAN​

1. 准备​

2. 连接​

3. 测试​

UART​

Intel J4125 与 RP2040 和 40-PIN GPIO 的关系介绍

安装必要工具

设置环境变量

构建编译

烧录

示例

RP2040 控制 40-PIN

GPIO

1. 准备

2. 连接

3. 测试

I2C

1. 准备

2. 连接

3. 测试

PWM

1. 准备

2. 连接

3. 测试

PoE FAN

1. 准备

2. 连接

3. 测试

UART