Home Arduino Sensore flessibile con moduli 433 mhz (Arduino)

Sensore flessibile con moduli 433 mhz (Arduino)

513

Il sensore di flessione part.2

Con Federico De Vincenti

 

Difficoltà: Media 

Ciao a tutti ragazzi e ben venuti nel mio nuovo post! Quest’oggi utilizzeremo ancora il sensore flessibile ma con una piccola variante, infatti, faremo girare sempre un Servo in base a come pieghiamo il sensore ma utilizzando i moduli 433 mhz come mezzo di comunicazione invece dei soliti fili che possono intralciare.

 

Prima di iniziare però ti ricordo che in fondo al post trovi un mio video riguardo al progetto! Non perdertelo.

 

Come mi è venuta in mente questa idea?

Essendo che avevo già fatto un progetto uguale in passato ma senza usare i 2 moduli radio ma bensì semplicemente dei jumper, ad un certo punto mi accorsi che il mio progetto era limitato perché non potevo allontanarmi molto con il sensore dall’Arduino essendo che era collegato a quest’ultimo, quindi ho deciso di optare per la soluzione migliore e ho preso 2 Arduino (uno e mega), ad uno ho collegato il Servo ed il ricevitore radio, all’altro invece il sensore e l’emettitore radio, così finalmente sono riuscito ad allontanarmi anche qualche metro con il sensore senza perdere qualità nello scambio dei dati.

 

A cosa può servire questo progetto?

Di solito per costruire mani robot, ma spetta alla vostra immaginazione realizzare a cosa potrebbe servire!

 

Cosa mi serve per completare il progetto?

  1. Arduino uno R3
  2. Arduino Mega
  3. Breadboard (X2)
  4. Sensore flessibile
  5. Servomotore
  6. Moduli 433 mhz
  7. Fili jumper
  8. Resistore da 10 kOhm
  9. Fili maschio-femmina

 

Bene, una volta che abbiamo tutti i componenti giusti, passiamo al circuito. Qui sotto trovi il circuito dell’emettitore  (Arduino Mega con sensore) :

 

Cattura-320x127 Sensore flessibile con moduli 433 mhz  (Arduino)

 

Questo invece è il programma dell’emettitore (da caricare sull’Arduino mega):

 

#include <VirtualWire.h>
const int flexpin = A0; // pin del sensore
//const int flexpin1 = A1; in caso si utilizzino più Sensori
//const int flexpin2 = A2;
void setup()
{
Serial.begin(115200);
Serial.println(“setup”);
vw_set_tx_pin(2);
vw_set_ptt_inverted(true);
vw_setup(2000); // Bits per sec
}

void loop()
{
String flexposition; //stringa madre
flexposition = String(analogRead(flexpin)); //converto il valore letto dal sensore in string
//flexposition = flexposition +”-“+ String(analogRead(flexpin1)); aggiungo alla stringa da mandare tutti i
//valori dei sensori in caso se ne utilizzino più di uno
//flexposition = flexposition +”-“+ String(analogRead(flexpin2));
char msg[14]; // calcolare numero caratteri massimi, in caso di 3 sensori il massimo di caratteri è 14
//es:(1000 – 1024 – 1011)
flexposition.toCharArray(msg,14); // converto da stringa a char il valore rilevato dal sensore
vw_send((uint8_t *)msg, strlen(msg)); // mando stringa madre con dentro tutte stringhe
vw_wait_tx();
Serial.println(flexposition); // scrivo quanto è il valore letto dal sensore
}

 

Qui trovi il circuito del ricevitore (Arduino uno son Servo):

Cattura-1-320x190 Sensore flessibile con moduli 433 mhz  (Arduino)

 

infine ecco il programma del ricevitore (da caricare sull’Arduino uno) :

 

#include <VirtualWire.h>
#include <SoftwareServo.h>
SoftwareServo mioservo1_gsx; // creo una variabile Servo
//SoftwareServo mioservo2_gsx; in caso si usino più Servo
int gradiservo1_gsx = 0; // gradi che il servo deve fare
//int gradiservo2_gsx = 0;

void setup()
{
Serial.begin(9600);
Serial.println(“setup”);
vw_set_rx_pin(2);
vw_set_ptt_inverted(true);
vw_setup(2000); // Bits per sec
vw_rx_start();
mioservo1_gsx.attach(9); // servo attaccato al pin 9
// mioservo2_gsx.attach(8);
Serial.println(“setup ok”);
}

void loop()
{
uint8_t buf[14]; // uguale al numero di caratteri del msg
uint8_t buflen = 14;
if (vw_get_message(buf, &buflen))
{
buf[buflen]=’\0′; // Metto il terminatore di stringa
String t_string = String((char *)buf);
Serial.println(t_string);
int v_1 = t_string.indexOf(“-“,0); // dico alla prima stringa arrivata di cercare il trattino a partire da 0
String s_1 = t_string.substring(0,v_1);
Serial.println(s_1); // scrivo valore singolo (senza trattino)
int t_1 = s_1.toInt(); // converto da string a int il valore ricevuto
//in caso si utilizzino più di un sensore
// int v_2 = t_string.indexOf(“-“,v_1+1);
//String s_2 = t_string.substring(v_1+1,v_2);
//Serial.println(s_2);
//int t_2 = s_2.toInt();
// int v_3 = t_string.indexOf(“-“,v_2+1);
//String s_3 = t_string.substring(v_2+1,v_3);
//Serial.println(s_3);
//int t_3 = s_3.toInt();

gradiservo1_gsx = map(t_1,956,660,0,180); // faccio map utilizzando t1, t2 ecc da un massimo ad un
//minimo
//Serial.println(gradiservo);
mioservo1_gsx.write(gradiservo1_gsx); //servo collegato ad un sensore si muove in base a come piego
//il sensore assegnato
SoftwareServo::refresh(); // da mettere alla fine di ogni mioservo.write
// gradiservo2_gsx = map(t_1,956,660,180,0); faccio map utilizzando t1, t2 ecc da un massimo ad un
//minimo
//Serial.println(gradiservo);
// mioservo2_gsx.write(gradiservo2_gsx); servo collegato ad un sensore si muove in base a come piego
//il sensore assegnato
// SoftwareServo::refresh();
}
}

 

Ecco alcune librerie utili per realizzare il progetto:

 

https://playground.arduino.cc/ComponentLib/Servo

https://github.com/m0/Updated-Arduino-VirtualWire-Library

 

 

Perfetto, una volta caricati i programmi nei giusti Arduino e aver scaricato le librerie, provate a piegare il sensore flessibile e se avete fatto tutto correttamente, il servomotore inizierà a girare in base a come piegate il sensore di flessione!

Ecco qui sotto il mio video:

Se il post ti è piaciuto visita il mio canale Youtube: Federico De Vincenti  

oppure vai alla sezione Arduino

favicon Sensore flessibile con moduli 433 mhz  (Arduino)
Load More Related Articles
Load More By Federico De Vincenti
Load More In Arduino

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.