v1.0.2: Added english version of readme.md

alexCajas · alexCajas · commit c4666aad496c · 2024-02-04T20:45:25.000+01:00
diff --git a/README.md b/README.md
@@ -1,38 +1,53 @@
+<center>
+
+## [click para versión en español](https://github.com/alexCajas/WrapperFreeRTOS/blob/main/SpanishReadme.md)
+
+</center>
+
+
+[![Esp8266](https://img.shields.io/badge/soc-ESP8266-green)](https://www.espressif.com/en/products/socs/esp8266)
+[![Esp32](https://img.shields.io/badge/soc-ESP32-orange)]()
+[![Arduino](https://img.shields.io/badge/platform-Arduino-green)](https://www.arduino.cc/)
+![C++](https://img.shields.io/badge/-C%2B%2B-red)
+[![FreeRTOS](https://img.shields.io/badge/-FreeRTOS-blue)](https://github.com/espressif/ESP8266_RTOS_SDK)
+[![RTOS](https://img.shields.io/badge/-RTOS-blue)](https://github.com/espressif/ESP8266_RTOS_SDK)
+[![Release](https://img.shields.io/github/v/release/alexCajas/WrapperFreeRTOS)](https://github.com/alexCajas/WrapperFreeRTOS/releases/latest)
+
 # WrapperFreeRTOS
 
-**FreeRTOS C++ Wrapper** para el fácil uso de las principales utilidades de concurrencia, de FreeRTOS, en **POO**, compatible con **Arduino core** y probado en un **ESP32**.
+**FreeRTOS C++ Wrapper** for easy use of the main concurrency utilities from FreeRTOS in **OOP**,compatible with **Arduino core** and tested on an  **ESP32** and **ESP8266**. Note that you must to use [esp8266RTOSArdoArduCore](https://github.com/alexCajas/esp8266RTOSArduCore) to use this library with **esp8266**.
 
-Está basado en los wrappers de **Neil Kolban** [https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/Task.cpp], y **Richard Damon** [https://github.com/richard-damon/FreeRTOScpp/blob/master/TaskCPP.h] .
+It is based on the wrappers by **Neil Kolban** [https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/Task.cpp], and **Richard Damon** [https://github.com/richard-damon/FreeRTOScpp/blob/master/TaskCPP.h] .
 
 ---
 
-## Ejemplos:
+## Examples:
 
-* **BasicTask:** Creación de un objecto concurrente.
+* **BasicTask:** Creation of a concurrent object.
 
-* **BasicMutex:** Coordinación entre dos objetos concurrentes mediante mutex o semáforo binario.     
+* **BasicMutex:** Coordination between two concurrent objects using a mutex or binary semaphore.
 
-* **BasicSemaphore:** Típico problema un productor lento y varios consumidores rápidos, resuelto mediante un "counting semaphore".
+* **BasicSemaphore:** Typical problem of a slow producer and several fast consumers, solved using a "counting semaphore."
 
-* **BasicQueue:** Envío de datos mediante QueueHandle_t entre dos objetos concurrentes.  
+* **BasicQueue:** Data transmission using QueueHandle_t between two concurrent objects.  
 
-* **CrossedReferences:** Ejemplo de una posible solución entre referencias cruzadas de objetos en C++.
+* **CrossedReferences:** Example of a possible solution to crossed object references in C++.
 
 ---
 
-## Adaptacion de wrappers
+## Wrapper Adaptation
 
-* La adaptación del wrapper Task.h y Task.cpp (nKolban), consitió en sustituir la libreria  std::string por Arduino.h, y redefinir toda variable y argumento tipo std::string u otros std:: por su conrrespondiente en Arduino.h, notar que se adapta según los parámetros pasados a las funciones de creación y manipulación de TaskHandle_t.
+* The adaptation of the Task.h and Task.cpp wrapper (nKolban) involved replacing the std::string library with Arduino.h and redefining any variable and argument of type std::string or other std:: with its corresponding in Arduino.h. Note that it adapts according to the parameters passed to the functions for creating and manipulating TaskHandle_t.
 
-* Se sustituye el valor de stack size de uint8 a uint32, puesto que xcreateTask() recibe un unit32. 
+* The stack size value is replaced from uint8 to uint32 since xcreateTask() receives a uint32.
 
-* Se añade un enum (TaskPriority) que recoge el valor númerico de las distintas prioridades predefinidas en la versión de FreeRTOS usada en tu proyecto (Richard Damon).
+* An enum (TaskPriority) is added that collects the numeric value of the different predefined priorities in the version of FreeRTOS used in your project (Richard Damon).
 
-* Se añade el método xTaskHandle getTaskHandle(). 
+* The method xTaskHandle getTaskHandle() is added.
 
 ---
 
-## Bibliografía
+## Bibliography
 
 * [https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/Task.cpp]
 
diff --git a/SpanishReadme.md b/SpanishReadme.md
@@ -0,0 +1,60 @@
+<center>
+
+## [click for english version](https://github.com/alexCajas/WrapperFreeRTOS/)
+
+</center>
+
+
+[![Esp8266](https://img.shields.io/badge/soc-ESP8266-green)](https://www.espressif.com/en/products/socs/esp8266)
+[![Esp32](https://img.shields.io/badge/soc-ESP32-orange)]()
+[![Arduino](https://img.shields.io/badge/platform-Arduino-green)](https://www.arduino.cc/)
+![C++](https://img.shields.io/badge/-C%2B%2B-red)
+[![FreeRTOS](https://img.shields.io/badge/-FreeRTOS-blue)](https://github.com/espressif/ESP8266_RTOS_SDK)
+[![RTOS](https://img.shields.io/badge/-RTOS-blue)](https://github.com/espressif/ESP8266_RTOS_SDK)
+[![Release](https://img.shields.io/github/v/release/alexCajas/WrapperFreeRTOS)](https://github.com/alexCajas/WrapperFreeRTOS/releases/latest)
+
+# WrapperFreeRTOS
+
+**FreeRTOS C++ Wrapper** para el fácil uso de las principales utilidades de concurrencia, de FreeRTOS, en **POO**, compatible con **Arduino core** y probado en un **ESP32** y **ESP8266**. Notar que necesitas usar [esp8266RTOSArdoArduCore](https://github.com/alexCajas/esp8266RTOSArduCore), para usar esta librería con **ESP8266**.
+
+Está basado en los wrappers de **Neil Kolban** [https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/Task.cpp], y **Richard Damon** [https://github.com/richard-damon/FreeRTOScpp/blob/master/TaskCPP.h] .
+
+---
+
+## Ejemplos:
+
+* **BasicTask:** Creación de un objecto concurrente.
+
+* **BasicMutex:** Coordinación entre dos objetos concurrentes mediante mutex o semáforo binario.     
+
+* **BasicSemaphore:** Típico problema un productor lento y varios consumidores rápidos, resuelto mediante un "counting semaphore".
+
+* **BasicQueue:** Envío de datos mediante QueueHandle_t entre dos objetos concurrentes.  
+
+* **CrossedReferences:** Ejemplo de una posible solución entre referencias cruzadas de objetos en C++.
+
+---
+
+## Adaptacion de wrappers
+
+* La adaptación del wrapper Task.h y Task.cpp (nKolban), consitió en sustituir la libreria  std::string por Arduino.h, y redefinir toda variable y argumento tipo std::string u otros std:: por su conrrespondiente en Arduino.h, notar que se adapta según los parámetros pasados a las funciones de creación y manipulación de TaskHandle_t.
+
+* Se sustituye el valor de stack size de uint8 a uint32, puesto que xcreateTask() recibe un unit32. 
+
+* Se añade un enum (TaskPriority) que recoge el valor númerico de las distintas prioridades predefinidas en la versión de FreeRTOS usada en tu proyecto (Richard Damon).
+
+* Se añade el método xTaskHandle getTaskHandle(). 
+
+---
+
+## Bibliografía
+
+* [https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/Task.cpp]
+
+* [https://github.com/richard-damon/FreeRTOScpp/blob/master/TaskCPP.h]
+
+
+---
+
+## Licencia
+* MIT License
diff --git a/examples/BasicMutex/BasicMutex.ino b/examples/BasicMutex/BasicMutex.ino
@@ -1,11 +1,11 @@
 /**
  * @file BasicMutex.ino
  * @author Alex Cajas (https://github.com/alexCajas/WrapperFreeRTOS)
- * @brief En este ejemplo, se muestra como coordinar dos hilos,
- * mediante un mutex.
+ * @brief In this example, 
+ * it is shown how to coordinate two threads using a mutex.
  * 
- * TaskHello, imprime la palabra "Hello", por pantalla.
- * TaskWorld, imprime la palabra "World" por pantalla.
+ * TaskHello prints the word "Hello", by Serial terminal.
+ * TaskWorld, prints the word "World" by Serial terminal.
  * @version 0.1
  * 
  */
@@ -25,7 +25,7 @@ void setup(){
     mutexWorld = xSemaphoreCreateMutex();
 
     if(mutexHello == NULL || mutexWorld == NULL ){
-        Serial.println("fallo al crear los mutex");
+        Serial.println("Failed to create mutex");
         ESP.restart();
     }
 
@@ -40,5 +40,5 @@ void setup(){
 }
 
 void loop(){
-    // tu codigo.
+    // your code.
 }
diff --git a/examples/BasicMutex/TaskHello.h b/examples/BasicMutex/TaskHello.h
@@ -4,7 +4,7 @@
 #include "Task.h"
 
 /**
- * @brief Imprime la palabra "Hello", por pantalla.
+ * @brief Prints the word "Hello", by Serial terminal.
  * 
  */
 class TaskHello : public Task{
diff --git a/examples/BasicMutex/TaskWorld.h b/examples/BasicMutex/TaskWorld.h
@@ -4,7 +4,7 @@
  #include "Task.h"
 
 /**
- * @brief Imprimer la palabra "World" por pantalla
+ * @brief Prints the word "World", by Serial terminal
  * 
  */
 class TaskWorld : public Task{
diff --git a/examples/BasicQueue/BasicQueue.ino b/examples/BasicQueue/BasicQueue.ino
@@ -1,10 +1,10 @@
 /**
  * @file BasicQeueue.ino
  * @author Alex Cajas (https://github.com/alexCajas/WrapperFreeRTOS)
- * @brief En este ejemplo, se muestra como coordinar dos hilos,
- * y pasar mensajes, mediante un mutex.
- * TaskHello, recibe mensaje de TaskWorldQueue y lo imprime por pantalla.
- * TaskWorld, recibe mensaje de TaskHelloQueue", y lo imprime por pantalla.
+ * @brief In this example, it is demonstrated how to 
+ * coordinate two threads and exchange messages using a queue mutex. 
+ * TaskHello, TaskHello receives a message from TaskWorldQueue and prints it on the Serial terminal.
+ * TaskWorld receives a message from TaskHelloQueue and prints it on the Serial terminal.
  * @version 0.1
  * 
  */
@@ -24,7 +24,7 @@ void setup(){
     queueWorld = xQueueCreate( 1, sizeof(String));
 
     if(queueHello == NULL || queueWorld == NULL ){
-        Serial.println("fallo al crear los queue");
+        Serial.println("Failed to create the queue");
         ESP.restart();
     }
 
@@ -36,5 +36,5 @@ void setup(){
 }
 
 void loop(){
-    // tu codigo.
+    // your code
 }
diff --git a/examples/BasicQueue/TaskHelloQ.h b/examples/BasicQueue/TaskHelloQ.h
@@ -4,8 +4,7 @@
 #include "Task.h"
 
 /**
- * @brief Manda y recibe un mensaje a TaskWorldQueue.
- * 
+ * @brief Send and receive a message from/to TaskWorldQueue. 
  */
 class TaskHelloQueue : public Task{
     private:
diff --git a/examples/BasicQueue/TaskWorldQ.h b/examples/BasicQueue/TaskWorldQ.h
@@ -4,7 +4,7 @@
  #include "Task.h"
 
 /**
- * @brief Manda y recibe un mensaje de TaskHelloQueue 
+ * @brief Send and receive a message from/to TaskHelloQueue 
  * 
  * 
  */
diff --git a/examples/BasicSemaphore/BasicSemaphore.ino b/examples/BasicSemaphore/BasicSemaphore.ino
@@ -1,8 +1,8 @@
 /**
  * @file BasicSemaphore.ino
  * @author Alex Cajas (https://github.com/alexCajas/)
- * @brief Ejemplo de coordinación entre consumidores rápidos
- * y productor lento. 
+ * @brief Example of coordination between fast consumers 
+ * and a slow producer.
  * @version 0.1
  * 
  */
@@ -20,7 +20,7 @@ void setup(){
     semaphore = xSemaphoreCreateCounting( 5, 0 ); 
 
     if(semaphore == NULL ){
-        Serial.println("fallo al crear el semaphore");
+        Serial.println("Faile to create the semaphore");
         ESP.restart();
     }
 
@@ -35,5 +35,5 @@ void setup(){
 }   
 
 void loop(){
-    // tu codigo.
+    // your code.
 }
diff --git a/examples/BasicSemaphore/TaskConsummer.hpp b/examples/BasicSemaphore/TaskConsummer.hpp
@@ -4,8 +4,7 @@
 #include "Task.h"
 
 /**
- * @brief Ejemplo de coordinación entre consumidores rapidos
- * y productor lento.
+ * @brief Faster consummer.
  * 
  */
 class TaskConsummer : public Task{
diff --git a/examples/BasicSemaphore/TaskProducer.hpp b/examples/BasicSemaphore/TaskProducer.hpp
@@ -4,8 +4,7 @@
  #include "Task.h"
 
 /**
- * @brief Ejemplo de coordinación entre consumidores rapidos
- * y productor lento.
+ * @brief Slow producer.
  */
 class TaskProducer : public Task{
     private:
diff --git a/examples/BasicTask/BasicTask.cpp b/examples/BasicTask/BasicTask.cpp
@@ -1,6 +1,6 @@
 #include "BasicTask.hpp"
 
-BasicTask::BasicTask(): Task("tarea",1024,TaskPrio_Low){
+BasicTask::BasicTask(): Task("task",1024,TaskPrio_Low){
 
 }
 
diff --git a/examples/BasicTask/BasicTask.hpp b/examples/BasicTask/BasicTask.hpp
@@ -3,20 +3,22 @@
 
 #include "Task.h"
 /**
- * @brief Objeto que hereda de Task, debe implementar el método
- * run, además notar que el constructor Task, recibe un "",
- * apesar de que está definido para recibir un const char* TaskName,
- * pasar una variable como const char * name = "nombre";
- * al constructor como por ejemplo:
+ * @brief cpp
+
+Object inheriting from Task must implement the run method. 
+Additionally, note that the Task constructor takes an empty string ("") 
+despite being defined to receive a const char* taskName. 
+Passing a variable like const char* name = "name" to the constructor, 
+as in the example:
  * SomeClass(const char* name):Task(name,...) 
- * da fallo de loadException. 
- * Uso correcto en el constructor de Task:
- * Task("nombre",...)
+results in a loadException error. 
+ * The correct usage in the Task constructor is:
+ * Task("name",...)
  */
 class BasicTask : public Task{
     public:
         BasicTask();
-        // override la función de la interfaz Task. 
+        // override run function of Task interface. 
         void run (void *data);
 };
 
diff --git a/examples/BasicTask/BasicTask.ino b/examples/BasicTask/BasicTask.ino
@@ -1,7 +1,7 @@
 /**
  * @file BasicTask.ino
  * @author Alex Cajas (https://github.com/alexCajas/)
- * @brief Ejemplo básico de creación de una clase Task.
+ * @brief Basic example of creating a basic Task class.
  * @version 0.1
  * 
  */
@@ -20,10 +20,10 @@ task.start();
 
 void loop(){
 
-    // Puedes parar la tarea con
+    // You can stop the Task
     // task.stop();
 
-    // o puedes suspender su actual ejecución con
+    // o or suspend the current execution
     // vTaskSuspend(task.getTaskHandle());
 }
 
diff --git a/examples/CrossedReferences/Controlador.hpp b/examples/CrossedReferences/Controlador.hpp
@@ -3,15 +3,14 @@
 
 #include "Task.h"
 /**
- * @brief Ejemplo para resolver el problema de la referencia 
- * Cruzada en c++.
+ * @brief  Example of a possible solution to crossed object references in C++.
  * 
  */
 
 class ThreadTask;
 
 /**
- * @brief Controlador tiene una referencia a ThreadTask.
+ * @brief Controlador Has a reference to ThreadTask.
  * 
  */
 class Controlador {
@@ -22,7 +21,7 @@ class Controlador {
         Controlador(String nombre);
         
         /**
-         * @brief pone en funcionamiento al hilo.
+         * @brief use run to to start the thread.
          * 
          */
         void start();
@@ -33,8 +32,8 @@ class Controlador {
 };
 
 /**
- * @brief ThreadTask curza su referencia con Controlador
- * al tenerlo como atributo.
+ * @brief ThreadTask crosses its 
+ * reference with Controller by having it as an attribute.
  * 
  */
 class ThreadTask : public Task{
@@ -43,8 +42,7 @@ class ThreadTask : public Task{
         Controlador *controlador;
 
         /**
-         * @brief Override de la función que hará 
-         * La tarea en bucle.
+         * @brief Override run function.
          * 
          * @param data 
          */
diff --git a/examples/CrossedReferences/CrossedReferences.ino b/examples/CrossedReferences/CrossedReferences.ino
diff --git a/library.properties b/library.properties
diff --git a/src/Task.h b/src/Task.h
diff --git a/src/WrapperFreeRTOS.h b/src/WrapperFreeRTOS.h

Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,11 @@`
`1`	`1`	`/**`
`2`	`2`	`* @file BasicMutex.ino`
`3`	`3`	`* @author Alex Cajas (https://github.com/alexCajas/WrapperFreeRTOS)`
`4`		`- * @brief En este ejemplo, se muestra como coordinar dos hilos,`
`5`		`- * mediante un mutex.`
	`4`	`+ * @brief In this example,`
	`5`	`+ * it is shown how to coordinate two threads using a mutex.`
`6`	`6`	`*`
`7`		`- * TaskHello, imprime la palabra "Hello", por pantalla.`
`8`		`- * TaskWorld, imprime la palabra "World" por pantalla.`
	`7`	`+ * TaskHello prints the word "Hello", by Serial terminal.`
	`8`	`+ * TaskWorld, prints the word "World" by Serial terminal.`
`9`	`9`	`* @version 0.1`
`10`	`10`	`*`
`11`	`11`	`*/`
`@@ -25,7 +25,7 @@ void setup(){`
`25`	`25`	`mutexWorld = xSemaphoreCreateMutex();`
`26`	`26`
`27`	`27`	`if(mutexHello == NULL \|\| mutexWorld == NULL ){`
`28`		`- Serial.println("fallo al crear los mutex");`
	`28`	`+ Serial.println("Failed to create mutex");`
`29`	`29`	`ESP.restart();`
`30`	`30`	`}`
`31`	`31`
`@@ -40,5 +40,5 @@ void setup(){`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`void loop(){`
`43`		`- // tu codigo.`
	`43`	`+ // your code.`
`44`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`	`#include "Task.h"`
`5`	`5`
`6`	`6`	`/**`
`7`		`- * @brief Imprime la palabra "Hello", por pantalla.`
	`7`	`+ * @brief Prints the word "Hello", by Serial terminal.`
`8`	`8`	`*`
`9`	`9`	`*/`
`10`	`10`	`class TaskHello : public Task{`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,8 @@`
`1`	`1`	`/**`
`2`	`2`	`* @file BasicSemaphore.ino`
`3`	`3`	`* @author Alex Cajas (https://github.com/alexCajas/)`
`4`		`- * @brief Ejemplo de coordinación entre consumidores rápidos`
`5`		`- * y productor lento.`
	`4`	`+ * @brief Example of coordination between fast consumers`
	`5`	`+ * and a slow producer.`
`6`	`6`	`* @version 0.1`
`7`	`7`	`*`
`8`	`8`	`*/`
`@@ -20,7 +20,7 @@ void setup(){`
`20`	`20`	`semaphore = xSemaphoreCreateCounting( 5, 0 );`
`21`	`21`
`22`	`22`	`if(semaphore == NULL ){`
`23`		`- Serial.println("fallo al crear el semaphore");`
	`23`	`+ Serial.println("Faile to create the semaphore");`
`24`	`24`	`ESP.restart();`
`25`	`25`	`}`
`26`	`26`
`@@ -35,5 +35,5 @@ void setup(){`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`void loop(){`
`38`		`- // tu codigo.`
	`38`	`+ // your code.`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,8 +4,7 @@`
`4`	`4`	`#include "Task.h"`
`5`	`5`
`6`	`6`	`/**`
`7`		`- * @brief Ejemplo de coordinación entre consumidores rapidos`
`8`		`- * y productor lento.`
	`7`	`+ * @brief Faster consummer.`
`9`	`8`	`*`
`10`	`9`	`*/`
`11`	`10`	`class TaskConsummer : public Task{`