buongiorno a tutti,
Sto lavorando ad un progetto che prevede un APP Android che scatta una foto e la converte un Gcode,
per poi stamparla su un V plotter. Android ed arduino dialogano via Bluetooth.
non mi dilungo tanto sulla descrizione generale del progetto che in estrema sintesi funziona bene
sia per la parte di elaborazione delle immagine lato android che sulla stampa sul protter controllato da arduino.
Lato android sto usando ide droidscript. Che in pratica è solo un contenitore di algoritmi di calcolo per passare
da: jpg -> toni di grigio-> algoritmo di Soblel-> postino cinese -> gcode ( con ovvie semplificazioni per
contenere il tempo di eleborazione a una qualità accettabile del prodotto finito.
La cosa che vorrei evitare è collegare direttamente il device android ad arduino via OTG o spostare la SD
dal lettore esterno di Android al lettore di arduino.
Quello che mi pare richieda ancora una implementazione è il dialogo tramite BT, per la trasmissione di file.
Sull'arduino UNO ho installato una SD ed un modulo DSD TECH HC-05, oltre ovviamente i motori ed il servo.
il modulo HC-05 è è sui pin 15 e 16 (gli altri digitali sono andati per gli altri componenti).
sono utilizzate le librerie SD.h e SoftwareSerial.h
Non si sono problemi quando la trasmissione da a verso android ed arduino è costituita sa un solo carattere.
Per comandi tipo:
se ricevi "a" accendi il led
se ricevi "b" muovi il servo
se ricevi "c" muovi il motore di 10 speep
Come noto i file gcode non sono piccolissimi e nel mio caso raggiungono mediamente il Mega.
Non avendo trovato metodo migliori per controllare il baffer della SoftwareSerial, mi sono inventato un
diciamo protocollino.
Android:
manda una stringa pari ad una riga di gcode (sempre meno di 24 caratteri ex: "G0X10,30Y20,45")
e si ferma fino a quando non riceve da android "k" (carattere non contemplato nel gcode)
arduino:
ricedere la stringa, legge ogni singolo carattere da buffer e lo scrive nel file sulla SD
quando il buffer è vuoto manda ad android "k"
Se riceve "k" chiude il file ed esce dalla funzione di ricezione
Con questo sistema android trasmette sono quando il buffer di arduino è vuoto.
Il problema è il tempo richiesto per finire la scrittura del file è infinito.
BT è a 38400
In teoria 1.000.000 di caratteri nel file.
Se 1 carattere = 8 bit
1.000.000 X 8 / 38400 = 208 = secondi di trasmissione
ma la trasmissione mi dura più di 30 minuti
Vi allego la funzione di ricezione
parametri generali
#include <SD.h> // Serve un modulo lettore di schede SD o un modulo lettore di schede tf. Se non esiste una libreria di questo tipo, premere Ctrl + Maiusc + I per cercare SD dal gestore della libreria e installarlo
#include <SoftwareSerial.h> //Includiamo la libreria per la gestione delle istruzioni di utilizzo del modulo bluetooth
const int rxpin = 15; //Andiamo ad assegnare al pin 2 l’indirizzo di ricezione dati (e lo colleghiamo al pin TXD del modulo)
const int txpin = 16; //Assegnamo invece al pin 3 l’indirizzo di trasmissione dati (collegandolo al pin RXD del nostro componente
SoftwareSerial bluetooth(rxpin, txpin); //Assegnamo ad un nome (bluetooth) i suoi pin di ricezione e trasmissione, per facilitarci la scrittura del codice
int g_led = 17; // pin per un led
const int chipSelect = 4; // variabile per testare SD cart
void scrivigcode(){
// funzione per ricevere file
// riceve da BT e scrive in file du SD
// quando il buffer BT è vuoto manda a BT un "k"
//
// parallelamente andriod manda una strinza >24 carateri e siferma
// fino a quando non riveve un "K" da arduino.
// in prarica:
// android manda una stringa e si ferma attendendo un "k"
// arduino la scrive la scringa a buffer vuoto manda "k"
// sosi per tutte le rigle, se Android manda "k"
// Arduino chiuse il file
// accendo un led per segnalae inizio ricezione
digitalWrite( g_led, HIGH );
// cancelle il file su SD
SD.remove("gcode.NC");
// inizializzo il nuovo file
File dataFile = SD.open("gcode.NC",FILE_WRITE);
// inizializzo variabili utilizzate e contatori
String contenuto="";
String carat_lettSTR="";
char carat_letto;
String giro="1";
int n_pacchetti=1;
// fino a quando non è "k"
while (carat_lettSTR!="k"){
while (bluetooth.available() and (carat_lettSTR!="k")){
//Se il bluetooth riceve qualche dato e il dato non è "k"
// lo accoda al file e alla variabile "contenuto"
// il in BT è vuoto escie c porta la variable giro = 2
carat_letto = bluetooth.read() ;
// mand a monitor il bit ricevuto
Serial.print (carat_letto) ;
// scrivo il bit ricevuto nel file
dataFile.print(carat_letto);
// delay(100);
// copia la variabile come stringa
carat_lettSTR= String(carat_letto);
//accodo alla variabile contenuto
contenuto=contenuto + carat_lettSTR;
giro="2";
}
if (giro=="2"){
// se il BT è vuoto trasmetto al BT il carattere "k"
bluetooth.write("K");
giro="1";
// due if legati al contatore n_pacchetti un if accende e l'altro spegne il led
// FACCIO LAMPEGGIARE IL LED
// spento
if (n_pacchetti == 100){
digitalWrite( g_led, LOW );
n_pacchetti=1;
Serial.println ("100");
}
// acceso
if (n_pacchetti == 25){
digitalWrite( g_led, HIGH );
// Serial.println ("spento");
}
n_pacchetti++;
}
}
//il BT ha ricevuto "k" quindi la trasmissione è finita
;
// attendo
delay(100);
//spengo il led
digitalWrite( g_led, LOW );
// chiudo il file sulla SD
dataFile.close();
Serial.println("file chiuso ");
// mando a monitor il file scritto
File myFilee;
myFilee = SD.open("gcode.NC",FILE_READ);
String rriga="";
if (myFilee) {
Serial.println("file aperto");
while (myFilee.available()) {
Serial.write(myFilee.read());
}
myFilee.close();
}
}
grazie a tutti, fosse solo per la pazienza di arrivare alla fine del post.
matteo