Go Down

Topic: Consiglio per contametri / scatti per telaio (Read 2052 times) previous topic - next topic

ale83biella

#30
Mar 05, 2014, 07:24 am Last Edit: Mar 05, 2014, 12:30 pm by ale83biella Reason: 1
ciao a tutti

sto procendo alla prova dei moduli nRF24L01.
La mia idea e' quella di installare su ogni telaio un arduino con un modulo radio.
Poi installato' un modulo su un arduino "server" che dovrà essere dotato di irta ethernet.

L'arduino server sovra chiamare in sequenza il telaio 01, telaio 02 , telaio 03 ecc e ciascun arduino "client" dovrà inviargli il numero di scatti e il timestamp.

una volta che il server ha ricevuto il dato chiamerò' una pagina php dove passero' al WebServer i dati raccolti.
Secondo Voi è il modo corretto?

Adesso vengo ai moduli radio.
Ne sto provando 2.
E per il test ho usato gli sketch di esempio di MIRF ( ping_server e ping_client)

Purtroppo i moduli non si vedono a meno che non avvicino i sensori quasi a contatto.In quel caso si vedono e pingano.
Ma questi moduli da quello che ho letto dovrebbero comunicare a qualche decina di mt di distanza.
A me serve che parlino in uno spazio aperto in un'area 20mtx10mt.

C'e'qualche valore che devo Settare??

PaoloP

--> http://forum.arduino.cc/index.php?topic=96917.msg743519#msg743519

ale83biella

#32
Mar 15, 2014, 03:30 pm Last Edit: Mar 15, 2014, 05:16 pm by ale83biella Reason: 1
ciao a tutti
è da questa mattina che sto lavorando sui moduli nrf24l01.
Premetto che uso 2 arduino uno e che sono collegati correttamente.( ho testato con gettingstarted della libreria rf24 e tutto funziona ovvero si parlano  :) )
Adesso sto scrivendo 2 sketch:
Il primo per l'arduino che raccogliera i dati dei telai
il secondo per gli arduino che andranno installati su ciascuno dei 40 telai

Sono partito dall'esempio del getting started modificandolo :

sketch arduinoServer
Code: [Select]



#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

/////////////////////////////////////////////////////////////////////////
/////////////////// Hardware configuration///////////////////////////////
/////////////////////////////////////////////////////////////////////////
// Set up nRF24L01 radio on SPI bus plus pins 9 & 10
RF24 radio(9,10);
//
// Topology
//
// Radio pipe addresses for the 2 nodes to communicate.
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };
//
// Role management
//
// Set up role.  This sketch uses the same software for all the nodes
// in this system.  Doing so greatly simplifies testing.  
//
// The various roles supported by this sketch
typedef enum { role_ping_out = 1, role_pong_back } role_e;

// The debug-friendly names of those roles
const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};

// The role of the current running sketch
role_e role = role_pong_back;

void setup(void)
{
 //
 // Print preamble
 //
 Serial.begin(57600);
 printf_begin();
 printf("Sistema Contametri telai Server  \n\r");
 //printf("ROLE: %s\n\r",role_friendly_name[role]);
 //printf("*** PRESS 'T' to begin transmitting to the other node\n\r");

 //
 // Setup and configure rf radio
 //

 radio.begin();

 // optionally, increase the delay between retries & # of retries
 radio.setRetries(15,15);

radio.openWritingPipe(pipes[0]);
radio.openReadingPipe(1,pipes[1]);
//
 // Start listening
 //

 radio.startListening();

 //
 // Dump the configuration of the rf unit for debugging
 //

 radio.printDetails();

}

void loop(void)
{
 //
 // Ping out role.  Repeatedly send the current time
 //
int numeroTelaio = 0;
//inserisco ciclo for per cercare tutti i telaio da 0 a 45
   for (numeroTelaio=1;numeroTelaio<5;++numeroTelaio)
{
// First, stop listening so we can talk.
radio.stopListening();

// Take the time, and send it.  This will block until complete
unsigned long time = millis();
printf("telaio %d , dammi subito la stringascatti... %lu...",numeroTelaio,time);
bool ok = radio.write(&numeroTelaio, sizeof(unsigned int));
//write restituisce true se la trasmissione e' avvenuta con successo e false in caso opposto

if (ok)
 printf("ok...");
else
 printf("fallito( write ha ritornato false.\n\r");

// qui devo iniziare ad attendere la risposta del telaioXX
radio.startListening();

// Wait here until we get a response, or timeout (250ms)
unsigned long started_waiting_at = millis();
bool timeout = false;
//finche non c'e' segnale radio , la variabile timeout a true
while ( ! radio.available() && ! timeout )
 if (millis() - started_waiting_at > 400 )
timeout = true;

// Describe the results
if ( timeout )
{
 printf("Failed, response timed out.\n\r");
}
else
{
 // Grab the response, compare, and send to debugging spew
 unsigned long stringascatti;
 radio.read( &stringascatti, sizeof(unsigned long) );

 // Spew it
 printf("Ricevuto telaio %d! stringascatti da telaio %d : %lu \n\r",numeroTelaio,numeroTelaio,stringascatti);
}
delay(1000);
}
   // Try again 1s later
   delay(20000);// 20 secondi e riparte il ciclo
 


}



altro sketch per l'arduinoTelaio
Code: [Select]
#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

/////////////////////////////////////////////////////////////////////////
/////////////////// Hardware configuration///////////////////////////////
/////////////////////////////////////////////////////////////////////////
// Set up nRF24L01 radio on SPI bus plus pins 9 & 10
RF24 radio(9,10);
//
// Topology
//
// Radio pipe addresses for the 2 nodes to communicate.
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };
//
// Role management
//
// Set up role.  This sketch uses the same software for all the nodes
// in this system.  Doing so greatly simplifies testing.  
//
// The various roles supported by this sketch
typedef enum { role_ping_out = 1, role_pong_back } role_e;

// The debug-friendly names of those roles
const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};

// The role of the current running sketch
role_e role = role_pong_back;

void setup(void)
{
 //
 // Print preamble
 //
 Serial.begin(57600);
 printf_begin();
 printf("Sistema Contametri telai Server  \n\r");
 //printf("ROLE: %s\n\r",role_friendly_name[role]);
 //printf("*** PRESS 'T' to begin transmitting to the other node\n\r");

 //
 // Setup and configure rf radio
 //

 radio.begin();

 // optionally, increase the delay between retries & # of retries
 radio.setRetries(15,15);

radio.openWritingPipe(pipes[1]);
     radio.openReadingPipe(1,pipes[0]);
 //
 // Start listening
 //

 radio.startListening();

 //
 // Dump the configuration of the rf unit for debugging
 //

 radio.printDetails();
int numeroTelaio_t = 2;//imposto il numero del telaio

}

void loop(void)
{
if ( radio.available() )
{resto dello sketch
     }




la mia domanda e' perche' radio.available  mi da false?
come devo settare le PIPE per far parlare i due sensori?
devo settare un pipe per la trasmissione da arduinoServer a arduinoTelaI
e una pipe per la trasmissione contraria?
oppure ne basterebbe una e si gestisce la cominicazione con stop e start listening?
inoltre anche se ho letto la guida http://maniacbug.wordpress.com/2011/11/02/getting-started-rf24/
non ho capito come generare queste chiavi hex per le pipe.

riuscite a indirizzarmi??
---------------------aggiornamento-------------------------
seguendo sempre l'esempio gettingstarted sono riuscito a impostare le pipe.
Resta comunque il mio interrogativo sul fatto se sia necessario avere una pipe per
le trasmissioni in un senso o una pipe per quelle in senso contrario
o se ne basterebbe una pero' facendo in moda che un sensore trasmetta e gli altri ricevano ( uno per volta insomma).

Vi posto l'altra parte di sketch perche' non mi e' chiara la funzione radio.read
Code: [Select]
void loop(void)
{
if ( radio.available() )
{
  //
  // Ping out role.  Repeatedly send the current time
  //
// qui devo iniziare ad attendere la risposta del telaioXX
radio.startListening();
bool done = false;
//leggo solo quello che mi comunica il Server
//e vedo se il numero del telaio corrisponde a me
unsigned long time = millis();
printf("Ascolto il numero del telaio..");
int  numeroTelaio ;
unsigned long stringascatti;
while(!done)
{
bool done = radio.read( &numeroTelaio, sizeof( int ) );
//read restituisce true se la trasmissione e' avvenuta con successo
//e false in caso opposto

if (done)
{
  printf("ok...");
  printf("telaio nr. %d \n\r",&numeroTelaio);
}
else
  printf("fallito!read ha ritornato false.\n\r");

delay(150);
}


delay(800);


durante l'esecuzione di questo sketch , in pratica mi gira all'infinito la while ( il delay(800) non viene mai fatto ) .
Da questo dedurrei che done sia sempre false , se non che se va a eseguire quello che c'e' nella if(done)
Come e' possibile? :smiley-roll-sweat:

inoltre alla funzione radio.read  cosa devo passare?
il primo argomento e' la variabile, mentre il secondo deve essere la dimensione in byte?
ma se io volessi leggere una stringa dovrei scrivere char numeroTelaio ; radio.read(&numeroTelaio, sizeof(char) ) ??

ale83biella

sono riuscito a far comunicare i moduli Rf , ho fatto una prova nella sala telai ,ma per raggiungere il punto dove colleghero' il tutto alla rete lan   devo fare un ponte con un altro rf intermedio.

Vi chiedo aiuto sul fatto su quale codice usare per passare ( con radio.read , radiowrite ) una stringa.
Sono riuscito a passare valori interi ( con variabile unsigned long) ma la stringa me la trasforma in numero.
Riuscite a darmi una dritta?

sniper61

Ciao
quello che hai postato sulla foto è un sensore induttivo NPN. La sua funzione è molto simile ad un cerca metalli e cioe se avvicini
una piastrina metallica, il sensore commuta da 0 (0 volt) a 1 (massima tensione di alimentazione data).
Vengono usati anche per conteggi fino a massimo 400 Hz (dipende dal tipo).
Se collegato ad in pin digitale di ingresso e colleghi un led su un pin di uscita, ogni volta che avvicini a circa 1,5-4 mm. ti si accende il led.
Spero di essere stato utile.

Go Up