Salve a tutti,
Con la clausura forzata vengono idee malsane che poi il mio cervello non sa portare a termine... e quindi provo a chiedere qui sul forum.
La mia intenzione sarebbe questa:
Ho costruito un rotore d'antenna Satnogs mosso da due motori passo passo comandati da un Arduino Uno + shield tipo stampante 3D.... funziona.
Questa scheda si collega tramite usb al pc dove gira un software, PSTRotator per controllare la rotazione e l'elevazione dell'antenna (poi tramite MyDDE, il tutto si connette ad Orbitron che fa in modo da far seguire automaticamente un satellite selezionato).... funziona.
Il mio problema é che l'antenna col rotore va posizionata fuori, mentre il pc é dentro casa :o
La malsana idea era quella di collegare una scheda al pc che inviasse via wifi i comandi alla scheda che si trova sotto il rotore (ho un muro in mezzo ma ho visto che il segnale arrivava quando avevo costruito un commutatore d'antenna wifi).
Avrei quindi bisogno di uno spunto per far dialogare le due schede come se avessi un lungo cavo usb collegato.
Spero di non aver scritto una strafalcionata e ammetto di usare da molto tempo Arduino ma di non sapere quasi niente di wifi.
Sotto un piccolo video del rotore.
Ringrazio chiunque abbia voglia di mostrarmi la strada.
Saluti
Lanfranco
Il tuo WIFI alla fine è una connessione internet, al massimo potresti usare i socket TCP/UDP ma quel software su PC che usi (PSTRotor) dice chiaramente che lavora su Seriale.
Esistono apparecchi che mandano segnale seriale via rete/wifi ma costano parecchio, esempio: LINK
In alternativa potresti usare dei moduli radio, esistono penne USB per il pc, avresti seriale che poi manda segnale ad un modulo radio su arduino, ma a priori non saprei se supera il tuo muro.
I moduli sono radio rf24 (assolutamente NO i moduli radio 433 Mhz che sono deboli)
Potrebbe ovviare facendo un "bridge" con due microcontrollori dotati di WiFi (es. il classico ESP8266)
In questo caso la seriale da usare con il tool PSTRotor, sarebbe quella associata al micro che quindi dovrebbe emulare la sua antenna.
Vi ringrazio per le risposte, ho ordinato due moduli 2,4 GHz e01 ml01dp5 in quanto volevo giocarci un po'.
Interessante il discorso extender USB in quanto sul muro che mi divide dal traliccio delle antenne c'e' un buco attraverso il quale passano i cavi schermati.... potrei far uscire una prolunga USB che sarebbe di un metro o poco piu', mettendo fuori il dongle..... Guardo i link che mi avete postato. Non so se serve, ma ho anche una scheda ESP32 devkit v1 e nella mia ignoranza nel campo wifi avevo pensato che si potesse usare... Comunque se potete mandarmi un link di un esempio di utilizzo di cio' che diceva cotestatnt, potrei studiarci un po' e magari imparo qualcosa di nuovo.
Intanto vi ringrazio e comincio a guardare i link.
Sempre aperto anche ad altre idee, vi ringrazio e saluto.
Lanfranco
Salve,
Sto sperimentando con la scheda ESP32 devkit v1 e mi si é aperto un mondo.... Un mondo alieno purtroppo, ma intravedo grosse possibilitá.
Quello che mio malgrado non conosco é cosa deve trasmettere attraverso il software PSTRotator (software che riceve informazioni da Orbitron tramite MyDDE e le trasforma in movimenti dei motori tramite Arduino UNO)... che tipo di informazioni.. Purtroppo non capisco e non riesco ad avere un riscontro tramite Monitor Seriale in quanto é ovviamente occupata la porta. Se qualcuno mi spiegasse a grandi linee come fare a vedere cosa sta facendo la scheda quando riceve le informazioni dal programma, sono sicuro che potrei andare avanti col progetto. la mia intenzione poteva anche essere quella di usare due Arduino anche attraverso un cavo di rete visto che la distanza é di circa 8 mt (6mt del traliccio piú i due per entrare in stazione).
Vorrei evitare accrocchi vari in quanto sono per il SELFMADE.
Grazie mille.
Lanfranco
Abbi pazienza, ma perché seriale? L'Arduino che comanda il rotore é collegato via USB...
E poi, scusa di nuovo, si tratta della voglia di imparare... Se riesco a far dialogare due schede.... mi sento piu' felice...
Anche con un cavo di rete tra due schede mi accontenterei, ma la trasmissione radio mi affascina... Ovviamente se é possibile.
Ho provato vari esempi per l'ESP, ma sono tutti destinati a questi accidenti di smartphone... nessuno che trasferisce i dati ad un'altra scheda dotata di wifi.
Grazie comunque per la delucidazione.
Saluti
Lanfranco
Se le cose stanno cosi allora è tutto diverso.
Tornando a bomba... quindi da un lato hai un ESP32 e dall'altro un Arduino Uno.
Manca un pezzo per completare la connessione wireless, devi dotare l'Uno di un adattatore WiFi oppure sostituirlo con una board che ce l'ha integrato come ad esempio un secondo ESP32.
A quel punto hai un "layer di trasporto" comune su cui ci puoi far viaggiare tutti i dati che preferisci con diversi protocolli: TCP e UDP sono tra i più comuni e per i quali troverai montagne di documentazione online.
AAAAAhhhhh! questa é la risposta che speravo .... solo un altro dubbio (forse)....
Se io sostituisco l'Arduino UNO che comanda il rotore, con la scheda ESP32, ci sta tutto il software di controllo oltre che la parte di software per la comunicazione? Poi vorrei utilizzare Arduino in quanto italiano... sarebbe possibile fare tutto questo con due Arduino UNO e questi due moduli wifi? 2,4 GHz e01 ml01dp5
Ho letto che sono alquanto potenti.
Grazie mille
Lanfranco
L'ESP32 è una MCU molto, ma molto più "potente" di un Arduino Uno ovvero ATMega328... Se dovessi dare i numeri, direi almeno 1 a100.
È una piattaforma a 32bit (l'ATMega328 è a 8 bit), maggior velocità di clock, maggior capacità computazionale, maggiore capacità di archiviazione, più RAM soprattutto.
Per quanto riguarda i moduli che hai linkato (che sono senza dubbio wireless, ma non WiFi) è certamente possibile, ma si tratta di un approccio "diverso" quindi devi scegliere quale strada intraprendere prima di tutto.
Si scusate.... So che la comunicazione é la stessa e avevo interpretato male la frase.
cotestatnt:
quindi devi scegliere quale strada intraprendere prima di tutto.
Visto che ora ho tra le mani sia l'ESP32 che varie schede Arduino e che un'Arduino Uno é giá funzionante sul rotore, la mia idea era quella di usare l'ESP32 come "trasmettitore" e all'UNo fargli fare quello che sta giá facendo bene... al limite aggiungendo uno shield wifi (dovró ristampare il case)... poi quando arriveranno dalla Cina i due chip avró modo di studiarci... ma ci vorrá un mese e vista la situazione di clausura vorrei cominciare con quello che ho.
Grazie ad entrambi.
Lanfranco
Ho trovato questa guida per lo scambio dati tra due ESP32.... Prima che io ordini un altro ESP32 qualcuno puó dirmi se si puó fare la stessa cosa con un ESP e un Arduino Uno dotato di shield wifi?
Grazie mille.
Vi chiedo una cortesia... Ho trovato un ottimo esempio per trasferire i dati da un ESP32 ad un altro ma il codice mi da: "impossibile caricare sulla scheda ecc ecc"
Qualcuno che ha un ESP 32 ha voglia di provare a caricare questo sketch e dirmi se sbaglio qualcosa io? Non ho mai avuto problemi irrisolvibili nel caricare sketch, ma stavolta non conoscendo il mondo wifi ho problemi.
Grazie mille.
/*
Rui Santos
Complete project details at https://RandomNerdTutorials.com/esp-now-two-way-communication-esp32/
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files.
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
*/
#include <esp_now.h>
#include <WiFi.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
Adafruit_BME280 bme;
// REPLACE WITH THE MAC Address of your receiver
uint8_t broadcastAddress[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
// Define variables to store BME280 readings to be sent
float temperature;
float humidity;
float pressure;
// Define variables to store incoming readings
float incomingTemp;
float incomingHum;
float incomingPres;
// Variable to store if sending data was successful
String success;
//Structure example to send data
//Must match the receiver structure
typedef struct struct_message {
float temp;
float hum;
float pres;
} struct_message;
// Create a struct_message called BME280Readings to hold sensor readings
struct_message BME280Readings;
// Create a struct_message to hold incoming sensor readings
struct_message incomingReadings;
// Callback when data is sent
void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
Serial.print("\r\nLast Packet Send Status:\t");
Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
if (status ==0){
success = "Delivery Success :)";
}
else{
success = "Delivery Fail :(";
}
}
// Callback when data is received
void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) {
memcpy(&incomingReadings, incomingData, sizeof(incomingReadings));
Serial.print("Bytes received: ");
Serial.println(len);
incomingTemp = incomingReadings.temp;
incomingHum = incomingReadings.hum;
incomingPres = incomingReadings.pres;
}
void setup() {
// Init Serial Monitor
Serial.begin(115200);
// Init BME280 sensor
bool status = bme.begin(0x76);
if (!status) {
Serial.println("Could not find a valid BME280 sensor, check wiring!");
while (1);
}
// Init OLED display
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Serial.println(F("SSD1306 allocation failed"));
for(;;);
}
// Set device as a Wi-Fi Station
WiFi.mode(WIFI_STA);
// Init ESP-NOW
if (esp_now_init() != ESP_OK) {
Serial.println("Error initializing ESP-NOW");
return;
}
// Once ESPNow is successfully Init, we will register for Send CB to
// get the status of Trasnmitted packet
esp_now_register_send_cb(OnDataSent);
// Register peer
esp_now_peer_info_t peerInfo;
memcpy(peerInfo.peer_addr, broadcastAddress, 6);
peerInfo.channel = 0;
peerInfo.encrypt = false;
// Add peer
if (esp_now_add_peer(&peerInfo) != ESP_OK){
Serial.println("Failed to add peer");
return;
}
// Register for a callback function that will be called when data is received
esp_now_register_recv_cb(OnDataRecv);
}
void loop() {
getReadings();
// Set values to send
BME280Readings.temp = temperature;
BME280Readings.hum = humidity;
BME280Readings.pres = pressure;
// Send message via ESP-NOW
esp_err_t result = esp_now_send(broadcastAddress, (uint8_t *) &BME280Readings, sizeof(BME280Readings));
if (result == ESP_OK) {
Serial.println("Sent with success");
}
else {
Serial.println("Error sending the data");
}
updateDisplay();
delay(10000);
}
void getReadings(){
temperature = bme.readTemperature();
humidity = bme.readHumidity();
pressure = (bme.readPressure() / 100.0F);
}
void updateDisplay(){
// Display Readings on OLED Display
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(0, 0);
display.println("INCOMING READINGS");
display.setCursor(0, 15);
display.print("Temperature: ");
display.print(incomingTemp);
display.cp437(true);
display.write(248);
display.print("C");
display.setCursor(0, 25);
display.print("Humidity: ");
display.print(incomingHum);
display.print("%");
display.setCursor(0, 35);
display.print("Pressure: ");
display.print(incomingPres);
display.print("hPa");
display.setCursor(0, 56);
display.print(success);
display.display();
// Display Readings in Serial Monitor
Serial.println("INCOMING READINGS");
Serial.print("Temperature: ");
Serial.print(incomingReadings.temp);
Serial.println(" ºC");
Serial.print("Humidity: ");
Serial.print(incomingReadings.hum);
Serial.println(" %");
Serial.print("Pressure: ");
Serial.print(incomingReadings.pres);
Serial.println(" hPa");
Serial.println();
}
Lanfra:
la mia idea era quella di usare l'ESP32 come "trasmettitore" e all'UNo fargli fare quello che sta giá facendo bene... al limite aggiungendo uno shield wifi (dovró ristampare il case)...
Mah, non so se tu abia requisiti particolari ma io ho risolto una cosa simile usando direttamente due WeMos (una D1 R2 fuori ed una D1 mini dentro casa) visto che sono "compatibili" con Arduino (ossia adattando un poco il codice ed eventualmente le librerie, il codice ti funziona come su Arduino), hanno lo stesso form factor per i connettori (tranne il fatto che c'è solo un pin analogico), hanno già il Wifi integrato, e quindi non necessitano di shield, ma hanno più memoria ram/flash...
Se poi ti basta la versione mini hai un oggetto compattissimo, e con 15€ ne prendi tre su Amazon che puoi avere in un paio di giorni. Vedi tu...
Il codice che hai trovato fa uso del protocollo ESP-NOW che è un protocollo "propretario" di Espressif e funzionerà solo ed esclusivamente con questi dispositivi (quindi l'opzione Uno + shield è da scartare).
Per quanto "figo" (consente la comunicazione tra più dispositivi senza un WiFi, anche in rete mesh) il mio consiglio è quello di evitare il copia/incolla di cose che non "padroneggi". Inizia da qualcosa di più comune ed interscambiabile.
Ad esempio una cosa "semplice" da implementare potrebbe essere l'invio di una stringa di testo usando il protocollo UDP
Ringrazio entrambi per le risposte.
Quello del copia e incolla é un sistema che odio anch'io..... Normalmente copio uno spunto e lo modifico per ottenere ció che voglio... ma in questo caso, come ho scritto nei miei primi post, sulla comunicazione seriale e wifi, sono completamente a digiuno. Presumo che voi siate persone giovani oltre che preparate e quindi (molto umilmente) non potete sapere cosa vuol dire per un quasi 60enne (domani sono 59) autodidatta, arrivare a capire certe cose. Amo Arduino e ho creato molti progetti, due dei quali da zero.... ma il tempo corre e alla fine non ho intenzione di diventare un programmatore... non ne ho il tempo e la preparazione... mi basterebbe uno spunto... due righe di sketch per capire come funziona vedendo funzionare la cosa...poi so di potermi arrangiare. Ho un sito (iz3zlu.weebly.com) dove pubblico tutti i miei progetti con sketch, file di stampa 3d, disegni dei pcb e file .tap per fresarli. Rispondo tempestivamente e gratuitamente alle richieste di aiuto perché credo nell'Ham Spirit... ma mi rendo conto che questo spirito non viene corrisposto. Mi rendo anche conto che qui ci sono un sacco di richieste per le quali molte persone non scrivono neanche grazie... Aggiungo, visto questo outing, che per quattro/cinque volte ho provato a chiedere in questo forum e solo questa volta e un'altra grazie a Fabpolli, ho ricevuto una risposta... le altre volte ho dovuto chiedere nel forum internazionale dove molte persone hanno fatto la guerra per chi riusciva ad aiutare di piú (ringrazio il buon Seithan per l'ennesima volta). Ma sono italiano e vorrei discutere con la mia gente.
Ringrazio ancora per le dritte, domani dovrebbe arrivare un altro ESP32 (regalo di compleanno) e forse riusciró nel mio intento.
Saluti
Lanfranco
Radioamatore, immagino... Io mi sono fermato ai "baracchini".
Rispondo tempestivamente e gratuitamente alle richieste di aiuto perché credo nell'Ham Spirit... ma mi rendo conto che questo spirito non viene corrisposto.
Beh, cosa farei io al posto tuo (anche se non conosco tutto il tuo background ed i requisiti del progetto) l'ho scritto, ossia mi semplificherei la vita usando un paio di WeMos che sono le board che uso in genere quando ho bisogno di far dialogare in rete dei device (per il resto ho tutti Arduino, da UNO a Nano, mini, tiny, e Mega...) che costano poco e funzionano bene.
Quindi non te la prendere, lo "spirito Ham" c'è lo stesso, solo che con decine di migliaia di utenti attivi non è detto che siano tutti "collaborativi" allo stesso modo...
Lanfra:
mi basterebbe uno spunto... due righe di sketch per capire come funziona
Questo potrebbe andar bene come spunto ( e non andiamo nemmeno troppo lontano).
In questo esempio viene inviata un stringa, ma ovviamente puoi inviare qualsiasi tipo di dati.
Modificato per compilare con ESP32 (e provato).
#include <WiFi.h>
#include <WiFiUdp.h>
int status = WL_IDLE_STATUS;
char ssid[] = "xxxxxxxx"; // your network SSID (name)
char pass[] = "xxxxxxxx"; // your network password
unsigned int localPort = 2390; // local port to listen on
char packetBuffer[255]; // buffer to hold incoming packet
char ReplyBuffer[] = "acknowledged"; // a string to send back
WiFiUDP Udp;
void setup() {
Serial.begin(9600);
// attempt to connect to Wifi network:
Serial.print("\nConnecting to ");
Serial.println(ssid);
WiFi.begin(ssid, pass);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
Udp.begin(WiFi.localIP(), localPort);
}
void loop() {
// if there's data available, read a packet
int packetSize = Udp.parsePacket();
if (packetSize) {
Serial.print("Received packet of size ");
Serial.println(packetSize);
Serial.print("From ");
IPAddress remoteIp = Udp.remoteIP();
Serial.print(remoteIp);
Serial.print(", port ");
Serial.println(Udp.remotePort());
// read the packet into packetBufffer
int len = Udp.read(packetBuffer, 255);
if (len > 0) {
packetBuffer[len] = 0;
}
Serial.println("Contents:");
Serial.println(packetBuffer);
// send a reply, to the IP address and port that sent us the packet we received
Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());
Udp.write((uint8_t *)ReplyBuffer, sizeof(ReplyBuffer));
Udp.endPacket();
}
}
.... solo un altro dubbio (forse)....