il taccuino di telpar

domenica 19 gennaio 2020

Ubuntu/Debian creare facilmente un hotspot sul proprio laptop/Raspberry

Dopo aver installato Ubuntu sul mio netbook 10" la prima cosa che mi è venuta in mente è stata quella di metterci su un hotspot "free access" per condividere file di lavoro, durante presentazioni Una sorta di "pirate box"....

Il procedimento va bene, ovviamente, per ogni distro Ubuntu based/like: parliamo dunque di Raspbian oppure di Debian, in quest'ultimo caso, ovviamente, usando "su -c" al posto di sudo

Il pacchetto che trasforma un computer con scheda di rete wireless in hotspot è "hostapd"; ma chi lo rende facile da configurare è "create_ap". Di seguito i passi da seguire:

1) INSTALLAZIONE HOSTAPD

Occorre git (nel caso non fosse già installato) e dnsmasq che farà da demone DHCP per i client che si collegheranno all'hot-spot:

sudo apt-get install git hostapd dnsmasq

2) INSTALLAZIONE CREATE_AP

cd
git clone https://github.com/oblique/create_ap
cd create_ap
sudo make install

3) TEST DEL L'INSTALLLAZIONE

Occorrerrà innanzitutto individuare il nome dell'interfaccia di rete wireless sulla quale verrà "acceso" l'hotspot. Il comando da lanciare è:

Molto probabilmente l''interfaccia di rete wireless ha nome; wlan0.

Con il comando:

sudo create_ap wlan0 MYHOTSPOT

"accendiamo " su wlan0 un hotspot aperto con SSID "MYHOTSPOT", senza password

Invece con il comando:

sudo create_ap wlan0 MYHOTSPOT 12345678

"accendiamo" un hotspot con SSID 'MYHOTSPOT' e password '12345678' , crittografia WPA2, sull'interfaccia wlan0.

Per spegnerlo basterà un Ctrl-C

Per fare in modo che create_ap si avvii in automatico all'avvio (sconsigliato ovviamente nel caso del laptop, ma consigliato nel caso il Raspberry faccia solo questo) e configurarlo come servizio:

sudo systemctl enable create_ap.service

in questo caso vari parametri vanno editati nel file di configurazione /etc/create_ap.conf

sudo nano /etc/create_ap.conf

in cui i parametri principali da modificare sono:

CHANNEL=6
WIFI_IFACE=wlan0
INTERNET_IFACE=eth0
SSID=MYHOTSPOT
PASSPHRASE=12345678

quindi è possibile modificare anche il canale wireless al fine di evitare interferenze con altre emissioni vicine. La INTERNET_IFACE invece è il nome dell'interfaccia collegata a internet; nel caso di Raspberry potrebbe essere la ethernet eth0 collegata al modem router casalingo.

CREDITI

https://github.com/oblique/create_ap

Installare Nodered e johnny-five su Ubuntu/Raspbian

1) INSTALLAZIONE DI NODE.JS

Dalla pagina di installazione di Nodered si legge:

We recommend the use of node.js LTS 6.x or 6.x . Node-RED no longer supports node.js 0.10.x or 0.12.x.
Node.js 7.x is under active development and is not recommended for a stable base

Raspbian, così come Ubuntu, installano di default, dal proprio repository Node.js 0,1, che quindi non va bene per Nodered.

Occorre installare una versione stabile (attualmente la 6) mentre la 7 è attualmente versione di sviluppo

Per Raspberry Pi V1 l'unica versione installabile è la 4 (l'unica supportata dalla CPU). Per hardware successivi ,così come un PC con Ubuntu, invece, dovrebbe andare bene la 7:

#STEP 1

Rimuovere ogni eventuale installazione precedente di nodejs e npm (il package manager di javascript):

sudo apt-get purge nodejs npm

#STEP 2

Per il Raspberry Pi, l'installazione cambia a seconda della versione ossia della CPU se ARMv61 per il Pi1, oppure ARMv7 e v8, per le versioni 2 e 3. Per conoscere la CPU del proprio Pi, lanciare il seguente comando:

cat /proc/cpuinfo | grep model

Nel caso del Rpi 1, si avrà:

model name : ARMv6-compatible processor rev 7 (v6l)

* Raspberry Pi 1 (ARM v61)

Scaricare la versione LTS (attualmente 8.9.3)

wget https://nodejs.org/dist/latest-v8.x/node-v8.9.3-linux-armv6l.tar.gz

Ddecomprimerla nella propria home dir

cd
tar zxvf node-v8.9.3-linux-armv6l.tar.xz

Copiare, quindi, la directory in /usr/local:

cd node-v6.10.2-linux-armv6l
sudo cp -R bin/ /usr/local/
sudo cp -R include /usr/local/
sudo cp -R lib/ /usr/local/
sudo cp -R share/ /usr/local

* Raspberry Pi2(ARM v7), Pi3 (ARM v8), PC, laptop:

curl -sL https://deb.nodesource.com/setup_6.x | sudo -E bash -

Installare nodejs (aggiungere curl nel caso che questo non sia già installato):.

sudo apt install -y curl nodejs

#STEP 3

Per tutti i casi, verificare le versioni installate con:

node -v
npm -v

2) INSTALLAZIONE DI NODERED

Completata l'installazione di Node.js si passa all'installazione di Nodered tramite npm:

sudo npm install -g --unsafe-perm node-red

N.B. L'installazione potrebbe durare diversi minuti. Non chiudere la finestra del terminale fino al termine della procedura (barra al 100%)

Terminata l'installazione è così possibile eseguire node--red:

node-red

Con un qualsiasi browser aprendo l'indirizzo:

http://RPI_IP:1880

3) AGGIUNTA DI JOHNNY-FIVE A NODE-RED

cd .node-red

sudo npm i node-red-contrib-gpio

CREDITI

https://nodejs.org/en/download/package-manager/#debian-and-ubuntu-based-linux-distributions
http://raspberrypi.stackexchange.com/questions/48303/install-nodejs-for-all-raspberry-pi
http://nodered.org/docs/getting-started/installation

mercoledì 3 luglio 2013

Raspberry Pi - Installare WiringPi e compilare il primo programma

Prima di generare il file eseguibile occorre installare, nel caso non sia già installata, la libreria WiringPi

L'installazione della libreria wiringPi

Lanciare in successione da shell i seguenti comandi:

sudo apt-get install git-core
sudo apt-get update
sudo apt-get upgrade
git clone git://git.drogon.net/wiringPi

Quindi:

cd wiringPi
git pull origin

Infine, senza spostarsi dalla directory wiringPi:

./build

Compilazione e collegamento

Compilazione e linking possono essere fatte contestualmente specificando con -l la libreria wiringPi (prestare attenzione alle maiuscole/minuscole).

pi@raspberrypi ~ $ gcc -o blink blink.c -lwiringPi

Esecuzione e interruzione del programma

L'accesso alla funzione wiringPiSetup() richiede privilegi di root. Quindi qualsiasi programma che sia stato scritto usando wiringPiSetup() deve essere lanciato mediante sudo :

pi@raspberrypi ~ $ sudo ./blink

E' sempre possibile eseguire il programma in background, ignorando però i messaggi di errore e sulla console (come eventuali printf() presenti nel programma.

pi@raspberrypi ~ $ sudo ./blink &> /dev/null

L'esecuzione del programma può essere terminata dal terminale (mediante il classico Ctrl-C) o ancora, se il relativo processo è in background, con sudo killall blink

< Raspberry Pi - Il primo programma, far lampeggiare un LED

Risorse e strumenti usati:
[0] WiringPi, Download and Install 
[1] Blink

martedì 2 luglio 2013

Raspberry Pi - Il primo programma, far lampeggiare un LED

Far lampeggiare un LED è il primo programma che si affronta per conoscere meglio un computer interfacciato al mondo esterno

L'hardware

L'anodo del LED è collegato al pin fisico 11 del GPIO, mediante un resistore di limitazione R1 da 330 Ω ; il catodo è collegato alla massa del Raspberry (pin fisico 6). Il LED si accende quando si manda sul pin un bit 1 (corrispondente a circa 3,3V) e si spegne inviando un bit zero (circa 0V).

Per il calcolo della resistenza R1 di limitazione, si è assunta una tensione diretta del LED rosso pari a 1,8V. Per la corrente di uscita di un pin GPIO è bene mantenersi fra i 3mA e i 5mA; con 5mA il LED ha una luminosità sufficiente. Dunque, la resistenza di limitazione sarà facilmente calcolabile come:

Il software

Il programma in linguaggio C, usa le estensioni wiringPi, che consentono di facilitare le comuni operazioni di lettura, scrittura sul GPIO di Raspberry Pi

BLINK.C

#include <wiringPi.h>

#define LED_PIN 0                // LED rosso (0 WiringPI, GPIO17, pin 11)

int main (void)
{
  // --- Init
  wiringPiSetup() 
     
  pinMode (LED_PIN, OUTPUT);    // configura LED_PIN come pin di uscita
  
  // --- Loop
  while (1)
  {
    digitalWrite (LED_PIN, HIGH) ;  // Accendi LED
    delay (500) ;               // Tienilo acceso per 500ms
    digitalWrite (LED_PIN, LOW) ;   // Spegni LED
    delay (500) ;               // Tienilo spento per 500ms
  }

  return 0 ;
}

Analizziamo il programma.

#include <wiringPi.h>

Ogni programma che usi wiringPi ovviamente dovrà prevedere la direttiva di inclusione del file header.

#define LED_PIN 0

#define LED_PIN 0 è una direttiva al processore. Tutte le successive occorrenze di LED_PIN verranno sostituite con il numero 0.

Per i pin si può seguire il seguente schema di commento:

// Descrizione del pin (numero_pin WiringPI, GPIOxx, numero_pin_fisico)

ossia

// Led rosso 1 (0 WiringPI, GPIO17, pin 11)

In questo modo, di ciascun pin si saprà sempre la numerazione secondo i tre modi: wiringPi, GPIO e pin fisico, agevolando così la fase di montaggio e di debug.

  // --- Init
  if (wiringPiSetup() == -1)  
      exit(1);
  pinMode (LED_PIN, OUTPUT); // configura LED_PIN di uscita

Il primo gruppo di istruzioni che troviamo nella main() sono quelle raggruppate dal commento Init.

Esse vanno a inizializzare la libreria WiringPi e a configurare i pin utilizzati, se di ingresso o uscita mediante la funzione pinMode().

L'istruzione pinMode (LED_PIN, OUTPUT); consente di configurare il nostro LED_PIN, come pin di uscita sul quale potremo dunque inviare bit 0 e 1.

La chiamata alla funzione wiringPiSetup() va fatta una sola volta, comunque prima che si inizino a invocare le estensioni wiringPi , quindi è bene collocarla come prima istruzione in assoluto della main().

  // --- Loop
  while (1)
  {
    digitalWrite (LED, HIGH) ;  // Accendi LED
    delay (500) ;               // Tienilo acceso per 500ms
    digitalWrite (LED, LOW) ;   // Spegni LED
    delay (500) ;               // Tienilo spento per 500ms
  }

Il ciclo while(1){} è il classico "loop senza fine" dei sistemi embedded: le istruzioni contenute nel corpo del while verranno eseguite ripetutamente, finché non si spegne/resetta il computer ovvero si interrompe in qualche modo l'esecuzione del programma (vedi pagina successiva). E' del tutto equivalente a for(;;).

La funzione digitalWrite() manda sul pin desiderato (specificato nel primo parametro) un bit 0 (LOW) o un bit 1 (HIGH). Per mantenere/acceso il LED si usa la funzione delay() che genera un ritardo pari al valore (espresso in ms) passato come argomento; quindi, nel nostro caso, il LED rimarrà acceso/spento per mezzo secondo.

La fase successiva sarà quella di generazione dell'eseguibile e della sua esecuzione ovviamente dopo aver installato la libreria WiringPi.

> Raspberry Pi - Installare WiringPi e compilare il primo programma

Risorse e strumenti utilizzati:
[0] Fritzing
[1] Editor online LaTeX
[2] Google Pretty Print
[3] FidoCadJ

giovedì 20 giugno 2013

Raspberry Pi - I pin fisici e virtuali del GPIO

Il Raspberry Pi dispone di un port di I/O digitale (GPIO), che gli consente di comunicare con il mondo esterno (sensori, attuatori ecc.)

Il GPIO è accessibile mediante un connettore maschio (riferimento sullo stampato "P1") da 26 pin, passo 100mil, disposti su due linee da 13 pin ciascuna.

Lo schema del connettore è riportato di seguito e si riferisce alla revisione attualmente in commercio (la n. 2):

Fonte: http://telpar.altervista.org/

• Pin fisici e pin virtuali

Una prima distinzione che bisogna fare è fra "pin fisici" e "pin virtuali".

I primi seguono la numerazione fisica del connettore, secondo la seguente convenzione: guardando il connettore dall'alto, in modo che la tacchetta di riferimento si trovi in basso a sinistra, il pin 1 è quello che si trova in corrispondenza della tacchetta stessa, il pin2, non si trova alla destra del pin 1, ma sulla linea opposta, di fronte, come riportato nell'immagine successiva:

Fonte: http://www.panu.it/raspberry/

Quindi, la convenzione "fisica" prevede che i pin inferiori siano numerati dispari: 1, 3, 5, ... , 25, mentre quelli superiori vengano numerati pari: 2, 4, 6, ... , 26

I pin virtuali, invece, sono numeri o nomi, usati per identificare i pin fisici nella programmazione o nell'accesso dalla shell.

Un esempio di convenzione virtuale è la numerazione dei pin adottata da WiringPI, una libreria C (e per altri linguaggi), che consente di programmare il Raspberry con una sintassi semplificata, simile a quella di Arduino.

I pin WiringPi sono riportati nell'immagine di sopra cerchiati di colore rosso; come si può vedere si usano 17 numeri (da 0 a 16) per identificare i pin di I/O; ad esempio il pin fisico 11, corrisponderà al pin virtuale 0 (secondo WiringPi) e al pin virtuale 17 (secondo la convenzione del produttore del chip).

La convenzione WiringPI ha un vantaggio non indifferente: è indipendente dalle revisioni delle schede (rev.1 e rev.2), quindi non occorre ridefinire i numeri dei pin nei sorgenti.

• Livelli di tensione e di corrente

I pin GPIO2 e GPIO3 sono internamente collegati a una resistenza di pull-up da 1,8kΩ (linee SDA/SCL della comunicazione I2C).

La massima corrente prelevabile dai pin di alimentazione 3,3V è 50mA, mentre dai rami +5V è 300mA (per la rev.2).

I valori di tensione nominali associati al livello alto e al livello basso sono, rispettivamente, 3,3V e 0V.

I circuiti interni non prevedono alcuna protezione per tensioni superiori a 3,3V, quindi, nel caso si debba applicare a un ingresso del GPIO una tensione superiore (es. 5V TTL) occorrerà utilizzare dei convertitori di livello (transistor, buffer/line driver ecc.), partitori di tensione o zener, per portare la tensione nell'intorno dei 3,3V (i livelli di tensione in ingresso sono: V_IH > = 1,3V e V_IL < = 0,8V)

Le impostazioni di default, infine, limitano la massima corrente a 8mA per pin, valore massimo che garantisce la corretta interpretazione del livello logico alto.

La rev.2 monta anche un secondo connettore (riferimento P5) che prevede altri 4 pin GPIO, nel caso i 17 pin del connettore P1 non fossero sufficienti.

Risorse consultate e strumenti utilizzati:

http://elinux.org/RPi_Low-level_peripherals
http://www.scribd.com/doc/101830961/GPIO-Pads-Control2
http://www.thebox.myzen.co.uk/Raspberry/Understanding_Outputs.html
http://www.raspberrypi.org/wp-content/uploads/2012/02/BCM2835-ARM-Peripherals.pdf (DS del SoC)
FidoCadJ

martedì 23 agosto 2011

Timer2 AVR: Fast PWM a frequenza non regolabile

Ultimo aggiornamento: 28/Apr/2012

Panoramica sul Timer2 come generatore di forme d'onda

Il Timer2 dei microcontrollori AVR ATmega è un timer a 8 bit, può dunque contare da 0 fino a 255;
ha a disposizione due canali (A e B a cui corrispondono rispettivamente in pin di uscita OC2A e OC2B) che condividono ovviamente la stessa configurazione del timer, ma che possono essere usati, ad esempio, per generare due segnali a frequenza uguale, ma con duty cicle diverso.

I fattori di prescaler del segnale di clock sono ben sette e segnatamente: 1, 8, 32, 64, 128, 256, 1024.

Le modalità di funzionamento per questo timer possono essere

Normale: il timer conta da 0 a 255, continuamente; è una modalità di funzionamento che offre margini di flessibilità praticamente nulli (a meno di non ricorrere ad espedienti software, in fase di runtime, che vanificano i vantaggi di usare un timer oppure usare particolari valori di frequenze di clock)
PWM Fast: il valore corrente del timer viene confrontato una sola volta con quello di un registro, durante la fase di conteggio da 0 verso 255.
Quando i valori dei due registri sono fra loro uguali, al successivo clock, viene effettuata una commutazione del livello d'uscita (questo metodo è preferibile per applicazioni ad alta frequenza, in cui non sia importante la fase del segnale PWM)
PWM a fase costante: il valore corrente del timer viene confrontato due volte con quello contenuto in un registro: una prima volta mentre il timer conta da 0 verso 255, una seconda volta, durante la fase di conteggio da 255 verso 0.
All'avvenuta uguaglianza fra questi due numeri, il pin d'uscita viene commutato al successivo impulso di clock (questo metodo è richiesto per applicazioni dove è importante mantenere la fase costante, es: regolazione PWM in motori a c.c.)

La modalità PWM fast può essere, a sua volta, implementata in tre modi:

a duty cicle regolabile e periodo/frequenza non regolabile sul canale A e/o B:
a duty cicle fisso al 50% e periodo/frequenza regolabile sul canale A
a duty cicle fisso al 50% sul canale A e
frequenza/periodo regolabile con duty cicle regolabile sul canale B
(ma con frequenza pari alla metà di quella sul canale A)

Per periodo/requenza regolabile si intende che nel software può essere regolata, in modo fine, il periodo (ovvero la frequenza) desiderato del segnale rettangolare; diversamente per periodo/frequenza non regolabile si intende che è possibile scegliere il periodo/frequenza, ma solo in un insieme di valori predeterminati, scegliendo quello che più si avvicina a quello desiderato

La seconda modalità è quella consigliata da Amtel per ottenere segnali simmetrici mediante il Timer2

La terza modalità, dunque, è quella più flessibile perché consente di ottenere sul canale B del timer un segnale regolabile in duty cicle e in periodo

Logica di funzionamento della Fast PWM

La logica di funzionamento della Fast PWM è simile a quella vista per il Timer1 a 16bit.

Nella modalità a duty cicle regolabile e frequenza non regolabile, appena il valore corrente del registro del timer2 (TCNT2) raggiungerà un valore NA contenuto nel registro OCR2A, al sucessivo impulso di clock si avrà la commutazione di livello, che potrà essere da livello alto a livello basso (nel caso della modalità non invertita) o da livello basso a livello alto (nel caso della modalità invertita).

La modalità non invertita è quella che corrisponde alla definizione di duty cicle ed è raffigurata di seguito, supponendo che vogliamo usare il canale A:

In questa modalità, il registro OCR1A viene sincronizzato a ogni successivo valore 0 del registro dati TCNT2, questo per evitare asimmetrie nel segnale generato.

Nella modalità Fast PWM a frequenza non regolabile con il Timer2, si dovrà dunque calcolare un valore (NA) che andrà caricato nel registro OCR2A (se ovviamente usiamo il canale A) che definisce il duty cicle del segnale PWM generato sul pin OC2A.

In questo tipo di FastPWM, invece, non è possibile, modificare il numero massimo N, dal quale dipende il periodo Ts e dunque il valore di frequenza del segnale generato non potrà essere regolato, ma scelto fra un insieme di valori (vedi tabella successiva).

Esempio applicativo

Supponiamo di avere questo semplice problema:

Usando il timer2, in modo Fast PWM, generare un segnale a 8kHz, con duty cicle del 40%. La frequenza di clock fc è di 16 MHz (si usa una board Arduino)

A un segnale a frequenza fck corrisponde un periodo Tck:

Il periodo Ts del segnale da generare può essere calcolato dalla nota equazione generale:

$T_{s} = T_{ck} \cdot k \cdot (N+1)$

ove:

Ts è il periodo del segnale PWM
N è il numero massimo, fisso, che può contare il timer (255 essendo il timer a 8bit)
k è il fattore di prescaler
Tck è il periodo del segnale di clock

e quindi, dal momento che il timer2 può contare fino a 255, il periodo del segnale Ts è calcolabile con l'equazione:

$T_{s} = T_{ck} \cdot k \cdot (256)$

Creando un tabella con il foglio elettronico, siamo così in grado di calcolare il periodo Ts del segnale PWM (ovvero la frequenza fs) per ogni fattore di prescaler k, assegnata la frequenza di clock di 16MHz:

Come si può notare, possiamo ottenere (con un clock assegnato di 16 MHz) solo frequenze fisse aventi determinati valori, che non possiamo regolare in modo fine; scegliendo k=8 abbiamo una frequenza del segnale fs=7,81kHz che si avvicina a 8 kHz.

Essendo richiesto di utilizzare il modo Fast PWM, non possiamo che accettare questo compromesso e scegliamo allora k=8

Successivamente vedremo un'altra modalità Fast PWM che consente di regolare il valore di frequenza esattamente a 8 kHz

La regolazione del duty cicle

Il duty cicle si esprime in percentuale e si definisce come rapporto fra il tempo in cui il segnale è alto (Ton) e l'intero periodo del segnale (Ts) moltiplicandolo per 100.

$dc_\% = \left( {T_{ON} \over T_S} \right )\cdot 100$

Calcolare i due tempi è molto semplice: se per un periodo Ts occorrono N+1 cicli di clock, per un periodo Ton ne occorreranno di meno, diciamo NA+1 ; dunque:

$T_S = T_{CK} \cdot k \cdot 256$

sostituendo nella formula generale del dutyu cicle abbiamo:

$dc_\% = \left (T_{ON} \over T_S \right ) \cdot 100 = \left({N_A+1} \over 256 \right ) \cdot 100$

Da cui siamo in grado di ricavare NA per il dc% desiderato:

$N_A = \left( dc_\% \cdot 256 \over 100 \right) - 1$

che per dc=40% diventa:

Il valore ricavato è stato approssimato, dal momento che i registri memorizzano numeri interi fra 0 a 255; l'effettivo duty cicle sarà dunque:

N.B. E' sempre possibile usare anche il canale B del timer, caricando un secondo valore NB in OCR2B (ovviamente calcolato secondo la stessa metodologia di NA) ottenendo così un secondo segnale PWM che ha la stessa frequenza e modalità del primo (dovendo condividere la stessa configurazione del timer0) ma con duty cicle diverso.

Scriviamo il programma

Vediamo ora un possibile pseudocodice per la configurazione del timer:

Configura il timer2 in modo PWM Fast a risoluzione fissa
Configura il modo PWM in modalità non invertente sul canale A
Carica il valore NA in OCR2A
Configura il prescaler (:8), il timer è avviato

Codifichiamo i vari step in GNU avr-libc:

1. Configura timer2 in modo PWM Fast a risoluzione fissa

Si fa riferimento alla tabella 18-8 del datasheet:

Bisogna dunque settare i bit WGM21 e WGM20, che si trovano nel registro di configurazione A del Timer2 (TCCR2A) :

TCCR2A = (1 << WGM21) | (1 << WGM20);

2. Configura il modo PWM in modalità non invertente sul canale A

Bisogna far riferimento alla Tab. 18-3 del d/sheet, che riporta come impostare i bit COM2A1 e COM2A0 del registro TCCR2A per avere la modalità PWM non invertente.

TCCR2A |= (1 << COM2A1);

3. Carica il valore NA in OCR2A

Conviene usare un'etichetta simbolica NA associata al numero da caricare, con un commento esplicativo sul duty cicle ottenuto in corrispondenza di esso:

#define NA 102 /* dc=40% @ fck=16MHz:8 */

OCR2A = NA; // carica NA in OCR2A

4. Configura il prescaler (:8)

La tabella 18.9 indica come settare i bit CS22, CS21 e CS20 del registro TCCR2B:

TCCR2B = (1 << CS21);

Dopo quest'ultima istruzione, il timer è così avviato.

Siamo dunque in grado di scrivere il codice definitivo, combinando assieme tutti i pezzi di codice creati passo per passo.

#include <avr/io.h>

#define NA 102  /* dc=40% @ fck=16MHz:8 */

int main (void)

{


  DDRB |= (1 << PB3);  // imposta pin PB3(OC2A) come uscita
  TCCR2A = (1 << WGM21) | (1 << WGM20) | // FastPWM a risoluzione fissa 
           (1 << COM2A1);    // PWM mod. non invertente

  OCR2A = NA;

  TCCR2B = (1 << CS21); // prescaler :8

  while(1)

  {

    /* il compito viene svolto completamente via hardware dal Timer2.. */

  }

}

Simulazione con VMLAB

File Project (per Windows non per Wine):
Si ricorda di rinominare il file ATmega168b.ini in ATmega168.ini

; Micro + software running
; ------------------------------------------------------------
.MICRO "ATmega168"      "CKSEL=0000 CKDIV8=1"
.CLOCK 16meg         ; Micro clock
.TOOLCHAIN "GCC"
.GCCPATH   "C:\WinAVR"
.GCCMAKE   AUTO
.TARGET    "pwm.hex"
.SOURCE    "main.c"

.TRACE     ; Activate micro trace

; Following lines are optional; if not included
; exactly these values are taken by default
; ------------------------------------------------------------
.POWER VDD=5 VSS=0  ; Power nodes
.STORE 50m     ; Trace (micro+signals) storage time
.PLOT V(PB3)   ; Plotta il livello del pin PB3(OC2A)

I risultati della simulazione

Ton:

e il periodo del segnale Ts:

I contenuti di questo documento, sono stati resi possibili grazie ai seguenti strumenti gratuiti:
- LaTex online equation editor
- FidoCADJ (disegno grafici)
- Google Code Prettify (sorgenti con sintassi evidenziata)
- Libreoffice Calc (calcolo valori prescaler ris. fissa)

sabato 25 dicembre 2010

Timer AVR in 5min: 7) Un foglio di calcolo

< Timer AVR in 5min: 5) Gen. forme d'onda PWM (fast)

Timer AVR in 5min: 7) Un foglio di calcolo >

Ultima revisione: 29/Apr/2012

TIMERS_ATMEGA168.ZIP

A conclusione della serie di post: "i timer AVR in cinque minuti" presento un semplice foglio elettronico (in formato OpenOffice.org Calc), che calcola i valori necessari per le configurazioni delle modalità di funzionamento viste.

Una volta appreso il metodo per calcolare, con carta e penna, i valori di N (e di NA) da caricare nei registri, a seconda della modalità di funzionamento del timer, può tornare utile uno strumento di calcolo che agevoli tale lavoro.

Esso è valido per le mcu AVR ATmegaxx8 (ATmega88/168/328) e - al momento - per il solo Timer1 (16bit); può essere sicuramente fatto meglio, per cui gradirei ben volentieri migliorìe e soprattutto correzioni.

Vediamo come si usa.

Le celle con sfondo colorato sono quelle nelle quali l'utente deve immettere una variabile.

La prima variabile richiesta, per tutti i modi di funzionamento, è la frequenza di clock (fc) del sistema espressa in MHz, nella cella C3 (sfondo colore celeste):

Nella cella immediatamente inferiore comparirà il relativo periodo di clock (Tc) espresso in microsecondi.

MODO NORMALE

A sinistra compariranno i vari valori di tempo, per ciascun fattore di prescaler:

MODO CTC

Sarà richiesto il tempo desiderato T (cella F13, sfondo colore verde lime) espresso in secondi:

A sinistra comparirà una tabella con i valori di N calcolati per ogni fattore di prescaler. I valori che riportano la dicitura "N.R." in rosso, sono non utilizzabili in quanto non possono essere rappresentati nel registro del timer, perché sono maggiori di quello massimo (65535, ricordarsi del +1) oppure minori di zero:

I valori N non interi (cifra decimale diversa da zero) sono comunque riportati, lasciando dunque piena flessibilità di scelta, caso per caso, se approssimare il valore all'intero successivo o precedente.

MODO CTC GEN. FORME D'ONDA

Sarà qui richiesta la frequenza desiderata del segnale (fs), nella cella F3 di colore verde oliva, espressa in Hertz:

A sinistra, verranno visualizzati i valori di N, per ciascun fattore di prescaler k:

Eventuali valori che riportano la dicitura "N.R." in rosso, sono non utilizzabili in quanto non possono essere rappresentati nel registro del timer, perché sono maggiori di quello massimo (65535, ricordarsi del +1) oppure minori di zero. Anche per questo modo di funzionamento i valori N non interi (cifra decimale diversa da zero) sono comunque riportati, lasciando dunque piena flessibilità di scelta se approssimare, o meno, per difetto o per eccesso all'intero immediatamente vicino.

MODO PWM FAST GEN. FORME D'ONDA

Per questa modalità c'è una prima tabella riportante tutte le frequenze fisse, che possono essere ricavate nelle singole modalità fisse (8, 9 e 10bit), per i diversi valori di prescaler (k):

Più sotto c'è una seconda tabella, che, invece, riporta i valori di N e NA necessari per generare un segnale rettangolare con una frequenza fs e duty cicle desiderati:

Valori che riportano la dicitura "N.R." in rosso, non sono utilizzabili in quanto o sono valori N che non possono essere rappresentati nel registro del timer, perché sono maggiori di quello massimo (65535, ricordarsi del +1) oppure perché minori di 3 (la risoluzione variabile minima è 2bit, quindi il valore minimo è 3 - cfr. Datasheet) oppure perché il valore NA è negativo.

I valori N e NA non interi (cifra decimale diversa da zero) sono comunque riportati, lasciando dunque piena flessibilità di scelta se approssimare, o meno, per difetto o per eccesso all'intero immediatamente vicino.
Per popolare questa tabella ovviamente occorre definire la frequenza fs (in Hz) nella cella F41 (sfondo colore marrone chiaro) e il duty cicle (in percento) nella cella F42:

MODO PWM A CORR. DI FASE E FREQUENZA

Essendo questa modalità tipicamente usata per il controllo di motori, si è preferito far immettere il periodo del segnale Ts (piuttosto che la frequenza) e la durata della larghezza dell'impulso Ton (piuttosto che il duty cicle); questi due tempi vanno inseriti, rispettivamente, nelle celle F52 (sfondo colore magenta) e F53 (sfondo colore celeste) e devono essere espressi in ms: