Pier Aisa Electronic Enthusiasts Community Forum

Funziona in modo strano, il primo led si accende. Inserisco il codice che ho modificato, ma specifico fin da subito, se già non si fosse capito, che non sono esperto di programmazione, ma non sono proprio a 0. Mi viene il dubbio che sul canale di comunicazione si debba prima creare una stringa di 2 interi che racchiudano il valore del primo e del secondo potenziometro, dopodichè estrarre sullo sketch in ricezione 2 caratteri diversi dalla stringa ricevuta e trasformarli in interi per le uscite pwm.


--------------------------------------------------------------Tx
#include <SPI.h>
#include <LoRa.h>
int pot = A0;
int pot2 = A1; //AGGIUNTO
void setup() {
Serial.begin(9600);
pinMode(pot,INPUT);
pinMode(pot2,INPUT); //AGGIUNTO

while (!Serial);
Serial.println("LoRa Sender");
if (!LoRa.begin(433E6)) { // or 915E6, the MHz speed of yout module
Serial.println("Starting LoRa failed!");
while (1);
}
}

void loop() {
int val = map(analogRead(pot),0,1024,0,255);
int val2 = map(analogRead(pot2),0,1024,0,255); //AGGIUNTO
LoRa.beginPacket();
LoRa.print(val);
LoRa.print(val2); //AGGIUNTO

LoRa.endPacket();
delay(50);

}
--------------------------------------------------------------------------------Rx
#include <SPI.h>
#include <LoRa.h>
int LED = 3;
int LED2 = 5; //AGGIUNTO
String inString = ""; // string to hold input
String inString2 = ""; //AGGIUNTO
int val = 0;
int val2 = 0; //AGGIUNTO


void setup() {
Serial.begin(9600);
pinMode(LED,OUTPUT);
pinMode(LED2,OUTPUT); //AGGIUNTO

while (!Serial);
Serial.println("LoRa Receiver");
if (!LoRa.begin(433E6)) { // or 915E6
Serial.println("Starting LoRa failed!");
while (1);
}
}

void loop() {

// try to parse packet
int packetSize = LoRa.parsePacket();
if (packetSize) {
// read packet
while (LoRa.available())
{
int inChar = LoRa.read();
int inChar2 = LoRa.read(); //AGGIUNTO
inString += (char)inChar;
inString2 += (char)inChar2; //AGGIUNTO

val = inString.toInt();
val2 = inString2.toInt(); //AGGIUNTO
}
inString = "";
inString2 = ""; //AGGIUNTO
LoRa.packetRssi();
}




Serial.println(val);
Serial.println(val2); //AGGIUNTO
analogWrite(LED, val);
analogWrite(LED2, val2); //AGGIUNTO






}

Confesso che e' la prima volta che leggo la documentazione della libreria LoRa del progetto, ma mi sembra che il problema sia qui, nel codice che riceve:
Dato che un oggetto LoRa() eredita da Stream(), immagino che si comporti come un oggetto Wire(), e che quindi read() estragga un carattere alla volta (sotto forma di int, ma un carattere alla volta e') dal "flusso" di caratteri. E questi caratteri sono gli stessi (in questo caso) che erano stati scritti nel "flusso" dal trasmettitore:
Quindi, ci sarebbe da aspettarsi che PRIMA arrivi NELLA SUA INTEREZZA la rappresentazione di val e solo allora, NELLA SUA INTEREZZA, quella di val2. Nella documentazione di Stream() trovo il metodo parseInt(), che restituisce il primo numero intero (long int) che trova nel flusso. Per sicurezza, io mi permetto di suggerire di aggiungere uno spazio tra i due interi in trasmissione:
e successivamente di sperimentare con quanto segue in ricezione:
Sempre ribadendo che non lo posso provare, coraggio!

Funziona perfettamente, entrambe le uscite su rx vengono pilotate da due potenziometri diversi. Non ho ben capito il discorso della variabile long; dato che viene trasmesso un valore per volta abbiamo bisogno di una variabile a 32 bit ? Se c'è già la map che fissa l'escursione massima del potenziometro a 255 non sarebbe stato possibile dichiarare una variabile int? Grazie mille per la disponibilità.

Il metodo parseInt() della classe Stream() restituisce sempre e comunque un valore a 32 bit, perche' non puo' sapere a priori quante cifre trovera' nel flusso di dati. Sta poi all'implementatore della specifica applicazione di sapere se si tratta di un intero a 8, 16 o 32 bit, con o senza segno eccetera.
Di nuovo, congratulazioni per il risultato!

Ciao! Ritorno sull'argomento perchè ho una curiosità che riguarda il chip Lora ma più in generale le trasmissioni spi: è possibile implementare nello stesso sketch un codice che per un periodo permetta a tx di trasmettere e ad rx di ricevere ma poi si scambino i ruoli, in modo che rx assuma il ruolo di tx e tx quello di rx?

Dovrebbe essere possibile. Il protocollo SPI prevede, oltre al clock e alla linea di selezione dello Slave, le linee MISO e MOSI ossia Master In Slave Out e Master Out Slave In quindi e' sicuramente possibile trasferire dati in entrambe le direzioni (io lo faccio per configurare un chip inizialmente scrivendo nei suoi registri e successivamente leggendo temperature dallo stesso chip). Quanto al protocollo Lora non ci ho mai giocato, ma sarebbe strano se non fosse bidirezionale. Pero' ammetto di non averlo mai fatto.

Va bene, essendo spi di tipo full duplex in teoria dovrebbe essere possibile la comunicazione bidirezionale anche per i Lora: devo fare la prova a inviare dal tx una stringa particolare che possa essere riconosciuta da rx e che modifichi di conseguenza SS su entrambi i dispositivi, una volta inviato il dato da rx a tx, con un delay si ripristina la comunicazione iniziale .. Provando a leggere la libreria Lora non è che abbia capito granchè, ci sono cose che ancora non ho affrontato nella programmazione e che richiedono tempo.

Non so se sia la stessa libreria, ma qui c'e' un esempio di trasmissione e ricezione:

https://github.com/sandeepmistry/arduin ... Duplex.ino

Sì sì, è proprio l'esempio che cercavo. Ora lo guardo bene e lo modifico. Grazie

Ciao, ho ripreso dopo un pò di tempo il progetto che stavo portando avanti, volevo utilizzarlo ma mi sono accorto che c'è qualcosa che non va, in poche parole il ricevente si blocca e non riesco a gestirlo più, se non resettando tutto. Pensavo fosse un problema di alimentazione, ma poi collegando Rx al monitor seriale ho avuto lo stesso problema dopo un pò di tempo. Il software che caricai è sempre lo stesso. Esiste un modo per capire cosa blocca il codice? Grazie.