Challenger+ RP2350 WiFi6/BLE5 datasheet

The Challenger+ RP2350 WiFi6/BLE5 is a small extremely powerful embedded computer based on the new dual core Cortex-M33/RISCV RP2350 from Raspberry Pi. Also featuring 8MByte of FLASH memory and 8MByte of RAM

The Challenger+ RP2350 WiFi6/BLE5 is an awesome board to start digging in to the new features of the RP2350. We paired the RP2350 micro controller with a 8MByte high speed flash capable of supplying data up to the max clock speed as well as an 8 MByte XIP RAM. The flash memory can be used both to store instructions for the micro controller as well as data in a file system and having a file system available makes it easy to store data in a structured and easy to program approach. With the RAM you can now store huge amounts of data as well as execute code giving a hole new heap of possibilities.

The board can be powered from a Lithium Polymer battery connected through a standard 1.25 mm connector on the side of the board. An internal battery charging circuit allows you to charge your battery safely and quickly. The device is shipped with a programming resistor that sets the charging current to 500mA. this resistor can be exchanged by the user to either increase or decrease the charging current, depending on the battery that is being used.

The combined WiFi and BLE module on this board is based on the Espressif ESP32-C6 chip. The ESP32-C6 is based on the RISC-V processor core combined with a complex and powerful 2.4GHz radio block and 4MByte FLASH memory, making it a complete WiFi and BLE solution only requiring very few external components.

Short introduction to the board

PCB
The board is based on a popular form factor called “Feather” which is created and maintained by an American company called Adafruit. The entire specification for the Feather format is available here. The size of the PCB for the module is 50.80mm x 22.86mm but the entire module is a little bit bigger as the Type C USB connector protrudes about 1 mm outside the board.

Antenna
On the opposite end from the USB connector the WiFi antenna is mounted. When mounting the board into any enclosure you should make sure to keep stuff like cables and/or walls from the enclosure away from the antenna as much as possible. Anything mounted in the vicinity of the antenna will affect its performance.

Headers
On each of the longer sides of the PCB there are holes intended for soldering pin header connectors. If you don’t want to use connectors for some reason you can also solder a wire directly into the hole, making a permanent connection to your external device. If you go this way please make sure that the wires are fixed in place, otherwise vibrations can cause the wire to brake at the soldering point.

LED’s
On each side of the USB connector there is a small indicator LED placed. The LED which is marked CHG is the charge control indicator. This red LED will shine whenever the connected battery is being charged, and when the battery is fully charged the LED will turn off again. If you haven’t connected a battery to the board this LED will not come on at all.

On the other side of the USB connector there is a user programmable green LED. This LED is connected to pin D13 and can easily be controlled by the user program.

BConnect
The board is equipped with one BConnect connector that allow you to connect an array of different peripherals based on the BConnect standard. You can read more about this standard here https://ilabs.se/bconnect/

Hardware details

Pins

The on board micro controller (RP2350) have a number of communication channels that have been routed out to the side (header connector) connectors.

• UART – One UART channel have been routed to the header pins (RX, TX). The micro controller have 2 UARTs in total and the second UART is tied to the ESP32-C6 module on the board.
• SPI – One SPI channel have been routed to the header pins (SCK, SDO, SDI). The RP2350 have 2 SPI channels and the second SPI channel is tied to the ESP32-C6 for high speed data transfer.
• I2C – One I2C channel have been routed to the header pins (SCL, SDA).
• Analog pins – The micro controller have 4 analog input pins that all are available on the header pins (A0-A3).
• PWM – All pins can be used for PWM.

The pin chart below shows the placement of all pins and their respective functions. When working in an Arduino environment (or Platform IO) use the blue pins when writing your code and when working with CircuitPython use the orange marked pin assignments.

Power

The board can be powered from multiple sources. The most obvious way to run the board is by plugging it in to a USB cable and attach it to your computer. In this mode you can write software and test the board with all its functionality.

The board can also be powered from the USB pin using a 5V source. Make sure you connect to this pin using a schottky diode to avoid having the external 5V collide with the voltage from the USB connector.

There is also a third way to supply the board. This way is more invasive and will disable the onboard 3.3V power regulator.

You will have to pull the EN header pin low and then supply your own 3.3V voltage on the 3.3V header pin. Please note that when disabling the onboard power regulator you will have to supply the 3.3V also when running the system on battery power.

Battery

As described earlier the board can be powered from a LiPo battery. The battery is connected using a standard 1.25 mm JST connector on the right side of the board. If the battery is an integral part of the system that you are designing it is possible to connect the battery through the BAT pin instead. The charge controller will charge your battery in both of those scenarios.

Switching between the battery voltage and the applied USB voltage or external 5V is done seamlessly by the on board circuitry.

Charging of the battery is done by either connecting a USB cable or by connecting a 5V power source to the header pin marked USB on the board. If you do this make sure you connect your voltage through a 1A schottky diode to avoid any excessive current draw in the system when the two levels are slightly different.

Please note that providing external charger circuitry could destroy the internal charger on the Challenger board.

BConnect

This board is equipped with one 4-pin BConnect connector that allows you to plug in peripherals based on this standard. With this connector you can very easily attach different BI2C and BSerial peripherals to extend the functionality of your system.

The following pins are connected to the connector:

• GPIO20 – SDA (Also connected to the SDA pin on the board pin header)
• GPIO21 – SCL (Also connected to the SCL pin on the board pin header)

These pins can also be configured to use RP2350 UART 1 if you want to attach a BSerial device but we recommend using PIOSerial to do this instead. Otherwise you will loose the connection to the WiFi ESP32-C6 WiFi module. Below is an example on how to configure a PIO Uart to be used with this board.

#include <SerialPIO.h>

SerialPIO PIOUart(PIN_WIRE0_SDA, PIN_WIRE0_SCL);

void setup() {
  PIOUart.begin(115200);
  PIOUart.println("Its as simple as this !");
}

Now obviously when changing the function of these pins you will loose the I2C functionality on those physical pins. If you project still requires I2C you will have to move this function to another set of pins.

ESP32-C6 Network controller

The RP2350 MCU is interfaced with the ESP32-C6 module via a serial communication channel to facilitate data exchange. In addition to the serial channel, a high-speed SPI channel is employed for rapid data transfer between the two devices. This dual-channel setup ensures robust and efficient communication for various applications. The integration of both serial and SPI channels enhances the overall performance and reliability of the system.

Connection between MCU and ESP32-C6 WiFi controller.

The board uses the second UART (UART 1) of the MCU to connect to the ESP32-C6 as well as a couple of GPIO pins that allows the RP2040 to reset and put the ESP32-C6 in flash mode. The pins used are as follows.

• GPIO4 is connected to the ESP32-C6 RXD input and acts as Data output (TXD) for the RP2350.
• GPIO5 is connected to the ESP32-C6 TXD output and acts as Data input (RXD) for the RP2350.
• GPIO15 is connected to ESP32-C6 reset and is active low (Referred to as PIN_ESP32_RST in the Arduino IDE).
• GPIO14 is connected to the boot mode pin of the ESP32-C6. If it is pulled low at the same time the reset signal is going high the chip will enter flash mode (Refered to as PIN_ESP32_MODE in the arduino IDE). This pin also acts as the Data ready pin (DREADY) when operating the module with the ESP Hosted firmware.

The ESP32-C6 is also connected via the second SPI channel to allow very high transfer speeds between the ESP32-C6 device and the RP2040.

SPI1 Pin usage:

• GPIO10 is the serial clock (SCK)
• GPIO8 is the serial data input (SDI)
• GPIO11 is the serial data output (SDO)
• GPIO9 is the ESP32-C6 chip select signal (#CS)

The ESP32-C6 SPI firmware ESP Hosted (https://github.com/espressif/esp-hosted) also uses an extra hand shake signal (HS) which is connected as follows.

• GPIO22 is the ESP32-C6 hand shake signal.

Software support and network functionality

Communicating with the WiFi subsystem

WiFi Subsystem Overview

The WiFi subsystem on the Challenger+ RP2350 board is based on a dedicated WiFi module capable of supporting WiFi 6 (802.11ax). WiFi 6 offers several advantages over previous generations, including higher data throughput, improved efficiency in crowded environments, and enhanced power management features. The WiFi module is connected to the RP2350 MCU through both a UART and an SPI interface, allowing developers to choose the most appropriate method based on their application requirements.

The Espressif ESP-AT Stack

Technical Description of the ESP-AT Stack

The Espressif ESP-AT stack is a firmware solution provided by Espressif for their Wi-Fi and Bluetooth-enabled microcontrollers, such as the ESP8266 and ESP32 series. The ESP-AT stack allows these devices to function as communication modules controlled via AT commands, enabling easy integration into various systems without requiring deep knowledge of the underlying wireless protocols.

Key Features:

• AT Command Interface: The ESP-AT stack provides a standardized set of AT commands that allow users to control Wi-Fi and Bluetooth functionalities, such as connecting to networks, configuring security settings, and managing data transmission.
• Wi-Fi and Bluetooth Support: The stack supports both Wi-Fi (802.11 b/g/n) and Bluetooth (classic and BLE), allowing dual-mode wireless communication in a single module.
• Extensive API: The AT command set includes a wide range of functions for network configuration, data transmission, device control, and more, making it versatile for various applications.
• Firmware Updates: Espressif regularly updates the ESP-AT firmware, ensuring security improvements, bug fixes, and new features, which can be easily flashed to devices.

Benefits:

• Ease of Integration: The AT command interface abstracts the complexity of Wi-Fi and Bluetooth communication, making it easy for developers to integrate wireless functionality into their projects without needing in-depth protocol knowledge.
• Platform Agnostic: Since communication with the ESP module is done through simple serial commands, the ESP-AT stack can be used with a wide range of host microcontrollers and platforms, regardless of their operating systems or architectures.
• Low Resource Requirement: The host microcontroller only needs to manage serial communication, offloading the complex wireless protocol management to the ESP module, thus saving processing power and memory on the host MCU.
• Flexibility: The ESP-AT stack supports various modes of operation, including station mode, access point mode, and mesh networking, making it suitable for a broad range of IoT applications.
• Cost-Effective: Using the ESP-AT stack allows developers to leverage the inexpensive yet powerful ESP modules for wireless communication, reducing the overall cost of developing connected devices.

In summary, the Espressif ESP-AT stack simplifies the integration of Wi-Fi and Bluetooth functionalities into embedded systems, offering a versatile, low-cost, and resource-efficient solution for a wide range of IoT applications.

Software example

Here’s a short example on how to get data from an http server.

/*
 * Web Client example
 */
#include <WiFiEspAT.h>
#include <ChallengerWiFi.h>

const char* server = "arduino.tips";
const char ssid[] = "ssid";
const char pass[] = "pwd";

WiFiClient client;

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, LOW);

  Serial.begin(115200);
  while (!Serial)
    delay(10);

  ESP_SERIAL_PORT.begin(115200);
  if (Challenger2040WiFi.reset()) {
    Serial.println(F("WiFi Chip reset OK !"));
  } else {
    Serial.println(F("Could not reset WiFi chip !"));
    while(1);
  }

  WiFi.init(ESP_SERIAL_PORT);

  if (WiFi.status() == WL_NO_MODULE) {
    Serial.println();
    Serial.println("Communication with WiFi module failed!");
    // don't continue
    while (true);
  }

  Serial.printf("Firmware version %sn", WiFi.firmwareVersion());

  Serial.println();
  Serial.print("Attempting to connect to SSID: ");
  Serial.println(ssid);
  int status = WiFi.begin(ssid, pass);

  Serial.println();
  Serial.println("Connected to WiFi network.");

  Serial.println("Starting connection to server...");
  if (client.connect(server, 80)) {
    digitalWrite(LED_BUILTIN, HIGH);
    Serial.println("connected to server");
    client.println("GET /asciilogo.txt HTTP/1.1");
    client.print("Host: ");
    client.println(server);
    client.println("Connection: close");
    client.println();
    client.flush();
  }
}

void loop() {
  // if there are incoming bytes available
  // from the server, read them and print them
  while (client.available()) {
    static int flicker = 0;
  if (!(flicker++ % 10))
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
    char c = client.read();
    Serial.write(c);
  }

  // if the server's disconnected, stop the client
  if (!client.connected()) {
    digitalWrite(LED_BUILTIN, LOW);
    Serial.println();
    Serial.println("disconnecting from server.");
    client.stop();
    // Wait a while before repeating.
    delay(120000);
    Serial.println("Starting connection to server...");
    if (client.connect(server, 80)) {
      digitalWrite(LED_BUILTIN, HIGH);
      Serial.println("connected to server");
      client.println("GET /asciilogo.txt HTTP/1.1");
      client.print("Host: ");
      client.println(server);
      client.println("Connection: close");
      client.println();
      client.flush();
    } else {
      Serial.println("Failed to connect to server\nWaiting 10 seconds before retrying");
    }
  }
}

The Espressif ESP-Hosted Stack

Technical Description of the ESP-Hosted Stack

The Espressif ESP-Hosted stack is a software framework designed to allow Espressif’s Wi-Fi and Bluetooth-enabled chips, like the ESP32, to serve as network co-processors for a host microcontroller or processor. Unlike the ESP-AT stack, which relies on AT commands for communication, the ESP-Hosted stack provides a more advanced and efficient interface for integrating wireless connectivity into a wide range of devices.

Key Features:

• Network Co-Processor Functionality: The ESP-Hosted stack allows the ESP chip to handle all Wi-Fi and Bluetooth networking tasks, offloading these complex operations from the host MCU or processor.
• High-Performance Interfaces: The stack supports communication between the ESP chip and the host processor via high-speed interfaces such as SPI, SDIO, and UART, ensuring efficient data transfer and low latency.
• Flexible Firmware: The ESP-Hosted stack can be customized and extended to meet specific application needs, offering more control and flexibility compared to AT command-based solutions.
• Comprehensive Networking Support: The stack includes support for various networking modes, security protocols, and features such as WPA3, mesh networking, and enterprise-level Wi-Fi configurations.

Benefits:

• Enhanced Performance: By using high-speed interfaces and offloading network tasks to the ESP chip, the ESP-Hosted stack enables higher data throughput and better overall system performance, making it ideal for demanding applications like video streaming or large-scale IoT deployments.
• Rich Networking Features: The ESP-Hosted stack provides advanced networking capabilities, including support for secure connections, multiple network interfaces, and efficient power management, making it suitable for both consumer and industrial applications.
• Reduced Development Complexity: Developers can focus on the core functionality of their application while the ESP chip manages all wireless communication, simplifying the integration process and reducing the time to market.
• Scalability: The ESP-Hosted stack is well-suited for applications that need to scale, such as smart home systems, industrial IoT, and enterprise-level deployments, due to its ability to handle multiple simultaneous connections and complex networking scenarios.
• Cross-Platform Compatibility: The stack is designed to work with various host processors and operating systems, making it a versatile solution that can be integrated into different types of hardware environments.

In summary, the Espressif ESP-Hosted stack provides a powerful and flexible solution for adding Wi-Fi and Bluetooth connectivity to embedded systems. By leveraging the capabilities of Espressif’s chips as network co-processors, it offers enhanced performance, rich features, and simplified integration for a wide range of IoT applications.

Information about the progress will be posted on our forum (https://ilabs.se/forum) so make sure you tune in.