Raspberry PI: Sensore di Temperatura ed Umidità

1
Raspberry PI DHT11

Raspberry Pi e DHT11 Sensore

15 agosto e la sera esco con camicia e felpa, quale miglior giorno per provare il mio nuovo sensore di temperatura ed umidità tramite il Raspberry Pi ? 😛

il Sensore in questione (DHT11) è uno di quelli “cinesi” che si trovano a pochi euro in qualsiasi negozio online. Ha un range di misurazione della temperatura tra 0-50°C & un range di umidità tra 20-95%.

Online si trovano miriadi di link su come collegarlo al nostro Raspberry Pi, La foto allegata all’inizio del post vi mostra il mio schema…

Bhe ammetto che si capisce molto poco, forse meglio utilizzarne uno preso dal web 😀

Sensor dht11 wiring

Schema collegamento DHT11

DHT11_Pins

Dettaglio Pins DHT11

Una volta collegato il nostro sensore al Raspberry PI (io uso il connettore Adafruit ) non vi resta che scaricare le librerie per l’interfacciamento con il sensore

[sourcecode language=”bash”]

$ git clone git://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code.git
$ cd Adafruit-Raspberry-Pi-Python-Code
$ cd Adafruit_DHT_Driver

[/sourcecode]

Bene, una volta scaricato il binario ( già compilato per il nostro processore) possiamo eseguirlo direttamente dalla shell dei comandi

[sourcecode language=”bash”]
root@raspberrypi: ./Adafruit_DHT 11 4
Using pin #4
Data (40): 0x24 0x0 0x1c 0x0 0x40
Temp = 28 *C, Hum = 36 %
[/sourcecode]

Dove “11” indica il modello del sensore, ed il “4” indica il PIN GPIO a cui è collegato.

Non sarebbe bello avere un grafico con l’andamento della temperatura ed accessibile ovunque tramite web??

Esistono molto modi (e molte API) per esportare i dati sul web, io ho utilizzato le API che google docs mette a disposizione.

1) Creazione Spreadsheet

Prima di tutto andiamo su google docs e creiamo il nostro spreadsheet dove andremo ad inserire i nostri dati

Creazione spreadsheet

Creazione spreadsheet

1) Installazione Ed esecuzione della libreria Python

Per poter fare upload dei dati presi dal sensore, possiamo utilizzare una libreria che ci semplifica di molto le operazioni per l’interfacciamento con google. La libreria in questione si chiama GSpread

[sourcecode language=”bash”]
wget http://pypi.python.org/packages/source/g/gspread/gspread-0.0.13.tar.gz#md5=d413ad08805f3f0a1e9d5f9bebe5d35b
tar -zxvf gspread-0.0.13.tar.gz
cd gspread-0.0.13
sudo python setup.py install
[/sourcecode]

Una volta installata dobbiamo modificare alcuni opzioni: andiamo nella directory Adafruit-Raspberry-Pi-Python-Code/Adafruit_DHT_Driver ed editiamo il file Adafruit_DHT_googledocs.ex.py nei seguenti punti:

[sourcecode language=”python”]
# ===========================================================================
# Google Account Details
# ===========================================================================

# Account details for google docs
email = ‘you@somewhere.com’
password = ‘my_password’
spreadsheet = ‘Temperature_Flavio_Home’
..
..
..
output = subprocess.check_output(["./Adafruit_DHT", "11", "4"]);

[/sourcecode]

Inserendo rispettivamente i dati del nostro account di google, il modello del nostro sensore (DHT11 nel mio caso) ed il pin a cui è collegato (4)

Se tutto è andato nel verso giusto avremo come output della shell

[sourcecode language=”python”]
pi@raspberrypi ~/Adafruit-Raspberry-Pi-Python-Code/Adafruit_DHT_Driver $ sudo python Adafruit_DHT_googledocs.ex.py
Using pin #4
Data (40): 0x25 0x0 0x1a 0x0 0x3f
Temp = 26 *C, Hum = 37 %

Temperature: 26.0 C
Humidity: 37.0 %
Wrote a row to Temperature_Flavio_Home
Using pin #4
Data (40): 0x25 0x0 0x1a 0x0 0x3f
Temp = 26 *C, Hum = 37 %

Temperature: 26.0 C
Humidity: 37.0 %
Wrote a row to Temperature_Flavio_Home
Using pin #4
Data (40): 0x24 0x0 0x1a 0x0 0x3e
Temp = 26 *C, Hum = 36 %
[/sourcecode]

Mentre se apriamo il nostro spreadsheet vedremo in real-time i valori letti dal nostro Raspberry Pi 😀

Questo è il grafico della mia stanza…

https://docs.google.com/spreadsheet/ccc?key=0AvfMfLVFJ7CPdHlNVzlzNmNNM01JMGZTTlA4bGl2WkE&usp=sharing

graph temperature Dragonetti

graph temperature Dragonetti

WiFi HotSpot e Captiva Portal tramite pfsense

0

caffedelcorso

Dovrei studiare per l’esame di stato ma, ogni giorno, trovo sempre qualcosa di piu’ interessante da fare.

Era da un po’ di tempo che avevo in mente l’idea di creare degli HotSpot WiFi Free per l’accesso gratuito ad Internet per i clienti di:  Caffe del Corso e Bar Belvedere (permettetemi un po’ di pubblicita’ 😛 ).

Dopo aver girovagato un po’ su internet sulle varie soluzioni da poter utilizzare, alla fine il suggerimento migliore (come sempre accade) e’ stato quello del mio mentore Franco 😀

Utilizzare pfsense come Captive Portal e’ davvero semplice ed intuitivo. Ci ho perso solo 2 gg 😛 , ma questo mi ha permesso di avere degli accessi controllati sia in termini di banda (download/upload) sia in termini di tempo (minuti per ogni connessione).

Ho usato una macchina virtuale tramite Virtualbox per far girare pfsense (Attenzione, quando create la macchina virtuale scegliete BSD e non Linux altrimenti non vi vede le interfacce di rete ). Di seguito vi mostro i passi da seguire per un corretto settaggio delle interfacce di rete e del Captive Portal.

Per l’installazione di pfsense su macchine virtuali trovate un sacco di tutorial su google, io ho scaricato direttamente la .iso image del LiveCD montata all’avvio e poi ho provvedo alla sua installazione sull’hard disk virtuale.

Premetto che da buon utilizzare di Slackware, ho utilizzato l’interfaccia testuale e non quella grafica. Il risultato finale è lo stesso, una volta capito cosa fare potete impostare i miei stessi parametri utilizzando la comoda interfaccia web che pfsense ci mette a disposizione.

Appena finita l’installazione di pfsense, ho settato la prima interfaccia virtuale in bridge mode con la mia interfaccia fisica WAN, e la seconda interfaccia virtuale in bridge mode con la mia ethernet che fungera’ da LAN interna per l’HotSpot.

ether_em0

Wan Interface

ether_em1

LAN Interface

1) Riepilogo Interfacce e Creazione VLANs

Al primo avvio di pfsense avremo il riepilogo delle interfacce che abbiamo a disposizione, rispettivamente: em0 ed em1 (quelle settate nelle figure precedenti), e la richiesta di creare delle interfacce vortuali all’interno di pfsense. Per ora scriviamo “n”, possiamo abilitare le interfacce viartuali in un secondo momento.

(altro…)

A tutti coloro che non ho potuto ringraziare di persona

0

Thank-You

A tutti coloro che non ho potuto ringraziare di persona, questa pagina e’ loro dedicata.

https://www.vitadastudente.it/master_thesis/dedication/

P.s. usate un browser “serio” per la visualizzazione 😀

STM32F3Discovery + ChibiOS/RT + Fortune Wheel

1

STM32f3discovery

I problemi erano gia’ parecchi prima di iniziare la tesi, ma ora credo di aver passato ogni limite. Non posso passare le nottate appresso ad una board con 48K di RAM, 256KB di Flash ed un processore ARM Cortex-M a 78 Mhz preso da una insana, quanto assurda, smania verso ogni tipo di controllore per montarci su un RTOS 😛

La board in questione mi e’ stata gentilmente concessa dal mio Professore, per giunta lo stesso professore relatore della mia tesi. Per tale motivo, credo di aver una scusa decente per essere un po’ in ritardo nella stesura  :P.

Il programma di esempio su cui mi sono cimentato utilizza un RTOS ( ChibiOS/RT ) e la sua toolchain (davvero semplicissima da usare grazie alla sua integrazione con Eclipse) usata per compilare il file oggetto e caricarlo direttamente in flash.

Una passeggiata rispetto a quello fatto per il porting di ThreadX su un microcontrollore ARC-based, ma questo (forse) sara’ un articolo che cerchero’ di scrivere un po’ piu’ il la… sempre che il lavoro svolto sia sufficientemente decente.

Ritornando all’applicazione, e’ davvero un programmino semplice che emula il comportamento del famoso gioco della fortune wheel (non sono sicuro del nome 😛 ) ed e’ composto da tre threads:

  • main
  • thread1
  • thread2

Dove il main si occupara di gestire un interrupt che gli arriva quando premiamo il pulsante USER; thread1 non e’ altro che un semplice ciclo while che accende e spegne, in maniera circolare, gli 8 LED;  il thread2 che si occupa di verificare se nell’attimo in cui e’ stato premuto il pulsante USER la luce del LED rosso era accesa…. vabbe’ e’ piu’ semplice a farsi che a dirsi.

[sourcecode language=”C”]
#include "ch.h"
#include "hal.h"
#include "test.h"

static int check=0;

/*
* This is a periodic thread that does absolutely nothing except flashing LEDs.
*/
static WORKING_AREA(waThread1, 128);
static msg_t Thread1(void *arg) {

(void)arg;
chRegSetThreadName("blinker");
int i=0;
int ledTime[10]={215,260,220,600,40,20,10,5,15,25};
while (TRUE) {

/* pseudo random generator */
if(i%9 ==0)
i=0;
palSetPad(GPIOE, GPIOE_LED3_RED);
check=1;
chThdSleepMilliseconds(ledTime[i]);
i++;
palClearPad(GPIOE, GPIOE_LED3_RED);
check=0;
palSetPad(GPIOE, GPIOE_LED5_ORANGE);
chThdSleepMilliseconds(125);
palClearPad(GPIOE, GPIOE_LED5_ORANGE);
palSetPad(GPIOE, GPIOE_LED7_GREEN);
chThdSleepMilliseconds(125);
palClearPad(GPIOE, GPIOE_LED7_GREEN);
palSetPad(GPIOE, GPIOE_LED9_BLUE);
chThdSleepMilliseconds(125);
palClearPad(GPIOE, GPIOE_LED9_BLUE);
palSetPad(GPIOE, GPIOE_LED10_RED);
chThdSleepMilliseconds(125);
palClearPad(GPIOE, GPIOE_LED10_RED);
palSetPad(GPIOE, GPIOE_LED8_ORANGE);
chThdSleepMilliseconds(125);
palClearPad(GPIOE, GPIOE_LED8_ORANGE);
palSetPad(GPIOE, GPIOE_LED6_GREEN);
chThdSleepMilliseconds(125);
palClearPad(GPIOE, GPIOE_LED6_GREEN);
palSetPad(GPIOE, GPIOE_LED4_BLUE);
chThdSleepMilliseconds(125);
palClearPad(GPIOE, GPIOE_LED4_BLUE);

}
}

static WORKING_AREA(waThread2, 128);

static msg_t Thread2(void *arg) {

(void)arg;
chRegSetThreadName("allLed");

if(check){
palSetPad(GPIOE, GPIOE_LED3_RED);
palSetPad(GPIOE, GPIOE_LED5_ORANGE);
palSetPad(GPIOE, GPIOE_LED7_GREEN);
palSetPad(GPIOE, GPIOE_LED9_BLUE);
palSetPad(GPIOE, GPIOE_LED10_RED);
palSetPad(GPIOE, GPIOE_LED8_ORANGE);
palSetPad(GPIOE, GPIOE_LED6_GREEN);
palSetPad(GPIOE, GPIOE_LED4_BLUE);

}
}
/*
* Application entry point.
*/
int main(void) {

/*
* System initializations.
* – HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* – Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/

//palSetPad(GPIOE, GPIOE_LED3_RED);

halInit();
chSysInit();

//palSetPad(GPIOE, GPIOE_LED3_RED);

/*
* Activates the serial driver 1 using the driver default configuration.
* PA9(TX) and PA10(RX) are routed to USART1.
*/
sdStart(&SD1, NULL);
palSetPadMode(GPIOA, 9, PAL_MODE_ALTERNATE(7));
palSetPadMode(GPIOA, 10, PAL_MODE_ALTERNATE(7));

//palSetPad(GPIOE, GPIOE_LED3_RED);

/*
* Creates the example thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);

//palSetPad(GPIOE, GPIOE_LED3_RED);

/*
* Normal main() thread activity, in this demo it does nothing except
* sleeping in a loop and check the button state, when the button is
* pressed the test procedure is launched.
*/
while (TRUE) {
if (palReadPad(GPIOA, GPIOA_BUTTON)){
chThdCreateStatic(waThread2, sizeof(waThread2), NORMALPRIO, Thread2, NULL);
chThdSleepMilliseconds(500);
}
}
}

[/sourcecode]

P.s. forse e’ ora di trovarmi una ragazza 😀

 

GitHub

https://github.com/flaviopace/FortuneWheel_STM32F3Discovery-

Raspberry Pi: Eseguire vncserver all’avvio

0

Raspberry Pi

Finalmente è arrivato a casa il Raspberry Pi. Settimane di attesa per poter smanettare un pò vicino a questo fantastico “giocattolino”.

Assieme a mio fratello abbiamo cercato di installare subito vncserver, ma le soluzioni che si trovano online : running-vncserver-at-startup , hanno bisogno dell’avvio del server grafico per poter lanciare correttamente il demone di vncserver.

Per ovvirare a questa limitazione, la mia soluzione avvia il demone di vncserver tramite lo script di avvio: /etc/rc.local 

[sourcecode language=”bash”]
#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.

# Print the IP address
_IP=$(hostname -I) || true
if [ "$_IP" ]; then
printf "My IP address is %s\n" "$_IP"
fi

#Start Vnc Server
export USER=pi
vncserver :1

exit 0

[/sourcecode]

Prima di lanciare il comando di avvio del server, ho dovuto esportare la variabile globale USER altrimenti il demone non riusciva a leggere correttamente i file di configurazione che avevo editato in /home/pi/.vnc e mi dava il seguente errore:

"Starting vncserver: Starting VNC server: 3: root vncserver: The USER
environments variable is not set"

Al primo avvio vi chiederà di inserire la password di accesso, poi la setterà in automatico ad ogni riavvio.

Disabilitare il Write Caching su Mac OS X: Safe Remove USB Device

0

remove-USB-safely

Posso staccare la penna USB senza forzare la rimozione?

Quante volte ho sentito questa domanda, la maggior parte della gente toglie la propria penna USB dal pc senza “smontarla” secondo la procedura, sicuri che non si danneggi nulla. Ma e’ davvero “sicuro” farlo??

Bhe se avete un pc con Windows 7 e versioni successive, e’ abbastanza sicuro. Windows disabilita il write caching sulle periferiche che riconosce come removable , consapevoli del fatto che la maggior parte dei sui utilizzatori non smonta mai il proprio device USB.

A questo punto, se sei arrivato a leggere fino a qui e non sei uno esperto/smanettone ti sarai chiesto: Ma cosa e’ il write-caching?

E’ la policy che utilizza la maggior parte dei Sistemi Operativi quando si deve scrivere un dato in una memoria dati esterna, magari collegata tramite USB. Tramite tale tecnica, non vengono copiati immediatamente i dati dal vostro pc sulla memoria (soprattutto se sono dati di piccoli dimensioni), ma vengono messe in una cache in attesa che ci siano altri dati da scrivere in modo da aumentare le performance. Infatti, la scrittura sui device esterni avviene molto piu’ velocemente per file di dimensioni grandi e non con file piccoli.

Per tale motivo, molti Sistemi Operativi la adottano; per aumentare le performance… costringendoci a “smontare” la chiavetta e “forzare” la scrittura dei dati che sono ancora in cache.

Mac OS X adotta la stessa politica di Windows?

Bhe se avete un Mac, vi tocca smontarla. Infatti il Sistema Operativo di casa Cupertino, non disabilita il write-caching come Windows.

Ma è possibile forzare in qualche modo tale policy e dire a Mac OS X di non usare il write-caching. Come farlo?

Il miglior modo per farlo è con il comando mount tramite la shell dei comandi:

[sourcecode language=”bash”]
mount -o noasync /dev/diskls1
[/sourcecode]

Dove diskls1 è il nome del device che vogliamo montare.

Il comando vale anche per molte distribuzioni Linux.

Ora potete rimuovere la vostra penna USB senza doverla smontare 😀

Reference:

http://developer.apple.com/mac/library/documentation/Darwin/Reference/ManPages/man8/mount.8.html

Facebook Hacker Cup 2 Round: my Card Game Solution

0

FacebookHackerCup 2 Round

This is my solution to the problem of Card Game, work fine for small input… but when the value of k grows (k>500 ) my code spent a lot of time.

The bottleneck it’s about the iteration to find the max in the array…

So i hope you can optimize it 😀

[sourcecode language=”python”]

import sys
import math
from collections import Counter
import re
import itertools

in_file = open(sys.argv[1],"r")
exp = in_file.read()
in_file.close()

inputFile= exp.split("\n")

index=[]
values=[]

def findsubsets(S,m):
return set(itertools.combinations(S, m))
a=[]
flavio=1
for i in range(1, len(inputFile)-1) :
values=[]
allsub=[]
if(i%2) :
# index.append(inputFile[i])
n,k=map(int,inputFile[i].split())
else :

values= map(int,inputFile[i].split())

# Optimization , not call a function
allsub=itertools.combinations(values,k)

my_sum=0

for f in allsub:

my_max=max(f)
my_sum += (my_max)

if(my_sum>=1000000007):
my_sum = my_sum -1000000007

print "Case #"+str(flavio)+": "+str(my_sum)

flavio +=1

[/sourcecode]

GitHub

https://github.com/flaviopace/FacebookHackerCup2_CardGameSolution

Facebook Hacker Cup Qualification 2013: le mie soluzioni in Python

2

Hacker Cup Facebook

Quest’anno sono riuscito a partecipare (me ne sono ricordato :P) all’Hacker Cup che Facebook organizza ogni anno. I problemi per le qualificazioni erano 3 e di seguito vi posto le mie soluzioni scritte in python.

Il terzo problema (Find the min) non e’ difficile, sono riuscito a risolverlo ma il tempo che ci impiega il mio algoritmo e’ molto al di sopra di quello che mette a disposizione Facebook. In realta’ bastava guardare un po output della lista che utilizzavo per memorizzare i valori per capire che da un certo punto in poi si ripeteva ( per cui non serviva tutta la potenza di calcolo che avevo immaginato 😛 ). In poche parole per gli indici della liste pari a 2k+1, i valori si ripetevano… me ne sono accorto troppo tardi ed ho finito solo i primi due step 😀

1 – Beautiful strings  (20 points)

beautiful_stringstxt.txt

outputFile.txt

[sourcecode language=”python”]import sys
import math
from collections import Counter

in_file = open(sys.argv[1],"r")
exp = in_file.read()
in_file.close()

a= exp.split("\n")

b=[]
c=[]

values=[]

d={}
u={}

for i in range(1, len(a)-1) :

b.append(a[i].lower()[::-1])

flavio=1
for i in b:
d={}

values=[]
num=26
find=1
numSum=0
for k in range(0,len(i)):

#d[str(i[k])] = i.count(i[k])
if(str(i[k]).isalpha()):# or str(i[k])==’!’):
d[str(i[k])] = i.count(i[k])

for k in range(0,len(i)):
if (str(i[k]) in d):
# print i[k] + " num "+ str(num) + " # " + str(d[i[k]])
numSum += num*d[i[k]]
values.append(d[i[k]])
del d[i[k]]
num -=1

values_sorted= sorted(values, reverse=True)

num=26
numSum =0
for item in range(len(values_sorted)):

numSum += num * values_sorted[item]
num -=1
print "Case #" + str(flavio)+ ": " +str(numSum)
flavio +=1
[/sourcecode]

2 – Balanced Smileys  (35 points)

balanced_smileystxt.txt

outputBalanced.txt

[sourcecode language=”python”]import sys
import math
from collections import Counter
import re

in_file = open(sys.argv[1],"r")
exp = in_file.read()
in_file.close()

b=[]
c=[]

values=[]

d={}
u={}

for i in range(1, len(a)-1) :

b.append(a[i].lower())

replacements = {":(",":)"}

for i in range(0,len(b)) :
#b[i]= b[i].replace(

b[i]= re.sub(r’\([^)]*\)’, "", b[i])

b[i]= b[i].replace(‘:(‘,”)
b[i]= b[i].replace(‘:)’,”)

def isBalanced(strInput):
"""Validate if an input string is having balanced bracket pairs
this includes bracket ordering. i.e a round bracket must be closed
by a round bracket. Emtpy strings are treated as balanced."""
#if strInput:
# list of all bracket kinds, in paired tuples
brackets = [ (‘(‘,’)’), (‘[‘,’]’), (‘{‘,’}’)]
# define fake constants – python does not support the concept of constants
kStart = 0
kEnd = 1
# internal stack used to push and pop brakets in the input string
stack = []

for char in strInput:
for bracketPair in brackets:
if char == bracketPair[kStart]:
stack.append(char)
elif char == bracketPair[kEnd] and len(stack) > 0 and stack.pop() != bracketPair[kStart]:
return False

if len(stack) == 0:
return True

#return False

flavio=1
for i in range(0,len(b)) :
if(isBalanced(b[i])):
print "Case #" + str(flavio) + ": YES"
else:
print "Case #" + str(flavio) + ": NO"

flavio +=1

[/sourcecode]

3 – Find the Min  (45 points)

find_the_mintxt.txt

outputFindTheMin.txt

[sourcecode language=”python”]import os, sys

f = open(sys.argv[1], ‘r’)

T = int(f.readline())

def next(ary, start):
j = start
l = len(ary)
ret = start – 1
while j < l and ary[j]:
ret = j
j += 1
return ret

for t in range(T):
n, k = map(int, f.readline().strip().split(‘ ‘))
a, b, c, r = map(int, f.readline().strip().split(‘ ‘))

m = [0] * (4 * k)
s = [0] * (k+1)
m[0] = a
if m[0] <= k:
s[m[0]] = 1
for i in xrange(1, k):
m[i] = (b * m[i-1] + c) % r
if m[i] < k+1:
s[m[i]] += 1

p = next(s, 0)
m[k] = p + 1
p = next(s, p+2)

for i in xrange(k+1, n):
if m[i-k-1] > p or s[m[i-k-1]] > 1:
m[i] = p + 1
if m[i-k-1] <= k:
s[m[i-k-1]] -= 1
s[m[i]] += 1
p = next(s, p+2)
else:
m[i] = m[i-k-1]
if p == k:
break

if p != k:
print ‘Case #%d: %d’ % (t+1, m[n-1])
else:
print ‘Case #%d: %d’ % (t+1, m[i-k + (n-i+k+k) % (k+1)])
[/sourcecode]

Riferimenti:

https://www.facebook.com/hackercup/problems.php?round=185564241586420

Correct Solution Find The Min

http://facebook.stackoverflow.com/questions/14536384/python-too-slow-of-large-inputs

 

GitHub

https://github.com/flaviopace/FacebookHackerCupQualification2013

 

Processori ARM: Gestione delle interruzione FIQ vs IRQ

0

Arm Processor

Devo ammettere che l’argomento di tesi che mi tocchera’ svolgere mi appassiona sempre piu’. Questo piccolo articolo ne e’ la dimostrazione ( spero di poterlo ri-utilizzare almeno in un paragrafo 😛 ).

La tesi sara’ una di quelle Top-Secret, rivoluzionarie e che cambieranno la concezione del mondo… vabbe’ lasciatemi delirare un po’ 😀

Lo scopo avra’ come obiettivo quello di rimpiazzare il firmware (un ciclo while backend/frontend) di gestione di una  memoria con un RTOS capace di gestire in maniera piu’ rigorosa ed attenta il multi-threading e gli eventi asincroni.

La scelta, per quando riguarda RTOS, credo che ricadra’ su ThreadX. Dalla lettura delle sue specifiche e guardando le sue features, sono giunto alla conclusione che sia la scelta migliore e per tale motivo ho focalizzato la mia analisi su due punti:

  • Gestione delle interruzioni ottimizzata per i processori ARM
  • Scheduler Preemption-Threshold

La maggior parte dei processori ARM supporta sia IRQ che FIQ come input interrups. FIQ viene definito come “fast” interrupt, mentre IRQ come “normal” interrupt. Entrambe le modalita’ di esecuzione hanno dei livelli di priorita’, e la modalita’ FIQ ha un livello piu’ alto rispetto a IRQ, per tale motivo se stiamo gestendo una interruzione con FIQ, essa non potra’ essere sospesa da un’altra interruzione arrivata sul canale IRQ.

Ma non e’ la sola differenza, ne esistono altre e sono molto piu’ sostanziali, rispetto alla precedente, sia a livello di architettura che a quello di gestione.

La prima sostanziale differenza e’ che la modalita’ FIQ ha dei registri in piu (7 registri in piu’ da R8-R14) mentre IRQ ne gestisce solo due ( vedi immagine successiva ), grazie ai quali si riduce l’overhead necessario alla copia dei valori di backup del processo precedente all’arrivo dell’interruzione. Per tale motivo, meno valori vengono spostati sullo stack e meno valori dovranno essere ripristinati nei registri alla fine delle gestione dell’interruzione. Il registro R14 viene usato come indirizzo di ritorno del PC(+4).

Arm Registers

Il secondo motivo per cui FIQ e’ piu’ veloce rispetto a IRQ e’ dovuto alla posizione della gestione degli interrupts all’interno del vettore delle interruzioni, il codice di gestione degli interrups FIQ e’ situato alla fine di tale vettore (0x1C). Questo fa in modo che le istruzioni possono essere eseguite direttamente da tale locazione (dato che lo stack cresce per l’alto), senza effettuare ulteriori jump ad indirizzi di memoria (cosa non vera per le interruzioni IRQ).

Vector Interrups Handler

Ad oggi, non molti RTOS e non supportano tale gestione delle interrups per un motivo semplice. La gestione delle interruzioni con FIQ puo’ essere effettuato solo scrivendo a “manella” il codice assembly.

Scrivere in C tale gestione non e’ sempre possibile, in quanto il compilatore utilizza i registri R0-R3 e non fornisce la corretta gestione del CSPR alla fine della funzione

 

Reference

http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0203j/Cacbhjjj.html

http://www.csie.nctu.edu.tw/~wjtsai/EmbeddedSystemDesign/Ch3-1.pdf

http://www.riveywood.com/fiqvsirq.html

Formattare Disco FAT32 con Mac OS X

0

Per gli amanti della Command Shell, eccovi il comando per poter formattare un qualsiasi disco utilizzando il File System FAT32 , ma allo stesso modo si potrebbe usare il FAT16 o addirittura il FAT12 ( basta specificare il giusto flag )

[sourcecode language=”bash”]
# newfs_msdos -F 32 /dev/disk2
[/sourcecode]

Torna all'inizio