From 5e925e5cad3d5c021687107afd21a44ca8ecd869 Mon Sep 17 00:00:00 2001 From: TaddyHC Date: Thu, 9 Mar 2023 18:59:50 -0600 Subject: [PATCH 1/8] Initial commit - Global Portenta X8 content update (User Manual) --- .../tutorials/01.user-manual/content.md | 385 ++++++++++-------- 1 file changed, 204 insertions(+), 181 deletions(-) diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md index 1b39307cfe..553a57ecff 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md @@ -1,7 +1,7 @@ --- beta: true title: '01. Portenta X8 User Manual' -description: 'Get a general overview of Portenta X8 and its features' +description: 'Get a general overview of Portenta X8 and its features.' difficulty: intermediate tags: - Embedded Linux @@ -20,6 +20,7 @@ software: ## Introduction + Portenta X8 is a powerful, industrial-grade System on Module with Linux OS preloaded onboard, capable of running device-independent software thanks to its modular container architecture. In this user manual, we will go through the foundations of the Portenta X8 to help you understand how the board works and how you can benefit from its advanced features. ## Required Hardware @@ -29,45 +30,48 @@ Portenta X8 is a powerful, industrial-grade System on Module with Linux OS prelo * 1x Wi-Fi® Access Point or Ethernet with Internet access ## Required Software -* Arduino IDE 1.8.10+, Arduino IDE 2.0+, or Arduino Web Editor + +* [Arduino IDE 1.8.10+](https://www.arduino.cc/en/software), [Arduino IDE 2.0+](https://www.arduino.cc/en/software), or [Arduino Web Editor](https://create.arduino.cc/editor) * Latest "Arduino Mbed OS Portenta Boards" Core > 3.0.1 * Latest Linux image available, check [this section](#portenta-x8-os-image-update) to verify if your Portenta X8 is already updated. ## Product Overview Portenta X8 offers the best of two approaches: flexibility of usage of Linux combined with real-time applications through the Arduino environment. Developers can now execute real-time tasks, while simultaneously performing high-performance processing on Linux cores. -So, let's have a look at its technical specification. - -### Architecture Overview +So, let's have a look at its technical specification. -Portenta X8 is a powerful, industrial-grade System on Module combining a Yocto Linux distribution with the well-known Arduino environment. +### Architecture Overview +Portenta X8 is a powerful, industrial-grade System on Module combining a Yocto Linux distribution with the well-known Arduino environment. ![Portenta X8 Tech Specs](assets/portenta_x8_call_outs.png "Portenta X8 Tech Specs") As you can see, Portenta X8 features two powerful computing units: + * **NXP® i.MX 8M Mini** Cortex®-A53 quad-core up to 1.8GHz per core + 1x Cortex®-M4 up to 400 MHz. This microprocessor is the one where the Yocto Linux distribution is running together with Docker containers (check [this section](#linux-environment) of this user manual to learn more). -* **STMicroelectronics STM32H747XI** dual-core Cortex®-M7 up to 480 MHz + M4 32 bit Arm® MCU up to 240 MHz. This microcontroller is the one where the "Arduino Mbed OS Portenta Boards" Core is running. M4 core is accessible and programmable by the user, while M7 is dedicated to establishing and guaranteeing the communication between i.MX 8M Mini and M4 as well as to manage peripherals through RPC. Check [this section](#arduino-environment) of this user manual to learn more. + +* **STMicroelectronics STM32H747XI** dual-core Cortex®-M7 up to 480 MHz + M4 32 bit Arm® MCU up to 240 MHz. This microcontroller is the one where the "Arduino Mbed OS Portenta Boards" Core is running. M4 core is accessible and programmable by the user, while M7 is dedicated to establishing and guaranteeing the communication between i.MX 8M Mini and M4 as well as to manage peripherals through RPC. Check [this section](#arduino-environment) of this user manual to learn more. The two computing units are responsible for different tasks, which are summarized in the table below. | NXP® i.MX 8M Mini | STMicroelectronics STM32H747XI (M4) | - | ------------------------------------------------------- | -------------------------------------------------------------- | - | Running Yocto Linux distribution with Docker containers | Running Arduino sketches with the Mbed OS Portenta Boards Core | + | ------------------------------------------------------- | -------------------------------------------------------------- | + | Running Yocto Linux distribution with Docker containers | Running Arduino sketches with the Mbed OS Portenta Boards Core | | Dedicated to high level tasks | Dedicated to real-time tasks | - | Manage network connectivity | No direct connection to any network stack | - | Manage network-based buses (e.g. Modbus TCP, etc.) | Manage field buses (e.g. Modbus RTU, CANbus, etc.) | - | Access to peripherals without concurrent access control | Access to peripherals without concurrent access control | + | Manage network connectivity | No direct connection to any network stack | + | Manage network-based buses (e.g. Modbus TCP, etc.) | Manage field buses (e.g. Modbus RTU, CANbus, etc.) | + | Access to peripherals without concurrent access control | Access to peripherals without concurrent access control | In addition to the above features, Portenta X8 guarantees security over time. A crypto element (i.e. [NXP® SE050C2](https://www.nxp.com/docs/en/data-sheet/SE050-DATASHEET.pdf)) ensures a secure connection at the hardware level and allows the board to be PSA certified from ARM® (click [here](https://www.psacertified.org/products/portenta-x8/) to learn more). -Moreover, Portenta X8 can be further customized to get a continuously maintained Linux kernel distribution and to keep security at first by Over-The-Air (OTA) device updates and fleet management. In order to activate these features, you need to create an Arduino Cloud for business account including the so-called **Portenta X8 Board Manager**. Portenta X8 Board Manager has been developed together with [Foundries.io](https://foundries.io/)) and allows a user to: +Moreover, Portenta X8 can be further customized to get a continuously maintained Linux kernel distribution and to keep security at first by Over-The-Air (OTA) device updates and fleet management. In order to activate these features, you need to create an Arduino Cloud for business account including the so-called **Portenta X8 Board Manager**. Portenta X8 Board Manager has been developed together with [Foundries.io](https://foundries.io/) and allows a user to: + * Securely maintain Linux distribution inside a FoundriesFactory, i.e. a dedicated workspace where all your Portenta X8 are provisioned and maintained. * Deploy and update applications packaged into containers, including both containers provided by Arduino or custom containers. * Get individual provisioning keys for each device. -* Perform secure Over-the-air (OTA) updates to target Portenta X8 devices/fleets +* Perform secure Over-the-air (OTA) updates to target Portenta X8 devices/fleets. -***Click [here](https://cloud.arduino.cc/plans#business) to learn more about Arduino Cloud for business and the Portenta X8 Board Manager add-on. Otherwise, check the [dedicated section](#working-with-portenta-x8-board-manager) of this user manual to start working with Portenta X8 Manager.*** +***Click [here](https://cloud.arduino.cc/plans#business) to learn more about Arduino Cloud for business and the Portenta X8 Board Manager add-on. Otherwise, check the [dedicated section](#working-with-portenta-x8-board-manager) of this user manual to start working with Portenta X8 Manager.*** ### Pinout @@ -76,57 +80,59 @@ The full pinout is available and downloadable as PDF from the link below: ### Datasheet -The full datasheet is available and downloadable as PDF from the link below: -* [Portenta X8 Datasheet](https://docs.arduino.cc/static/77d2be9902708fcb73b19d0f1173c6bb/ABX00049-datasheet.pdf) +The full datasheet is available and downloadable as PDF from the link below: +* [Portenta X8 Datasheet](https://docs.arduino.cc/static/e12188dbbde2deba83f37965615c3c5a/ABX00049-datasheet.pdf) ### Schematics -The full schematics are available and downloadable as PDF from the link below: +The full schematics are available and downloadable as PDF from the link below: * [Portenta X8 Schematics](https://docs.arduino.cc/static/c92dbfc6c6a7c3f79c9987d36f017e48/ABX00049-schematics.pdf) ### STEP Files -The full _STEP_ files are available and downloadable from the link below: +The full _STEP_ files are available and downloadable from the link below: * [Portenta X8 STEP files](https://docs.arduino.cc/static/5d95e348688a9678e04d6f4d0b994844/ABX00049-step.zip) ### Linux Environment -As you already know, Portenta X8 is based on a Yocto Linux distribution. +As you already know, Portenta X8 is based on a Yocto Linux distribution. + +Before going into the details of Yocto distribution, it is important to understand how embedded Linux works. -Before going into the details of Yocto distribution, it is important to understand how embedded Linux works. The term **Embedded Linux** is used to define embedded systems based on the Linux Kernel and other open-source components. Over the years, Linux has established itself as the best operating system to be installed on embedded devices. This achievement is due to the fact that Linux is an open-source and completely free operating system. -An **Embedded Linux** system is composed of the following items: +An **Embedded Linux** system is composed of the following items: + * **Bootloader:** The first program executed right after powering the board. It has the task of initializing the hardware and loading the operating system loading the **device tree** and its configuration file into the RAM. The **device tree** is basically a database containing information on the hardware components of the board and it is used to forward information from the bootloader to the Kernel at the hardware level. * **Linux Kernel:** The core of the operating system. It deals with resource management, scheduling, hardware access and all the low-level operations which the user does not want to worry about. In particular, the Linux Kernel manages all the hardware resources, like CPU, memory and I/Os, and it provides a set of APIs that abstracts those resources allowing the user applications and libraries to be easily deployed. -* **Root Filesystem:** It contains all system programs and utilities, configurations and user data (roughly speaking, the equivalent of the `C:\` drive on Windows). The Root Filesystem can be mounted from a USB stick, SD card or flash memory, being the case of the Portenta X8. +* **Root Filesystem:** It contains all system programs and utilities, configurations and user data (roughly speaking, the equivalent of the `C:\` drive on Windows). The Root Filesystem can be mounted from a USB stick, SD card or flash memory, being the case of the Portenta X8. ![Embedded Linux Start-Up](assets/Embedded_Linux_Start.png "Embedded Linux Start-Up") #### Linux Yocto Distribution -In order to install a Linux operating system on a board, you need to decide which packages, applications and libraries you want to use, so basically you need to decide which Linux distribution better suits your needs. As a matter of fact, a Linux distribution is an operating system consisting of the Linux Kernel, GNU tools, additional software and a package manager. It may also include a display server and a desktop environment for using it as a regular desktop operating system. -There are more than 300 Linux distributions available in the market, like Ubuntu, Debian, Fedora, Red Hat, etc. +In order to install a Linux operating system on a board, you need to decide which packages, applications and libraries you want to use, so basically you need to decide which Linux distribution better suits your needs. As a matter of fact, a Linux distribution is an operating system consisting of the Linux Kernel, GNU tools, additional software and a package manager. It may also include a display server and a desktop environment for using it as a regular desktop operating system. There are more than 300 Linux distributions available in the market, like Ubuntu, Debian, Fedora, Red Hat, etc. + +Portenta X8 is running a [Yocto Linux distribution](https://www.yoctoproject.org/). Yocto is built on the basis of [OpenEmbedded (OE)](http://www.openembedded.org/wiki/Main_Page), which uses [BitBake](https://docs.yoctoproject.org/bitbake/) build to generate a full Linux image. BitBake and OE are combined together to form the Yocto reference project, historically called [Poky](https://www.yoctoproject.org/software-item/poky/). -Portenta X8 is running a [Yocto Linux distribution](https://www.yoctoproject.org/). Yocto is built on the basis of [OpenEmbedded (OE)](http://www.openembedded.org/wiki/Main_Page), which uses [BitBake](https://docs.yoctoproject.org/bitbake/) build to generate a full Linux image. BitBake and OE are combined together to form the Yocto reference project, historically called [Poky](https://www.yoctoproject.org/software-item/poky/). +In addition, a full selection of metadata is defined to select which tasks to be performed. The following metadata is used in a Yocto project: -In addition, a full selection of metadata is defined to select which tasks to be performed. The following metadata is used in a Yocto project: * **Recipes:** They deliver information regarding each package (i.e. author, homepage, license, etc.), recipe version, existing dependencies, source code location and how to retrieve it, configuration settings and target path where the created package will be saved. Files with the `.bb` extension are recipe files. -* **Configuration file:** They contain metadata that define how to perform the build process. These files (with `.conf` file extension) determine the configuration options for the machine, the compiler, the distribution and general and user configurations. They allow you to set the target where you want to create the image and where you want to save the downloaded sources and other particular configurations. +* **Configuration file:** They contain metadata that define how to perform the build process. These files (with `.conf` file extension) determine the configuration options for the machine, the compiler, the distribution and general and user configurations. They allow you to set the target where you want to create the image and where you want to save the downloaded sources and other particular configurations. * **Classes:** Class files, which have the extension `.bbclass`, contain common functionalities that can be shared between various recipes within the distribution. When a recipe inherits a class, it also inherits its settings and functions. -* **File append:** With the extension `.bbappend`, File append extends or overwrites information for an existing recipe. +* **File append:** With the extension `.bbappend`, File append extends or overwrites information for an existing recipe. OpenEmbedded Core contains a recipe layer, classes and a set of associated files, common to all OE-based systems, including Yocto. This set of metadata is in fact maintained by both the Yocto project and the OpenEmbedded project. -The development environment of the Yocto distribution is made up of various functional areas, as shown in the figure below. +The development environment of the Yocto distribution is made up of various functional areas, as shown in the figure below. ![Yocto Distribution Architecture](assets/Yocto_Architecture.png "Yocto Distribution Architecture") * **Layer:** The layers allow you to separate metadata by differentiating them according to: software, hardware information, metadata concerning distribution and adopted policies. Within each layer, there are the `conf` (with layer-specific configuration files) and `recipes-` directories. To illustrate how to use layers to maintain modularity, consider the example of recipes to support a specific target, which usually resides in a BSP layer. In this scenario, those recipes should be isolated from other recipes and supporting metadata, like a new Graphical User Interface (GUI). You would then have a couple of layers: one for the configurations of the machine and one for the GUI environment. This would allow a specific machine to present special GUI features within the BSP layer, without affecting the recipes inside the GUI layer itself. All of this is possible via an append file. -* **Source file:** To cross-compile any software module, being it a distribution or an application, we must have access to various source files. The latter can be sourced from three different upstream areas: Upstream Project Releases (archived at a specific location), Local Projects (available at a certain local path) and Source Control Managers (like GitHub). +* **Source file:** To cross-compile any software module, being it a distribution or an application, we must have access to various source files. The latter can be sourced from three different upstream areas: Upstream Project Releases (archived at a specific location), Local Projects (available at a certain local path) and Source Control Managers (like GitHub). * **Package feeds:** This area contains packages generated by the build system and they will be used later to generate operating system images or Software Development Kits (SDKs). -* **Build System:** The Build System macroblock is the heart of the Yocto distribution. It contains various processes controlled by BitBake, a tool written in Python language. The Build System is responsible for parsing the metadata, from which it extracts the list of tasks to be performed. BitBake checks the software build process by using the recipes and, for each successfully completed task, it writes a *stamp* file in the Build Directory. -* **Images:** They are compressed forms of the Root Filesystem, ready to be installed on the target. BitBake releases multiple lists of images saved into the Build Directory, including *kernel-image*, *root-filesystem-image* and *bootloaders*. +* **Build System:** The Build System macroblock is the heart of the Yocto distribution. It contains various processes controlled by BitBake, a tool written in Python language. The Build System is responsible for parsing the metadata, from which it extracts the list of tasks to be performed. BitBake checks the software build process by using the recipes and, for each successfully completed task, it writes a *stamp* file in the Build Directory. +* **Images:** They are compressed forms of the Root Filesystem, ready to be installed on the target. BitBake releases multiple lists of images saved into the Build Directory, including *kernel-image*, *root-filesystem-image* and *bootloaders*. * **SDK:** From the SDK generation process you can get a standard SDK or an extensible SDK. In both cases, the output is an installation script of the SDK, which installs: a cross-development toolchain, a set of libraries and headers files; generating an environment setup script. The toolchain can be considered as part of the build system, while libraries and headers as target parts, since they are generated for the target hardware. ***If you want to learn more about how to work with Yocto Distribution on your Portenta X8, please check the [dedicated section](#working-with-linux) of this user manual.*** @@ -143,13 +149,14 @@ On one side, classic virtualization is able to virtualize an entire machine; on Traditional virtual machines share hardware resources, but the operating system and applications are on the host. This translates into long start-up times (it takes minutes) and considerable use of resources (several Gigabytes). Containers, on the other hand, share the operating system as well as the infrastructure with the host. This means that start-up times are short (a few seconds) and dimensions are significantly reduced (even a few KB). -Being able to "pack" applications and distribute them in any environment leads to a series of advantages in terms of: performance, time, costs and integration. As a matter of fact, containers can be an interesting way to simplify infrastructure complexity, provide maximum performance and optimize costs by eliminating virtual machine licenses. +Being able to "pack" applications and distribute them in any environment leads to a series of advantages in terms of: performance, time, costs and integration. As a matter of fact, containers can be an interesting way to simplify infrastructure complexity, provide maximum performance and optimize costs by eliminating virtual machine licenses. But let's see in detail some of the advantages of this technology: + * **Simple development, test and deployment:** The decoupling between applications and the environments in which they run allows you to deploy a container everywhere: on a public cloud, in a private data center or on a PC. Whatever the chosen environment, the container will always remain the same. This means that even applications updates can be released easily without involving the operating system hosting the container, or all the other containers in use. In a nutshell, if you have to update an application, it will not be necessary to restart the whole machine. * **Control version:** In the case that the deployment of an update was not successful, thanks to the containers architecture it is easier to roll back and to have the previous version working again in few time. * **Isolation and security:** In containers, applications and resources are isolated. This means that if an application has to be deleted, it will be sufficient to remove its container and the operation will delete everything that concerns it, such as temporary or configuration files. At the same time, since containers are isolated, each of them "sees" only their own processes, while the others will remain unknown. Security first! -* **Granularity:** It is possible to containerize not only an entire application, but also a single component. In this way, resources can be reduced into micro-services, guaranteeing greater control and improved performance. +* **Granularity:** It is possible to containerize not only an entire application, but also a single component. In this way, resources can be reduced into micro-services, guaranteeing greater control and improved performance. At this point, it is worth mentioning that Portenta X8 containers are based on [Docker](https://www.docker.com/). Docker is an open-source software platform, developed by the company with the same name, which allows you to create, test and distribute containerized applications. The goal of Docker is therefore to facilitate the creation and management of containers, in order to distribute the resources required for an application in any environment, always keeping the executed code under control. Docker containers can run everywhere, in on-premises data centers or in public and private clouds. Thanks to the virtualization at the operating system level, typical of this technology, Docker allows you to natively create containers in Linux environments. @@ -160,36 +167,38 @@ Docker specifically facilitates the interface between the container and the end The reasons for using Docker are therefore closely connected to the usefulness of the containers themselves, now indispensable tools for developing software based on a microservices architecture. In particular, this applies to the DevOps methodologies used for the development of native cloud applications, which provide for continuous integration / continuous deployment cycles, to guarantee the end user always and only the most up-to-date version. The technology behind containers, and therefore of Docker itself, can be extremely summarized in three key terms: + * **Builder:** tools used to create containers. In the case of Docker, this tool corresponds to the **Dockerfile**. * **Engine:** it is the engine that allows you to run containers, as in the case of **Docker command** and **Docker Daemon**. * **Orchestration:** technology used to manage containers, with full visibility of their execution status (tasks, servers / VMs, etc.), as in the case of **Docker Swarm** or the famous **Kubernetes**. -The fundamental advantage of a container is that it makes both the application and the execution environment configuration available. This allows you to manage the various images as instances, without having to install the application each time, as happens in the case of traditional procedures. +The fundamental advantage of a container is that it makes both the application and the execution environment configuration available. This allows you to manage the various images as instances, without having to install the application each time, as happens in the case of traditional procedures. As already mentioned, containers running with Docker are absolutely isolated and independent from each other and it is therefore possible to have complete control over their visibility and management, without any constraints whatsoever. The advantages in terms of IT security are obvious: if a container is corrupted, for example by exploiting a vulnerability of the application it is running, this event does not affect the functioning of the other running containers. Isolation prevents, or at least makes it more difficult, the propagation of the threat within the host system, allowing Docker to terminate the corrupted instance and restart it in completely safe conditions, as well as having traces of what happened in the system logs. Thus, Docker is able to ensure application security without sacrificing anything in terms of portability, guaranteeing full operation both on-premise and in the cloud, using open and closed APIs to respond optimally to any business need. -As shown in the image below, Docker needs to be installed in the host operating system and it is composed of three main items: +As shown in the image below, Docker needs to be installed in the host operating system and it is composed of three main items: + * ***docker-daemon:*** It is a service that runs on the host operating system and leverages Linux Kernel features to work. It allows the user to create a container and run it, starting from an image developed by the user or downloaded from a registry. * ***docker-cli:*** It is a command-line tool that allows the user to properly communicate with the *docker-daemon*. As a matter of fact, any operation on images or containers always starts via *docker-cli*. When Docker is installed, both the *docker-daemon* and the *docker-cli* are installed together and any operation always takes place via *docker-cli*, even if managed via *docker-daemon*. -* ***docker-hub:*** It is a [Docker image repository](https://hub.docker.com/) from which it is possible to download all the images of interest and run them to create containers. Alternatively, a user can create the needed images through a *dockerfile*, using the repository only to download the required base images (like Linux-alpine). +* ***docker-hub:*** It is a [Docker image repository](https://hub.docker.com/) from which it is possible to download all the images of interest and run them to create containers. Alternatively, a user can create the needed images through a *dockerfile*, using the repository only to download the required base images (like Linux-alpine). ![Docker host](assets/Docker_host.png "Docker host vs client") -Now it is time to highlight better which is the difference between an image and a container. In programming languages, an image can be assimilated to a class, while a container to an object. It is possible to create a container starting from an image and then run it, stop it or pause it. When it is no longer needed, it can be deleted without removing the corresponding image. +Now it is time to highlight better which is the difference between an image and a container. In programming languages, an image can be assimilated to a class, while a container to an object. It is possible to create a container starting from an image and then run it, stop it or pause it. When it is no longer needed, it can be deleted without removing the corresponding image. As already mentioned, images can be downloaded from a registry like Docker or they can be defined through a *dockerfile*. A *dockerfile* is a text file that contains all the commands (*FROM, COPY, CMD, ENTRYPOINT, etc.*) that a user can call from the command line to build various image layers. The *dockerfile* represents a definition of the image but not the final image, which can be built through `docker build` command. A Docker image is made up of many layers and includes everything needed to configure a container. In particular, all the layers an image contains are read-only and, consequently, the image itself is also read-only. In this way, it is possible to launch the image several times always creating the same container. When the container is created, a thin writable layer will be placed on top of the existing image layers and will be prepared to execute the main process command. This last writable layer will contain any changes made when the container is running, but will not affect the original underlying image. When the container is deleted, this thin writable layer is removed. -An important thing to keep in mind is that, even if Docker shares the Linux Kernel with the underlying host, it is always necessary to add a full operating system or a Linux distribution as the first layer. +An important thing to keep in mind is that, even if Docker shares the Linux Kernel with the underlying host, it is always necessary to add a full operating system or a Linux distribution as the first layer. ![Images and containers](assets/images_containers.png "Images vs containers") On the other hand, a container represents a process, which runs starting from an image. The important thing to understand is that a container has a lifecycle and, for this reason, it can reach different states depending on whether it is running or not. The lifecycle of a Container consists of the following states: * **Created:** This is the first state of the container lifecycle and it occurs after an image has been created with the command `docker create`. A writable thin layer is created on the specified image and prepared to execute the main process commands. Consider that in this state the container is created but not started. -* **Running:** This is the state in which the container is actually running. A container created through `docker create` or interrupted can be restarted through the command `docker start`. +* **Running:** This is the state in which the container is actually running. A container created through `docker create` or interrupted can be restarted through the command `docker start`. * **Paused:** A running container can be paused through the command `docker pause`. As a consequence, all the processes of the specified container are suspended or blocked. When a container is paused, both the file system and the RAM are not affected. * **Stopped:** A stopped container does not have any running process. When a container is stopped through the command `docker stop`, the file system is not affected, but the RAM gets deleted. This is the main difference between stopped and paused states. * **Deleted:** A container can be removed through the command `docker rm`. This implies the complete cancellation of all the data associated with the container, including file system, volume and network mapping. @@ -197,7 +206,7 @@ On the other hand, a container represents a process, which runs starting from an Let's now have a look at the main Docker commands. The full list can be found [here](https://docs.docker.com/engine/reference/commandline/docker/). Through the command `docker image ls` it is possible to check all the images installed on your Portenta. These images may have been downloaded from a repository using the command `docker pull XXX` or created from scratch with the command `docker build XXX` starting from a *dockerfile*. -Through the command `docker run XXX`, it is possible to run the image downloaded from the repository. But, if a user tries to launch a container through the command `docker run XXX` for a container whose image has not been downloaded yet, first the image will be downloaded and then the container will start running. +Through the command `docker run XXX`, it is possible to run the image downloaded from the repository. But, if a user tries to launch a container through the command `docker run XXX` for a container whose image has not been downloaded yet, first the image will be downloaded and then the container will start running. To verify whether a container is running as expected, it is possible to launch the command `docker ps`. @@ -217,33 +226,35 @@ From a user perspective, the process may appear to be the same as for other Ardu ### Communication Between Linux And Arduino -The two processors inside Portenta X8 need a communication mechanism to exchange data with one another. The communication mechanism that is used is called **RPC (Remote Procedure Call)**. +The two processors inside Portenta X8 need a communication mechanism to exchange data with one another. The communication mechanism that is used is called **RPC (Remote Procedure Call)**. -The expression RPC refers to the activation of a "procedure" or "function" by a program on a computer other than the one on which the program itself is executed. In other words, RPC allows a program to execute procedures "remotely" on "remote" computers (but accessible through a network). +The expression RPC refers to the activation of a "procedure" or "function" by a program on a computer other than the one on which the program itself is executed. In other words, RPC allows a program to execute procedures "remotely" on "remote" computers (but accessible through a network). -Essential to the concept of RPC is also the idea of transparency: the remote procedure call must in fact be performed in a way similar to that of the traditional "local" procedure call; the details of the network communication must therefore be "hidden" (i.e. made transparent) for the user. +Essential to the concept of RPC is also the idea of transparency: the remote procedure call must in fact be performed in a way similar to that of the traditional "local" procedure call; the details of the network communication must therefore be "hidden" (i.e. made transparent) for the user. The RPC paradigm is particularly suitable for distributed computing based on the client-server model: the "call procedure" corresponds to the "request" sent by the "client" and the "return value" of the procedure corresponds to the "response" sent by the "server". In fact, distributed computing uses the resources of several computers connected to each other in a network (usually via the Internet) to solve large-scale computational problems. -Although the ultimate goal of the RPC paradigm is to provide a remote procedure call mechanism whose semantics is essentially equivalent to that of the local procedure call (hence the aforementioned transparency of the mechanism), this equivalence is never fully achieved, due to difficulties that can arise in network communication (always subjected to failure). +Although the ultimate goal of the RPC paradigm is to provide a remote procedure call mechanism whose semantics is essentially equivalent to that of the local procedure call (hence the aforementioned transparency of the mechanism), this equivalence is never fully achieved, due to difficulties that can arise in network communication (always subjected to failure). Since there is no single obviously "right" way to handle these complications, RPC mechanisms can differ subtly in the exact semantics of the remote call. Some mechanisms, for example, have "at most once" semantics: in other words, a remote procedure call can fail (i.e. not be executed) but it is guaranteed not to result in multiple activations. The opposite approach is represented by the "at least once" semantics, which guarantees that the procedure is called at least once (it could therefore happen that it is activated several times). As a consequence, there are multiple types of RPC implementations. In the case of Portenta X8, **MessagePack-RPC** is used (check the [library repository](https://github.com/msgpack-rpc/msgpack-rpc) to get more details). It is an RPC implementation that uses MessagePack as a serialization protocol, i.e. data exchange is encoded in MsgPack format. It is transported over different protocols: + * OpenAMP via Shared Memory * SPI * Linux Char Device * TCP/IP - + ![Linux Arduino RPC](assets/linux_arduino_RPC.png "Linux Arduino RPC") -As you can see in the image above, the **M7 core** of **STM32H7** is used to facilitate the communication between the Linux and the Arduino environments. If an Arduino sketch is running on the **M4 core**, the **M7 core** will hand over any data/request between the M4 core and the Linux side. Due to this hardware design, traditional dual-core processing is not supported in the Portenta X8. +As you can see in the image above, the **M7 core** of **STM32H7** is used to facilitate the communication between the Linux and the Arduino environments. If an Arduino sketch is running on the **M4 core**, the **M7 core** will hand over any data/request between the M4 core and the Linux side. Due to this hardware design, traditional dual-core processing is not supported in the Portenta X8. At the same time, on the Linux side, there is a service that takes care of sending data between the two worlds, `m4-proxy`. -So, the communication between Arduino and Linux side will proceed as follow (check the image below): +So, the communication between Arduino and Linux side will proceed as follow (check the image below): + * A program registers as the RPC server on port X for a list of procedures that the M4 may call * `m4-proxy` will forward the calls from the M4 to the registered program/port @@ -259,11 +270,11 @@ You can now start interacting with your Portenta X8. Portenta X8 comes with an e Connect the Portenta X8 to your PC via a USB-C® cable (either USB-C® to USB-A or USB-C® to USB-C®). -Once connected, you will see the Portenta X8 LEDs starting blinking. Portenta X8 features two LEDs, a Power LED and a Status LED, which can blink in parallel. +Once connected, you will see the Portenta X8 LEDs starting blinking. Portenta X8 features two LEDs, a Power LED and a Status LED, which can blink in parallel. ![Portenta X8 LEDs](assets/portenta_x8_leds.png "Portenta X8 LEDs") -The table below describes LEDs meaning and functionalities. +The table below describes LEDs meaning and functionalities. | LED Type | Colour | Meaning | | ------------ | ------------ | ------------------------------------------------| @@ -273,19 +284,19 @@ The table below describes LEDs meaning and functionalities. | Status LED | Green | Board connected to the Internet | | Status LED | Red | STM32H7 LED, blinking when triggered in the IDE | -### Out-Of-The-Box Experience +### Out-Of-The-Box Experience ***Before following this tutorial, please update your Portenta X8 to the latest version. Check [this section](#portenta-x8-os-image-update) to learn how to do it.*** -Once the Portenta X8 is correctly powered up, you can start interacting with it. +Once the Portenta X8 is correctly powered up, you can start interacting with it. -In order to do that, you have the possibility to connect to your Portenta X8 through [**ADB**](https://developer.android.com/studio/command-line/adb). Android Debug Bridge (ADB) is a tool included in the SDK software (Software Development Kit) and used, inter alia, to make an Android device and a computer to communicate with each other. +In order to do that, you have the possibility to connect to your Portenta X8 through [**ADB**](https://developer.android.com/studio/command-line/adb). Android Debug Bridge (ADB) is a tool included in the SDK software (Software Development Kit) and used, inter alia, to make an Android device and a computer to communicate with each other. -In the case of the Portenta X8, ADB allows to establish a reliable communication between Portenta X8 and a command-line interface of a computer. In order to check if you have already installed ADB on your computer, you have to verify you installed the latest **Mbed OS Portenta Core** from the IDE. Portenta core contains ADB in it. +In the case of the Portenta X8, ADB allows to establish a reliable communication between Portenta X8 and a command-line interface of a computer. In order to check if you have already installed ADB on your computer, you have to verify you installed the latest **Mbed OS Portenta Core** from the IDE. Portenta core contains ADB in it. ***If you need to install ADB, you can also download the right tool for your Operating System directly from the [official Android website](https://developer.android.com/studio/releases/platform-tools).*** -At this point, you can open your terminal window and look for ADB inside the directory **Arduino15/packages/arduino/tools/adb/32.0.0**. +At this point, you can open your terminal window and look for ADB inside the directory **Arduino15/packages/arduino/tools/adb/32.0.0**. ***The Arduino15 folder may have a different location depending on the Operating System you are using. Check [this article](https://support.arduino.cc/hc/en-us/articles/360018448279-Open-the-Arduino15-folder) to learn where your Arduino15 folder is located.*** @@ -293,7 +304,7 @@ To check if ADB is working correctly, you can type `adb devices`. Your Portenta ![Connection with ADB](assets/adb-connection.png "Connection with ADB") -To start the Out-of-the-box experience, you can continue typing in your terminal `adb forward tcp:8080 tcp:80`. With this command, ADB allows to forward the requests of the `8080 TCP-IP port` of your computer to the `80 TCP-IP port` of your device, that for this case it is the device with the name _Portenta X8_. +To start the Out-of-the-box experience, you can continue typing in your terminal `adb forward tcp:8080 tcp:80`. With this command, ADB allows to forward the requests of the `8080 TCP-IP port` of your computer to the `80 TCP-IP port` of your device, that for this case it is the device with the name _Portenta X8_. ![ADB forward command](assets/adb-tcp-port.png "ADB forward command") @@ -303,7 +314,8 @@ Now you can open your browser, go to [http://localhost:8080](http://localhost:80 #### Portenta X8 Out-Of-The-Box Homepage -This web page is hosted on the Portenta X8 and allows a user to: +This web page is hosted on the Portenta X8 and allows a user to: + - Get board details - [Configure Portenta X8 Wi-Fi®](#wi-fi-configuration) - [Interact with the board through the embedded Python® Alpine Shell](#portenta-x8-with-python-alpine-shell) @@ -312,25 +324,25 @@ This web page is hosted on the Portenta X8 and allows a user to: #### Wi-Fi Configuration -Click **Wi-Fi Settings** to start configuring your network connectivity. Otherwise, you can also connect your Portenta X8 to the Internet through an Ethernet cable, using a USB-C® hub with an RJ45 port or a Portenta Carrier. In this tutorial, Wi-Fi® connectivity will be used. +Click **Wi-Fi Settings** to start configuring your network connectivity. Otherwise, you can also connect your Portenta X8 to the Internet through an Ethernet cable, using a USB-C® hub with an RJ45 port or a Portenta Carrier. In this tutorial, Wi-Fi® connectivity will be used. ![Out-of-the-box Wi-Fi® Settings](assets/OOTB_homepage_Wifi.png "Out-of-the-box Wi-Fi® Settings") -Select your Wi-Fi® SSID. You can either select a network from the available list or insert your SSID manually. +Select your Wi-Fi® SSID. You can either select a network from the available list or insert your SSID manually. ![Out-of-the-box Wi-Fi® SSID set-up](assets/OOTB_wifi_selection.png "Out-of-the-box Wi-Fi® SSID set-up") -Type your Wi-Fi® password. +Type your Wi-Fi® password. ![Out-of-the-box Wi-Fi® password set-up](assets/OOTB_wifi_SSID.png "Out-of-the-box Wi-Fi® password set-up") -Once it is connected, you will get a notification confirming your Portenta X8 is now connected to the selected network. +Once it is connected, you will get a notification confirming your Portenta X8 is now connected to the selected network. -Moreover, you can check the network you are connected to in the bottom left section of this dashboard. +Moreover, you can check the network you are connected to in the bottom left section of this dashboard. ![Out-of-the-box Wi-Fi® connection successful](assets/OOTB_wifi_connected.png "Out-of-the-box Wi-Fi® connection successful") -Now you can click **OK** and you will be redirected to the Out-of-the-box homepage shown below. +Now you can click **OK** and you will be redirected to the Out-of-the-box homepage shown below. ![Out-of-the-box Homepage](assets/OOTB_homepage.png "Out-of-the-box Homepage") @@ -341,7 +353,7 @@ Click the **Shell** button to start using your Portenta X8 with Python-Alpine. ![Out-of-the-box Shell button](assets/OOTB_homepage_shell.png "Out-of-the-box Shell button") -This shell is running in a Python-Alpine container embedded in Portenta X8. In this shell, you will find multiple examples under the directory `/root/examples`. Additionally, you can either add your own package through the command `apk add ` or start exploring the packages available online at [this link]( https://pkgs.alpinelinux.org/packages). +This shell is running in a Python-Alpine container embedded in Portenta X8. In this shell, you will find multiple examples under the directory `/root/examples`. Additionally, you can either add your own package through the command `apk add ` or start exploring the packages available online at [this link]( https://pkgs.alpinelinux.org/packages). ![Out-of-the-box Python-Alpine Shell](assets/OOTB_alpine_shell.png "Out-of-the-box Python-Alpine Shell") @@ -369,56 +381,56 @@ At this point, you will be asked to insert your API Key credentials and Organiza In order to get API keys, you need to log into your Arduino Cloud account and select the Space you would like your X8 to be provisioned into. -Thus, click on **GENERATE API KEY** in your Out-of-the-box dashboard. A new window will open in your web browser to allow you to login to your Arduino Cloud space. +Thus, click on **GENERATE API KEY** in your Out-of-the-box dashboard. A new window will open in your web browser to allow you to login to your Arduino Cloud space. ***If you want to learn more about what API keys are and how they work, please take a look at the dedicated documentation available at [this link](https://docs.arduino.cc/arduino-cloud/getting-started/arduino-iot-api).*** ![Arduino Cloud Login](assets/web_Cloud_login.png "Arduino Cloud Login") -Click on **SIGN IN**. If you do not have an Arduino Cloud account yet, create a new one from the same webpage. +Click on **SIGN IN**. If you do not have an Arduino Cloud account yet, create a new one from the same webpage. -Sign in to your Arduino Cloud account by adding your credentials, i.e. Username/email and Password. +Sign in to your Arduino Cloud account by adding your credentials, i.e. Username/email and Password. ![Arduino Cloud Sign in](assets/web_cloud_signin.png "Arduino Cloud Sign in") -You are now logged into your Arduino Cloud space. Go on by clicking on **API keys** in the bottom left-hand corner. +You are now logged into your Arduino Cloud space. Go on by clicking on **API keys** in the bottom left-hand corner. ![Arduino Cloud Homepage](assets/web_cloud_homepage.png "Arduino Cloud Homepage") -It is time to generate your API keys. Click on **CREATE API KEY** in the upper right-hand corner. +It is time to generate your API keys. Click on **CREATE API KEY** in the upper right-hand corner. ![Arduino Cloud New API Key](assets/web_cloud_new_api.png "Arduino Cloud New API Key") -Define a name for your API key, in this case *portenta-x8-test-API*, and click on **CONTINUE**. These API Keys are personal and visible just from your account. +Define a name for your API key, in this case *portenta-x8-test-API*, and click on **CONTINUE**. These API Keys are personal and visible just from your account. ![Arduino Cloud API Key name](assets/web_cloud_API_name.png "Arduino Cloud API Key name") -At this point, your API key has been created. Save the correspondent credentials in a safe storage space by clicking on **download the PDF**. +At this point, your API key has been created. Save the correspondent credentials in a safe storage space by clicking on **download the PDF**. -Keep this file safely stored, your API credentials cannot be recovered otherwise. If you lose it, you will have to generate new API keys by repeating the above procedure. +Keep this file safely stored, your API credentials cannot be recovered otherwise. If you lose it, you will have to generate new API keys by repeating the above procedure. ![Arduino Cloud API Key](assets/web_cloud_API_key.png "Arduino Cloud API Key") -The PDF file will look like the image below and it will include the credentials you need to copy and paste into the Out-of-the-box page. +The PDF file will look like the image below and it will include the credentials you need to copy and paste into the Out-of-the-box page. ![Arduino Cloud API Key PDF](assets/web_cloud_API_key_PDF.png "Arduino Cloud API Key PDF") -Thus, copy the **Client ID** and the **Client Secret** credentials and paste them into your Out-of-the-box dashboard as shown below. +Thus, copy the **Client ID** and the **Client Secret** credentials and paste them into your Out-of-the-box dashboard as shown below. ![Out-of-the-box with API Keys](assets/OOTB_cloud_API_copy.png "Out-of-the-box with API Keys") -If you are using an Arduino Cloud for Business account with Shared Spaces, you need to add also the Organization ID you would like your Portenta X8 to be provisioned into by clicking on **ADD ORGANIZATION**. +If you are using an Arduino Cloud for Business account with Shared Spaces, you need to add also the Organization ID you would like your Portenta X8 to be provisioned into by clicking on **ADD ORGANIZATION**. ![Out-of-the-box successful Cloud provisioning](assets/OOTB_cloud_success.png "Out-of-the-box successful Cloud provisioning") -In order to recover the Organization ID of your Shared Space on Arduino Cloud for Business, open your Arduino Cloud homepage and navigate to **Settings > General Settings** in the sidebar on the left. +In order to recover the Organization ID of your Shared Space on Arduino Cloud for Business, open your Arduino Cloud homepage and navigate to **Settings > General Settings** in the sidebar on the left. ![Space ID on Cloud Settings](assets/shared-space-settings.png "Space ID on Cloud Settings") -At this point, you can copy the **Space ID** of your Shared Space and paste it into your Out-of-the-box dashboard together with your API keys. +At this point, you can copy the **Space ID** of your Shared Space and paste it into your Out-of-the-box dashboard together with your API keys. ![API keys and Organization ID](assets/OOTB_cloud_organization_ID.png "API keys and Organization ID") -Click on **SETUP DEVICE** and you are ready to go, your Portenta X8 is now provisioned into your Arduino Cloud space. +Click on **SETUP DEVICE** and you are ready to go, your Portenta X8 is now provisioned into your Arduino Cloud space. ![Out-of-the-box successful Cloud provisioning](assets/OOTB_cloud_success.png "Out-of-the-box successful Cloud provisioning") @@ -426,48 +438,48 @@ Once provisioned, the Portenta X8 will be automatically linked to an example [Th ![Portenta X8 example Thing](assets/cloud_thing_created.png "Portenta X8 example Thing") -As already said, Arduino provides you with an example dashboard that will automatically set up and be visible live after your Portenta X8 has been provisioned. In order to make this dashboard to automatically update its data, you need to go back to your Out-of-the-box and launch the example. +As already said, Arduino provides you with an example dashboard that will automatically set up and be visible live after your Portenta X8 has been provisioned. In order to make this dashboard to automatically update its data, you need to go back to your Out-of-the-box and launch the example. -To do so, it is sufficient to copy the shown code `python3 examples/arduino_iot_cloud_example.py` and click on **Launch Example**. An Alpine-Python shell will open and you will have to paste the previous code here to launch the example. +To do so, it is sufficient to copy the shown code `python3 examples/arduino_iot_cloud_example.py` and click on **Launch Example**. An Alpine-Python shell will open and you will have to paste the previous code here to launch the example. ![Launching dashboard example](assets/OOTB_example_dashboard_launch.png "Launching dashboard example") -Now you can navigate to your dashboard [here](https://create.arduino.cc/iot/dashboards) to see your Portenta X8 LED blinking as well as the live temperature inside the microprocessor. +Now you can navigate to your dashboard [here](https://create.arduino.cc/iot/dashboards) to see your Portenta X8 LED blinking as well as the live temperature inside the microprocessor. ![Portenta X8 dashboard working](assets/cloud_dashboard_working.png "Portenta X8 dashboard working") ***If you face any issues during the provisioning of your Portenta X8, feel free to repeat the procedure above.*** ***If you would like to customize your Portenta X8 Things/Dashboards with your own data, check [this section](#working-with-arduino-cloud) of the user manual.*** -#### Portenta X8 Board Manager +#### Portenta X8 Board Manager ***Note: this is an optional step. Although the Portenta X8 Board manager opens a wide range of possibilities that are important for business applications, the Portenta X8 can be used for free without the need of any additional paid license*** -Now you can start connecting your Portenta X8 to the Portenta X8 Board Manager. To enjoy this feature, you need an Arduino Cloud for business account. +Now you can start connecting your Portenta X8 to the Portenta X8 Board Manager. To enjoy this feature, you need an Arduino Cloud for business account. Check the Arduino Cloud for business plan with Portenta X8 Manager [here](https://cloud.arduino.cc/plans#business) and create your Arduino Cloud account in a couple of steps (see the dedicated documentation at [this link](https://docs.arduino.cc/arduino-cloud/)). -When your Arduino Cloud for business account is correctly set up, log into it [here](https://cloud.arduino.cc/home/) and click on **Portenta X8 Board Manager**. +When your Arduino Cloud for business account is correctly set up, log into it [here](https://cloud.arduino.cc/home/) and click on **Portenta X8 Board Manager**. ![Arduino Cloud homepage with Portenta X8 Manager](assets/web_board_manager_cloud_integration.png "Arduino Cloud homepage with Portenta X8 Manager") -At this point, you will be asked to create a new account on [Foundries.io](https://foundries.io/) platform. It is recommended to register with the same email address you are currently using in your Arduino Cloud for business account. +At this point, you will be asked to create a new account on [Foundries.io](https://foundries.io/) platform. It is recommended to register with the same email address you are currently using in your Arduino Cloud for business account. ![Foundries.io login](assets/web_board_manager_foundries_login.png "Foundries.io login") -Add all your credentials and click on **Sign up**. +Add all your credentials and click on **Sign up**. ![Foundries.io sign up](assets/web_board_manager_signup.png "Foundries.io sign up") -So, let's create your brand new FoundriesFactory. Select **Arduino Portenta X8**, define a **Factory name** for your Factory and then click on **Create Factory**. +So, let's create your brand new FoundriesFactory. Select **Arduino Portenta X8**, define a **Factory name** for your Factory and then click on **Create Factory**. ![FoundriesFactory name](assets/web_board_manager_factory_name.png "FoundriesFactory name") -Your FoundriesFactory is correctly set-up. As you can see, the Factory does not have any device connected to it. +Your FoundriesFactory is correctly set-up. As you can see, the Factory does not have any device connected to it. ![FoundriesFactory homepage with no devices](assets/web_board_manager_factory_overview.png "FoundriesFactory homepage with no devices") -To provision your Portenta X8, you need to go back to your Out-of-the-box webpage and click on **Portenta X8 Manager** button. +To provision your Portenta X8, you need to go back to your Out-of-the-box webpage and click on **Portenta X8 Manager** button. ![Out-of-the-box Portenta X8 Manager](assets/OOTB_homepage_portenta_x8_manager.png "Out-of-the-box Portenta X8 Manager") @@ -475,27 +487,27 @@ Enter the Factory name you have just registered, in this case *user-test*, and a ![Out-of-the-box Factory and device registration](assets/OOTB_board_manager_factory_registration.png "Out-of-the-box Factory and device registration") -To complete the registration of the Board with the FoundriesFactory, copy the code that appeared in your Out-of-the-box. +To complete the registration of the Board with the FoundriesFactory, copy the code that appeared in your Out-of-the-box. ![Out-of-the-box Factory code challenge](assets/OOTB_board_manager_factory_challenge.png "Out-of-the-box Factory code challenge") -Click on **COMPLETE REGISTRATION** to be re-directed to the Foundries.io activation page. +Click on **COMPLETE REGISTRATION** to be re-directed to the Foundries.io activation page. -Paste your token in the text box and press **Next**. +Paste your token in the text box and press **Next**. -***The token code is valid for 15 minutes; if you do not paste it in this time span, you have to repeat all the above registration steps in your Out-of-the-box to generate a new code.*** +***The token code is valid for 15 minutes; if you do not paste it in this time span, you have to repeat all the above registration steps in your Out-of-the-box to generate a new code.*** ![FoundriesFactory pasted token](assets/web_board_manager_factory_challenge.png "FoundriesFactory pasted token") -Confirm the addition of your Portenta X8 by pressing **Connect**. +Confirm the addition of your Portenta X8 by pressing **Connect**. ![FoundriesFactory device confirmation](assets/web_board_manager_factory_challange_connect.png "FoundriesFactory device confirmation") -Go to your FoundriesFactory by clicking on **Factories Page**. +Go to your FoundriesFactory by clicking on **Factories Page**. ![FoundriesFactory device registration completed](assets/web_board_manager_factory_challenge_approved.png "FoundriesFactory device registration completed") -Now you will see the number of devices associated with your FoundriesFactory to be equal to 1. +Now you will see the number of devices associated with your FoundriesFactory to be equal to 1. ![FoundriesFactory with 1 device](assets/web_board_manager_factory_device.png "FoundriesFactory with 1 device") @@ -509,11 +521,11 @@ To verify your device status, click on your FoundriesFactory, go to **Devices** ### Portenta X8 with Arduino IDE -In this section you will learn how to upload a sketch to the M4 core on the STM32H747XI MCU. +In this section you will learn how to upload a sketch to the M4 core on the STM32H747XI MCU. -Open the Arduino IDE and make sure you downloaded the latest Arduino Mbed OS Portenta Boards Core. Learn how to do it by following [this tutorial](https://docs.arduino.cc/software/ide-v1/tutorials/getting-started/cores/arduino-mbed_portenta). +Open the Arduino IDE and make sure you downloaded the latest Arduino Mbed OS Portenta Boards Core. Learn how to do it by following [this tutorial](https://docs.arduino.cc/software/ide-v1/tutorials/getting-started/cores/arduino-mbed_portenta). -Select Portenta X8 in the board selector. +Select Portenta X8 in the board selector. ![IDE Board Selector](assets/x8-IDE.png "IDE Board Selector") @@ -532,7 +544,7 @@ void loop(){ } ``` -At this point, select the port of your device in the port selector menu and then press the Compile and Upload button. +At this point, select the port of your device in the port selector menu and then press the Compile and Upload button. Behind the curtains, the sketch gets compiled into a binary. That binary file is then uploaded to the Linux side of the Portenta X8. The flashing is done on the board itself by the RPC service running on Linux (see [Communication between Linux and Arduino section](#communication-between-linux-and-arduino) of this user manual to learn more). @@ -551,19 +563,19 @@ adb push /tmp/arduino/m4-user-sketch.elf ## Working with Linux -Now it is time to start interacting with the Linux OS embedded in your Portenta X8. To do that, you need to open your terminal window and look for ADB inside the directory **Arduino15/packages/arduino/tools/adb/32.0.0**. +Now it is time to start interacting with the Linux OS embedded in your Portenta X8. To do that, you need to open your terminal window and look for ADB inside the directory **Arduino15/packages/arduino/tools/adb/32.0.0**. To check if ADB is working correctly, you can type `adb devices`. Your Portenta X8 will be listed there. ![Connection with ADB](assets/adb-connection.png "Connection with ADB") -At this point, you can type `adb shell` to start communicating with your Portenta X8. +At this point, you can type `adb shell` to start communicating with your Portenta X8. ![ADB shell command](assets/adb-shell-command.png "ADB shell command") -As it is a Linux device, you can do tasks like creating files, changing directories, etc. +As it is a Linux device, you can do tasks like creating files, changing directories, etc. -To gain admin (root) access, type `sudo su -` and the password, which by default is `fio`. After that, the terminal prefix should turn red. +To gain admin (root) access, type `sudo su -` and the password, which by default is `fio`. After that, the terminal prefix should turn red. ![ADB shell with admin access](assets/adb-sudo-su.png "ADB shell with admin access") @@ -571,14 +583,15 @@ You can now freely program your Portenta X8 Linux OS. In the sections below you ### Manage Your Network Via CLI -In order to connect to a Wi-Fi® Access Point via CLI, you can use the network manager tool **nmcli**. These are some of the most used commands: -* `nmcli device Wi-Fi connect password ` to connect to a specific SSID +In order to connect to a Wi-Fi® Access Point via CLI, you can use the network manager tool **nmcli**. These are some of the most used commands: + +* `nmcli device wifi connect password ` to connect to a specific SSID * `nmcli de` to check the connection status * `nmcli connection show` to visualize the active network interfaces (and their types) on your Portenta X8 ### Inspect Real-Time Tasks And Logs Via CLI -Run `journalctl -f` to check the status of active services and possibly their errors, but also various system event logs. +Run `journalctl -f` to check the status of active services and possibly their errors, but also various system event logs. ![ADB shell journalctl package](assets/adb-shell-real-time-tasks.png "ADB shell journalctl package") @@ -595,27 +608,28 @@ By calling `journalctl` it is possible to take a look at the log of all the runn | 6 | Info | | 7 | Debug | -When you specify the error code, it shows all messages from that code and above. For example, if you specify error code 2, then it shows all messages with priority 2, 1 and 0. +When you specify the error code, it shows all messages from that code and above. For example, if you specify error code 2, then it shows all messages with priority 2, 1 and 0. -Additionally, you can also view logs for a specific time and date duration. You can use the `-- since` switch with a combination of `"yesterday"`, `"now"`, or a specific date and time `"YYYY-MM-DD HH:MM:SS"`. +Additionally, you can also view logs for a specific time and date duration. You can use the `-- since` switch with a combination of `"yesterday"`, `"now"`, or a specific date and time `"YYYY-MM-DD HH:MM:SS"`. -An example of how to use the command: +An example of how to use the command: ```arduino journalctl --since "2022-12-22 12:20:00" --until yesterday ``` ### Create And Upload Docker Containers To Portenta X8 -We created dedicated tutorials covering this topic. Go check them out: +We created dedicated tutorials covering this topic. Go check them out: * [Managing Containers with Docker on Portenta X8](https://docs.arduino.cc/tutorials/portenta-x8/docker-container) -* [Create and Upload a Custom Container to the Portenta X8](https://docs.arduino.cc/tutorials/portenta-x8/custom-container) -* [Running Wordpress and Database Containers on the Portenta X8](https://docs.arduino.cc/tutorials/portenta-x8/wordpress-webserver) +* [Deploy a Custom Container with Portenta X8 Manager](https://docs.arduino.cc/tutorials/portenta-x8/custom-container) +* [Running Wordpress & Database Containers on Portenta X8](https://docs.arduino.cc/tutorials/portenta-x8/wordpress-webserver) ### Output Video Content On A Screen -The USB-C® port on your Portenta X8 supports video output. As a consequence, you can freely connect a USB-C® monitor or a USB-C® to HDMI hub to your Portenta X8 to start visualizing video or other visual renders. +The USB-C® port on your Portenta X8 supports video output. As a consequence, you can freely connect a USB-C® monitor or a USB-C® to HDMI hub to your Portenta X8 to start visualizing video or other visual renders. + +Here you can find a list of validated compatible USB-C® to HDMI hubs: -Here you can find a list of validated compatible USB-C® to HDMI hubs: * [ACT AC7022](https://www.act-connectivity.com/en-us/usb-c-to-hdmi-multiport-adapter-4k-usb-hub-pd-pass-ac7022) * [ACT AC7041](https://www.act-connectivity.com/en-us/usb-c-to-hdmi-multiport-adapter-with-ethernet-ac7041) * [ACT AC7042](https://www.act-connectivity.com/en-us/usb-c-to-hdmi-multiport-adapter-with-ethernet-and-ac7042) @@ -630,29 +644,29 @@ You may want to build a custom image for the Portenta X8 with the source code pr ### Additional Tutorials -If you want to continue working with your Portenta X8, you can find tons of additional tutorials in the **Tutorials** section of our [Arduino Docs](https://docs.arduino.cc/hardware/portenta-x8). Go check them out! +If you want to continue working with your Portenta X8, you can find tons of additional tutorials in the **Tutorials** section of our [Arduino Docs](https://docs.arduino.cc/hardware/portenta-x8). Go check them out! -## Working With Arduino +## Working With Arduino -You have learned how to use your Portenta X8 with the Arduino IDE in the section [Portenta X8 with Arduino IDE](#portenta-x8-with-arduino-ide), but you can do much more with the Arduino environment, in particular leveraging the RPC communication between the Arduino layer and the Linux layer. +You have learned how to use your Portenta X8 with the Arduino IDE in the section [Portenta X8 with Arduino IDE](#portenta-x8-with-arduino-ide), but you can do much more with the Arduino environment, in particular leveraging the RPC communication between the Arduino layer and the Linux layer. You can have a look at this [GitHub repository](https://github.com/arduino/ArduinoCore-mbed/tree/master/libraries/RPC/examples) to have access to multiple IDE examples showing how to use RPC communication with Portenta X8. ***Check [Communication between Linux and Arduino](#communication-between-linux-and-arduino) section of this user manual to learn more about RPC.*** -You can build an Arduino sketch to manage all the tasks requiring real-time, including sensors communication, Fieldbus management, etc., and then send those data to a Cloud or remote server via multiple connectivity options, by leveraging the high-performance network management capabilities of Linux OS. +You can build an Arduino sketch to manage all the tasks requiring real-time, including sensors communication, Fieldbus management, etc., and then send those data to a Cloud or remote server via multiple connectivity options, by leveraging the high-performance network management capabilities of Linux OS. -For instance, try [Data Exchange Between Python® on Linux and an Arduino Sketch](https://docs.arduino.cc/tutorials/portenta-x8/python-arduino-data-exchange) tutorial to learn how to exchange sensor data between the Python® container embedded on Portenta X8 and an Arduino sketch. +For instance, try [Data Exchange Between Python® on Linux and an Arduino Sketch](https://docs.arduino.cc/tutorials/portenta-x8/python-arduino-data-exchange) tutorial to learn how to exchange sensor data between the Python® container embedded on Portenta X8 and an Arduino sketch. Additionally, if you are a more advanced user, you can check [Multi-Protocol Gateway With Portenta X8 & Max Carrier](https://docs.arduino.cc/tutorials/portenta-x8/multi-protocol-gateway) tutorial to develop your own multi-protocol gateway: receive data from a sensor with the Arduino layer via MQTT protocol, take advantage of RPC to establish communication between Arduino and Linux, and then send the acquired data to The Things Network via LoRaWAN® managed by the Linux layer. ## Working With Arduino Cloud -To start using your Portenta X8 with Arduino Cloud, provision your device as described in [this section](#portenta-x8-with-arduino-cloud). +To start using your Portenta X8 with Arduino Cloud, provision your device as described in [this section](#portenta-x8-with-arduino-cloud). Once ready, you will have the chance to customize Portenta X8 example Thing and Dashboard. This can be done by writing your own Python script leveraging the [Arduino IoT Cloud Python library](https://github.com/arduino/arduino-iot-cloud-py). Check the documentation and the examples inside the library to learn more about how to create your own Python application. -When your Python script is ready, you have to create a dedicated Dockerfile integrating your new script. The Dockefile needs the Out-of-the-box Python container (i.e. `arduino-ootb-python-devel`) to be able to correctly interact with your Arduino IoT Cloud account. +When your Python script is ready, you have to create a dedicated Dockerfile integrating your new script. The Dockefile needs the Out-of-the-box Python container (i.e. `arduino-ootb-python-devel`) to be able to correctly interact with your Arduino IoT Cloud account. So, open a terminal window and create a Dockerfile integrating the following code together with your Python script: @@ -670,14 +684,16 @@ You can create your own custom container and build them inside the Portenta X8. ```arduino docker build . -t x8-custom-devel ``` -Otherwise, if you are using a different architecture or building machine, use `buildx` command to specify which architecture your build should compile for: + +Otherwise, if you are using a different architecture or building machine, use `buildx` command to specify which architecture your build should compile for: ```arduino docker buildx build --platform linux/arm64 -t x8-custom-devel --load . ``` + In this way, your Docker image will be built and tagged with the name `x8-custom-devel`. -Now it is time for you to deploy the newly created Docker image. To do so, you need to save it somewhere and then deploy it on your Portenta X8. +Now it is time for you to deploy the newly created Docker image. To do so, you need to save it somewhere and then deploy it on your Portenta X8. ### Deploy Your Container With Docker Hub @@ -686,6 +702,7 @@ If you have a [Docker Hub account](https://hub.docker.com/), you can freely uplo ```arduino docker push yourhubusername/x8-custom-devel ``` + Your image is now available in your Docker Hub registry `yourhubusername`. At this point, you can directly pull the image to your Portenta X8. To do so, connect to your Portenta X8 through ADB. It can be found at `Arduino15\packages\arduino\tools\adb\32.0.0`. @@ -696,11 +713,12 @@ From that directory, you can pull the image to the location you prefer. adb shell portenta-x8$: docker pull x8-custom-devel ``` + Now your image is correctly deployed on your Portenta X8. ### Deploy Your Container Without Docker Hub -If you do not have a Docker Hub account, you can also save the Docker container locally as a .tar archive, and then you can easily load that to an image. +If you do not have a Docker Hub account, you can also save the Docker container locally as a .tar archive, and then you can easily load that to an image. To save a Docker image after you have built it, you can use the `docker save` command. For example, let's save a local copy of the `x8-custom-devel` docker image you made: @@ -713,9 +731,10 @@ At this point, you can directly pull the image to your Portenta X8. To do so, co ```arduino portenta-x8$: docker import /home/fio/x8-custom-devel_latest.tar.gz x8-custom-devel:latest ``` -Now your image is correctly deployed on your Portenta X8. -### Launch Your Container +Now your image is correctly deployed on your Portenta X8. + +### Launch Your Container In order to launch your brand new image, you need to create a new `docker-compose.yml`. To do so, first you must stop the current `docker-compose.yml`. @@ -728,7 +747,8 @@ You can now create the path for the new `docker-compose.yml`: ```arduino portenta-x8$: mkdir /var/sota/compose-apps/custom-devel && cd /var/sota/compose-apps/custom-devel && touch docker-compose.yml ``` -Before uploading, open the `docker-compose.yml` and edit it as follow to make it use the Docker image you have just created: + +Before uploading, open the `docker-compose.yml` and edit it as follow to make it use the Docker image you have just created: ```arduino services: @@ -760,23 +780,23 @@ It is now time to upload the new `docker-compose.yml` to your Portenta X8: portenta-x8$: docker-compose up --detach ``` -And you are ready to go! Your Portenta X8 Dashboards and Things can be customized multiple times with the same process. +And you are ready to go! Your Portenta X8 Dashboards and Things can be customized multiple times with the same process. ***If you are using the Portenta X8 Manager, go to [this documentation](https://docs.foundries.io/latest/tutorials/getting-started-with-docker/getting-started-with-docker.html) to learn how to upload the newly created container in your FoundriesFactory.*** ## Working With Portenta X8 Board Manager -As already mentioned, Portenta X8 Board Manager allows you to easily keep your Portenta X8 Linux image and corresponding containers up to date, even from remote through Over-The-Air (OTA) updates (via wireless connectivity). +As already mentioned, Portenta X8 Board Manager allows you to easily keep your Portenta X8 Linux image and corresponding containers up to date, even from remote through Over-The-Air (OTA) updates (via wireless connectivity). -Subscribe to an *Arduino Cloud for business* plan with Portenta X8 Board Manager to have access to all these features. Take a look at [this section](#portenta-x8-board-manager) of the user manual to learn more. +Subscribe to an *Arduino Cloud for business* plan with Portenta X8 Board Manager to have access to all these features. Take a look at [this section](#portenta-x8-board-manager) of the user manual to learn more. ### Device And Fleet Management With Portenta X8 Board Manager -Verify that your Portenta X8 is correctly added to your FoundriesFactory by checking if it is listed among the available devices under the **Devices** section. +Verify that your Portenta X8 is correctly added to your FoundriesFactory by checking if it is listed among the available devices under the **Devices** section. ![FoundriesFactory device overview](assets/web_board_manager_factory_device-overview.png "FoundriesFactory device overview") -If you want to check if your Portenta X8 is updated according to the latest available Target (i.e. update), you can check the color of the bulb under the status column. There are three main color options: +If you want to check if your Portenta X8 is updated according to the latest available Target (i.e. update), you can check the color of the bulb under the status column. There are three main color options: | Bulb color | Meaning | |-------------|--------------------------------| @@ -784,13 +804,13 @@ If you want to check if your Portenta X8 is updated according to the latest avai | Yellow | Device online and not updated | | Red | Device offline and not updated | -In this case, the Portenta X8 is connected to the network (and so to the FoundriesFactory), but it is not updated. +In this case, the Portenta X8 is connected to the network (and so to the FoundriesFactory), but it is not updated. -You can see the Target uploaded on your device under the Target column, i.e. *portenta-x8-lmp-569*, and get additional information about what is included in this specific Target by clicking on it. +You can see the Target uploaded on your device under the Target column, i.e. *portenta-x8-lmp-569*, and get additional information about what is included in this specific Target by clicking on it. ![FoundriesFactory device target specs](assets/web_board_manager_factory_device_specs.png "FoundriesFactory device target specs") -The above window also shows you all the container apps you have installed on your device and you can start using. +The above window also shows you all the container apps you have installed on your device and you can start using. If you scroll down in the same window, you can also have a look at the update history of that specific device. @@ -803,6 +823,7 @@ At this point, you can compare the Target uploaded on your Portenta X8 with the ***Learn how to update your Portenta X8 with your FoundriesFactory by checking the [dedicated section](#portenta-x8-os-image-update) of this user manual.*** This **Target** page contains the Linux images built each time something is committed in the repositories available under the **Source** section. In this section, you can find the four repositories that are used to customize the images: + * **ci-scripts.git:** Scripts that define the platform and container build jobs on the FoundriesFactory system. * **containers.git:** This is where containers and docker-compose apps are defined. It allows you to define which containers to build/deploy and how to orchestrate them on the platform. * **lmp-manifest.git:** The repo manifest for the platform build. It defines which layer versions are included in the platform image. This includes **meta-partner-arduino**, the layer containing Arduino-specific customizations (machine definition, device drivers, etc.). @@ -810,19 +831,19 @@ This **Target** page contains the Linux images built each time something is comm Committing to **lmp-manifest.git** or **meta-subscriber-overrides.git** repositories will create a platform Target, i.e. base Linux platform image. On the other hand, committing to **containers.git** will create a container Target including all the containers and docker-compose apps you would like to upload on your Portenta X8. Both these Targets will generate the artifacts specified in the **ci-scripts.git**, which includes all the required files to program the Target in case of platform build. -### RBAC With Portenta X8 Board Manager +### RBAC With Portenta X8 Board Manager -You do not have to be the only one in your organization with permission to update your Portenta X8 devices. The FoundriesFactory integrates a Role-Based-Access-Control functionality (RBAC) to allow users to add multiple teams with multiple members each. +You do not have to be the only one in your organization with permission to update your Portenta X8 devices. The FoundriesFactory integrates a Role-Based-Access-Control functionality (RBAC) to allow users to add multiple teams with multiple members each. You can start defining a new team by clicking on **Teams** section. ![FoundriesFactory Teams](assets/web_board_manager_team.png "FoundriesFactory Teams") -The level of access and specific permissions are defined by the team’s role in the FoundriesFactory. As you can notice from the image below, multiple roles and permissions are available. +The level of access and specific permissions are defined by the team’s role in the FoundriesFactory. As you can notice from the image below, multiple roles and permissions are available. ![FoundriesFactory Team roles and permissions](assets/web_board_manager_factory_team_roles.png "FoundriesFactory Team roles and permissions") -Once you created the team, you can go to the **Members** section of your FoundriesFactory to invite new members to the team. +Once you created the team, you can go to the **Members** section of your FoundriesFactory to invite new members to the team. ![FoundriesFactory new member](assets/web_board_manager_factory_member.png "FoundriesFactory new member") @@ -830,26 +851,27 @@ You can type the email addresses of your teammates and they will receive an auto ### FoundriesFactory FIOCTL -The FoundriesFactory includes a command line tool called [FIOCTL](https://docs.foundries.io/latest/getting-started/install-fioctl/index.html) which allows you to manage your Portenta X8 through your CLI. +The FoundriesFactory includes a command line tool called [FIOCTL](https://docs.foundries.io/latest/getting-started/install-fioctl/index.html) which allows you to manage your Portenta X8 through your CLI. -With this tool, you can easily upload containers to a board that is linked to your FoundriesFactory just by stating the FoundriesFactory name, the board name and the app you would like to upload. +With this tool, you can easily upload containers to a board that is linked to your FoundriesFactory just by stating the FoundriesFactory name, the board name and the app you would like to upload. ***Learn how to use this tool by checking the dedicated tutorial at [this link](https://docs.arduino.cc/tutorials/portenta-x8/custom-container) or the corresponding [Foundries documentation](https://docs.foundries.io/latest/getting-started/install-fioctl/index.html).*** ## Portenta X8 OS Image Update -It is recommended to check every now and then if your Portenta X8 image version is up to date, in order to have the latest security updates. +It is recommended to check every now and then if your Portenta X8 image version is up to date, in order to have the latest security updates. + +In the next sections, three major ways to update your Portenta X8 are described: -In the next sections, three major ways to update your Portenta X8 are described: * Update through Out-of-the-box experience (available for OS release XXXX or newer) * Update through Portenta X8 Manager in your Arduino Cloud for Business account (available for all OS releases) * Update for OS release V.399 ### Check Portenta X8 OS Release -In order to verify which OS release is flashed on your Portenta X8, you need to connect to your board through **ADB**, as explained in [this section](#working-with-linux) of this user manual. +In order to verify which OS release is flashed on your Portenta X8, you need to connect to your board through **ADB**, as explained in [this section](#working-with-linux) of this user manual. -At this point, you can type `cat /etc/os-release` in your command line window to get the OS release currently running on your device. +At this point, you can type `cat /etc/os-release` in your command line window to get the OS release currently running on your device. ![Get OS release](assets/adb-shell-os-release.png "Get OS Release") @@ -865,7 +887,7 @@ Open your Out-of-the-box as explained in [this section](#first-use). ![Out-of-the-box homepage](assets/OOTB_homepage.png "Out-of-the-box homepage") -Click on **CHECK FOR UPDATES** in the lower right corner. +Click on **CHECK FOR UPDATES** in the lower right corner. At this point, you have to select whether you would like to proceed with the update. If yes, click on **UPDATE**. @@ -875,13 +897,13 @@ During the update, do not turn off your Portenta X8 or disconnect it from the ne ![Successful update](assets/OOTB-succesful-OS-update.png "Successful update") -Once the update is finished, your Portenta X8 will automatically restart with the new Linux image in place. +Once the update is finished, your Portenta X8 will automatically restart with the new Linux image in place. At this point, if you would to continue to use your Out-of-the-box, you can open a new command line window and launch again the command `adb forward tcp:8080 tcp:80`. Now open your browser, go to [http://localhost:8080](http://localhost:8080) and the same Out-of-the-box dashboard will appear. #### Troubleshooting -If something gets wrong during the update, you still have the possibility to manually flash your Portenta X8 with the latest Linux image provided at [this link](https://github.com/arduino/lmp-manifest/releases). Follow [this tutorial](https://docs.arduino.cc/tutorials/portenta-x8/image-flashing) to learn how to flash your device manually. +If something gets wrong during the update, you still have the possibility to manually flash your Portenta X8 with the latest Linux image provided at [this link](https://github.com/arduino/lmp-manifest/releases). Follow [this tutorial](https://docs.arduino.cc/tutorials/portenta-x8/image-flashing) to learn how to flash your device manually. ### Update With Portenta X8 Board Manager @@ -893,9 +915,9 @@ If this is not the case, you can update your device using FoundriesFactory **Wav ### Update For OS Release V.399 -If your Portenta X8 is flashed with the OS release V.399, open a new Command Line window and type the following commands on your PC: +If your Portenta X8 is flashed with the OS release V.399, open a new Command Line window and type the following commands on your PC: -```arduino +```arduino user-pc$: wget https://downloads.arduino.cc/portentax8image/update-latest.tar.gz user-pc$: wget https://downloads.arduino.cc/portentax8image/aklite-offline-399.tar.gz @@ -903,13 +925,13 @@ user-pc$: adb push update-latest.tar.gz /home/fio user-pc$: adb push aklite-offline-399.tar.gz /home/fio ``` -These commands will make your V.399 compatible with [aklite-offline](https://docs.foundries.io/latest/user-guide/offline-update/offline-update.html) tool and will allow you to update your Portenta X8 to the latest image version Arduino released at that point in time. Arduino provides this tool for free for any Portenta X8 user to enable offline secure updates to all devices, even if those devices are not connected to any FoundriesFactory. +These commands will make your V.399 compatible with [aklite-offline](https://docs.foundries.io/latest/user-guide/offline-update/offline-update.html) tool and will allow you to update your Portenta X8 to the latest image version Arduino released at that point in time. Arduino provides this tool for free for any Portenta X8 user to enable offline secure updates to all devices, even if those devices are not connected to any FoundriesFactory. -After the updates have been correctly downloaded to your PC, you can open a Command Line window and connect to your Portenta X8 through `ADB Shell`, as explained in [this section](#working-with-linux) of this user manual. +After the updates have been correctly downloaded to your PC, you can open a Command Line window and connect to your Portenta X8 through `ADB Shell`, as explained in [this section](#working-with-linux) of this user manual. -Once your Portenta X8 is correctly connected to your PC, launch the following commands to update your device to the latest released OS image version: +Once your Portenta X8 is correctly connected to your PC, launch the following commands to update your device to the latest released OS image version: -```arduino +```arduino user-pc$: adb shell portenta-x8$: cd /home/fio @@ -919,26 +941,28 @@ portenta-x8$: export LD_LIBRARY_PATH=usr/lib/ portenta-x8$: usr/bin/aklite-offline install --src-dir /var/rootdirs/home/fio/offline-updates/ ``` -After the update process is finalized, you need to restart your Portenta X8 by pressing its button for around 10 seconds. Once restarted, your Portenta X8 will immediately start running the latest OS release. +After the update process is finalized, you need to restart your Portenta X8 by pressing its button for around 10 seconds. Once restarted, your Portenta X8 will immediately start running the latest OS release. ## Pins -In order to learn how to properly call GPIOs or other peripherals both in the Arduino environment or in Linux, with or without a carrier, you can check the following pinout diagrams: +In order to learn how to properly call GPIOs or other peripherals both in the Arduino environment or in Linux, with or without a carrier, you can check the following pinout diagrams: + * [Portenta X8 pinout](https://docs.arduino.cc/static/019dd9ac3b08f48192dcb1291d37aab9/ABX00049-full-pinout.pdf) * [Portenta Breakout pinout](https://docs.arduino.cc/static/1d4277f47a3df614b726a89b2129ec69/ASX00031-full-pinout.pdf) * [Portenta Max Carrier pinout](https://docs.arduino.cc/static/d0bd73b17e97af0fe376b7d518b18660/ABX00043-full-pinout.pdf) ## Communication -In this section you will learn how to make your Portenta X8 to communicate with multiple types of sensors or other external devices, leveraging the vast variety of supported interfaces: +In this section you will learn how to make your Portenta X8 to communicate with multiple types of sensors or other external devices, leveraging the vast variety of supported interfaces: + * [SPI](#SPI) * [I2C](#I2C) * [UART](#UART) * [Bluetooth®](#Bluetooth®) -### SPI +### SPI -In this case, a Portenta X8 with Portenta Breakout board is used to connect an external SPI device. +In this case, a Portenta X8 with Portenta Breakout board is used to connect an external SPI device. #### SPI With Linux @@ -946,10 +970,10 @@ You need to enable SPI support before using SPI devices. Open Portenta X8 Shell as explained [here](#working-with-linux). -```arduino +```arduino sudo madprobe spi-dev ``` -Insert the user password `fio`. +Insert the user password `fio`. An upcoming image release for the X8 will load the `spi-dev` modules automatically at boot. In the current version, please create a `/etc/modules-load.d/spi-dev.conf` file with the following content: @@ -957,7 +981,7 @@ An upcoming image release for the X8 will load the `spi-dev` modules automatical spi-dev ``` -and restart the board. +and restart the board. ```arduino echo "spi-dev" | sudo tee > /etc/modules-load.d/spi-dev.conf @@ -975,7 +999,7 @@ services: - /dev/spi-3 ``` -If the Linux user on which the container is running is not `root`, you need to set up the permissions for the user to access the SPI devices. You might add the required comments to an `entrypoint.sh` shell file (to be added to the `Dockerfile` or the `docker-compose.yml` file). +If the Linux user on which the container is running is not `root`, you need to set up the permissions for the user to access the SPI devices. You might add the required comments to an `entrypoint.sh` shell file (to be added to the `Dockerfile` or the `docker-compose.yml` file). ```arduino #!/usr/bin/env sh @@ -993,25 +1017,24 @@ gosu /usr/bin/python my_spi_service.py #### SPI Port Mapping -| Linux | Arduino Portenta Breakout | +| Linux | Arduino Portenta Breakout | |-------|---------------------------| -| 134 | **`SPI1 CK`** | +| 134 | **`SPI1 CK`** | | 135 | **`SPI1 COPI`** | | 136 | **`SPI1 CIPO`** | -| 137 | **`SPI1 CS`** | +| 137 | **`SPI1 CS`** | #### SPI With Arduino The `SPI` object is [mapped](https://github.com/arduino/ArduinoCore-mbed/blob/23e4a5ff8e9c16bece4f0e810acc9760d3dd4462/variants/PORTENTA_X8/pins_arduino.h#L85) as follows on the Portenta Breakout Board and can be deployed as usual: -| SPI Pin | Arduino Portenta Breakout | +| SPI Pin | Arduino Portenta Breakout | |---------|---------------------------| -| CIPO | Pin 0 (Header GPIO0) | +| CIPO | Pin 0 (Header GPIO0) | | COPI | Pin A6 (Header Analog) | | SCK | Pin A5 (Header Analog) | -| CS | Pin 1 (Header GPIO0) | - +| CS | Pin 1 (Header GPIO0) | ### I2C @@ -1021,15 +1044,15 @@ In this case, a Portenta X8 with Portenta Breakout board is used to connect an e You need to enable I2C support before using I2C devices. -Open Portenta X8 Shell as explained [here](#working-with-linux). +Open Portenta X8 Shell as explained [here](#working-with-linux). -Thus, execute the following command: +Thus, execute the following command: -```arduino +```arduino sudo madprobe i2c-dev ``` -Insert the user password `fio`. +Insert the user password `fio`. An upcoming image release for the X8 will load the `i2c-dev` modules automatically at boot. In the current version, please create a `/etc/modules-load.d/i2c-dev.conf` file with the following content: @@ -1037,7 +1060,7 @@ An upcoming image release for the X8 will load the `i2c-dev` modules automatical i2c-dev ``` -and restart the board. +and restart the board. ```arduino echo "i2c-dev" | sudo tee > /etc/modules-load.d/i2c-dev.conf @@ -1055,7 +1078,7 @@ services: - /dev/i2c-3 ``` -If the Linux user on which the container is running is not `root`, you need to set up the permissions for the user to access the I2C devices. You might add the required comments to an `entrypoint.sh` shell file (to be added to the `Dockerfile` or the `docker-compose.yml` file). +If the Linux user on which the container is running is not `root`, you need to set up the permissions for the user to access the I2C devices. You might add the required comments to an `entrypoint.sh` shell file (to be added to the `Dockerfile` or the `docker-compose.yml` file). ```arduino #!/usr/bin/env sh @@ -1119,7 +1142,7 @@ Since one of the `I2C` pins is GPIO-multiplexed, you need to detach it from the { pinMode(PA_12, INPUT); } - ``` + ``` ### UART @@ -1137,9 +1160,9 @@ Please note that the Arduino RS485 (thus the Arduino Modbus library) library is ### Bluetooth -Portenta X8 supports Bluetooth connectivity just on the Linux side. +Portenta X8 supports Bluetooth connectivity just on the Linux side. -In order to communicate with Bluetooth devices via the Portenta X8 Shell, you can use the Bluetooth utility **bluetoothctl**. These are some of the most used commands: +In order to communicate with Bluetooth devices via the Portenta X8 Shell, you can use the Bluetooth utility **bluetoothctl**. These are some of the most used commands: * `bluetoothctl devices` to list all the available Bluetooth devices * `bluetoothctl pair [mac_address]` to pair with a specific device through its MAC address * `bluetoothctl connect [mac_address]` to connect to a paired device From 7514d0ea317cfa827443bdc98c0ff947b4289b8a Mon Sep 17 00:00:00 2001 From: TaddyHC Date: Thu, 9 Mar 2023 19:17:27 -0600 Subject: [PATCH 2/8] General X8 content update --- .../boards/portenta-x8/tutorials/01.user-manual/content.md | 4 +++- .../tutorials/06.waves-fleet-managment/content.md | 4 ++-- .../tutorials/12.multi-protocol-gateway/content.md | 6 +++--- 3 files changed, 8 insertions(+), 6 deletions(-) diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md index 553a57ecff..9d7b854a89 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md @@ -197,7 +197,8 @@ An important thing to keep in mind is that, even if Docker shares the Linux Kern ![Images and containers](assets/images_containers.png "Images vs containers") On the other hand, a container represents a process, which runs starting from an image. The important thing to understand is that a container has a lifecycle and, for this reason, it can reach different states depending on whether it is running or not. The lifecycle of a Container consists of the following states: -* **Created:** This is the first state of the container lifecycle and it occurs after an image has been created with the command `docker create`. A writable thin layer is created on the specified image and prepared to execute the main process commands. Consider that in this state the container is created but not started. + +* **Created:** This is the first state of the container lifecycle and it occurs after an image has been created with the command `docker create`. A writable thin layer is created on the specified image and prepared to execute the main process commands. Consider that in this state the container is created but not started. * **Running:** This is the state in which the container is actually running. A container created through `docker create` or interrupted can be restarted through the command `docker start`. * **Paused:** A running container can be paused through the command `docker pause`. As a consequence, all the processes of the specified container are suspended or blocked. When a container is paused, both the file system and the RAM are not affected. * **Stopped:** A stopped container does not have any running process. When a container is stopped through the command `docker stop`, the file system is not affected, but the RAM gets deleted. This is the main difference between stopped and paused states. @@ -1163,6 +1164,7 @@ Please note that the Arduino RS485 (thus the Arduino Modbus library) library is Portenta X8 supports Bluetooth connectivity just on the Linux side. In order to communicate with Bluetooth devices via the Portenta X8 Shell, you can use the Bluetooth utility **bluetoothctl**. These are some of the most used commands: + * `bluetoothctl devices` to list all the available Bluetooth devices * `bluetoothctl pair [mac_address]` to pair with a specific device through its MAC address * `bluetoothctl connect [mac_address]` to connect to a paired device diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/06.waves-fleet-managment/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/06.waves-fleet-managment/content.md index dcec608f61..85ea4b9fe5 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/06.waves-fleet-managment/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/06.waves-fleet-managment/content.md @@ -30,13 +30,13 @@ This tutorial will show you how to define fleets and how to construct a Wave tha - Arduino Create account - Arduino Cloud for business subscription with Portenta X8 Manager add-on: [Learn more about here](https://cloud.arduino.cc/plans#business) - Foundries.io™ account (linked with the Arduino Cloud for business subscription) -- FoundriesFactory® and devices already attached to your Factory ([Check the Getting Started tutorial](https://docs.arduino.cc/tutorials/portenta-x8/out-of-the-box)) +- FoundriesFactory® and devices already attached to your Factory ([User Manual for setup process](tutorials/portenta-x8/user-manual#out-of-the-box-experience)) ## Instructions ### Setting Up the Terminal -Waves fleet management requires us to have the X8 setup with FoundriesFactory. If you have not done so, please follow our [Getting Started tutorial](https://docs.arduino.cc/tutorials/portenta-x8/out-of-the-box), as it will walk you through setting up the X8 with your Factory. +Waves fleet management requires us to have the X8 setup with FoundriesFactory. If you have not done so, please follow our [User Manual for setup process](tutorials/portenta-x8/user-manual#out-of-the-box-experience), as it will walk you through setting up the X8 with your Factory. To use Waves, you need to have fioctl installed and configured. Follow this [guide](https://docs.foundries.io/latest/getting-started/install-fioctl/index.html) to do so. Creating Waves and device groups will be done via the host, which is your factory. As such, the following commands will be entered in a terminal using fioctl to connect to your Factory. diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/12.multi-protocol-gateway/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/12.multi-protocol-gateway/content.md index 2eea2bf963..e35855bd89 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/12.multi-protocol-gateway/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/12.multi-protocol-gateway/content.md @@ -103,7 +103,7 @@ Before setting up the software, it is necessary to configure the hardware to be ![Multi-Protocol Gateway Hardware Setup](assets/multi-protocol-hardware.png) -***If you have not set up your Portenta X8, please have a look at [Portenta X8 Getting Started](https://docs.arduino.cc/tutorials/portenta-x8/out-of-the-box) tutorial*** +***If you have not set up your Portenta X8, please have a look at [User Manual's Out-of-the-box experience](tutorials/portenta-x8/user-manual#out-of-the-box-experience)*** ### Setting Up The Portenta X8 @@ -146,7 +146,7 @@ If you have not configured internal Wi-Fi® connectivity within the system, plea nmcli device wifi connect "SSID" password "PASSWORD" ``` -### Setting Up *The Things Network* +### Setting Up The Things Network You now have the prerequisites for the Portenta X8 ready, but since you are using the LoRa® connectivity, you will need a platform capable of receiving data transmitted from the Portenta X8 and Max Carrier. **The Things Network** will be the platform we will use to communicate using LoRaWAN®. On the platform, you will need to create an application to add the Portenta Max Carrier as an End-Device. @@ -154,7 +154,7 @@ You now have the prerequisites for the Portenta X8 ready, but since you are usin ![General End-Device Configuration](assets/ttn-end-device.png) -***To learn more about LoRa® and LoRaWAN®, please have a look at our [Arduino Guide to LoRa® and LoRaWAN®](https://docs.arduino.cc/learn/communication/lorawan-101). Additionally, if you wish to learn how to properly set up the End-Device in *The Things Network*, please read [this tutorial](https://docs.arduino.cc/tutorials/mkr-wan-1310/the-things-network) reference*** +***To learn more about LoRa® and LoRaWAN®, please have a look at our [Arduino Guide to LoRa® and LoRaWAN®](https://docs.arduino.cc/learn/communication/lorawan-101). Additionally, if you wish to learn how to properly set up the End-Device in The Things Network, please read [this tutorial](https://docs.arduino.cc/tutorials/mkr-wan-1310/the-things-network) reference*** We will now build a multi-protocol gateway using Portenta X8 and Max Carrier. From 13793e24af5d8d57ea4666fb5df28bfbb28a6c65 Mon Sep 17 00:00:00 2001 From: TaddyHC Date: Thu, 9 Mar 2023 19:25:13 -0600 Subject: [PATCH 3/8] Global X8 content update --- .../tutorials/01.user-manual/content.md | 30 +++++++++++-------- .../tutorials/10.datalogging-iot/content.md | 4 +-- .../12.multi-protocol-gateway/content.md | 2 +- .../13.wordpress-webserver/content.md | 4 +-- 4 files changed, 22 insertions(+), 18 deletions(-) diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md index 9d7b854a89..a7fa20a921 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md @@ -233,7 +233,7 @@ The expression RPC refers to the activation of a "procedure" or "function" by a Essential to the concept of RPC is also the idea of transparency: the remote procedure call must in fact be performed in a way similar to that of the traditional "local" procedure call; the details of the network communication must therefore be "hidden" (i.e. made transparent) for the user. -The RPC paradigm is particularly suitable for distributed computing based on the client-server model: the "call procedure" corresponds to the "request" sent by the "client" and the "return value" of the procedure corresponds to the "response" sent by the "server". In fact, distributed computing uses the resources of several computers connected to each other in a network (usually via the Internet) to solve large-scale computational problems. +The RPC paradigm is particularly suitable for distributed computing based on the client-server model: the "call procedure" corresponds to the "request" sent by the "client" and the "return value" of the procedure corresponds to the "response" sent by the "server". In fact, distributed computing uses the resources of several computers connected to each other in a network (usually via the Internet) to solve large-scale computational problems. Although the ultimate goal of the RPC paradigm is to provide a remote procedure call mechanism whose semantics is essentially equivalent to that of the local procedure call (hence the aforementioned transparency of the mechanism), this equivalence is never fully achieved, due to difficulties that can arise in network communication (always subjected to failure). @@ -350,6 +350,7 @@ Now you can click **OK** and you will be redirected to the Out-of-the-box homepa ***You can change your network by clicking on the Wi-Fi Settings button and repeat the steps from above.*** #### Portenta X8 with Python Alpine Shell + Click the **Shell** button to start using your Portenta X8 with Python-Alpine. ![Out-of-the-box Shell button](assets/OOTB_homepage_shell.png "Out-of-the-box Shell button") @@ -362,7 +363,7 @@ This shell is running in a Python-Alpine container embedded in Portenta X8. In t ***Note: this is an optional step. The Portenta X8 can be also used with a local IDE without the need for any internet connection.*** -Making Portenta X8 compatible with Arduino Cloud means opening a wide range of new applications. This compatibility is guaranteed by a brand-new Python container, which includes a dedicated [Arduino IoT Cloud Python library](https://github.com/arduino/arduino-iot-cloud-py). Through Arduino Cloud APIs, the Python container ensures full interaction and simple porting of any Python developed application in the Arduino Cloud. +Making Portenta X8 compatible with Arduino Cloud means opening a wide range of new applications. This compatibility is guaranteed by a brand-new Python container, which includes a dedicated [Arduino IoT Cloud Python library](https://github.com/arduino/arduino-iot-cloud-py). Through Arduino Cloud APIs, the Python container ensures full interaction and simple porting of any Python developed application in the Arduino Cloud. ***Check all the available Arduino Cloud plans [here](https://cloud.arduino.cc/plans#business) and create your Arduino Cloud account in a couple of steps (see the dedicated documentation at [this link](https://docs.arduino.cc/arduino-cloud/)).*** @@ -547,15 +548,16 @@ void loop(){ At this point, select the port of your device in the port selector menu and then press the Compile and Upload button. -Behind the curtains, the sketch gets compiled into a binary. That binary file is then uploaded to the Linux side of the Portenta X8. The flashing is done on the board itself by the RPC service running on Linux (see [Communication between Linux and Arduino section](#communication-between-linux-and-arduino) of this user manual to learn more). +Behind the curtains, the sketch gets compiled into a binary. That binary file is then uploaded to the Linux side of the Portenta X8. The flashing is done on the board itself by the RPC service running on Linux (see [Communication between Linux and Arduino section](#communication-between-linux-and-arduino) of this user manual to learn more). When the sketch has been uploaded successfully, the onboard LED of your Portenta X8 will start blinking at an interval of one second. -You can also upload the firmware manually if you like. To do so, you first need to compile the sketch: select **Export compiled binary** from the Sketch menu in the Arduino IDE. It will compile the sketch and save the binary file in the sketch folder. Alternatively, you can use the [Arduino CLI](https://arduino.github.io/arduino-cli/0.29/) to create an `elf` file. +You can also upload the firmware manually if you like. To do so, you first need to compile the sketch: select **Export compiled binary** from the Sketch menu in the Arduino IDE. It will compile the sketch and save the binary file in the sketch folder. Alternatively, you can use the [Arduino CLI](https://arduino.github.io/arduino-cli/0.29/) to create an `elf` file. To upload the firmware you can use the ADB tool that has been installed as part of the Portenta X8 core. It can be found at `Arduino15\packages\arduino\tools\adb\32.0.0`. From that directory, you can use the `adb` tool. To upload your compiled sketch, you just need to type the following command into your terminal window: + ``` adb push /tmp/arduino/m4-user-sketch.elf ``` @@ -618,9 +620,11 @@ An example of how to use the command: ```arduino journalctl --since "2022-12-22 12:20:00" --until yesterday ``` + ### Create And Upload Docker Containers To Portenta X8 We created dedicated tutorials covering this topic. Go check them out: + * [Managing Containers with Docker on Portenta X8](https://docs.arduino.cc/tutorials/portenta-x8/docker-container) * [Deploy a Custom Container with Portenta X8 Manager](https://docs.arduino.cc/tutorials/portenta-x8/custom-container) * [Running Wordpress & Database Containers on Portenta X8](https://docs.arduino.cc/tutorials/portenta-x8/wordpress-webserver) @@ -880,7 +884,7 @@ As shown in the image above, the OS release of this Portenta X8 corresponds to ` ### Update Through Out-Of-The-Box Experience -Leverage the integrated Out-of-the-box experience to update your Portenta X8 to the latest release. +Leverage the integrated Out-of-the-box experience to update your Portenta X8 to the latest release. ***Warning: The Out-of-the-box update feature is not a complete Over-The-Air (OTA) update, it allows the user to update only Portenta X8 default image and containers. It will overwrite any custom container application. Thus, it is recommended to make a local copy of your containers before updating your Portenta X8.*** @@ -967,13 +971,14 @@ In this case, a Portenta X8 with Portenta Breakout board is used to connect an e #### SPI With Linux -You need to enable SPI support before using SPI devices. +You need to enable SPI support before using SPI devices. -Open Portenta X8 Shell as explained [here](#working-with-linux). +Open Portenta X8 Shell as explained [here](#working-with-linux). ```arduino sudo madprobe spi-dev ``` + Insert the user password `fio`. An upcoming image release for the X8 will load the `spi-dev` modules automatically at boot. In the current version, please create a `/etc/modules-load.d/spi-dev.conf` file with the following content: @@ -1025,8 +1030,7 @@ gosu /usr/bin/python my_spi_service.py | 136 | **`SPI1 CIPO`** | | 137 | **`SPI1 CS`** | - -#### SPI With Arduino +#### SPI With Arduino The `SPI` object is [mapped](https://github.com/arduino/ArduinoCore-mbed/blob/23e4a5ff8e9c16bece4f0e810acc9760d3dd4462/variants/PORTENTA_X8/pins_arduino.h#L85) as follows on the Portenta Breakout Board and can be deployed as usual: @@ -1159,13 +1163,13 @@ The `Serial1` object in the Arduino sketch is mapped to the **`UART0`** port on Please note that the Arduino RS485 (thus the Arduino Modbus library) library is not supported on the Arduino core of the X8. -### Bluetooth +### Bluetooth® -Portenta X8 supports Bluetooth connectivity just on the Linux side. +Portenta X8 supports Bluetooth® connectivity just on the Linux side. -In order to communicate with Bluetooth devices via the Portenta X8 Shell, you can use the Bluetooth utility **bluetoothctl**. These are some of the most used commands: +In order to communicate with Bluetooth® devices via the Portenta X8 Shell, you can use the Bluetooth® utility **bluetoothctl**. These are some of the most used commands: -* `bluetoothctl devices` to list all the available Bluetooth devices +* `bluetoothctl devices` to list all the available Bluetooth® devices * `bluetoothctl pair [mac_address]` to pair with a specific device through its MAC address * `bluetoothctl connect [mac_address]` to connect to a paired device * `bluetoothctl disconnect [mac_address]` to disconnect from a paired device diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/10.datalogging-iot/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/10.datalogging-iot/content.md index ed4c6e024d..079f93a5e1 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/10.datalogging-iot/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/10.datalogging-iot/content.md @@ -47,7 +47,7 @@ These four blocks will be running locally on the [Arduino® Portenta X8](https:/ - Command-line interface - [Arduino IDE 2.0](https://www.arduino.cc/en/software) -***If you are new to the Portenta X8 board, check out this [getting started tutorial](/tutorials/portenta-x8/out-of-the-box#controlling-portenta-x8-through-the-terminal) on controlling your board using a terminal or command-line interface.*** +***If you are new to the Portenta X8 board, check out this [User Manual](tutorials/portenta-x8/user-manual) on controlling your board using a terminal or command-line interface.*** ## IoT Architecture Basics @@ -276,7 +276,7 @@ We can now proceed to configure InfluxDB. ## Installing InfluxDB -InfluxDB is an open-source, high-performance, time series database; with InfluxDB data can be written and read in real-time, and data can be processed in the background for extract, transform, and load (ETL) purposes or for monitoring and alerting purposes. User dashboards for visualizing and exploring data can also be set up. +InfluxDB is an open-source, high-performance, time series database; with InfluxDB data can be written and read in real-time, and data can be processed in the background for extract, transform, and load (ETL) purposes or for monitoring and alerting purposes. User dashboards for visualizing and exploring data can also be set up. The simplest form to run InfluxDB with Docker is by using the following command: diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/12.multi-protocol-gateway/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/12.multi-protocol-gateway/content.md index e35855bd89..b1a3273c5d 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/12.multi-protocol-gateway/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/12.multi-protocol-gateway/content.md @@ -35,7 +35,7 @@ In this tutorial, we will go through the steps on how to set up both the Linux a - USB-C® cable (either USB-C® to USB-A or USB-C® to USB-C®) - Wi-Fi® Access Point with Internet Access - 868-915 MHz antenna with SMA connector -- ADB or SSH [Check how to connect to your Portenta X8](https://docs.arduino.cc/tutorials/portenta-x8/out-of-the-box#controlling-portenta-x8-through-the-terminal) +- ADB: [Check how to connect to your Portenta X8](tutorials/portenta-x8/user-manual#out-of-the-box-experience) - [Multi-protocol gateway example code](assets/Multi_Protocol_Gateway_X8.zip) - [Arduino IDE 1.8.10+](https://www.arduino.cc/en/software), [Arduino IDE 2.0+](https://www.arduino.cc/en/software), or [Arduino Web Editor](https://create.arduino.cc/editor) diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/13.wordpress-webserver/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/13.wordpress-webserver/content.md index dd5a915549..0377ea1a65 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/13.wordpress-webserver/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/13.wordpress-webserver/content.md @@ -31,7 +31,7 @@ The Arduino Portenta X8 is a powerful board that has many features that can be e ## Instructions -First, make sure your Portenta X8 is set up correctly by following the [getting started tutorial](https://docs.arduino.cc/tutorials/portenta-x8/out-of-the-box). +First, make sure your Portenta X8 is set up correctly by following the [User Manual's Out-of-the-box experience](tutorials/portenta-x8/user-manual#out-of-the-box-experience). ### Creating the Docker-compose.yml File @@ -96,7 +96,7 @@ When you are in the correct directory and no other container is running on the p ### Connecting to the WordPress Site -To connect to the WordPress setup site, you simply need to access it with your Portenta X8s unique id and port. So for example: `http://portenta-x8-.local:`, where you would substitute the `` with your Portenta X8's unique id and the port chosen for the WordPress container with ``. The `` can be found on the setup page that is shown in the [Getting started tutorial](https://docs.arduino.cc/tutorials/portenta-x8/out-of-the-box), but you can also see it in the terminal when running `adb` or you can go to `http://192.168.7.1:8000` if you use Windows and Linux, on MacOS use `http://192.168.8.1:8000`. +To connect to the WordPress setup site, you simply need to access it with your Portenta X8s unique id and port. So for example: `http://portenta-x8-.local:`, where you would substitute the `` with your Portenta X8's unique id and the port chosen for the WordPress container with ``. The `` can be found on the setup page that is shown in the [User Manual's Out-of-the-box experience](tutorials/portenta-x8/user-manual#out-of-the-box-experience), but you can also see it in the terminal when running `adb` or you can go to `http://192.168.7.1:8000` if you use Windows and Linux, on MacOS use `http://192.168.8.1:8000`. When you connect, you should get some feedback in the terminal. Text will begin printing in the terminal, showing you information about the connection that has just been established as shown in the image below. From 72af1b826ef8c720b521a3dba0ed1b02b165a1c7 Mon Sep 17 00:00:00 2001 From: TaddyHC Date: Thu, 9 Mar 2023 19:56:34 -0600 Subject: [PATCH 4/8] Global X8 content update --- .../tutorials/06.waves-fleet-managment/content.md | 4 ++-- .../portenta-x8/tutorials/10.datalogging-iot/content.md | 4 ++-- .../tutorials/12.multi-protocol-gateway/content.md | 7 ++++--- .../tutorials/13.wordpress-webserver/content.md | 4 ++-- 4 files changed, 10 insertions(+), 9 deletions(-) diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/06.waves-fleet-managment/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/06.waves-fleet-managment/content.md index 85ea4b9fe5..cc1a021a16 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/06.waves-fleet-managment/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/06.waves-fleet-managment/content.md @@ -30,13 +30,13 @@ This tutorial will show you how to define fleets and how to construct a Wave tha - Arduino Create account - Arduino Cloud for business subscription with Portenta X8 Manager add-on: [Learn more about here](https://cloud.arduino.cc/plans#business) - Foundries.io™ account (linked with the Arduino Cloud for business subscription) -- FoundriesFactory® and devices already attached to your Factory ([User Manual for setup process](tutorials/portenta-x8/user-manual#out-of-the-box-experience)) +- FoundriesFactory® and devices already attached to your Factory ([User Manual for Out-of-the-box experience](https://docs.arduino.cc/tutorials/portenta-x8/user-manual#out-of-the-box-experience)) ## Instructions ### Setting Up the Terminal -Waves fleet management requires us to have the X8 setup with FoundriesFactory. If you have not done so, please follow our [User Manual for setup process](tutorials/portenta-x8/user-manual#out-of-the-box-experience), as it will walk you through setting up the X8 with your Factory. +Waves fleet management requires us to have the X8 setup with FoundriesFactory. If you have not done so, please follow our [User Manual for Out-of-the-experience](https://docs.arduino.cc/tutorials/portenta-x8/user-manual#out-of-the-box-experience), as it will walk you through setting up the X8 with your Factory. To use Waves, you need to have fioctl installed and configured. Follow this [guide](https://docs.foundries.io/latest/getting-started/install-fioctl/index.html) to do so. Creating Waves and device groups will be done via the host, which is your factory. As such, the following commands will be entered in a terminal using fioctl to connect to your Factory. diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/10.datalogging-iot/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/10.datalogging-iot/content.md index 079f93a5e1..e139414a64 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/10.datalogging-iot/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/10.datalogging-iot/content.md @@ -47,7 +47,7 @@ These four blocks will be running locally on the [Arduino® Portenta X8](https:/ - Command-line interface - [Arduino IDE 2.0](https://www.arduino.cc/en/software) -***If you are new to the Portenta X8 board, check out this [User Manual](tutorials/portenta-x8/user-manual) on controlling your board using a terminal or command-line interface.*** +***If you are new to the Portenta X8 board, check out this [User Manual](https://docs.arduino.cc/tutorials/portenta-x8/user-manual) on controlling your board using a terminal or command-line interface.*** ## IoT Architecture Basics @@ -516,7 +516,7 @@ If everything is ok, we should see the following in the Serial monitor of the Ar ![Debug messages in the Arduino IDE 2.0 Serial Monitor.](assets/x8-data-logging-img_25.png) -Check out now the Grafana dashboard we configured earlier; we should see data coming from the MKR WiFi 1010 board. +Check out now the Grafana dashboard we configured earlier; we should see data coming from the MKR WiFi 1010 board. ## Conclusion diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/12.multi-protocol-gateway/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/12.multi-protocol-gateway/content.md index b1a3273c5d..74d0f2ed62 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/12.multi-protocol-gateway/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/12.multi-protocol-gateway/content.md @@ -35,7 +35,7 @@ In this tutorial, we will go through the steps on how to set up both the Linux a - USB-C® cable (either USB-C® to USB-A or USB-C® to USB-C®) - Wi-Fi® Access Point with Internet Access - 868-915 MHz antenna with SMA connector -- ADB: [Check how to connect to your Portenta X8](tutorials/portenta-x8/user-manual#out-of-the-box-experience) +- ADB: [Check how to connect to your Portenta X8](https://docs.arduino.cc/tutorials/portenta-x8/user-manual#out-of-the-box-experience) - [Multi-protocol gateway example code](assets/Multi_Protocol_Gateway_X8.zip) - [Arduino IDE 1.8.10+](https://www.arduino.cc/en/software), [Arduino IDE 2.0+](https://www.arduino.cc/en/software), or [Arduino Web Editor](https://create.arduino.cc/editor) @@ -73,7 +73,7 @@ Foremost, you will learn how the multi-protocol gateway is implemented with a Po The Arduino layer extends within the M4 Core, which is the layer dedicated to real-time operations development. Thus, you can use the Arduino layer to perform Proportional-Integral-Derivative (PID) tasks and make the RPC calls to exchange data with the Linux layer. An example could be a temperature sensor driven with PID controller, which will use the actual reading as input and compare with the desired temperature target to provide an output for the control element. -***To learn in-depth about how to exchange data using RPC between Arduino and Linux layer, please check out [User Manual: Communication Between Linux And Arduino](tutorials/portenta-x8/what-is-portenta-x8) or [Data Exchange Between Python® on Linux and an Arduino Sketch](https://docs.arduino.cc/tutorials/portenta-x8/python-arduino-data-exchange)*** +***To learn in-depth about how to exchange data using RPC between Arduino and Linux layer, please check out [User Manual: Communication Between Linux And Arduino](https://docs.arduino.cc/tutorials/portenta-x8/user-manual#communication-between-linux-and-arduino) or [Data Exchange Between Python® on Linux and an Arduino Sketch](https://docs.arduino.cc/tutorials/portenta-x8/python-arduino-data-exchange)*** ## The Linux Layer @@ -103,7 +103,7 @@ Before setting up the software, it is necessary to configure the hardware to be ![Multi-Protocol Gateway Hardware Setup](assets/multi-protocol-hardware.png) -***If you have not set up your Portenta X8, please have a look at [User Manual's Out-of-the-box experience](tutorials/portenta-x8/user-manual#out-of-the-box-experience)*** +***If you have not set up your Portenta X8, please have a look at [User Manual's Out-of-the-box experience](https://docs.arduino.cc/tutorials/portenta-x8/user-manual#out-of-the-box-experience)*** ### Setting Up The Portenta X8 @@ -551,6 +551,7 @@ If you are curious about what to expect from the build you have made in this tut In this tutorial, you have learned how to set up a Multi-Protocol Gateway composed of MQTT protocol, RPC, and LoRaWAN®, by using the Portenta X8 and the Portenta Max Carrier. You have built the gateway that will connect to *The Things Network* to send the desired data. Also, the gateway is capable of exchanging data between Arduino and Linux layers using RPC, in which you have exposed the ports to be able to receive data from the local sensor to be sent directly to *The Things Network*. ### Next Steps + - Now that you have developed a multi-protocol gateway, using Wi-Fi® and LoRaWAN® connectivity, expand the gateway's capability by adding other connectivity types such as Cat. M1 and NB-IoT. - Expand functionalities for data processing using RPC while using multi-protocol architecture. diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/13.wordpress-webserver/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/13.wordpress-webserver/content.md index 0377ea1a65..c04f820a58 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/13.wordpress-webserver/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/13.wordpress-webserver/content.md @@ -31,7 +31,7 @@ The Arduino Portenta X8 is a powerful board that has many features that can be e ## Instructions -First, make sure your Portenta X8 is set up correctly by following the [User Manual's Out-of-the-box experience](tutorials/portenta-x8/user-manual#out-of-the-box-experience). +First, make sure your Portenta X8 is set up correctly by following the [User Manual's Out-of-the-box experience](https://docs.arduino.cc/tutorials/portenta-x8/user-manual#out-of-the-box-experience). ### Creating the Docker-compose.yml File @@ -96,7 +96,7 @@ When you are in the correct directory and no other container is running on the p ### Connecting to the WordPress Site -To connect to the WordPress setup site, you simply need to access it with your Portenta X8s unique id and port. So for example: `http://portenta-x8-.local:`, where you would substitute the `` with your Portenta X8's unique id and the port chosen for the WordPress container with ``. The `` can be found on the setup page that is shown in the [User Manual's Out-of-the-box experience](tutorials/portenta-x8/user-manual#out-of-the-box-experience), but you can also see it in the terminal when running `adb` or you can go to `http://192.168.7.1:8000` if you use Windows and Linux, on MacOS use `http://192.168.8.1:8000`. +To connect to the WordPress setup site, you simply need to access it with your Portenta X8s unique id and port. So for example: `http://portenta-x8-.local:`, where you would substitute the `` with your Portenta X8's unique id and the port chosen for the WordPress container with ``. The `` can be found on the setup page that is shown in the [User Manual's Out-of-the-box experience](https://docs.arduino.cc/tutorials/portenta-x8/user-manual#out-of-the-box-experience), but you can also see it in the terminal when running `adb` or you can go to `http://192.168.7.1:8000` if you use Windows and Linux, on MacOS use `http://192.168.8.1:8000`. When you connect, you should get some feedback in the terminal. Text will begin printing in the terminal, showing you information about the connection that has just been established as shown in the image below. From a6e88af46c1b13bf859be34e6194f74e08509041 Mon Sep 17 00:00:00 2001 From: TaddyHC Date: Thu, 9 Mar 2023 20:15:32 -0600 Subject: [PATCH 5/8] Global X8 content minor update --- .../portenta-x8/tutorials/12.multi-protocol-gateway/content.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/12.multi-protocol-gateway/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/12.multi-protocol-gateway/content.md index 74d0f2ed62..e4364ee69d 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/12.multi-protocol-gateway/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/12.multi-protocol-gateway/content.md @@ -73,7 +73,7 @@ Foremost, you will learn how the multi-protocol gateway is implemented with a Po The Arduino layer extends within the M4 Core, which is the layer dedicated to real-time operations development. Thus, you can use the Arduino layer to perform Proportional-Integral-Derivative (PID) tasks and make the RPC calls to exchange data with the Linux layer. An example could be a temperature sensor driven with PID controller, which will use the actual reading as input and compare with the desired temperature target to provide an output for the control element. -***To learn in-depth about how to exchange data using RPC between Arduino and Linux layer, please check out [User Manual: Communication Between Linux And Arduino](https://docs.arduino.cc/tutorials/portenta-x8/user-manual#communication-between-linux-and-arduino) or [Data Exchange Between Python® on Linux and an Arduino Sketch](https://docs.arduino.cc/tutorials/portenta-x8/python-arduino-data-exchange)*** +***To learn in-depth about how to exchange data using RPC between Arduino and Linux layer, please check out the [User Manual: Communication Between Linux And Arduino](https://docs.arduino.cc/tutorials/portenta-x8/user-manual#communication-between-linux-and-arduino) or [Data Exchange Between Python® on Linux and an Arduino Sketch](https://docs.arduino.cc/tutorials/portenta-x8/python-arduino-data-exchange)*** ## The Linux Layer From 7c4670d8870cb44cda51fc29c036df166df4b5e1 Mon Sep 17 00:00:00 2001 From: TaddyHC Date: Thu, 9 Mar 2023 22:35:20 -0600 Subject: [PATCH 6/8] Global X8 content update --- .../tutorials/04.python-arduino-data-exchange/content.md | 6 +++--- .../portenta-x8/tutorials/05.docker-container/content.md | 6 +++--- .../portenta-x8/tutorials/07.custom-container/content.md | 7 ++++--- .../portenta-x8/tutorials/09.image-flashing/content.md | 2 +- 4 files changed, 11 insertions(+), 10 deletions(-) diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/04.python-arduino-data-exchange/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/04.python-arduino-data-exchange/content.md index 8bba7350e1..d14cd56d59 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/04.python-arduino-data-exchange/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/04.python-arduino-data-exchange/content.md @@ -13,9 +13,9 @@ hardware: The container infrastructure provided by Arduino contains a pre-built Python® image that you can use to run Python® applications on the Portenta X8. In this tutorial, we're going to build a container based on a provided one. -While all the peripherals are accessible from the iMX8 processor running the Linux environment, it can be useful to let the onboard microcontroller take care of certain peripheral handling and exchange only the required data between the microcontroller and the Python® application. +While all the peripherals are accessible from the iMX8 processor running the Linux environment, it can be useful to let the onboard microcontroller take care of certain peripheral handling and exchange only the required data between the microcontroller and the Python® application. -Thus you will learn how to do that. If you haven't done so, read through the [user manual](/tutorials/portenta-x8/user-manual) to understand the fundamental concepts of the X8 and the provided infrastructure. +Thus you will learn how to do that. If you haven't done so, read through the [user manual](https://docs.arduino.cc/tutorials/portenta-x8/user-manual) to understand the fundamental concepts of the X8 and the provided infrastructure. ## Goals @@ -74,7 +74,7 @@ Make sure you have installed the "Arduino Mbed OS Portenta Boards" core and uplo ### Debugging the Arduino Sketch -To check if the Arduino sketch is working correctly, you may want to read the messages from the `Serial.println` statements. You cannot currently read them directly in the serial monitor of the Arduino IDE. Instead, you can use a simple service called `py-serialrpc`, which listens for those messages and prints them to the console. +To check if the Arduino sketch is working correctly, you may want to read the messages from the `Serial.println` statements. You cannot currently read them directly in the serial monitor of the Arduino IDE. Instead, you can use a simple service called `py-serialrpc`, which listens for those messages and prints them to the console. This service needs to run on the Linux side of the X8. You can get the files [here](assets/py-serialrpc.zip). From the command prompt of your local machine, navigate to the adb tool folder and upload the files to the X8 with `adb push /py-serialrpc /home/fio`. diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/05.docker-container/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/05.docker-container/content.md index c00074d325..9fd40a0f79 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/05.docker-container/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/05.docker-container/content.md @@ -34,7 +34,7 @@ In this tutorial, we will go through the steps of how to install, run and remove - [Arduino® Portenta X8](https://store.arduino.cc/products/portenta-x8) - USB-C® cable (either USB-C® to USB-A or USB-C® to USB-C®) - Wi-Fi® Access Point with Internet Access -- ADB, [Check how to connect to your Portenta X8](/tutorials/portenta-x8/out-of-the-box#controlling-portenta-x8-through-the-terminal) +- ADB: [Check how to connect to your Portenta X8](https://docs.arduino.cc/tutorials/portenta-x8/user-manual#out-of-the-box-experience) - [Arduino IDE 1.8.10+](https://www.arduino.cc/en/software), [Arduino IDE 2.0+](https://www.arduino.cc/en/software), or [Arduino Web Editor](https://create.arduino.cc/editor) ***Make sure to have the Portenta X8 with the latest image as well as bootloader. Please check [how to flash your Portenta X8](/tutorials/portenta-x8/image-flashing) to have latest version.*** @@ -47,7 +47,7 @@ The Portenta X8 provides Docker CLI by default. The following command will help docker -v ``` -***To use this tool, you will need to connect to your device first. Check [how to connect using adb/ssh](/tutorials/portenta-x8/out-of-the-box#controlling-portenta-x8-through-the-terminal).*** +***To use this tool, you will need to connect to your device first. Check [how to connect using adb/ssh](https://docs.arduino.cc/tutorials/portenta-x8/user-manual#out-of-the-box-experience).*** You can check the Docker's reference documentation, which covers all the features of the tool in depth at [docs.docker.com](https://docs.docker.com/). @@ -133,4 +133,4 @@ In this tutorial, you have learned how to use Docker with Portenta X8. You have - Now that you have the base of the workflow to use [Docker](https://docker.com), go to its docs page and make sure you understand all the features. - Look for a container image from [Docker hub](http://hub.docker.com), install it and make your own application out of it. -- Create a container to run your custom made application. For this, it may interest you [Create and Upload a Custom Container to the Portenta X8](tutorials/portenta-x8/custom-container) tutorial. \ No newline at end of file +- Create a container to run your custom made application. For this, it may interest you [Deploy a Custom Container with Portenta X8 Manager](tutorials/portenta-x8/custom-container) tutorial. \ No newline at end of file diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/07.custom-container/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/07.custom-container/content.md index 26ef243ece..ffd1be2833 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/07.custom-container/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/07.custom-container/content.md @@ -22,7 +22,7 @@ In this tutorial, we will create a simple container and upload it to the Arduino ### Required Hardware and Software - [Portenta X8](https://store.arduino.cc/portenta-x8) -- ADB +- ADB: [Check how to connect to your Portenta X8](https://docs.arduino.cc/tutorials/portenta-x8/user-manual#out-of-the-box-experience) - USB-C® cable (either USB-C® to USB-A or USB-C® to USB-C®) - Arduino Pro Cloud Subscription [Learn more about the Pro Cloud](https://www.arduino.cc/pro/hardware/product/portenta-x8#pro-cloud) - [Arduino IDE 1.8.10+](https://www.arduino.cc/en/software), [Arduino IDE 2.0+](https://www.arduino.cc/en/software), or [Arduino Web Editor](https://create.arduino.cc/editor) @@ -57,6 +57,7 @@ TEST_CMD="python3 --help" ``` ### Container File: Docker-compose.yml + This file defines the app name through the Factory, permissions, and settings for the involved containers. The argument in the image tag will make it, so our image file builds locally. ```python @@ -128,7 +129,7 @@ if __name__ == '__main__': ## Uploading the Container Folder -First, you will need to set up your board to a Factory setting, as shown in the [Portenta X8 Out of the Box tutorial](https://docs.arduino.cc/tutorials/portenta-x8/out-of-the-box). +First, you will need to set up your board to a Factory setting, as shown in the Portenta X8 [Out-of-the-box experience from the User Manual](https://docs.arduino.cc/tutorials/portenta-x8/user-manual#out-of-the-box-experience). Once finished, we will push our folder to a repository within the Factory. Let us place our folder "x8-custom-test" inside the "containers.git" repository. You can find this repository inside your Factory page under "Source". Then, on "container.git", the page URL will be used in the following command. @@ -217,5 +218,5 @@ To get a better understanding of how to manage containers with Docker, take a lo Here are some errors that might occur in the process of this tutorial: -- Make sure you have followed our other tutorials that shows how to set up the [Portenta X8 out of the box](https://docs.arduino.cc/tutorials/portenta-x8/out-of-the-box) +- Make sure you have followed our other tutorials that shows how to set up the Portenta X8 with [Out-of-the-box experience from the User Manual](https://docs.arduino.cc/tutorials/portenta-x8/user-manual#out-of-the-box-experience) - If you are having issues with the adb shell, don't forget to try and use `sudo` and `su` diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/09.image-flashing/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/09.image-flashing/content.md index 7905d05ee2..2c2f756818 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/09.image-flashing/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/09.image-flashing/content.md @@ -27,7 +27,7 @@ In this tutorial, you will learn how to manually flash your Portenta X8 with the - [Arduino Portenta X8](https://store.arduino.cc/products/portenta-x8) - [Portenta Breakout Board](https://store.arduino.cc/products/arduino-portenta-breakout) or [Arduino Portenta Max Carrier](https://store.arduino.cc/products/portenta-max-carrier) - USB-C® cable (either USB-C® to USB-A or USB-C® to USB-C®) - + ## Instructions ### Arduino's Download Repository From a8f8f2c90621c447697b1de6ce4f1169135c2229 Mon Sep 17 00:00:00 2001 From: TaddyHC <94547080+TaddyHC@users.noreply.github.com> Date: Fri, 10 Mar 2023 15:23:46 -0600 Subject: [PATCH 7/8] Update content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Julián Caro Linares --- .../boards/portenta-x8/tutorials/01.user-manual/content.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md index a7fa20a921..d9546f46c7 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md @@ -81,7 +81,7 @@ The full pinout is available and downloadable as PDF from the link below: ### Datasheet The full datasheet is available and downloadable as PDF from the link below: -* [Portenta X8 Datasheet](https://docs.arduino.cc/static/e12188dbbde2deba83f37965615c3c5a/ABX00049-datasheet.pdf) +* [Portenta X8 Datasheet](https://docs.arduino.cc/resources/datasheets/ABX00049-datasheet.pdf) ### Schematics From 722dd4a926b03b4f7b6015e3797d4de851174202 Mon Sep 17 00:00:00 2001 From: TaddyHC <94547080+TaddyHC@users.noreply.github.com> Date: Fri, 10 Mar 2023 15:24:42 -0600 Subject: [PATCH 8/8] Update content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Julián Caro Linares --- .../boards/portenta-x8/tutorials/01.user-manual/content.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md b/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md index d9546f46c7..9074235538 100644 --- a/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md +++ b/content/hardware/04.pro/boards/portenta-x8/tutorials/01.user-manual/content.md @@ -86,7 +86,7 @@ The full datasheet is available and downloadable as PDF from the link below: ### Schematics The full schematics are available and downloadable as PDF from the link below: -* [Portenta X8 Schematics](https://docs.arduino.cc/static/c92dbfc6c6a7c3f79c9987d36f017e48/ABX00049-schematics.pdf) +* [Portenta X8 Schematics](https://docs.arduino.cc/resources/schematics/ABX00049-schematics.pdf) ### STEP Files