Firtec

Procesador Xtensa LX6 doble núcleo de 32 bits.

Tensilica es una compañía fundada en 1997 pero que en los últimos tiempos viene sorprendiendo con sus nuevos procesadores y en particular por el alto grado de integración de periféricos. 
Tomando como ejemplo el Xtensa LX6 con dos núcleos de 32 bits y donde todo está a bordo.

  • 18 Canales ADC.
  • 3 SPI.
  • 2 I2C.
  • 2 I2S.
  • 3 UART.
  • 16 Salidas PWM para manejo de LEDs.
  • 2 DAC.
  • 10 Entradas Touch Capacitivas.
  • Sensor Hall.
  • Sensor de temperatura.
  • Host para el control de memorias SD/SDIO/MMC.
  • Bus CAN.
  • Puertos GPIO.
  • WiFi.
  • Bluetooth.
  • Y varias cosas mas!!!!

Dos núcleos operando a 240 Mhz que pueden trabajar en forma cooperativa o independiente. Todo compatible con ARM y siguiendo la misma filosofía de programación como se puede ver en el siguiente código para leer un canal analógico.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/******************************************************************************
**  Descripción  : Uso del conversor A/D usando ADC_0 (GPIO36)                
**  Target       : Tensilica Xtensa LX6 Dual Core 240 Mhz
**  ToolChain    : Esp-Idf
**  www.firtec.com.ar
*******************************************************************************/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "driver/gpio.h"
#include "driver/adc.h"
 
#define ADC1 (0)
 
void tarea_adc1(void* arg)
{
    unsigned int dato;
    // Configura el ADC
    adc1_config_width(ADC_WIDTH_12Bit);
    adc1_config_channel_atten(ADC1,ADC_ATTEN_11db);
    while(1){
		dato = adc1_get_raw(ADC1_CHANNEL_0);
		printf("ADC = %d\n",dato);
		vTaskDelay(1000/portTICK_PERIOD_MS);
    }
}
 
void app_main()
{
    xTaskCreate(tarea_adc1, "tarea_adc1", 1024*3, NULL, 10, NULL);
}

 

 

Tener mas de una CPU lleva el trabajo con microcontroladores a otro nivel donde el concepto de multitareas se hace realidad.
El siguiente es un ejemplo completo donde se ejecutan tres tareas con distinto nivel de prioridad en sus interrupciones.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
/********************************************************************************************
**  Descripción  : Crea distintas tareas, destella dos LED en GPIO5 y GPIO4
**                 también envía por la UART el mensaje "Hola Firtec" 
**  Target       : Tensilica Xtensa LX6 Dual Core 240 Mhz
**  ToolChain    : Esp-Idf
**  www.firtec.com.ar
*********************************************************************************************/
 #include <stdio.h>
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "esp_system.h"
 #include "driver/gpio.h"
     
 #define led1_pin 5  // Pin donde está el LED_1
 #define led2_pin 32 // Pin donde está el LED_2
     
     
    void UART(void *pvParameter)
    {
     
    	while(1)
    	{
    	    printf("Hola Firtec!\n");
    	    vTaskDelay(1000 / portTICK_RATE_MS);
    	}
    }
     
    void Led_1(void *pvParameter)
    {
         gpio_pad_select_gpio(led1_pin);
	 gpio_set_direction(led1_pin, GPIO_MODE_OUTPUT);
        while(1) {
            /* LED apagado */
            gpio_set_level(led1_pin, 0);
            vTaskDelay(200 / portTICK_RATE_MS);
            /* LED encendido */
            gpio_set_level(led1_pin, 1);
            vTaskDelay(200 / portTICK_RATE_MS);
        }
    }
	
	 void Led_2(void *pvParameter)
    {
        gpio_pad_select_gpio(led2_pin);
        /* Configura el pin como salida */
        gpio_set_direction(led2_pin, GPIO_MODE_OUTPUT);
        while(1) {
            /* LED apagado */
            gpio_set_level(led2_pin, 0);
            vTaskDelay(500 / portTICK_RATE_MS);
            /* LED encendido */
            gpio_set_level(led2_pin, 1);
            vTaskDelay(500 / portTICK_RATE_MS);
        }
    }
     
    void app_main()
    {  
    
   REG_CLR_BIT (RTC_IO_XTAL_32K_PAD_REG, RTC_IO_X32P_MUX_SEL);
   /* gpio33 ruta a digital io_mux */
    REG_CLR_BIT (RTC_IO_XTAL_32K_PAD_REG, RTC_IO_X32N_MUX_SEL);
 
   // Se crean las tareas a ejecutar.
        xTaskCreate(&UART, "UART", 2048, NULL, 3, NULL);
        xTaskCreate(&Led_1, "Led_1", 512,NULL,5,NULL );
	xTaskCreate(&Led_2, "Led_1", 512,NULL,4,NULL );
    }


En los ejemplos estuvimos probando la placa SparkFun ESP32 Thing con resultados realmente muy interesantes.
Para construir una aplicación completa no necesitamos agregar ningún microcontrolador, esta placa tiene todo lo necesario incluso conectividad WiFi.
(Estaremos publicando un ejemplo completo de control web con el ESP32).

   Estaremos sumando a nuestros cursos la programación completa para el Xtensa LX6. 

Que es ARM?

ARM inició en 1983, como un proyecto de desarrollo en la empresa Acorn Computers  y en abril de 1985 presentaron su primer chip que contenía un bus de datos de 32 bits, ARM es 32 bits desde su origen.

ARM es una empresa peculiar ya que no fabrica los dispositivos si no que ofrece distintos tipos de licencias tanto sobre sus conjuntos de instrucciones como sobre sus arquitecturas.

El fabricante del dispositivo que puede ser una televisión, una cámara de fotos, una lavadora o una tablet decide si le conviene más usar el diseño propio de ARM o crear el suyo.
El trabajo de ARM es más el de un arquitecto que el de un constructor, ellos diseñan y otros lo ponen en práctica. Esos otros son empresas como Samsung, Texas Instruments, Qualcomm, Nvidia, Apple, Motorola, etc, que basan sus procesadores en diseños licenciados a ARM.

Que es Cortex M4?

Es un microcontrolador que pertenece a la arquitectura ARM7 de última generación y de los mas poderosos dentro de la gama de núcleos escalares con un set de instrucciones ortogonal que dan a este controlador gran flexibilidad y eficiencia para ejecutar código en C.

Cortex M4 es una arquitectura RISC con un conjunto de instrucciones de 32 bits. Las prestaciones de este controlador permite ya la ejecución de RTOS, Android, Linux, etc.

Dentro de un Cortex hay varios buses de datos que se vinculan a distintos periféricos, esto último es muy importante porque marca una de las grandes diferencias con un microcontrolador de 8 bits o de arquitectura “tradicionalen donde podemos tener la certeza de que cada operación dura un determinado tiempo o ciclo de CPU lo que lleva a que los tiempos en juego se pueden determinar con facilidad. En un micro de 32 bits hay varios buses y los tiempos ya no son tan fáciles de predecir puesto que otros periféricos pueden estar usando estos buses o si el micro tiene memoria cache esto altera los tiempos en juego por lo que debe usted desterrar la idea que solo basta con contar las instrucciones y multiplicar por la velocidad del bus.

Lo siguiente que puede resultar un poco confuso es que todo dentro del Cortex tiene su reloj individual que por defecto esta desconectado. Es decir entonces que para hacer uso de un módulo una de las configuraciones que debemos incluir es activar y el reloj y determinar una frecuencia de operación dentro del rango que el bus admite.

Que es CMSIS?

El éxito comercial de licenciar los núcleos de los procesadores y permitir que cada cliente pueda incorporarle a este núcleo los periféricos que necesita para sus aplicaciones específicas trae un problema que es la compatibilidad para programar estos periféricos bajo un mismo criterio, es decir que un periférico de Freescale y uno con la misma funcionalidad de STM se deberían programar de igual manera para de esta forma simplificar el trabajo y permitir a los programadores tener una forma mas flexible de elegir el hardware.

Esto es lo que hace CMSIS, genera una capa de software que separa al programador del hardware permitiendo programar en un nivel superior y con un interfaz unificada para todos los Cortex independientemente de su fabricante.

Porqué me debería interesar ARM?

Bueno, si estamos trabajando con microcontroladores y vemos que actualmente cerca del 85% de los dispositivos móviles llevan un chip ARM y que las principales empresas fabricantes de chips están trabajando con núcleos ARM, y si a esto sumamos los bajos costos, herramientas de desarrollo libres y microcontroladores que no requieren un programador específico para ser programados, es motivo al menos que justifica investigar que está pasando con ARM.