Portenta Mid Carrier User Manual

Overview

The user manual comprehensively explains the Arduino Portenta Mid Carrier, compiling all its features in one place for easy accessibility. It includes instructions for setting up, testing, and using its various onboard functions.

This manual can help users deploy the Portenta Mid Carrier industrial prototyping, swift development of machine vision applications, control systems for active mechanical designs, and many more applications.

Hardware and Software Requirements

Hardware Requirements

The Portenta Mid Carrier requires one of the SOM boards from the Portenta Family for operation:

• Portenta X8
• Portenta C33
• Portenta H7

The following accessories are needed:

• USB-C® cable (either USB-C® to USB-A or USB-C® to USB-C®) (x1)
• Wi-Fi® Access Point or Ethernet with Internet access (x1)
• Compatible antennas like the Arduino Pro 4G Module Antennas Kit (x1)
• Power cables: Wires with a cross-sectional area ranging from 0.82 mm² to 1.3 mm², corresponding to AWG sizes 18 to 16

Software Requirements

To use the Portenta Mid Carrier with a Portenta X8, please follow these guidelines:

• Ensure your Portenta X8 has the latest Linux image. Check this section of Portenta X8's user manual to verify that your Portenta X8 is up-to-date.

For the smooth functioning of the Portenta Mid Carrier with the Portenta X8, it is crucial to have at least Linux image version > 746 on the Portenta X8. To update your board to the latest image, use the Portenta X8 Out-of-the-box method or manually flash it, downloading the most recent version from this link.

To enter Flashing Mode with the Portenta X8 and the Portenta Mid Carrier, please consult the BOOT DIP switch configuration instructions within the present user manual.

• You will need Arduino IDE 1.8.10+, Arduino IDE 2.0+, or the Arduino Web Editor if you plan to run Arduino code on the auxiliary microcontroller of the Portenta X8.

For using the Portenta Mid Carrier with a Portenta H7/C33:

• The Arduino IDE 1.8.10+, Arduino IDE 2.0+, or Arduino Web Editor is needed to use the Portenta H7/C33 to run the Arduino code.

Product Overview

The Portenta Mid Carrier enhances the functionality of the Portenta family boards by providing a user-friendly platform for rapid prototyping. Designed for versatility, the carrier is fully compatible with all the Portenta SOM, making it a robust choice for a wide array of development and prototyping applications. It conveniently brings all high-density signals within reach through dedicated headers.

This carrier provides access to various peripherals. It highlights a Mini PCIe connector for Cat.4 cellular modules, suitable for solutions requiring extensive network coverage. It also includes two CAN lines, Ethernet, microSD, USB, camera connectors for DVP and MIPI interfaces, and a Display Serial Interface (DSI) compatible with GIGA Display Shield. Additionally, it features dedicated debug pins and an RTC battery backup, further enhancing the development experience by simplifying processes.

Carrier Architecture Overview

The Portenta Mid Carrier is designed for the Portenta family of SOM boards and offers a versatile range of power supply options:

• Power input of 5.0 V via the screw terminal
• Power through USB-C® connection on Portenta SOM

Its extensive connectivity features include a USB-A port for peripheral devices, 1000 Mbit Base-T Ethernet, and various interfaces like SPI, I2C, I2S, and UART accessible through a dedicated male header. It also supports MIPI and ArduCam® camera connections. The MIPI connector is specifically designed for the Portenta X8.

The carrier integrates a microSD slot for data logging purposes. It has dedicated headers for diverse interface options, JTAG pins for debugging purposes, and a mini PCIe connector for Cat.4 cellular modules. The CAN bus can be used either via an onboard or external transceiver.

The Portenta Mid Carrier has the following characteristics:

• Compatible SOM boards: The carrier is compatible with the Portenta X8 (ABX00049), Portenta H7 (ABX00042/ABX00045/ABX00046) and Portenta C33 (ABX00074).

• Power management: The board can be powered up from different sources. The onboard screw terminal block allows a 5.0 V power supply to power the Portenta board, the carrier, and a mini PCIe module, if available.

  The USB-C® interface of the Portenta X8, H7, and C33 can supply the needed power to the board when a 4G Module is not connected. It will require a 5.0 V external power source when operating mPCIe modules to guarantee a consistent power supply for the Portenta SOM and its carrier.

The 5.0 V pin from the carrier's breakout male header can also power the board. The carrier can deliver a maximum current of 2.0 A and therefore wires of at least 0.82 mm2 / 18 AWG are recommended.

• USB connectivity: A USB-A female connector is used for data logging and supports 2.0 standard rates.

• Communication: The carrier supports Ethernet interface (X1) via RJ45 connector 1000 MBase-T connected to High-Density pins.

  The SPI (X2), I2C (x3), I2S (x1), and UART (x4) are accessible via dedicated breakout male header connectors (J14 - J15).

• Two CAN bus ports are available, and CAN1 has an onboard transceiver controlled via CAN1 DIP switch (SW2). The CAN0 bus can be used with an external transceiver. CAN0 and CAN1 are available via the breakout pins header.

• The MIPI interface (high-speed differential serial interface) is compatible only with the Portenta X8. Examples of supported devices include the OmniVision OV5647 and the Sony IMX219 sensors. For Portenta MCU SOM, the ArduCam® connector is also available, providing a Display Video Port (DVP) parallel interface.

• Storage: The board has a microSD card slot and a USB-A female connector for data logging operation purposes.

• Ethernet connectivity: The carrier offers a Gigabit Ethernet interface through an RJ45 connector 1000 MBase-T. The Ethernet properties can be configured with a dedicated 4-way DIP switch. More information can be found in the DIP switch configuration section.

• Mini PCIe Connector: The carrier has a mini PCIe (Peripheral Component Interconnect Express) connector, i.e., an expansion card interface for modules compatible with its standard, such as Cat.4 modems as Arduino Pro 4G Modules.

• PCIe Breakout Header: Besides the standard breakout header, the carrier also features a specific PCIe breakout header. This header provides access to each pin, enabling manual probing or the creation of external extensions for prototyping purposes.

• GIGA Display Shield Connector: The Portenta Mid Carrier features a Display Serial Interface (DSI), which matches the Mobile Industry Processor Interface (MIPI) specifications, allowing it to connect displays that support MIPI DSI signals through its MIPI/DSI connector.

  The GIGA Display Shield is compatible with the Portenta Mid Carrier. It is connected through the MIPI/DSI connector found on the carrier. This setup supports widely used frameworks like LVGL and GFX, enhancing its utility for various display applications.

• Breakout Header: The carrier eases access to all the high-density pins on the Portenta boards. It makes all pins associated with communication protocols, buses, and GPIOs easily accessible for various applications.

• Screw terminal block: The terminal block allows power supply line feed for the carrier and bus ports. It consists of VIN 5.0 VDC (x1), VCC 3.3 V (x1), CANH (CAN1) (x1), CANL (CAN1) (x1), and GND (x2).

• Debug interface: The carrier features an onboard 10x pin 1.27mm JTAG connector.

• DIP switch: The carrier features different DIP switches, allowing for different profiles for dedicated features or functionalities. The DIP switches are ETH CENTER TAP, BOOT, and CAN1. More information can be found in the DIP switch configuration section.

Carrier Topology

Pinout

Datasheet

The complete datasheet is available and downloadable as PDF from the link below:

• Portenta Mid Carrier Datasheet

Schematics

The complete schematics are available and downloadable as PDF from the link below:

• Portenta Mid Carrier Schematics

STEP Files

The complete STEP files are available and downloadable from the link below:

• Portenta Mid Carrier STEP files

Mechanical Information

In this section, you can find mechanical information about the Portenta Mid Carrier. The board's dimensions are all specified here, within top and bottom views, including the placements of the components onboard.

Suppose you desire to design and manufacture a custom mounting device or create a custom enclosure for your carrier. In that case, the following image shows the dimensions for the mounting holes and general board layout. The given dimensions are all in millimeters [mm].

You can also access the STEP files, available here.

For reference, the following diagram outlines the dimensions measured between the connectors.

First Use Of Your Portenta Mid Carrier

Stack The Carrier

The design of the Portenta Mid Carrier enables effortless stacking of your preferred Portenta board.

The illustration below demonstrates the pairing of the Portenta Mid Carrier with Portenta boards via High-Density connectors.

Once the Portenta is mounted on the carrier, you can power the carrier and begin prototyping.

Power The Board

The Portenta Mid Carrier offers several options for power supply:

• The most recommended method is using an external 5.0 V power supply connected to the VIN pin on the screw terminal block of the board. This approach ensures that the Portenta Mid Carrier, the SOM (System on Module), and any connected PCIe modules are adequately powered.

  To ensure the power demands are met, especially for the PMIC modules' external power, we recommend using cables that conform to appropriate electrical standards, such as ASTM B 258 standard, and can carry currents up to 2.0 A. Cables with a cross-sectional area ranging from 0.82 mm² to 1.3 mm², corresponding to AWG 18-16, should be adequate to manage 2.0 A of current.

  For detailed information about connection points, please refer to the board pinout section in the user manual. It is essential to ensure that the current provided meets the requirements of all components, as specified in the operating conditions table provided later.

• An external 5.0 V power supply can also be used, connected to the 5.0 V pin on the dedicated breakout header.

  This method can power the Portenta Mid Carrier, the SOM, and any connected PCIe modules.

  For further information on this type of connection, consult the board pinout section in the user manual. Ensure the power supply’s maximum current adheres to the specifications of all components.

• Using a USB-C® cable (not included) connected to the Portenta core board of your choice (like the Portenta X8, H7, or C33) also powers the selected core board and the Portenta Mid Carrier. When a mPCIe module is attached, a 5.0 V external power source will be needed to ensure all connected boards receive a steady power supply.

The Portenta Mid Carrier can deliver a maximum current of 2.0 A.

The following diagram provides an overview of the power connection options available on the Portenta Mid Carrier, illustrating the different ways it can be powered:

Please use a 5.0 V external power source when using an Arduino Pro 4G Module (EMEA / GNSS Global) or any other mPCIe modules due to their high power consumption. This is important for maintaining a stable power supply to the Portenta SOM and the carrier, particularly for extended periods of use.

The image below focuses on the terminal block area of the Portenta Mid Carrier. This close-up view highlights the specific position for connecting the 5 V power sources within the terminal block:

Refer to the power tree diagram to understand how power is distributed within the Portenta Mid Carrier. This diagram visually represents the allocation of power resources within the carrier:

Recommended Operating Conditions

To ensure the safety and longevity of the board, it is important to be aware of the Portenta Mid Carrier's operating conditions. The table provided below outlines the recommended operating conditions for the carrier:

The onboard screw terminal powers both the carrier and the connected Portenta board.

To ensure the power demands are met, and connectivity is reliable, especially for the PMIC modules' external power, we recommend using cables that conform to the appropriate electrical standards, such as ASTM B 258 standard and can carry currents up to 2.0 A. Cables with a cross-sectional area ranging from 0.82 mm² to 1.3 mm², corresponding to AWG 18-16, should be adequate to manage 2.0 A of current.

Carrier Characteristics Highlight

The Portenta Mid Carrier's functionality varies depending on which Portenta family board it is paired with. The table below outlines these differences:

This table provides a quick overview of the Portenta Mid Carrier's performance when paired with different Portenta boards. Each feature will be detailed in the subsequent section, and a guide on properly connecting the Portenta boards will be provided.

Hello World Carrier

Hello World Using Linux

Using Portenta X8 with Linux

To effectively use the Portenta Mid Carrier with the Portenta X8, align the High-Density connectors and the USB-C® port facing outside the carrier. The accompanying diagrams illustrate how to stack the board onto the carrier.

For optimal operation of the Portenta Mid Carrier with the Portenta X8, ensure you have at least version > 746 of the Linux image on the Portenta X8. The latest version can be downloaded [here]](https://downloads.arduino.cc/portentax8image/image-latest.tar.gz).

Hello World With Portenta X8 Shell

To verify the correct functioning of the Portenta Mid Carrier with the Portenta X8, we will use several Hello World examples with different approaches. These examples use Linux commands, Python® scripts, and the Arduino IDE to demonstrate various debugging methods and provide a basic introduction.

Starting with a Hello World example using Linux commands, we control GPIO through the Portenta X8's shell. Instructions for connecting to the Portenta X8 shell can be found here.

The commands below will help you set and control GPIO3, which can be linked to an LED or similar accessory.

Access the Portenta X8's shell using:

Copy
1adb shell
2sudo su -

Upon executing the

sudo su -

The default password is

fio

These grants root user access and the corresponding environment settings like

$HOME

$PATH.

These commands provide elevated access to the Portenta X8's shell, enabling system configuration changes that require administrative rights.

Use the following command to activate the GPIO device in

/sys/class/

Copy
1echo 163 > /sys/class/gpio/export

Check available GPIO elements with:

Copy
1ls /sys/class/gpio

This lists all initialized GPIOs. To view details of GPIO 163 (or GPIO3), use:

Copy
1ls /sys/class/gpio/gpio163

Once the GPIO3 elements are exported, configure the GPIO using this command to set the I/O state of the pin. It can be set as Input (

in

out

Copy
1echo <I/O> >/sys/class/gpio/gpio163/direction

For our example, we set the pin as Output:

Copy
1echo out >/sys/class/gpio/gpio163/direction

To confirm the pin's setting, use:

Copy
1cat /sys/class/gpio/gpio163/direction

After setting the GPIO as an output, control its state by setting it to High or Low.

To set the pin to HIGH:

Copy
1echo 1 >/sys/class/gpio/gpio163/value

To set the pin to LOW:

Copy
1echo 0 >/sys/class/gpio/gpio163/value

To stop controlling the GPIO, you can use the following command to unexport it, ensuring it no longer appears in the userspace:

Copy
1echo 163 >/sys/class/gpio/unexport

To confirm that the specified GPIO has been properly unexported, you can use the following command:

Copy
1ls /sys/class/gpio

This step helps you to prevent unintentional modifications to the GPIO element configuration.

Hello World Using Linux and Python® Scripts

Instead of manually toggling the GPIO3 on the Portenta X8 via the command line, we can use a Python® script for automation and extended control logic.

Here is a compatible script for the ADB shell on the Portenta X8:

Copy
1#!/usr/bin/env python3
2import time
3
4class GPIOController:
5    def __init__(self, gpio_number):
6        self.gpio_number = gpio_number
7        self.gpio_path = f"/sys/class/gpio/gpio{gpio_number}/"
8
9    def export(self):
10        with open("/sys/class/gpio/export", "w") as f:
11            f.write(str(self.gpio_number))
12
13    def unexport(self):
14        with open("/sys/class/gpio/unexport", "w") as f:
15            f.write(str(self.gpio_number))
16
17    def set_direction(self, direction):
18        with open(f"{self.gpio_path}direction", "w") as f:
19            f.write(direction)
20
21    def read_direction(self):
22        with open(f"{self.gpio_path}direction", "r") as f:
23            return f.read().strip()
24
25    def set_value(self, value):
26        with open(f"{self.gpio_path}value", "w") as f:
27            f.write(str(value))
28
29    def read_value(self):
30        with open(f"{self.gpio_path}value", "r") as f:
31            return int(f.read().strip())
32
33def main():
34    print("============================================")
35    print("Hello World!")
36    print("============================================")
37
38    gpio = GPIOController(163)
39
40    # Export GPIO
41    gpio.export()
42
43    # Set as output
44    gpio.set_direction("out")
45    if gpio.read_direction() == "out":
46        print("GPIO set as output.")
47        print("GPIO3 blinking 20 times")
48
49
50    # Turn on (set to 1) and then off (set to 0)
51    for i in range(1,20,1):
52        gpio.set_value(1)
53        time.sleep(1)
54        gpio.set_value(0)
55        time.sleep(1)
56
57
58    print("GPIO Unexport")
59    gpio.unexport()
60    print("End of the program")
61    exit()
62
63if __name__ == "__main__":
64    main()

The script can be named

hello_world_python.py

Copy
1adb push hello_world_python.py /home/fio

This uploads the file to the

/home/fio

Copy
1cd /home/fio

Use the following command to run the script:

Copy
1python3 hello_world_python.py

When the script runs, the Portenta Mid Carrier's GPIO3 will begin to toggle its state.

For more information on how the board operates and to maximize its use with the Portenta Mid Carrier, refer to the Portenta X8 user manual.

The Portenta X8 works in a Linux environment based on the Yocto Linux distribution. It is recommendable to read how the Portenta X8 works in terms of Linux environment here.

Hello World Using Arduino

Using Portenta X8 / H7 / C33 with Arduino

The Portenta X8 can also operate within the Arduino environment and retains the same hardware setup as explained here. It can become a handy tool when opting for the Remote Procedure Call (RPC) mechanism within development. You can find more information on RPC in the "Data Exchange Between Python® on Linux & Arduino Sketch" tutorial.

The Portenta H7 and C33 boards have hardware setups identical to the Portenta X8. To mount them on the Mid Carrier, please align the High-Density connectors along with the USB-C® port orientation facing outside the carrier.

The diagrams below show how the Portenta H7 and C33 stack on the carrier:

• Portenta H7

• Portenta C33

Hello World With Arduino

In this section, you will learn how to use the Portenta X8, Portenta H7, or Portenta C33 with the Portenta Mid Carrier. You will interact with the GPIO3 pin within the Arduino environment.

Upon connecting a compatible Portenta board to the Portenta Mid Carrier, launch the Arduino IDE and set up the following code:

Copy
1// the setup function runs once when you press reset or power the board
2void setup() {
3  // Initialize the digital pin of the chosen SOM as an output
4  pinMode(<DIGITAL_PIN>, OUTPUT);
5}
6
7// the loop function runs over and over again forever
8void loop() {
9  digitalWrite(<DIGITAL_PIN>, HIGH);         // turn the select pin on (HIGH is the voltage level)
10  delay(1000);                               // wait for a second
11  digitalWrite(<DIGITAL_PIN>, LOW);          // turn the select pin off by making the voltage LOW
12  delay(1000);                               // wait for a second
13}

Make sure to substitute

<DIGITAL_PIN>

• Portenta X8: PF_4
• Portenta H7: PD_5
• Portenta C33: 30

For instance, with the Portenta X8, the script will be:

Copy
1// the setup function runs once when you press reset or power the board
2void setup() {
3  // Initialize the digital pin of the chosen SOM as an output
4  pinMode(PF_4, OUTPUT);
5}
6
7// the loop function runs over and over again forever
8void loop() {
9  digitalWrite(PF_4, HIGH);         // turn the select pin on (HIGH is the voltage level)
10  delay(1000);                      // wait for a second
11  digitalWrite(PF_4, LOW);          // turn the select pin off by making the voltage LOW
12  delay(1000);                      // wait for a second
13}

Upon uploading the sketch to the board, GPIO3 will be driven to switch its state. The image below shows the anticipated outcome if an oscilloscope probe is connected to GPIO3, exemplifying a blinking LED or any actuator that imitates signal switching.

Please check out the following documentation below to better understand each board and optimize its use with the Portenta Mid Carrier:

• Portenta C33 user manual.
• Portenta H7 set-up guide.
• Portenta X8 user manual. Additionally, here is a tutorial for a detailed guide on uploading sketches to the M4 Core on Arduino Portenta X8.

Carrier Features and Interfaces

The carrier presents various features and interfaces to meet needs and applications. This section summarizes the key hardware interfaces, storage alternatives, and configuration methods incorporated into the carrier.

The following sub-sections offer a detailed examination of each feature's specifications, providing thorough information for the most effective use of the carrier.

Hardware Interfaces

The present sub-section delves into the fundamental hardware connection points and interfaces on the Portenta Mid Carrier. It covers a variety of components, from the mini PCIe interface to the connectors and camera interfaces.

High-Density Connectors

The Portenta X8, H7, and C33 models expand their capabilities using High-Density connectors. To fully grasp the functionality and layout of these connectors, it is recommended that you consult the detailed pinout documentation available for each Portenta model.

This documentation provides an in-depth view of the connectors, ensuring a comprehensive understanding of how they enhance the functionality of these devices.

• Complete Portenta X8 pinout information
• Complete Portenta H7 pinout information
• Complete Portenta C33 pinout information

Mini PCI Express Interface (J8)

Mini PCIe, short for Mini Peripheral Component Interconnect Express, is a compact version of the PCIe interface, predominantly used in laptops and small devices for adding functionalities like Wi-Fi®, Bluetooth®, and cellular modems.

These cards are significantly smaller than standard PCIe cards, typically measuring around 30 mm x 50.95 mm, and are designed to fit into the limited spaces of compact systems. They connect to a motherboard via a dedicated Mini PCIe slot, supporting PCIe and USB 2.0 interfaces. They are available in full-size and half-size variants.

In its portfolio, Arduino has two mini PCIe modules compatible with Portenta Mid Carrier, the Arduino Pro 4G Module, a Cat.4 modem mini PCIe card available in two variants: EMEA and GNSS Global.

The onboard Mini PCIe slot of the Portenta Mid Carrier has the following pin layout:

Mini PCIe Power Breakout Header (J9)

The Mini PCIe slot of the Portenta Mid Carrier has a dedicated breakout pin to control the power distribution of its interface.

To accommodate the power requirements and ensure reliable connectivity, jumper cables with appropriate electrical standards, such as ASTM B 258 standard, should be used to support a current of up to 2A. Jumper cables with a cross-sectional area of 0.82 mm² to 1.3 mm² (approximately equivalent to AWG 18-16) should support 2.0 A of current.

This precaution is necessary to prevent wire overheating and ensure reliable power transmission for the connected Mini PCIe-compatible module, such as Cat.4 modems. A minimum requirement to set the mini PCIe interface with the Portenta Mid Carrier consists of:

• 3V3 PCIE pin connected to 3V3 BUCK pin
• Properly inserted mini PCIe module, e.g., Pro 4G GNSS Module Global / Pro 4G EMEA Module

Please use a 5.0 V external power source when using an Arduino Pro 4G Module (EMEA / GNSS Global) or any other mPCIe modules due to their high power consumption. This is important for maintaining a stable power supply to the Portenta SOM and the carrier, particularly for extended periods of use.

The following animation shows the assembly process using a mini PCIe slot compatible with the Pro 4G module.

To immediately jump to the Pro 4G Module integration with the Portenta Mid Carrier, you can go to the Cat.4 Modem (Cellular Connectivity) subsection within the Network Connectivity section.

Accessing Mini PCIe Interface

It is possible to know if the compatible mini PCIe module has been correctly set up and detected using the Portenta X8. The Portenta Mid Carrier's mini PCIe lanes contain USB lines, and the Pro 4G Module is recognized as a USB module.

Thus, to verify that the Pro 4G Module has been correctly powered up and recognized by the Portenta X8 with the Portenta Mid Carrier, the following command is used instead of the

lspci

Copy
1lsusb

The above command will list the devices that the Portenta X8 has recognized. The following image shows similar results if the Pro 4G Module is detected.

To learn about implementing the Pro 4G Module with the Portenta Mid Carrier immediately, you can jump to the Cat.4 Modem (Cellular Connectivity) section under the Network Connectivity section.

MIPI Camera Connector(J10)

The Portenta Mid Carrier integrates a dedicated camera connector, enabling the Portenta X8 to interface with MIPI cameras. However, it is important to note that the out-of-the-box Alpine shell does not support specific commands directly through the ADB shell.

In contrast, the Portenta H7 and C33 models do not support the MIPI interface and thus cannot use the camera connector.

The MIPI connector's pin distribution is as follows:

The Portenta Mid Carrier supports MIPI cameras when paired with the Portenta X8, allowing for a flexible connection to compatible cameras via a flex cable.

The following camera devices are compatible:

• OmniVision OV5647 sensor (Raspberry Pi® Camera Module 1)
• Sony IMX219 sensor (Raspberry Pi® Camera Module 2)

Using Linux

To initialize the Raspberry Pi Camera v1.3, based on the OV5647 CMOS sensor, follow these steps using the Portenta X8 environment, which will set environment variables and specify camera and board overlays:

Copy
1fw_setenv carrier_custom 1

Copy
1fw_setenv is_on_carrier yes

Copy
1fw_setenv carrier_name mid

Copy
1fw_setenv overlays 'ov_som_lbee5kl1dx ov_som_x8h7 ov_carrier_breakout_usbfs ov_carrier_mid_pcie_mini ov_carrier_mid_ov5647_camera_mipi'

Then, you can consider proceeding to start the camera to capture beginning with the runtime directory definition for

Wayland

Copy
1export XDG_RUNTIME_DIR=/run # location of wayland-0 socket
2modprobe ov5647_mipi

Check the supported formats and controls of the connected video device:

Copy
1v4l2-ctl --list-formats-ext --device /dev/video0
2v4l2-ctl -d /dev/video0 --list-ctrls

Capture a single frame in JPEG format using GStreamer:

Copy
1export GST_DEBUG=3
2gst-top-1.0 gst-launch-1.0 -v v4l2src device=/dev/video0 num-buffers=1 ! "video/x-bayer, format=bggr, width=640, height=480, bpp=8, framerate=30/1"  ! bayer2rgbneon reduce-bpp=t ! jpegenc ! filesink location=/tmp/test.jpg

This command allows to capture one frame and save the file as

/tmp/test.jpg

GStreamer

Copy
1gst-top-1.0 gst-launch-1.0 -v v4l2src device=/dev/video0 num-buffers=300 ! "video/x-bayer, format=bggr, width=640, height=480, bpp=8, framerate=30/1"  ! bayer2rgbneon reduce-bpp=t ! queue ! waylandsink

Following these instructions, you can capture and stream video from the Raspberry Pi Camera v1.3 with the OV5647 sensor.

For improved image quality, consider using a MIPI camera module with an integrated Image Signal Processor (ISP).

ArduCam® Compatibility Via Camera Socket (J11)

The Portenta Mid Carrier is also characterized for compatibility with the ArduCam® via the Digital Video Port (DVP) interface. Its compatibility can go with HM01B0, HM0360, GC2145, or OV7675 modules.

The connection is accomplished via the Camera socket (J11), and it is specified as follows:

The following image shows the camera socket close-up of the Portenta Mid Carrier with an ArduCam® module that may be used to stack on the carrier.

As well as the following clip shows Arducam-F Shield V2 Camera module shield with OV2640, which is compatible with the Portenta Mid Carrier when paired with the Portenta H7 and C33.

Using Arduino

The arducam_dvp library provides an example that supports three types of camera models: OV7670, Himax HM0360, Himax HM01B0, and GC2145. It captures pixel data and stores it in a frame buffer. These stored frames can subsequently be accessed continuously for further processing. It is compatible with the Portenta H7, and the CameraCaptureRawBytes example looks as follows:

Copy
1#include "arducam_dvp.h"
2
3#define ARDUCAM_CAMERA_HM01B0
4
5#ifdef ARDUCAM_CAMERA_HM01B0
6    #include "Himax_HM01B0/himax.h"
7    HM01B0 himax;
8    Camera cam(himax);
9    #define IMAGE_MODE CAMERA_GRAYSCALE
10#elif defined(ARDUCAM_CAMERA_HM0360)
11    #include "Himax_HM0360/hm0360.h"
12    HM0360 himax;
13    Camera cam(himax);
14    #define IMAGE_MODE CAMERA_GRAYSCALE
15#elif defined(ARDUCAM_CAMERA_OV767X)
16    #include "OV7670/ov767x.h"
17    // OV7670 ov767x;
18    OV7675 ov767x;
19    Camera cam(ov767x);
20    #define IMAGE_MODE CAMERA_RGB565
21#elif defined(ARDUCAM_CAMERA_GC2145)
22    #include "GC2145/gc2145.h"
23    GC2145 galaxyCore;
24    Camera cam(galaxyCore);
25    #define IMAGE_MODE CAMERA_RGB565
26#endif
27
28FrameBuffer fb;
29
30void blinkLED(uint32_t count = 0xFFFFFFFF,uint32_t t_delay = 50)
31{
32    while (count--)
33    {
34        digitalWrite(LED_BUILTIN, LOW);  // turn the LED on (HIGH is the voltage level)
35        delay(t_delay);                  // wait for a second
36        digitalWrite(LED_BUILTIN, HIGH); // turn the LED off by making the voltage LOW
37        delay(t_delay);                  // wait for a second
38    }
39}
40
41
42void setup()
43{
44    pinMode(LED_BUILTIN, OUTPUT);
45    // Init the cam QVGA, 30FPS
46    if (!cam.begin(CAMERA_R320x240, IMAGE_MODE, 30))
47    {
48        blinkLED();
49    }
50    blinkLED(5);
51    Serial.begin(921600);
52}
53
54void loop()
55{
56    if(Serial.read() != 0x01)
57    {
58        blinkLED(1,10);
59        return;
60    }
61    // Grab frame and write to serial
62    if (cam.grabFrame(fb, 3000) == 0)
63    {
64        Serial.write(fb.getBuffer(), cam.frameSize());
65     }
66    else
67    {
68        blinkLED(20,100);
69        delay(1000);
70    }
71}

For the Portenta C33, given it has a different architecture, it is possible to navigate using the official ArduCam® source known as Arducam_Mega library.

GIGA Display Shield Connector (J19)

The Arduino GIGA Display Shield is an add-on that can be used with the Portenta Mid Carrier, offering an 800x480 display with touch support. The display shield can be connected via MIPI DSI (Display Serial Interface).

The shield also features a camera connector, built-in IMU, microphone, and an RGB pixel. The video display connector (J19) of the carrier is specified in the following table:

The MIPI DSI (Mobile Industry Processor Interface Display Serial Interface) connector provides a high-speed interface that supports complex display functionalities like high resolutions and color depths. Its design is suitable for compact and mobile devices, making it ideal for applications where space and power efficiency are critical.

The following image shows the orientation of the connection between the GIGA Display Shield and the Portenta Mid Carrier.

For a more detailed connection orientation with a brief pinout designation, the following diagram might help you understand how to stack the GIGA Display Shield to the Portenta Mid Carrier.

Once you have aligned and connected the Portenta Mid Carrier with the GIGA Display Shield, you should have a similar setup as in the following image:

Using Linux

To review the current device tree overlay configurations, which are crucial for hardware feature management and system customization, to interface with the GIGA Display Shield, use the following command:

Copy
1fw_printenv overlays

This command invokes the

fw_printenv

This can include enabling additional peripherals, configuring pin mappings, or activating specific hardware features, providing a flexible approach to hardware customization. From this, the following overlay should be available:

Copy
1ov_carrier_mid_dsi_panel

If it is not present, the following steps will help you to set the needed overlays to use the GIGA Display Shield. Access the docker container named x8-devel with the following command:

Copy
1docker exec -it x8-devel sh

This command uses docker exec to begin a new shell session inside the running x8-devel container. The

-it

We need to search for tenta_runner Python script, and the following command can help to locate the script:

Copy
1find / -name *.py

Starting from the root directory, this command recursively searches for files ending in

.py

Having located the tenta_runner.py, navigate to the directory using the following command:

Copy
1cd /root/examples/tenta-config

Run the tenta_runner.py script using the following command:

Copy
1python tenta_runner.py

The script will bring up a GUI within the

tenta

It will then show a list of available options that can be executed within the Portenta Mid Carrier platform. Here, the Enable alternative overlays option will be selected.

Because the GIGA Display Shield will be used, Removes video output on USB-C enables video output on DSI connector configuration will be selected. This configuration will disable video output via the USB-C connector and switch the video output to be available to the DSI connector.

Once selected, it will prompt a message showing differences that overlays will have after the change.

Proceed to accept with Ok, and the device will now be ready with the overlays to enable video output on the DSI connector.

We can now observe if the GIGA Display Shield is powered on and ready for use, having the shield connected to the Portenta Mid Carrier.

Using Arduino IDEs

With the Portenta H7, it is possible to use the following example:

Copy
1/*
2  ArduinoLogo
3
4  created 17 Apr 2023
5  by Leonardo Cavagnis
6*/
7
8#include "Arduino_H7_Video.h"
9#include "ArduinoGraphics.h"
10
11#include "img_arduinologo.h"
12// Alternatively, any raw RGB565 image can be included on demand using this macro
13// Online image converter: https://lvgl.io/tools/imageconverter (Output format: Binary RGB565)
14/*
15#define INCBIN_PREFIX
16#include "incbin.h"
17INCBIN(test, "/home/user/Downloads/test.bin");
18*/
19
20Arduino_H7_Video Display(800, 480, GigaDisplayShield);
21//Arduino_H7_Video Display(1024, 768, USBCVideo);
22
23Image img_arduinologo(ENCODING_RGB16, (uint8_t *) texture_raw, 300, 300);
24
25void setup() {
26  Display.begin();
27
28  Display.beginDraw();
29  Display.image(img_arduinologo, (Display.width() - img_arduinologo.width())/2, (Display.height() - img_arduinologo.height())/2);
30  Display.endDraw();
31}
32
33void loop() { }

It will require the ArduinoGraphics library installed to compile the code without any issues.

The example can be found within the Arduino IDE, and it is located under File -> Examples -> Portenta_H7_Video. The name of the example is ArduinoLogo.

Once the example has been compiled and uploaded to the Portenta H7, you will be able to see the Arduino logo drawn on the GIGA Display Shield.

CAN FD (Onboard Transceiver)

The Portenta Mid Carrier is equipped with a CAN bus port that connects to a screw terminal block. This bus incorporates the TJA1049 module. This high-speed CAN FD transceiver is integral to the Portenta Mid Carrier.

The TJA1049 module complies with various standards, including ISO 11898-2:2016, SAE J2284-1, and SAE J2284-5. These standards pertain to the CAN physical layer, ensuring reliable communication, especially during the fast phase of CAN FD.

Since CAN FD is accessible within the screw terminal block, we have highlighted the CAN bus ports within the screw terminal block pinout for reference. It is important to know that the onboard transceiver is attached for CAN1. The CAN bus port is controlled via the DIP switch for CANH and CANL lines. The following table shows the Screw Terminal Block (J4) with CAN1 Bus that is connected to the onboard transceiver of the Portenta Mid Carrier:

For stable CAN bus communication, it is recommended to install a 120 Ω termination resistor between CANH and CANL lines.

For more information on implementing the CAN Bus protocol, you can go directly to the CAN Bus section in the Communication section.

CAN FD (External Transceiver)

In addition to the onboard TJA1049 transceiver, the Portenta Mid Carrier allows for the integration of external CAN FD transceivers. This flexibility is crucial for applications requiring multiple CAN networks or specific transceiver characteristics not provided by the onboard module.

Integrating an external CAN FD transceiver involves connecting it to the Portenta Mid Carrier's I/O ports. Ensuring the external transceiver is compatible with the CAN FD protocol and adheres to relevant standards such as ISO 11898-2:2016.

The connection typically involves linking the transceiver's CANH and CANL lines to the respective pins (CAN0 TX/RX) on the Mid Carrier. Power and ground connections must be established according to the transceiver's specifications.

Some technical considerations must be taken into account as well:

• Compatibility: Ensure the external transceiver is compatible with the Portenta Mid Carrier's voltage levels and pin configurations.

• Termination Resistors: Like the onboard transceiver, it is recommended to use a 120 Ω termination resistor between the CANH and CANL lines of the external transceiver to ensure signal integrity.

• Software Configuration: Depending on the external transceiver used, software configuration might be necessary to establish communication between the Portenta Mid Carrier and the external module.

  This could involve setting up the correct CAN baud rate, configuring the CAN controller, and defining message filters.

There are some advantages to using an external transceiver:

• Customization: Users can select a transceiver with specific features such as higher fault tolerance, different voltage levels, or advanced diagnostics capabilities.

• Enhanced Performance: Some external transceivers might offer better performance regarding data rates or reliability in specific environmental conditions.

• Redundancy and Multiple Networks: External transceivers provide an effective solution for systems that require redundancy or need to connect to multiple CAN networks simultaneously.

Using an external CAN FD transceiver with the Portenta Mid Carrier makes it possible to customize the CAN network setup to specific requirements, ensuring both flexibility and robust application performance.

For detailed information about the CAN Bus protocol implementation, please refer to the CAN Bus section in the Communication section.

Storage Options

The Portenta Mid Carrier enhances its capabilities by offering storage options for data logging operations, allowing for effective data storage management. This sub-section provides insights into the onboard storage options and how to access and use them.

MicroSD Storage (J12)

The carrier features a microSD card slot, offering the option to expand storage capacity significantly. This is particularly useful for handling large volumes of data, such as sensor logs or onboard computer registries.

The detailed connector designation for the microSD slot is as follows:

Using Linux

To use a microSD card with the Portenta X8, run the following command to fetch a Docker container. This container eases the setup of elements essential for the microSD card interaction:

Copy
1docker run -it --cap-add SYS_ADMIN --device /dev/mmcblk1p1 debian:stable-slim bash

The command launches the image immediately after successfully downloading the container image. You will be directed inside the container once it is operational.

First, locate the partition scheme of the microSD card. If it lacks a partition table, create partitions using the

fdisk

To check if the Portenta X8 has detected the microSD card, enter either of these commands:

Copy
1lsblk
2
3# or
4fdisk -l

The microSD card typically appears as

/dev/mmcblk0

/dev/sdX

Before accessing the microSD card's contents, mount it. Create a directory to use as a mount point:

Copy
1mkdir -p /tmp/sdcard

Mount the microSD card to the previously defined directory with the correct partition number (e.g.,

p1

Copy
1mount /dev/mmcblk1p1 /tmp/sdcard

You can navigate to the mount point and view the contents of the microSD card:

Copy
1cd /tmp/sdcard
2ls

The' echo' command is useful for writing data on the microSD card. For instance, to make a hello.txt file with

"Hello World Carrier!"

Copy
1echo "Hello World Carrier!" > hello.txt

To read the contents of the file you have just created:

Copy
1cat hello.txt

This displays the saved content in hello.txt on your present shell.

Once you are done with the operations related to the microSD card, proceed to unmount its partition properly:

Copy
1umount /tmp/sdcard

If you need to format the SD card to the ext4 filesystem, use the following command. Please be cautious, as this will remove all data on the microSD card.

Copy
1# Please be aware that this command will erase all data on the microSD card.
2mkfs.ext4 /dev/mmcblk1p1

With this, you could write and read a text file on a microSD card using the Portenta X8 and Mid Carrier.

Using Arduino IDE

To learn how the microSD card slot works for enhanced storage with the Arduino IDE, please follow this guide.

For Portenta H7, you can use the following Arduino IDE script to test the mounted SD card within the Portenta Mid Carrier:

Copy
1#include "SDMMCBlockDevice.h"
2#include "FATFileSystem.h"
3
4SDMMCBlockDevice block_device;
5mbed::FATFileSystem fs("fs");
6
7void setup() {
8  Serial.begin(9600);
9  while (!Serial);
10
11  Serial.println("Mounting SDCARD...");
12  int err =  fs.mount(&block_device);
13  if (err) {
14    // Reformat if we can't mount the filesystem
15    // this should only happen on the first boot
16    Serial.println("No filesystem found, formatting... ");
17    err = fs.reformat(&block_device);
18  }
19  if (err) {
20     Serial.println("Error formatting SDCARD ");
21     while(1);
22  }
23
24  DIR *dir;
25  struct dirent *ent;
26  int dirIndex = 0;
27
28  Serial.println("List SDCARD content: ");
29  if ((dir = opendir("/fs")) != NULL) {
30    // Print all the files and directories within directory (not recursively)
31    while ((ent = readdir (dir)) != NULL) {
32      Serial.println(ent->d_name);
33      dirIndex++;
34    }
35    closedir (dir);
36  } else {
37    // Could not open directory
38    Serial.println("Error opening SDCARD\n");
39    while(1);
40  }
41  if(dirIndex == 0) {
42    Serial.println("Empty SDCARD");
43  }
44}
45
46void loop() {
47  // Empty
48}

If the micro SD card has been successfully detected and mounted, you will be able to see the list of the files printed on the Arduino IDE's Serial Monitor:

For Portenta C33, consider the following script for testing a mounted SD card.

Copy
1#include <vector>
2#include <string>
3#include "SDCardBlockDevice.h"
4#include "FATFileSystem.h"
5
6#define TEST_FS_NAME "fs"
7#define TEST_FOLDER_NAME "TEST_FOLDER"
8#define TEST_FILE "test.txt"
9#define DELETE_FILE_DIMENSION 150
10
11
12SDCardBlockDevice block_device(PIN_SDHI_CLK, PIN_SDHI_CMD, PIN_SDHI_D0, PIN_SDHI_D1, PIN_SDHI_D2, PIN_SDHI_D3, PIN_SDHI_CD, PIN_SDHI_WP);
13FATFileSystem fs(TEST_FS_NAME);
14
15std::string root_folder       = std::string("/") + std::string(TEST_FS_NAME);
16std::string folder_test_name  = root_folder + std::string("/") + std::string(TEST_FOLDER_NAME);
17std::string file_test_name    = folder_test_name + std::string("/") + std::string(TEST_FILE);
18
19void setup() {
20  /*
21   *  SERIAL INITIALIZATION
22   */
23  Serial.begin(9600);
24  while(!Serial) {
25
26  }
27
28  /* list to store all directory in the root */
29  std::vector<std::string> dir_list;
30
31  Serial.println();
32  Serial.println("##### TEST SD CARD with FAT FS");
33  Serial.println();
34
35  /*
36   *  MOUNTING SDCARD AS FATFS filesystem
37   */
38  Serial.println("Mounting SDCARD...");
39  int err =  fs.mount(&block_device);
40  if (err) {
41    // Reformat if we can't mount the filesystem
42    // this should only happen on the first boot
43    Serial.println("No filesystem found, formatting... ");
44    err = fs.reformat(&block_device);
45  }
46  if (err) {
47     Serial.println("Error formatting SDCARD ");
48     while(1);
49  }
50
51  /*
52   *  READING root folder
53   */
54
55  DIR *dir;
56  struct dirent *ent;
57  int dirIndex = 0;
58
59  Serial.println("*** List SD CARD content: ");
60  if ((dir = opendir(root_folder.c_str())) != NULL) {
61    while ((ent = readdir (dir)) != NULL) {
62
63      if(ent->d_type == DT_REG) {
64        Serial.print("- [File]: ");
65      }
66
67      else if(ent->d_type == DT_DIR) {
68        Serial.print("- [Fold]: ");
69        dir_list.push_back(ent->d_name);
70      }
71      Serial.println(ent->d_name);
72      dirIndex++;
73    }
74    closedir (dir);
75  }
76  else {
77    // Could not open directory
78    Serial.println("Error opening SDCARD\n");
79    while(1);
80  }
81
82  if(dirIndex == 0) {
83    Serial.println("Empty SDCARD");
84  }
85
86  bool found_test_folder = false;
87
88  /*
89   *  LISTING CONTENT of the first level folders (the one immediately present in root folder)
90   */
91
92  if(dir_list.size()) {
93    Serial.println();
94    Serial.println("Listing content of folders in root: ");
95  }
96  for(unsigned int i = 0; i < dir_list.size(); i++) {
97    if(dir_list[i] == TEST_FOLDER_NAME) {
98      found_test_folder = true;
99    }
100    Serial.print("- ");
101    Serial.print(dir_list[i].c_str());
102    Serial.println(":");
103
104    std::string d = root_folder + std::string("/") + dir_list[i];
105    if ((dir = opendir(d.c_str())) != NULL) {
106      while ((ent = readdir (dir)) != NULL) {
107        if(ent->d_type == DT_REG) {
108          Serial.print("   - [File]: ");
109        }
110        else if(ent->d_type == DT_DIR) {
111          Serial.print("   - [Fold]: ");
112        }
113        Serial.println(ent->d_name);
114      }
115      closedir (dir);
116    }
117    else {
118      Serial.print("ERROR OPENING SUB-FOLDER ");
119      Serial.println(d.c_str());
120    }
121  }
122
123  /*
124   *  CREATING TEST FOLDER (if does not exist already)
125   */
126
127  err = 0;
128  if(!found_test_folder) {
129    Serial.println("TEST FOLDER NOT FOUND... creating folder test");
130    err = mkdir(folder_test_name.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
131    if(err != 0) {
132      Serial.print("FAILED folder creation with error ");
133      Serial.println(err);
134    }
135  }
136
137  /*
138   *  READING TEST FILE CONTENT
139   */
140
141  if(err == 0) {
142    int file_dimension = 0;
143    FILE* fp = fopen(file_test_name.c_str(), "r");
144    if(fp != NULL) {
145      Serial.print("Opened file: ");
146      Serial.print(file_test_name.c_str());
147      Serial.println(" for reading");
148
149      fseek(fp, 0L, SEEK_END);
150      int numbytes = ftell(fp);
151      fseek(fp, 0L, SEEK_SET);
152
153      Serial.print("Bytes in the file: ");
154      Serial.println(numbytes);
155      file_dimension = numbytes;
156
157      if(numbytes > 0) {
158        Serial.println();
159        Serial.println("-------------------- START FILE CONTENT --------------------");
160      }
161
162      for(int i = 0; i < numbytes; i++) {
163        char ch;
164        fread(&ch, sizeof(char), 1, fp);
165        Serial.print(ch);
166      }
167
168      if(numbytes > 0) {
169        Serial.println("--------------------- END FILE CONTENT ---------------------");
170        Serial.println();
171      }
172      else {
173        Serial.println("File is EMPTY!");
174        Serial.println();
175      }
176
177      fclose(fp);
178    }
179    else {
180      Serial.print("FAILED open file ");
181      Serial.println(file_test_name.c_str());
182    }
183
184    /*
185     * DELETE FILE IF THE File dimension is greater than 150 bytes
186     */
187
188    if(file_dimension > DELETE_FILE_DIMENSION) {
189      Serial.println("Test file reached the delete dimension... deleting it!");
190      if(remove(file_test_name.c_str()) == 0) {
191        Serial.println("TEST FILE HAS BEEN DELETED!");
192      }
193    }
194
195    /*
196     * APPENDING SOMETHING TO FILE
197     */
198
199    fp = fopen(file_test_name.c_str(), "a");
200    if(fp != NULL) {
201      Serial.print("Opened file: ");
202      Serial.print(file_test_name.c_str());
203      Serial.println(" for writing (append)");
204      char text[] = "This line has been appended to file!\n";
205      fwrite(text, sizeof(char), strlen(text), fp);
206      fclose(fp);
207    }
208    else {
209      Serial.print("FAILED open file for appending ");
210      Serial.println(file_test_name.c_str());
211    }
212
213    /*
214     * READING AGAIN FILE CONTENT
215     */
216
217    fp = fopen(file_test_name.c_str(), "r");
218    if(fp != NULL) {
219      Serial.print("Opened file: ");
220      Serial.print(file_test_name.c_str());
221      Serial.println(" for reading");
222
223      fseek(fp, 0L, SEEK_END);
224      int numbytes = ftell(fp);
225      fseek(fp, 0L, SEEK_SET);
226
227      Serial.print("Bytes in the file: ");
228      Serial.println(numbytes);
229
230      if(numbytes > 0) {
231        Serial.println();
232        Serial.println("-------------------- START FILE CONTENT --------------------");
233      }
234
235      for(int i = 0; i < numbytes; i++) {
236        char ch;
237        fread(&ch, sizeof(char), 1, fp);
238        Serial.print(ch);
239      }
240
241      if(numbytes > 0) {
242        Serial.println("--------------------- END FILE CONTENT ---------------------");
243        Serial.println();
244      }
245      else {
246        Serial.println("File is EMPTY!");
247        Serial.println();
248      }
249
250      fclose(fp);
251
252    }
253    else {
254      Serial.print("FAILED open file for appending ");
255      Serial.println(file_test_name.c_str());
256    }
257  }
258
259}
260
261void loop() {
262  // Empty
263}

Once the micro SD card is recognized and accessed, its files will be shown in the Arduino IDE's Serial Monitor:

USB Interface (J13)

The Portenta Mid Carrier is equipped with a USB interface, which is USB 2.0, designed for data logging purposes.

For those interested in the specifics of the USB-A port's pinout, the table below provides detailed information on how the connections are distributed:

This USB-A interface can accommodate devices such as storage drives for data logging.

Using Linux

To demonstrate a write operation on a USB memory drive using the Portenta X8's shell, follow this sequence of commands:

Copy
1sudo su -

First, switch to root mode to obtain necessary permissions for mounting and unmounting peripherals, such as a USB memory drive.

Copy
1lsblk

The

lsblk

/dev/sda1

A helpful tip to pinpoint the newly connected USB drive is to run

lsblk

lsusb

Copy
1mkdir -p /mnt/USBmount

Here,

mkdir -p

/mnt/USBmount

Copy
1mount -t vfat /dev/sda1 /mnt/USBmount

This command mounts the USB drive (presumed to have a FAT filesystem, vfat) at

/dev/sda1

/mnt/USBmount

/mnt/USBmount

Copy
1cd /mnt/USBmount

An

ls

Copy
1ls

To create a simple text file with the message

Hello, World!

Copy
1dd if=<(echo -n "Hello, World!") of=/mnt/USBmount/helloworld.txt

This command uses

dd

echo

Hello, World!

dd

/mnt/USBmount

To read and display the file's contents in the shell:

Copy
1cat helloworld.txt

The

cat

Hello, World!

With these steps, you can effectively manage external storage devices like USB sticks or hard drives, expanding the storage capabilities of your solution with the Portenta Mid Carrier.

Using Arduino IDE

The following example illustrates the process of using the USB interface on the Portenta Mid Carrier with the Portenta C33 to interface with a Mass Storage Device (MSD).

By implementing this example, you can connect with and access data on a USB storage device, thus simplifying managing external storage through the USB interface.

Copy
1#include <vector>
2#include <string>
3#include "UsbHostMsd.h"
4#include "FATFileSystem.h"
5
6#define TEST_FS_NAME "usb"
7#define TEST_FOLDER_NAME "TEST_FOLDER"
8#define TEST_FILE "test.txt"
9#define DELETE_FILE_DIMENSION 150
10
11
12USBHostMSD block_device;
13FATFileSystem fs(TEST_FS_NAME);
14
15std::string root_folder       = std::string("/") + std::string(TEST_FS_NAME);
16std::string folder_test_name  = root_folder + std::string("/") + std::string(TEST_FOLDER_NAME);
17std::string file_test_name    = folder_test_name + std::string("/") + std::string(TEST_FILE);
18
19/* this callback will be called when a Mass Storage Device is plugged in */
20void device_attached_callback(void) {
21  Serial.println();
22  Serial.println("++++ Mass Storage Device detected ++++");
23  Serial.println();
24}
25
26void setup() {
27  /*
28   *  SERIAL INITIALIZATION
29   */
30  Serial.begin(9600);
31  while(!Serial) {
32
33  }
34
35  Serial.println();
36  Serial.println("*** USB HOST Mass Storage Device example ***");
37  Serial.println();
38
39  /* attached the callback so that when the device is inserted the device_attached_callback
40     will be automatically called */
41  block_device.attach_detected_callback(device_attached_callback);
42  /* list to store all directory in the root */
43  std::vector<std::string> dir_list;
44
45  /*
46   *  Check for device to be connected
47   */
48
49  int count = 0;
50  while (!block_device.connect()) {
51        if(count == 0) {
52          Serial.println("Waiting for Mass Storage Device");
53        }
54        else {
55          Serial.print(".");
56          if(count % 30 == 0) {
57            Serial.println();
58          }
59        }
60        count++;
61        delay(1000);
62  }
63
64  Serial.println("Mass Storage Device connected.");
65
66  /*
67   *  MOUNTIN SDCARD AS FATFS filesystem
68   */
69
70  Serial.println("Mounting Mass Storage Device...");
71  int err =  fs.mount(&block_device);
72  if (err) {
73    // Reformat if we can't mount the filesystem
74    // this should only happen on the first boot
75    Serial.println("No filesystem found, formatting... ");
76    err = fs.reformat(&block_device);
77  }
78
79  if (err) {
80     Serial.println("Error formatting USB Mass Storage Device");
81     while(1);
82  }
83
84  /*
85   *  READING root folder
86   */
87
88  DIR *dir;
89  struct dirent *ent;
90  int dirIndex = 0;
91
92  Serial.println("*** List USB Mass Storage Device content: ");
93  if ((dir = opendir(root_folder.c_str())) != NULL) {
94    while ((ent = readdir (dir)) != NULL) {
95      if(ent->d_type == DT_REG) {
96        Serial.print("- [File]: ");
97      }
98      else if(ent->d_type == DT_DIR) {
99        Serial.print("- [Fold]: ");
100        if(ent->d_name[0] != '.') { /* avoid hidden folders (.Trash might contain a lot of files) */
101          dir_list.push_back(ent->d_name);
102        }
103      }
104      Serial.println(ent->d_name);
105      dirIndex++;
106    }
107    closedir (dir);
108  }
109  else {
110    // Could not open directory
111    Serial.println("Error opening USB Mass Storage Device\n");
112    while(1);
113  }
114
115  if(dirIndex == 0) {
116    Serial.println("Empty SDCARD");
117  }
118
119  bool found_test_folder = false;
120
121  /*
122   *  LISTING CONTENT of the first level folders (the one immediately present in root folder)
123   */
124
125  if(dir_list.size()) {
126    Serial.println();
127    Serial.println("Listing content of folders in root: ");
128  }
129  for(unsigned int i = 0; i < dir_list.size(); i++) {
130    if(dir_list[i] == TEST_FOLDER_NAME) {
131      found_test_folder = true;
132    }
133    Serial.print("- ");
134    Serial.print(dir_list[i].c_str());
135    Serial.println(":");
136
137    std::string d = root_folder + std::string("/") + dir_list[i];
138    if ((dir = opendir(d.c_str())) != NULL) {
139      while ((ent = readdir (dir)) != NULL) {
140        if(ent->d_type == DT_REG) {
141          Serial.print("   - [File]: ");
142        }
143        else if(ent->d_type == DT_DIR) {
144          Serial.print("   - [Fold]: ");
145        }
146        Serial.println(ent->d_name);
147      }
148      closedir (dir);
149    }
150    else {
151      Serial.print("ERROR OPENING SUB-FOLDER ");
152      Serial.println(d.c_str());
153    }
154  }
155
156  /*
157   *  CREATING TEST FOLDER (if does not exist already)
158   */
159
160  err = 0;
161  if(!found_test_folder) {
162    Serial.println("TEST FOLDER NOT FOUND... creating folder test");
163    err = mkdir(folder_test_name.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
164    if(err != 0) {
165      Serial.print("FAILED folder creation with error ");
166      Serial.println(err);
167    }
168  }
169
170  /*
171   *  READING TEST FILE CONTENT
172   */
173
174  if(err == 0) {
175    int file_dimension = 0;
176    FILE* fp = fopen(file_test_name.c_str(), "r");
177    if(fp != NULL) {
178      Serial.print("Opened file: ");
179      Serial.print(file_test_name.c_str());
180      Serial.println(" for reading");
181
182      fseek(fp, 0L, SEEK_END);
183      int numbytes = ftell(fp);
184      fseek(fp, 0L, SEEK_SET);
185
186      Serial.print("Bytes in the file: ");
187      Serial.println(numbytes);
188      file_dimension = numbytes;
189
190      if(numbytes > 0) {
191        Serial.println();
192        Serial.println("-------------------- START FILE CONTENT --------------------");
193      }
194
195      for(int i = 0; i < numbytes; i++) {
196        char ch;
197        fread(&ch, sizeof(char), 1, fp);
198        Serial.print(ch);
199      }
200
201      if(numbytes > 0) {
202        Serial.println("--------------------- END FILE CONTENT ---------------------");
203        Serial.println();
204      }
205      else {
206        Serial.println("File is EMPTY!");
207        Serial.println();
208      }
209
210      fclose(fp);
211    }
212    else {
213      Serial.print("FAILED open file ");
214      Serial.println(file_test_name.c_str());
215    }
216
217    /*
218     * DELETE FILE IF THE File dimension is greater than 150 bytes
219     */
220
221    if(file_dimension > DELETE_FILE_DIMENSION) {
222      Serial.println("Test file reached the delete dimension... deleting it!");
223      if(remove(file_test_name.c_str()) == 0) {
224        Serial.println("TEST FILE HAS BEEN DELETED!");
225      }
226    }
227
228    /*
229     * APPENDING SOMETHING TO FILE
230     */
231
232    fp = fopen(file_test_name.c_str(), "a");
233    if(fp != NULL) {
234      Serial.print("Opened file: ");
235      Serial.print(file_test_name.c_str());
236      Serial.println(" for writing (append)");
237      char text[] = "This line has been appended to file!\n";
238      fwrite(text, sizeof(char), strlen(text), fp);
239      fclose(fp);
240    }
241    else {
242      Serial.print("FAILED open file for appending ");
243      Serial.println(file_test_name.c_str());
244    }
245
246    /*
247     * READING AGAIN FILE CONTENT
248     */
249
250    fp = fopen(file_test_name.c_str(), "r");
251    if(fp != NULL) {
252      Serial.print("Opened file: ");
253      Serial.print(file_test_name.c_str());
254      Serial.println(" for reading");
255
256      fseek(fp, 0L, SEEK_END);
257      int numbytes = ftell(fp);
258      fseek(fp, 0L, SEEK_SET);
259
260      Serial.print("Bytes in the file: ");
261      Serial.println(numbytes);
262
263      if(numbytes > 0) {
264        Serial.println();
265        Serial.println("-------------------- START FILE CONTENT --------------------");
266      }
267
268      for(int i = 0; i < numbytes; i++) {
269        char ch;
270        fread(&ch, sizeof(char), 1, fp);
271        Serial.print(ch);
272      }
273
274      if(numbytes > 0) {
275        Serial.println("--------------------- END FILE CONTENT ---------------------");
276        Serial.println();
277      }
278      else {
279        Serial.println("File is EMPTY!");
280        Serial.println();
281      }
282
283      fclose(fp);
284
285    }
286    else {
287      Serial.print("FAILED open file for appending ");
288      Serial.println(file_test_name.c_str());
289    }
290  }
291
292}
293
294void loop() {
295  // Empty
296}