Dual Cores para GO: Procesamiento Dual Core en ODROID-GO

¿Quién lo hubiera adivinado? Pero está ahí en la página 1 de la hoja de especificaciones técnicas del ESP32 WROVER: "Existen dos núcleos de CPU que pueden ser controlados individualmente, ..."

Y podemos encontrar otra referencia al dual core en la página 7: "ESP32-D0WDQ6 contiene dos microprocesadores LX6 de 32 bits Xtensa® de baja potencia".

En fin, es interesante saberlo, pero ¿cómo se puede usar este dual core en ODROID-GO? Por ejemplo, ¿cómo puede un programa escrito en el Entorno de Desarrollo Integrado de Arduino (IDE) aprovechar el dual core de ESP32?

Es muy fácil usar el dual core dentro de ODROID-GO, pero primero recopilemos algo de información básica.

Cuando se ejecuta un esquema "tradicional" de Arduino, es decir, un programa que contiene las funciones setup() y loop(), solo se usa uno de los núcleos. Ese núcleo es el Core 1, el segundo núcleo (empiezan desde el 0). Puedes probarlo por ti mismo agregando la llamada xPortGetCoreID() a tus funciones de configuración y bucle. Cuando se redirecciona al Serial Monitor del IDE de Arduino (ver Figura 1), deberías ver el valor del núcleo actual, Core 1.

Ahora, el código original utilizado para el descubrimiento e implementación de los dual cores en este artículo procede de un artículo de Rui Santos de randomnerdtutorials.com y de un blog del 14 de febrero de 2019, y de un post sobre SparkFun Electronics en sparkfun.com. Si deseas obtener información adicional sobre la programación de dual cores en Arduino, empieza con estos dos recursos. Luego puede hacer que tu ODROID-GO haga dos cosas al mismo tiempo.

Instrucciones paso a paso

1. Introduce este ejemplo de esquema Arduino:

/*
* Dual Core Demonstration for
* ODROID-GO
* 
* Derived from code by Rui Santos
* at randomnerdtutorials.com
* 
* Mentioned in SparkFun Electronics
* blog on February 14, 2019
* at sparkfun.com
* 
* ODROID Magazine
* by Dave Prochnow
*/
 
// Instantiate one task for separate execution
// inside core 0
 
TaskHandle_t Task0;
 
void setup() {
   // put your setup code here, to run once:
 
   // All of our dual core results will be
   // displayed on the Arduino Serial Monitor
 
   Serial.begin(115200);
 
   // The native core used by the Arduino is Core 1
   // Use xPortGetCoreID() to confirm
 
   Serial.print("Setup() and Loop() run in Core ");
   Serial.println(xPortGetCoreID());
 
   // Define the function xTaskCreatePinnedToCore()
   // for the core 0 task
 
   xTaskCreatePinnedToCore(
     task0Code, // task function 
     "Task0", // task name
     10000, // stack size allotment in words
     NULL, // task input parameter
     1, // task priority 
     &Task0, // task handle; as instantiated above
     0); // designate core
 
   // A very short delay for displaying the Task 0
   // core information
   vTaskDelay(.25);
}
 
// Create the core 0 task function; which will run
// forever
 
void task0Code( void * pvParameters) {
 Serial.print("This is Task0 running in Core ");
 // Label the core with xPortGetCoreID
 Serial.println(xPortGetCoreID());
 int x = 0;
 String xPreamble = "Core 0 - ";
 // You can create an infinite loop with for(;;)
 for(;;){
   Serial.println(xPreamble + x);
   x++;
 }
}
 
void loop() {
   // put your main code here, to run repeatedly:
   // This function will run in Core 1
 int y = 0;
 String yPreamble = "Core 1 - ";
 for(;;) {
   Serial.println(yPreamble + y);
   y = y + 2;
 }
}

2. Compila este programa y cárgalo en el ODROID-GO (consulta la Figura 2).

3. Deja el ODROID-GO conectado a tu PC e inmediatamente, apaga el interruptor de encendido.

4. Ahora abre el Serial Monitor y ajusta los baudios a 115200 como se muestra en la Figura 3.

5. Enciende y apaga el interruptor de alimentación del ODROID-GO muy rápidamente. Este rápido cambio permitirá que solo se envíe una breve ráfaga de información del dual core al Serial Monitor.

6. Desplázate hasta la parte superior de la impresión del Serial Monitor y revisa las líneas que aparecen después de la información de inicio del ESP32. Debería ver un par de IDs de núcleo y una larga lista de valores que son calculados por cada núcleo, algo similar a lo que puedes ver en la Figura 4.

7. Ahora adapta esta técnica a tus propios desafíos de Arduino (ve la Figura 5) y enséñale a tu ODROID-GO cómo recorrer y mascar código al mismo tiempo.