Per vedere il log delle attivita' del terminale Android si puo', collegando il cavo dati al PC, digitare il comando
adb logcat
per vedere solo i log generati da Python si puo' scrivere invece
adb logcat -s python:*
lunedì 16 gennaio 2012
Datalogger su Bluetooth
Esempio di comunicazione via Bluetooth
Per funzionare si deve caricare sia sul telefono che sul computer la libreria PyBluez.
Per il telefono si deve seguire la procedura per importare i moduli di Py4a e quindi si deve scaricare il file .egg da posizionare poi nella directory download della scheda SD
Per la libreria sul computer ho riscontrato che scaricando i file tgz ed eseguendo python setup.py install si genera un errore di compilazione su gcc. Per questo motivo ho installato il pacchetto Debian gia' compilato python-bluez
----------------------------------------------------------------------------------------------------------------------------
# file: rfcomm-server.py
# auth: Albert Huang <albert@csail.mit.edu>
# desc: simple demonstration of a server application that uses RFCOMM sockets
#
# $Id: rfcomm-server.py 518 2007-08-10 07:20:07Z albert $
from bluetooth import *
server_sock=BluetoothSocket( RFCOMM )
server_sock.bind(("",PORT_ANY))
server_sock.listen(1)
port = server_sock.getsockname()[1]
uuid = "94f39d29-7d6d-437d-973b-fba39e49d4ee"
advertise_service( server_sock, "SampleServer",
service_id = uuid,
service_classes = [ uuid, SERIAL_PORT_CLASS ],
profiles = [ SERIAL_PORT_PROFILE ],
# protocols = [ OBEX_UUID ]
)
print "Waiting for connection on RFCOMM channel %d" % port
client_sock, client_info = server_sock.accept()
print "Accepted connection from ", client_info
try:
while True:
data = client_sock.recv(1024)
if len(data) == 0: break
print "%s" % data
except IOError:
pass
print "disconnected"
client_sock.close()
server_sock.close()
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
# file: rfcomm-client.py
# auth: Albert Huang <albert@csail.mit.edu>
# desc: simple demonstration of a client application that uses RFCOMM sockets
# intended for use with rfcomm-server
#
# $Id: rfcomm-client.py 424 2006-08-24 03:35:54Z albert $
from bluetooth import *
import sys
import android
import time
import math
addr = None
droid = android.Android();
droid.startSensingTimed(1,1000)
time.sleep(3)
uuid = "94f39d29-7d6d-437d-973b-fba39e49d4ee"
service_matches = find_service( uuid = uuid, address = addr )
if len(service_matches) == 0:
print "couldn't find the SampleServer service =("
sys.exit(0)
first_match = service_matches[0]
port = first_match["port"]
name = first_match["name"]
host = first_match["host"]
sock=BluetoothSocket( RFCOMM )
sock.connect((host, port))
print "Connesso"
while True:
az = str(math.degrees(droid.sensorsReadOrientation().result[0]))
pitch = str(math.degrees(droid.sensorsReadOrientation().result[1]))
roll = str(math.degrees(droid.sensorsReadOrientation().result[2]))
data = az+";"+pitch+";"+roll
if len(data) == 0: break
sock.send(data)
sock.close()
----------------------------------------------------------------------------------------------------------------------------
Per funzionare si deve caricare sia sul telefono che sul computer la libreria PyBluez.
Per il telefono si deve seguire la procedura per importare i moduli di Py4a e quindi si deve scaricare il file .egg da posizionare poi nella directory download della scheda SD
Per la libreria sul computer ho riscontrato che scaricando i file tgz ed eseguendo python setup.py install si genera un errore di compilazione su gcc. Per questo motivo ho installato il pacchetto Debian gia' compilato python-bluez
----------------------------------------------------------------------------------------------------------------------------
# file: rfcomm-server.py
# auth: Albert Huang <albert@csail.mit.edu>
# desc: simple demonstration of a server application that uses RFCOMM sockets
#
# $Id: rfcomm-server.py 518 2007-08-10 07:20:07Z albert $
from bluetooth import *
server_sock=BluetoothSocket( RFCOMM )
server_sock.bind(("",PORT_ANY))
server_sock.listen(1)
port = server_sock.getsockname()[1]
uuid = "94f39d29-7d6d-437d-973b-fba39e49d4ee"
advertise_service( server_sock, "SampleServer",
service_id = uuid,
service_classes = [ uuid, SERIAL_PORT_CLASS ],
profiles = [ SERIAL_PORT_PROFILE ],
# protocols = [ OBEX_UUID ]
)
print "Waiting for connection on RFCOMM channel %d" % port
client_sock, client_info = server_sock.accept()
print "Accepted connection from ", client_info
try:
while True:
data = client_sock.recv(1024)
if len(data) == 0: break
print "%s" % data
except IOError:
pass
print "disconnected"
client_sock.close()
server_sock.close()
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
# file: rfcomm-client.py
# auth: Albert Huang <albert@csail.mit.edu>
# desc: simple demonstration of a client application that uses RFCOMM sockets
# intended for use with rfcomm-server
#
# $Id: rfcomm-client.py 424 2006-08-24 03:35:54Z albert $
from bluetooth import *
import sys
import android
import time
import math
addr = None
droid = android.Android();
droid.startSensingTimed(1,1000)
time.sleep(3)
uuid = "94f39d29-7d6d-437d-973b-fba39e49d4ee"
service_matches = find_service( uuid = uuid, address = addr )
if len(service_matches) == 0:
print "couldn't find the SampleServer service =("
sys.exit(0)
first_match = service_matches[0]
port = first_match["port"]
name = first_match["name"]
host = first_match["host"]
sock=BluetoothSocket( RFCOMM )
sock.connect((host, port))
print "Connesso"
while True:
az = str(math.degrees(droid.sensorsReadOrientation().result[0]))
pitch = str(math.degrees(droid.sensorsReadOrientation().result[1]))
roll = str(math.degrees(droid.sensorsReadOrientation().result[2]))
data = az+";"+pitch+";"+roll
if len(data) == 0: break
sock.send(data)
sock.close()
----------------------------------------------------------------------------------------------------------------------------
Datalogger in UDP
L'ennesima versione del datalogger che usa il protocollo UDP per scambiare i dati
-----------------------------------------------------------------------------------------------------
import android
import socket
import time
import math
droid = android.Android();
hostname = "192.168.0.1";
port = 21567;
data = "";
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM);
s.connect((hostname,port));
droid.startSensingTimed(1,1000)
time.sleep(3)
while True:
az = str(math.degrees(droid.sensorsReadOrientation().result[0]))
pitch = str(math.degrees(droid.sensorsReadOrientation().result[1]))
roll = str(math.degrees(droid.sensorsReadOrientation().result[2]))
s.sendto(az+";"+pitch+";"+roll,(hostname,port));
-----------------------------------------------------------------------------------------------------
# Server program
import string
from socket import *
host = "192.168.0.1"
port = 21567
buf = 1024
addr = (host,port)
UDPSock = socket(AF_INET,SOCK_DGRAM)
UDPSock.bind(addr)
while 1:
data,addr = UDPSock.recvfrom(buf)
if not data:
print "Client has exited!"
break
else:
valori = string.split(data,";")
print valori[0]
print valori[1]
print valori[2]
# Close socket
UDPSock.close()
Arduino + Python
Esempio di come pilotare una Arduino mediante Python
Ho fatto molte prove ma al momento l'unico sistema funzionate e' quello di impiegare le librerie che si trovano qui.
Prima di deve caricare lo sketch sulla scheda (il file pde) mediante il programmatore della Arduino ed in seguito si puo' lanciare lo script da computer
Ho fatto molte prove ma al momento l'unico sistema funzionate e' quello di impiegare le librerie che si trovano qui.
Prima di deve caricare lo sketch sulla scheda (il file pde) mediante il programmatore della Arduino ed in seguito si puo' lanciare lo script da computer
Esiste un problema: deve essere ricaricato lo sketch per ogni volta che si deve lanciare lo script Python
Di seguito lo script leggermente modificato rispetto a quello dell'esempio
-----------------------------------------------------------------------------------------
from arduino import Arduino
import time
my_board = Arduino('/dev/ttyUSB0')
my_board.output([11,12,13])
i=0
while(i<3):
my_board.setHigh(13)
time.sleep(1)
my_board.setHigh(12)
time.sleep(1)
my_board.setLow(13)
time.sleep(1)
my_board.setLow(12)
time.sleep(1)
i+=1
-----------------------------------------------------------------------------------------
Oggi mi gira il cubo
Un merge tra il codice ripreso qui del wireframe_cube.py ed il mio codice di datalogger_udp_client/server
Lato server
-------------------------------------------------------------------------------------------
"""
Wireframe 3D cube simulation.
Developed by Leonel Machava <leonelmachava@gmail.com>
http://codeNtronix.com
modificato da Luca Innocenti
"""
import sys, math, pygame
from pygame.locals import *
import string
from socket import *
host = "192.168.0.1"
port = 21567
buf = 1024
addr = (host,port)
class Point3D:
def __init__(self, x = 0, y = 0, z = 0):
self.x, self.y, self.z = float(x), float(y), float(z)
def rotateX(self, angle):
""" Rotates the point around the X axis by the given angle in degrees. """
rad = angle * math.pi / 180
cosa = math.cos(rad)
sina = math.sin(rad)
y = self.y * cosa - self.z * sina
z = self.y * sina + self.z * cosa
return Point3D(self.x, y, z)
def rotateY(self, angle):
""" Rotates the point around the Y axis by the given angle in degrees. """
rad = angle * math.pi / 180
cosa = math.cos(rad)
sina = math.sin(rad)
z = self.z * cosa - self.x * sina
x = self.z * sina + self.x * cosa
return Point3D(x, self.y, z)
def rotateZ(self, angle):
""" Rotates the point around the Z axis by the given angle in degrees. """
rad = angle * math.pi / 180
cosa = math.cos(rad)
sina = math.sin(rad)
x = self.x * cosa - self.y * sina
y = self.x * sina + self.y * cosa
return Point3D(x, y, self.z)
def project(self, win_width, win_height, fov, viewer_distance):
""" Transforms this 3D point to 2D using a perspective projection. """
factor = fov / (viewer_distance + self.z)
x = self.x * factor + win_width / 2
y = -self.y * factor + win_height / 2
return Point3D(x, y, 1)
class Simulation:
def __init__(self, win_width = 640, win_height = 480):
pygame.init()
self.screen = pygame.display.set_mode((win_width, win_height))
pygame.display.set_caption("3D Wireframe Cube Simulation (http://codeNtronix.com)")
self.clock = pygame.time.Clock()
self.vertices = [
Point3D(-1,1,-1),
Point3D(1,1,-1),
Point3D(1,-1,-1),
Point3D(-1,-1,-1),
Point3D(-1,1,1),
Point3D(1,1,1),
Point3D(1,-1,1),
Point3D(-1,-1,1)
]
# Define the vertices that compose each of the 6 faces. These numbers are
# indices to the vertices list defined above.
self.faces = [(0,1,2,3),(1,5,6,2),(5,4,7,6),(4,0,3,7),(0,4,5,1),(3,2,6,7)]
self.angleX, self.angleY, self.angleZ = 0, 0, 0
def run(self):
""" Main Loop """
host = "192.168.0.1"
port = 21567
buf = 1024
addr = (host,port)
UDPSock = socket(AF_INET,SOCK_DGRAM)
UDPSock.bind(addr)
while 1:
data,addr = UDPSock.recvfrom(buf)
valori = string.split(data,";")
# for event in pygame.event.get():
# if event.type == pygame.QUIT:
# sys.exit()
# if (event.type == KEYUP) or (event.type == KEYDOWN):
# if (event.key == K_a):
# self.angleX = self.angleX + 1
# if (event.key == K_z):
# self.angleX = self.angleX - 1
self.clock.tick(50)
self.screen.fill((0,0,0))
# Will hold transformed vertices.
t = []
for v in self.vertices:
# Rotate the point around X axis, then around Y axis, and finally around Z axis.
r = v.rotateX(self.angleX).rotateY(self.angleY).rotateZ(self.angleZ)
# Transform the point from 3D to 2D
p = r.project(self.screen.get_width(), self.screen.get_height(), 256, 4)
# Put the point in the list of transformed vertices
t.append(p)
for f in self.faces:
pygame.draw.line(self.screen, (255,255,255), (t[f[0]].x, t[f[0]].y), (t[f[1]].x, t[f[1]].y))
pygame.draw.line(self.screen, (255,255,255), (t[f[1]].x, t[f[1]].y), (t[f[2]].x, t[f[2]].y))
pygame.draw.line(self.screen, (255,255,255), (t[f[2]].x, t[f[2]].y), (t[f[3]].x, t[f[3]].y))
pygame.draw.line(self.screen, (255,255,255), (t[f[3]].x, t[f[3]].y), (t[f[0]].x, t[f[0]].y))
self.angleX = round(float(valori[0]),0)
self.angleY = round(float(valori[1]),0)
self.angleZ = round(float(valori[2]),0)
pygame.display.flip()
if __name__ == "__main__":
Simulation().run()
-------------------------------------------------------------------------------------------
Lato client
-------------------------------------------------------------------------------------------
import android
import socket
import time
import math
droid = android.Android();
hostname = "192.168.0.1";
port = 21567;
data = "";
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM);
s.connect((hostname,port));
droid.startSensingTimed(1,1000)
time.sleep(3)
while True:
az = str(math.degrees(droid.sensorsReadOrientation().result[0]))
pitch = str(math.degrees(droid.sensorsReadOrientation().result[1]))
roll = str(math.degrees(droid.sensorsReadOrientation().result[2]))
s.sendto(az+";"+pitch+";"+roll,(hostname,port));
-------------------------------------------------------------------------------------------
Lato server
-------------------------------------------------------------------------------------------
"""
Wireframe 3D cube simulation.
Developed by Leonel Machava <leonelmachava@gmail.com>
http://codeNtronix.com
modificato da Luca Innocenti
"""
import sys, math, pygame
from pygame.locals import *
import string
from socket import *
host = "192.168.0.1"
port = 21567
buf = 1024
addr = (host,port)
class Point3D:
def __init__(self, x = 0, y = 0, z = 0):
self.x, self.y, self.z = float(x), float(y), float(z)
def rotateX(self, angle):
""" Rotates the point around the X axis by the given angle in degrees. """
rad = angle * math.pi / 180
cosa = math.cos(rad)
sina = math.sin(rad)
y = self.y * cosa - self.z * sina
z = self.y * sina + self.z * cosa
return Point3D(self.x, y, z)
def rotateY(self, angle):
""" Rotates the point around the Y axis by the given angle in degrees. """
rad = angle * math.pi / 180
cosa = math.cos(rad)
sina = math.sin(rad)
z = self.z * cosa - self.x * sina
x = self.z * sina + self.x * cosa
return Point3D(x, self.y, z)
def rotateZ(self, angle):
""" Rotates the point around the Z axis by the given angle in degrees. """
rad = angle * math.pi / 180
cosa = math.cos(rad)
sina = math.sin(rad)
x = self.x * cosa - self.y * sina
y = self.x * sina + self.y * cosa
return Point3D(x, y, self.z)
def project(self, win_width, win_height, fov, viewer_distance):
""" Transforms this 3D point to 2D using a perspective projection. """
factor = fov / (viewer_distance + self.z)
x = self.x * factor + win_width / 2
y = -self.y * factor + win_height / 2
return Point3D(x, y, 1)
class Simulation:
def __init__(self, win_width = 640, win_height = 480):
pygame.init()
self.screen = pygame.display.set_mode((win_width, win_height))
pygame.display.set_caption("3D Wireframe Cube Simulation (http://codeNtronix.com)")
self.clock = pygame.time.Clock()
self.vertices = [
Point3D(-1,1,-1),
Point3D(1,1,-1),
Point3D(1,-1,-1),
Point3D(-1,-1,-1),
Point3D(-1,1,1),
Point3D(1,1,1),
Point3D(1,-1,1),
Point3D(-1,-1,1)
]
# Define the vertices that compose each of the 6 faces. These numbers are
# indices to the vertices list defined above.
self.faces = [(0,1,2,3),(1,5,6,2),(5,4,7,6),(4,0,3,7),(0,4,5,1),(3,2,6,7)]
self.angleX, self.angleY, self.angleZ = 0, 0, 0
def run(self):
""" Main Loop """
host = "192.168.0.1"
port = 21567
buf = 1024
addr = (host,port)
UDPSock = socket(AF_INET,SOCK_DGRAM)
UDPSock.bind(addr)
while 1:
data,addr = UDPSock.recvfrom(buf)
valori = string.split(data,";")
# for event in pygame.event.get():
# if event.type == pygame.QUIT:
# sys.exit()
# if (event.type == KEYUP) or (event.type == KEYDOWN):
# if (event.key == K_a):
# self.angleX = self.angleX + 1
# if (event.key == K_z):
# self.angleX = self.angleX - 1
self.clock.tick(50)
self.screen.fill((0,0,0))
# Will hold transformed vertices.
t = []
for v in self.vertices:
# Rotate the point around X axis, then around Y axis, and finally around Z axis.
r = v.rotateX(self.angleX).rotateY(self.angleY).rotateZ(self.angleZ)
# Transform the point from 3D to 2D
p = r.project(self.screen.get_width(), self.screen.get_height(), 256, 4)
# Put the point in the list of transformed vertices
t.append(p)
for f in self.faces:
pygame.draw.line(self.screen, (255,255,255), (t[f[0]].x, t[f[0]].y), (t[f[1]].x, t[f[1]].y))
pygame.draw.line(self.screen, (255,255,255), (t[f[1]].x, t[f[1]].y), (t[f[2]].x, t[f[2]].y))
pygame.draw.line(self.screen, (255,255,255), (t[f[2]].x, t[f[2]].y), (t[f[3]].x, t[f[3]].y))
pygame.draw.line(self.screen, (255,255,255), (t[f[3]].x, t[f[3]].y), (t[f[0]].x, t[f[0]].y))
self.angleX = round(float(valori[0]),0)
self.angleY = round(float(valori[1]),0)
self.angleZ = round(float(valori[2]),0)
pygame.display.flip()
if __name__ == "__main__":
Simulation().run()
-------------------------------------------------------------------------------------------
Lato client
-------------------------------------------------------------------------------------------
import android
import socket
import time
import math
droid = android.Android();
hostname = "192.168.0.1";
port = 21567;
data = "";
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM);
s.connect((hostname,port));
droid.startSensingTimed(1,1000)
time.sleep(3)
while True:
az = str(math.degrees(droid.sensorsReadOrientation().result[0]))
pitch = str(math.degrees(droid.sensorsReadOrientation().result[1]))
roll = str(math.degrees(droid.sensorsReadOrientation().result[2]))
s.sendto(az+";"+pitch+";"+roll,(hostname,port));
-------------------------------------------------------------------------------------------
domenica 15 gennaio 2012
Un semplicissimo web server in Python per Android (risponde sulla porta 8000)
Nell'esempio mostra le fotografie presenti nel telefono
-----------------------------------------------------------------------------------------------------------------------------
import SimpleHTTPServer
from os import chdir
chdir('/sdcard/DCIM/Camera')
SimpleHTTPServer.test()
Limitazioni sui sensori dei telefoni Android
Accelerometri
Come riportato qui la misura delle accelerazioni con i sensori dei telefoni e' chiaramente dipendente dal tipo di chip che si utilizza ma in ogni caso Android mostrera' un valore con un numero di cifre decimali che e' di molto superiore a quello realmente significativo per lo strumento. Per esempio (qui) il sensore Bosch BMA 150 campiona solo su 8 bit quindi in un range 0-2g vede solo variazioni di 0.08g.
In generale inoltre i sensori a basso costo sono molto rumorosi; il comando StartSensing cerca di ridurre il rumore dello strumento.
In alcuni casi il costruttore limita il range di misura da 0 a 2g
Sensore di luce
In molti casi il sensore di luce viene impiegato come sensore di prossimita' quindi in alcuni casi la risposta del sensore e', a livello software, limitata ad una risposta di tipo binario anche se di fatto l'hardware sarebbe in grado di effettuare misure piu' precise. Inoltre il sensore di luce puo' essere molto lento nel refresh del proprio stato anche a valori prossimi ad 1 secondo
Magnetometro
Questo sensore, che fornisce informazioni anche di orientamento, e' fortemente affetto dalla presenza di sostanze metalliche nelle vicinanze
Da un breve test basato su 120 misure effettuate lasciando il telefono su un tavolo senza muoverlo ho registrato che
Accelerazione X = -0.41 +- 0.11 m/sec2
Accelerazione Y = -0.032 +- 0.23 m/sec2
Accelerazione Z = 9.91 +- 0.14 m/sec2
Come riportato qui la misura delle accelerazioni con i sensori dei telefoni e' chiaramente dipendente dal tipo di chip che si utilizza ma in ogni caso Android mostrera' un valore con un numero di cifre decimali che e' di molto superiore a quello realmente significativo per lo strumento. Per esempio (qui) il sensore Bosch BMA 150 campiona solo su 8 bit quindi in un range 0-2g vede solo variazioni di 0.08g.
In generale inoltre i sensori a basso costo sono molto rumorosi; il comando StartSensing cerca di ridurre il rumore dello strumento.
In alcuni casi il costruttore limita il range di misura da 0 a 2g
Sensore di luce
In molti casi il sensore di luce viene impiegato come sensore di prossimita' quindi in alcuni casi la risposta del sensore e', a livello software, limitata ad una risposta di tipo binario anche se di fatto l'hardware sarebbe in grado di effettuare misure piu' precise. Inoltre il sensore di luce puo' essere molto lento nel refresh del proprio stato anche a valori prossimi ad 1 secondo
Magnetometro
Questo sensore, che fornisce informazioni anche di orientamento, e' fortemente affetto dalla presenza di sostanze metalliche nelle vicinanze
Da un breve test basato su 120 misure effettuate lasciando il telefono su un tavolo senza muoverlo ho registrato che
Accelerazione X = -0.41 +- 0.11 m/sec2
Accelerazione Y = -0.032 +- 0.23 m/sec2
Accelerazione Z = 9.91 +- 0.14 m/sec2
Azimuth = -0.44 +- 0.075 (errore di circa 4.2°)
Pitch = 0.0017 +- 0.024 (errore di circa 1.35°)
Roll = 0.04 +- 0.014 (errore di circa 0.8°)
sabato 14 gennaio 2012
FTP Client su Android + Python
per utilizzare il telefono Android come client FTP e' piuttosto semplice utilizzando la libreria ftplib
---------------------------------------------------------------------------------------------------------
import ftplib
s = ftplib.FTP('192.168.0.1','luca','password')
f = open('/mnt/sdcard/datalogger.db','rb') #path del file che deve essere inviato
s.storbinary('STOR datalogger.db', f) #come deve essere salvato il file sul server
#il comando STOR non accetta il percorso ma solo il
#nome del file per cui per porlo in directory particolare
# si deve usare il comando CWD
f.close()
s.quit()
---------------------------------------------------------------------------------------------------------
Qualche problema in piu' deriva dal lato server. Per esempio installando su Linux il server FTP VsFtp si avra' una configurazione di base sostanzialmente paranoica che non permette di fare quasi niente oltre a loggarsi per cui si deve editare il file di configurazione in modo da permettere la scrittura agli utenti
---------------------------------------------------------------------------------------------------------
import ftplib
s = ftplib.FTP('192.168.0.1','luca','password')
f = open('/mnt/sdcard/datalogger.db','rb') #path del file che deve essere inviato
s.storbinary('STOR datalogger.db', f) #come deve essere salvato il file sul server
#il comando STOR non accetta il percorso ma solo il
#nome del file per cui per porlo in directory particolare
# si deve usare il comando CWD
f.close()
s.quit()
---------------------------------------------------------------------------------------------------------
Qualche problema in piu' deriva dal lato server. Per esempio installando su Linux il server FTP VsFtp si avra' una configurazione di base sostanzialmente paranoica che non permette di fare quasi niente oltre a loggarsi per cui si deve editare il file di configurazione in modo da permettere la scrittura agli utenti
venerdì 13 gennaio 2012
Datalogger + Twetter
Una versione del Datalogger con salvataggio su Twetter (poco utile a fini scientifici). Dalle prime prove la latenza di Twetter e' decisamente superiore a quella di GDocs
---------------------------------------------------------------------------------------------
import android, time, tweepy
from time import strftime
CONSUMER_KEY = 'xxxxxxxxx'
CONSUMER_SECRET = 'xxxxxxxxxxxxx'
ACCESS_KEY = 'xxxxxxxxxxxxxxxx'
ACCESS_SECRET = 'xxxxxxxxxxxxxxxxxxx'
auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)
api = tweepy.API(auth)
droid = android.Android()
droid.startSensingTimed(1,1000)
time.sleep(3)
acq = 0
while True:
accx = str(droid.sensorsReadAccelerometer().result[0])
accy = str(droid.sensorsReadAccelerometer().result[1])
accz = str(droid.sensorsReadAccelerometer().result[2])
az = str(droid.sensorsReadOrientation().result[0])
pitch = str(droid.sensorsReadOrientation().result[1])
roll = str(droid.sensorsReadOrientation().result[2])
orario = strftime("%Y-%m-%d %H:%M:%S")
outString = "Azimuth: " + az + " Pitch: " + pitch + " Roll: " + roll + " - " + orario
api.update_status(outString)
acq = acq + 1
print "Dato " + str(acq)
time.sleep(30)
droid.stopSensing()
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
import android, time, tweepy
from time import strftime
CONSUMER_KEY = 'xxxxxxxxx'
CONSUMER_SECRET = 'xxxxxxxxxxxxx'
ACCESS_KEY = 'xxxxxxxxxxxxxxxx'
ACCESS_SECRET = 'xxxxxxxxxxxxxxxxxxx'
auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)
api = tweepy.API(auth)
droid = android.Android()
droid.startSensingTimed(1,1000)
time.sleep(3)
acq = 0
while True:
accx = str(droid.sensorsReadAccelerometer().result[0])
accy = str(droid.sensorsReadAccelerometer().result[1])
accz = str(droid.sensorsReadAccelerometer().result[2])
az = str(droid.sensorsReadOrientation().result[0])
pitch = str(droid.sensorsReadOrientation().result[1])
roll = str(droid.sensorsReadOrientation().result[2])
orario = strftime("%Y-%m-%d %H:%M:%S")
outString = "Azimuth: " + az + " Pitch: " + pitch + " Roll: " + roll + " - " + orario
api.update_status(outString)
acq = acq + 1
print "Dato " + str(acq)
time.sleep(30)
droid.stopSensing()
---------------------------------------------------------------------------------------------
FPing
In modo piu' o meno puntuale mi capita di aver bisogno di un apparato di rete sepolto in qualche cassetto di cui ho perso l'indirizzo IP per l'amministrazione (...il foglio allegato e' regolarmente sbagliato)
In particolare con gli Access Point
In questi casi e' fondamentale il programma FPing che permette di automatizzare il Ping su intere classi di indirizzi (in genere finisco abbastanza alla svelta perche' le classi che uso sono quasi sempre la 192.168.0.x, 192.168.1.x e 10.0.0.x)
un esempio (si rimanda al man) per limitare la ricerca ai primi 100 indirizzi
fping -g 192.168.1.1 192.168.1.100
PS: ovviamente si deve sperare che l'apparato di rete non sia in modalita' No_ping come spesso vedono impostati molti server...
In particolare con gli Access Point
In questi casi e' fondamentale il programma FPing che permette di automatizzare il Ping su intere classi di indirizzi (in genere finisco abbastanza alla svelta perche' le classi che uso sono quasi sempre la 192.168.0.x, 192.168.1.x e 10.0.0.x)
un esempio (si rimanda al man) per limitare la ricerca ai primi 100 indirizzi
fping -g 192.168.1.1 192.168.1.100
PS: ovviamente si deve sperare che l'apparato di rete non sia in modalita' No_ping come spesso vedono impostati molti server...
Twitter via Android su telefono
Inviare tweet dal telefono Android prevede una procedura un po' differente rispetto a quella pubblicata qualche post fa.
Per prima cosa si deve scaricare da qui la libreria tweepy, in particolare a me funziona la versione 2.6
Successivamente dal telefono si deve aprire Python per Android/Import Modules e si seleziona la libreria per l'installazione
Lo script per postare su Tweet e' semplice come nell'esempio ripreso da un libro su SL4A
-------------------------------------------------------------------------------------------------------------
import android, datetime, time, tweepy
CONSUMER_KEY = 'xxxxxxx'
CONSUMER_SECRET = 'xxxxxxxxxxxxx'
ACCESS_KEY = 'xxxxxxxxxxx'
ACCESS_SECRET = 'xxxxxxxxxxxx'
auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)
api = tweepy.API(auth)
droid = android.Android()
droid.startLocating()
time.sleep(15)
loc = droid.readLocation()
droid.stopLocating()
if 'gps' in loc.result:
lat = str(loc.result['gps']['latitude'])
lon = str(loc.result['gps']['longitude'])
else:
lat = str(loc.result['network']['latitude'])
lon = str(loc.result['network']['longitude'])
now = str(datetime.datetime.now())
outString = 'I am here: ' + now + ' ' + lat + ' ' + lon
api.update_status(outString)
-------------------------------------------------------------------------------------------------------------
Per prima cosa si deve scaricare da qui la libreria tweepy, in particolare a me funziona la versione 2.6
Successivamente dal telefono si deve aprire Python per Android/Import Modules e si seleziona la libreria per l'installazione
Lo script per postare su Tweet e' semplice come nell'esempio ripreso da un libro su SL4A
-------------------------------------------------------------------------------------------------------------
import android, datetime, time, tweepy
CONSUMER_KEY = 'xxxxxxx'
CONSUMER_SECRET = 'xxxxxxxxxxxxx'
ACCESS_KEY = 'xxxxxxxxxxx'
ACCESS_SECRET = 'xxxxxxxxxxxx'
auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)
api = tweepy.API(auth)
droid = android.Android()
droid.startLocating()
time.sleep(15)
loc = droid.readLocation()
droid.stopLocating()
if 'gps' in loc.result:
lat = str(loc.result['gps']['latitude'])
lon = str(loc.result['gps']['longitude'])
else:
lat = str(loc.result['network']['latitude'])
lon = str(loc.result['network']['longitude'])
now = str(datetime.datetime.now())
outString = 'I am here: ' + now + ' ' + lat + ' ' + lon
api.update_status(outString)
-------------------------------------------------------------------------------------------------------------
Hacking Access Point WG602w4
Tempo fa avevo bisogno di estendere la copertura di una rete WiFi e cosi' ho cercato di acquistare un Access Point con modalita' Repeater. Il simpatico negoziante mi ha venduto un AP, anche abbastanza costoso, dicendo "Certo che funziona come repeater..c'e' scritto sulla scatola!!"
Dopo un giorno di prove ho letto su Internet che il WG602w4 funziona come repeater solo con altri AP della stessa ditta (??)
Ho quindi modificato il software dell'AP montando DD-WRT (http://www.dd-wrt.com/site/index), un firmware basato su Linux con una procedura ben descritta sul sito e andata liscia come l'olio
Una volta terminato lo scatolotto era pieno di nuove funzionalita' tra cui il repeater che ha funzionato a meraviglia....certe che un po' fa pensare di spendere soldi (anche abbastanza) per un hardware limitato poi dal software che ci gira sopra....
Dopo un giorno di prove ho letto su Internet che il WG602w4 funziona come repeater solo con altri AP della stessa ditta (??)
Ho quindi modificato il software dell'AP montando DD-WRT (http://www.dd-wrt.com/site/index), un firmware basato su Linux con una procedura ben descritta sul sito e andata liscia come l'olio
Una volta terminato lo scatolotto era pieno di nuove funzionalita' tra cui il repeater che ha funzionato a meraviglia....certe che un po' fa pensare di spendere soldi (anche abbastanza) per un hardware limitato poi dal software che ci gira sopra....
Datalogger + GDocs + Python + Android
Una versione differente del datalogger con salvataggio non in locale ma in real timesu Goggle Docs
Per prima cosa si deve creare uno Spreadsheet su Google Docs mettendo nella prima riga il nome delle colonne che saranno poi di riferimento per lo scrpit Python (i nomi devono essere minucoli e senza caratteri speciali)
Ci si deve inoltre annotare la key che compare nella URL
a questo punto lo script del Datalogger e' modificato come segue utilizzando le librerie GData che sono incluse in Python per SL4A nel pacchetto extra
-----------------------------------------------------------------------------------------------------
import android, time
from time import strftime
import gdata.spreadsheet.service
droid = android.Android()
email = 'lucainnoc@gmail.com'
password = 'password'
# Find this value in the url with 'key=XXX' and copy XXX below
spreadsheet_key = '0AvBeE7yoBqdHdFdmOW1UQUthVFpMZzF1S0lRWjRWdFE'
worksheet_id = 'od6' #indica il primo foglio
spr_client = gdata.spreadsheet.service.SpreadsheetsService()
spr_client.email = email
spr_client.password = password
spr_client.source = 'Example Spreadsheet Writing Application'
spr_client.ProgrammaticLogin()
droid.startSensingTimed(1,1000)
time.sleep(3)
acq = 0
while True:
accx = str(droid.sensorsReadAccelerometer().result[0])
accy = str(droid.sensorsReadAccelerometer().result[1])
accz = str(droid.sensorsReadAccelerometer().result[2])
az = str(droid.sensorsReadOrientation().result[0])
pitch = str(droid.sensorsReadOrientation().result[1])
roll = str(droid.sensorsReadOrientation().result[2])
orario = strftime("%Y-%m-%d %H:%M:%S")
dict = {}
#dict['date'] = time.strftime('%m/%d/%Y')
dict['time'] = orario
dict['accx'] = accx
dict['accy'] = accy
dict['accz'] = accz
dict['az'] = az
dict['pitch'] = pitch
dict['roll'] = roll
entry = spr_client.InsertRow(dict, spreadsheet_key, worksheet_id)
if isinstance(entry, gdata.spreadsheet.SpreadsheetsList):
#print "Insert row succeeded."
acq = acq + 1
print "Dato " + str(acq)
else:
print "Insert row failed."
time.sleep(1)
droid.stopSensing()
conn.close()
-----------------------------------------------------------------------------------
Lanciando lo script su telefono e tenendo aperto il foglio di calcolo nel browser del computer si vedranno le righe popolarsi con il passare del tempo. Il tempo di campionamento minimo e' piuttosto lungo (al minimo occorre circa 1 secondo per acquisizione) a causa della latenza della rete
Riferimenti : http://www.brokenairplane.com/2011/08/im-not-texting-im-programming.html (il sistema di autenticazione del mio script rispetto a quello di DoScience.py e' differente in quanto con il metodo proposto al link Google risponde con un errore di autenticazione)
Per prima cosa si deve creare uno Spreadsheet su Google Docs mettendo nella prima riga il nome delle colonne che saranno poi di riferimento per lo scrpit Python (i nomi devono essere minucoli e senza caratteri speciali)
Ci si deve inoltre annotare la key che compare nella URL
a questo punto lo script del Datalogger e' modificato come segue utilizzando le librerie GData che sono incluse in Python per SL4A nel pacchetto extra
-----------------------------------------------------------------------------------------------------
import android, time
from time import strftime
import gdata.spreadsheet.service
droid = android.Android()
email = 'lucainnoc@gmail.com'
password = 'password'
# Find this value in the url with 'key=XXX' and copy XXX below
spreadsheet_key = '0AvBeE7yoBqdHdFdmOW1UQUthVFpMZzF1S0lRWjRWdFE'
worksheet_id = 'od6' #indica il primo foglio
spr_client = gdata.spreadsheet.service.SpreadsheetsService()
spr_client.email = email
spr_client.password = password
spr_client.source = 'Example Spreadsheet Writing Application'
spr_client.ProgrammaticLogin()
droid.startSensingTimed(1,1000)
time.sleep(3)
acq = 0
while True:
accx = str(droid.sensorsReadAccelerometer().result[0])
accy = str(droid.sensorsReadAccelerometer().result[1])
accz = str(droid.sensorsReadAccelerometer().result[2])
az = str(droid.sensorsReadOrientation().result[0])
pitch = str(droid.sensorsReadOrientation().result[1])
roll = str(droid.sensorsReadOrientation().result[2])
orario = strftime("%Y-%m-%d %H:%M:%S")
dict = {}
#dict['date'] = time.strftime('%m/%d/%Y')
dict['time'] = orario
dict['accx'] = accx
dict['accy'] = accy
dict['accz'] = accz
dict['az'] = az
dict['pitch'] = pitch
dict['roll'] = roll
entry = spr_client.InsertRow(dict, spreadsheet_key, worksheet_id)
if isinstance(entry, gdata.spreadsheet.SpreadsheetsList):
#print "Insert row succeeded."
acq = acq + 1
print "Dato " + str(acq)
else:
print "Insert row failed."
time.sleep(1)
droid.stopSensing()
conn.close()
-----------------------------------------------------------------------------------
Lanciando lo script su telefono e tenendo aperto il foglio di calcolo nel browser del computer si vedranno le righe popolarsi con il passare del tempo. Il tempo di campionamento minimo e' piuttosto lungo (al minimo occorre circa 1 secondo per acquisizione) a causa della latenza della rete
Riferimenti : http://www.brokenairplane.com/2011/08/im-not-texting-im-programming.html (il sistema di autenticazione del mio script rispetto a quello di DoScience.py e' differente in quanto con il metodo proposto al link Google risponde con un errore di autenticazione)
giovedì 12 gennaio 2012
Twitter via programma
Per il datalogger una funzione carina poteva essere quella di inviare i dati via Twitter.
Tra gli esempi di SL4A si trovano diversi client twitter peccato che si basino sul metodo di autenticazione Authentication Basic che ad oggi Twitter non usa piu'.
Al momento riesco ad inviare tweet via programma usando la libreria python-twitter-0.8.2 ed in particolare l'esempio tweet.py nella sottodirectory /examples impiegando il sistema di autenticazione OAuth
Prima di tutto pero' si deve andare su http://dev.twitter.com registrandosi con il proprio utente e creando una nuova applicazione.
Verranno cosi' create la Consumer Key e la Consumer Secret...non basta...si deve settare Access Application Type a Read and Write e poi creare Access Token e Access Token Secret
Tra gli esempi di SL4A si trovano diversi client twitter peccato che si basino sul metodo di autenticazione Authentication Basic che ad oggi Twitter non usa piu'.
Al momento riesco ad inviare tweet via programma usando la libreria python-twitter-0.8.2 ed in particolare l'esempio tweet.py nella sottodirectory /examples impiegando il sistema di autenticazione OAuth
Prima di tutto pero' si deve andare su http://dev.twitter.com registrandosi con il proprio utente e creando una nuova applicazione.
Verranno cosi' create la Consumer Key e la Consumer Secret...non basta...si deve settare Access Application Type a Read and Write e poi creare Access Token e Access Token Secret
Con questi quattro codici si crea un file .tweetrc nella propria home copiando i valori
[Tweet]
consumer_key: XXXXXXXXXXX
consumer_secret: XXXXXXXXXXX
access_key: XXXXXXXXXXXXXXX
access_secret: XXXXXXXXXXXXXX
(gli stessi valori possono essere passati da linea di comando)
a questo punto si puo' usare il file di esempio tweet.py (magari modificando la prima riga che fa riferimento all'obsoleto python 2.4) con la sintassy
tweet.py 12344
sulla pagina andando sulla pagina di Twitter si vede il nuovo Tweet
Per i futuri Tweet del sensore Android seguire https://twitter.com/#!/sensore_android
Iscriviti a:
Post (Atom)
FigSpec FS-60CL
A lavoro mi hanno rifilato questo sensore iperspettrale cinese (pushbroom 400-1000 nm con larghezza di banda di 0.5 nm compatibile con DJI M...
-
Aggiornamento questo e' la risposta degli sviluppatori First of all, almost all operating systems on both mobile and laptop/desktop n... -
La scheda ESP32-2432S028R monta un Esp Dev Module con uno schermo TFT a driver ILI9341 di 320x240 pixels 16 bit colore.Il sito di riferiment... -
Questo post e' a seguito di quanto gia' visto nella precedente prova Lo scopo e' sempre il solito: creare un sistema che permet...