Archivi tag: sensore

myR: sensore ultrasuoni

The ultrasound sensor is used to measure the distance respect an item in front of it.

A basic ultrasonic sensor consists of one or more ultrasonic transmitters (basically speakers), a receiver, and a control circuit. The transmitters emit a high frequency ultrasonic sound, which bounce off any nearby solid objects. Some of that ultrasonic noise is reflected and detected by the receiver on the sensor.

WP_20160212_002

There are a bounce of tutorial on how to use it.I  just follow this perfect tutorial :

www.modmypi.com

In this post I want to focus the sw code I developed and I just post the wiring:HC_SR04_2

The module is called us_sensor.py and it is upload in  Github>>myRover.

Inside you can find an class object called us_sensor_data, that collect the information to share with the world (the distance in [mm] and the period of  measurements in [sec].

This choice to create a separate class will become very useful when I will put all togheter (in the rover.py). In this way any  object can see all the information from other objects.

The main class  is the us_sensor  object.

def __init__(self, name, trigpin, echopin, data):

Where you need to pass a name, the GPIO pin for the trig signal (output) and the GPIO pin for the echo (input) signal.

This object  works in a parallel thread (threading.thread), so while in your main loop you can do something, the us_sensor continuously (every data.period time) measures the range and put this information in data.distance.

Since it is parallel thread you need to start it first,by calling  mySensor.start(). This call recalls then the run(), where there is the measurement loop.

Then you need to stop it when closing the application , and mySensor.stop().

Note that if you have more threads running  the measurements become less precise.

In addition if an item is very close to the sensor it happens to loose some echo signal.In order to avoid the loop to freeze waiting for a signal that was lost, I manege also a timeout.

Finally you can find a main()  to test the sensor by itsself.

#init data class
data = us_sensor_data()
#init sensor
mySensor = us_sensor('HC_SR04', 4, 17, data)
mySensor.start()
#from this moment the sensor is measuring and puts the result in mySensor.data.distance
...
while mySensor.cycling:
     #here do something...
     ...
     #than get the info when you need it
     s = 'Distance: ' + str(mySensor.data.distance)
     ...
finally:
# shut down cleanly
...
mySensor.stop()

Istallazione del sensore IMU

Da una settimana circa sto giocando  col mio IMU: Inertial Measurement Unit.

Ho acquistato su e-bay un MPU6050, sensore che include:

  • un giroscopio a tre assi,che e’ ingrado di restituire la velocita’ angolare registrata intorno a 3 assi x,y,z.
  • un accelerometro che e’ in grado di misurare l’accelerazione lungo i 3 assi x,y,z.

Tale sensore e’ in grado di comuncare attraverso l’interfaccia  I2C.

Qui potete trovare lo schema elettrico che sto utilizzando.

wiring_IMU

Per la parte di software ho trovato un chiaro tutorial sul sito della Adafruit , per cui vi rimando li per i dettagli. Qui riporto per promemoria i passaggi fondamentali per istallazione:

in sudo nano /etc/modules  add:

  • i2c-bcm2708
  • i2c-dev

sudo apt-get install python-smbus

sudo apt-get install i2c-tools

in sudo nano /etc/modprobe.d/raspi-blacklist.conf  comment:

  • #blacklist spi-bcm2708
  • #blacklist i2c-bcm2708

Ora, lanciando  sudo i2cdetect -y 1 si dovra’ vedere l’indirizzo 0x68, corrispondente all’indirizzo di default del sensore.

SW Dev : intro loop di controllo

Finora lo sviluppo sw ha incluso funzionalita di jogging base andando a modificare direttamente le velocita’ dei motori e lasciando all utilizzatore la loro modulazione.

A questo punto ho introdotto il concetto di controllo in cui l’ operatore indica l’ angolo desiderato ed il controllore , il nostro rapberry pi, deve decidere le velocita’ dei motori.

control_loop

La relazione teorica fra angolo del quadricottero (sia esso roll, pitch, yaw o una combinazione di essi) puo’ essere ritrovata nella pagina del quadricottero.
L equilibrio che si ottiene e’ di tipo instabile: e’ sufficiente un minimo disturbo (ad esempio un alito di vento) perche tale equilibrio si perda.

Nella realta’ bisogna anche considerare dissimetrie costruttive (struttura, eliche etc.), o comportamenti non costanti dei motori.

Cio si traduce nella necessita’ di sapere:

  • qual’e’ il comportamento istantaneo del velivolo
  • qual’e’ la reale relazione fra angoli e velocita motori in quanto differente da quella teorica

Per il primo punto si deve introdurre qualcosa che possa leggere lo stato attuale del quadricottero, diciamo un sensore.
Nella maggior parte dei casi si utilizza un sensore montato a bordo come un giroscopio o un giro+ accelerometro.

Il giroscopio ritorna la velocita angolare dal cui integrale si ottiene l’angolo.
L’ accelerometro ritorna l’ accelerazione nelle sue componenti x,y,z

Quindi, noto l’ angolo attuale e l’ angolo desiderato (target) posso calcolare l’ errore e decidere una strategia di modulazione della velocita’ dei motori.

Tale strategia si traduce in un metodo di controllo denominato PID.

Si ipotizza cioe’ che la relazione fra due variabili (nel nostro caso velocita’ angolare del motore e angolo) sia approssimabile a tre componenti:
Proporzionale (P) = kp*Ei
Integrale(I) = Ki* sum (Ei)*t
Derivativa(D)= kd * (Ei-Ei-1)/t

Dove Ei e’ errore fra w target e w current all’istante i-esimo, t e’ il tempo ciclo del loop
Dove i vari k vanno determinati empiricamente.

Il pid qundi mi restituisce un valore di variazione motori che deve permettere di minimizzare E.

Un loop di lettura da sensore, calcolo correzione con pid e applicazione correzione w motori costituisce la base del controllo d’ angolo.

Nei post seguenti dedichero’ una descrizione specifica agli specifici blocchi: sensore, PID e control loopcon lo scopo di definire la struttura finale del programma.