The Embedded Notes Blog

The official Embedded Notes Blog. [Fri May 26 2017]

Nuova serie dalla STM: STM32H7

MCU STM32H7

Novità dalla STM

La STM ha presentato la nuova serie di MCU STM32H7 con ARM core Cortex-M7 cloccato alla spettacolare velocità di 400MHz !
Questo è il link ufficiale STM.
L'ulteriore incremento di velocità, dai 216MHz della versione F7 ad oggi, si è avuto grazie al cambio di tecnologia nel processo di fabbricazione passato a 40nm. Questo ha portato ad ottenere dei livelli di consumo di tutto rispetto:280µA/MHz in esecuzione e 7µA in stand-by

Ma c'è dell'altro.

Con questa nuova serie di MCU la STM ha anche voluto introdurre una serie di periferiche direi: "di alto livello". Dedicate cioà ad una fascia di mercato che vuole alte prestazioni: POS multimediali, prodotti di consumo smart e dotati di una interfaccia utente "smartphone like".
Vi riporto l'elenco presente sul sito STM:
  • AXI and multi-AHB bus matrixes for interconnecting core, peripherals and memories
  • 16 Kbytes +16 Kbytes of I-cache and D-cache
  • Up to 2 Mbytes of embedded dual-bank Flash memory, with ECC and Read-While-Write capability
  • A high-speed master direct memory access (MDMA) controller, two dual-port DMAs with FIFO and request router capabilities for optimal peripheral management, and one additional DMA
  • Chrom-ART acceleration for efficient 2D image copy
  • Double-precision FPU are also part of the acceleration features available in the device
  • Peripheral speed independent from CPU speed (dual-clock support) allowing system clock changes without any impact on peripheral operations
  • Even more peripherals, such as four serial audio interfaces (SAI) with SPDIF output support, three full-duplex I²S interfaces, a SPDIF input interface supporting four inputs, two USB OTG with dedicated power supply and Dual-mode Quad-SPI interface, two FD-CAN controllers, a high-resolution timer, a TFT-LCD controller, a JPEG codec, two SDIO interfaces and many other analog peripherals including three fast 14-bit ADCs, two comparators and two operational amplifiers.
  • 1 Mbyte of SRAM with a scattered architecture:
    192 Kbytes of TCM RAM (including 64 Kbytes of ITCM RAM and 128 Kbytes of DTCM RAM for time-critical routines and data),
    512 Kbytes, 288 Kbytes and 64 Kbytes of user SRAM, and 4 Kbytes of SRAM in backup domain to keep data in the lowest power modes
Nel prossimo anno saranno disponibili anche le versioni con Crypto module

Nuovo ESP32: novità nel WiFi!

Nuovo ESP32

Nuovo modulo WiFi e BLE ESP32

Il nuovo modulo WiFi della Espressif chiamato ESP32 è presente sul mercato, ad un prezzo economico, e capace di servire sia come modulo WiFi e BLE stand-alone sia come modulo slave per una MCU che necessita di una robusta e veloce connettività.
Questo è il link ufficiale ESP32.
Il modulo è composto da un dual core Tensilica LX6 a 240MHz, e da una corposa dotazione di periferiche, oltre ovviamente al necessario per il WiFi e BLE!

Ma andiamo con ordine.

Di seguito un elenco preso dal sito web della Espressif:
  • 240 MHz dual core Tensilica LX6 microcontroller with 600 DMIPS
  • Integrated 520 KB SRAM
  • Integrated 802.11BGN HT40 Wi-Fi transceiver, baseband, stack and LWIP
  • Integrated dual mode Bluetooth (classic and BLE)
  • 16 MByte flash
  • 2.2V to 3.6V operating voltage
E poi ancora i sensori:
  • Ultra-low noise analog amplifier
  • Hall sensor
  • 10x capacitive touch interface
  • 32 kHz crystal oscillator
E le interfacce:
  • 3 x UARTs, including hardware flow control
  • 3 x SPI
  • 2 x I2S
  • 12 x ADC input channels
  • 2 x DAC
  • 2 x I2C
  • PWM/timer input/output available on every GPIO pin
  • OpenOCD debug interface with 32 kB TRAX buffer
  • SDIO master/slave 50 MHz
  • Supports external SPI flash up to 16 MB
  • SD-card interface support
Per quanto riguarda la sicurezza WiFi:
  • WEP, WPA/WPA2 PSK/Enterprise
  • Hardware accelerated encryption: AES / SHA2 / Elliptical Curve Cryptography / RSA-4096
Queste le capacità del chip:
  • Supports sniffer, station, softAP and Wi-Fi direct modes
  • Max data rate of 150 Mbps@11n HT40, 72 Mbps@11n HT20, 54 Mbps@11g, and 11 Mbps@11b
  • Maximum transmit power of 19.5 dBm@11b, 16.5 dBm@11g, 15.5 dBm@11n
  • Minimum receiver sensitivity of -98 dBm
  • 135 Mbps UDP sustained throughput
  • 2.5 μA deep sleep current

Che dire...

E' un chip eccezionale! Sul mercato si iniziano a trovare molti moduli dotati di ESP32: Sparkfun, Adafuit, hanno già pronta la loro versione di breakout-board. Altre ne arrivano sul mercato ogni giorno, pubbliczzate dalla stessa Espresif su Twitter. Oltre ad essere l'ideale, per equipaggiare i dispositivi IoT dual protocol: WiFi e BLE, si presta anche all'utilizzo come dispositivo WiFi BLE slave alle MCU. Non so se ci sono già le API disponibili per l'interfacciamento SDIO a 50MHz, ma sarebbe interessante verificarne il throughput.

RayTracing per ESP32 e STM32F7!

RayTracing ESP32 e STM32F7

Eccezionale codice di RayTracing per ESP32 di cui ho fatto il porting per STM32F7-Discovery

Mi è arrivato da Twitter la GIF animata del rendering di questo software di RayTracing eseguito su di un ESP32. Questo è il link ufficiale per ESP32. Sempre sul sito ho trovato il codice di RayTracing, e subito ne ho fatto il porting, non senza qualche problema, sul Keil per la STM32F7-Discovery.

Il codice di RayTracing è tutto in un sorgente .h scritto in C++. Una cosa veramente bella che l'autore ha fatto è l'uso dell'"operator overloading".

Questo è il codice per la classe principale:

/*------------------------------------------------------------------------
  A 3D vector class
------------------------------------------------------------------------*/
struct vec3 {

  float x,y,z;  // Vector has three float attributes.
  vec3(){}
  vec3(float a, float b, float c){x=a;y=b;z=c;}
  vec3 operator+(const vec3& v) const { return vec3(x+v.x,y+v.y,z+v.z);  }    // Vector add
  vec3 operator-(const vec3& v) const { return (*this)+(v*-1);           }    // Vector subtract
  vec3 operator*(float s)       const { return vec3(x*s,y*s,z*s);        }    // Vector scale
  float operator%(const vec3& v)const { return x*v.x+y*v.y+z*v.z;        }    // Scalar product
  vec3 operator^(const vec3& v) const { return vec3(y*v.z-z*v.y, z*v.x-x*v.z, x*v.y-y*v.x);  } // Vector product
  vec3 operator!()              const { return *this*(1.0f/(float)(sqrt(*this%*this)));  }  // Normalized vector
  void operator+=(const vec3& v)      { x+=v.x;  y+=v.y;  z+=v.z;        }
  void operator*=(float s)            { x*=s;    y*=s;    z*=s;          }
};

Avendo sostituito gli operatori con degli operatori che sono a loro volta delle funzioni, tutto il codice a seguire è estremamente leggibile. E pensare che l'autore lo ha tratto dal sito di Paul Heckbert ed era scritto in formato "business card"

Questi snoo i risultati che ho ottenuto con il Keil sulla STM32F7-Discovery alla risoluzione di 320x240: RayTracing STM32F7 320x240

ed alla risoluzione piena 480x272: RayTracing STM32F7 320x240

UPDATE !

Sono riuscito a portare il rendeing full-screen a 0.872014 secondi ed il rendering a 320x240 a 0.5391 secondi.

Porting per il Keil

Nel fare il porting del codice per il Keil, ho incontrato alcuni problemi.
Il programma di raytracing è contenuto tutto in un include file ed è scritto in C++. Per prima cosa ho include il file "raytracer.h" nel "mail.c", indicando però al Keil che da adesso in poi il "mail.c" doveva essere interpretato come sorgente C++.
Pulsante dx sul nome file, poi "Option For File main.c" e poi "File Types" come "C++ Source File".
A queso punto ho iniziato ad avere degli errori: il compilatore non riconosceva il costrutto "class"! Cercando su Internet ho trovato che la soluzione stava nel togliere la direttiva C99 impostata nel campo "Misc Control" nelle Opzioni di progetto.
Fatto questo le cose sono andate meglio, ma avevo ancora problemi, questa volte di "Undefined symbol". Anche in questo caso Internet mi ha aiutato a trovare la soluzione.
Ho inserito la direttiva:

extern "C" 
{
}
con all'interno tutti gli include file del main.c, ed alcune dichiarazioni di funzioni sempre presenti nel main, per cui avevo problemi.
Non sono esperto di C++, quindi dovrò tornare su questi problemi e studiarmeli. I link da cui ho preso le soluzioni sono i seguenti:
Undefined symbol
Keil C99 & C++ mix
Sempre nel file "raytracing.h" ho sostituito il tipo "byte" con "uint8_t" ed ho incluso il file "stdbool.h" per mantenere il tipo "bool", e le definizioni di "true" e "false".
I sorgenti sono disponibili su github: https://github.com/cledic/STM32F7