next topic »

[on:]

Ciao a tutti, sto cercando di mandare una stringa di testo da processing ad arduino che dovrà poi essere visualizzata su un piccolo display collegato ad arduino,
il display si trova su un piccolo robot rover che comando tramite seriale bluetooth,
ho creato un'interfaccia con processing e la libreria G4P che manda comandi tramite seriale ad arduino e fa muovere il robot
e in pratica ora vorrei mandare delle stringe di testo che verranno poi visualizzate sul piccolo display
c'è qualcuno che sa aiutarmi?

Grazie, ciao.

[Reply #1 on:]

Code:

ho creato un'interfaccia con processing e la libreria G4P che manda comandi tramite seriale ad arduino e fa muovere il robot

quindi cosa ti manca? forse intendi che VORRESTI mandare i messaggi.. bhe processing ha la libreira Serial!! è molto simile a quella arduino:

http://processing.org/reference/libraries/serial/index.html

[Reply #2 on:]

Ciao lesto grazie mille per avermi risposto, allora spiego meglio il mio problema,
in pratica io già utilizzo processing con la libreria seriale e faccio muovere il mio robot via bluetooth,
esempio mandando ad arduino: w,x,a,d,s faccio muovere il mio robot avanti,indietro,destra,sinistra,fermo
ora io vorrei mandare una stringa di testo in una casella da processing, e premendo poi un pulsanti la invia ad arduino e la visualizza poi sul display

esempio: scrivo nella casella di testo "Hello Word" premo invio e la invia ad arduino che la visualizza sul display.

E da ieri pomeriggio che ci provo ma niente da fare, non riesco a capire in che modo devo fare

spero di essermi spiegato ciao.

[Reply #3 on:]

io farei così, una funzione "interpreta comandi" che lancio ogni loop (di arduino):

se è disponibile ALMENO un carattere su seriale:
   leggo un carattere da seriale.
   Se è 'M' entro nella funzione "movimento":
      leggo il prossimo carattere, se è W-A-S-D muovo di consegenza, se non do errore sulla seriale ed esco dalla funzione
   se è 'D' entro nlla funzione "display":
      creo una stringa vuota
      leggo il prossimo carattere.
      se NON è '\n'(a capo)
         salvo il carattere nella stringa
     altrimenti
         stampo la stringa sul display ed esco dalla funzione
esci dalla funzione "interpreta comando"


a questo punto da processing posso scrivere:
"mwmwmadciao ho eseguito un pò di comandi, ora li esegio al contrario
mdmsms"

che fara; avanti avanti sinistra stampa "ciao ho eseguito un pò di comandi, ora li esegio al contrario"(notare il "a capo") destra indietro indietro

[Reply #4 on:]

lesto grazie ancora per la risposta, come idea la tua e giusta ed è quello che vorrei fare,
il mio problema e che non so come scrivere il pezzo di codice per la funzione del display
cioè come faccio a salvare una scritta in una variabile che arriva da seriale tramite processing
per poi scriverla sul display?

metto il codice di arduino che ho scritto

Code:

// ARDUROVER-MINI (C) 2013 Davide Gallo
// VERSIONE: 1.2
// DATA CREAZIONE: 05/02/2013
// ULTIMO AGGIORNAMENTO: 07/02/2013

#include <IRremote.h>
#include <SoftwareSerial.h>
#include <Wire.h>
#include <Servo.h>
#include <LiquidCrystal_I2C.h>
#include "pitches.h"

// DISPLAY INFO
char nome[] = "ARDUROVER-MINI";
char versione[] = "VERSIONE 1.2";

// BLUETOOTH
const int txPin = 2;
const int rxPin = 3;
SoftwareSerial bluetooth(rxPin, txPin);

// SERVO RUOTE
Servo servo_ruota_destra;   
Servo servo_ruota_sinistra;
const int pin_servo_ruota_destra = 4;
const int pin_servo_ruota_sinistra = 5;

// SERVO SENSORE ULTRASUONI
Servo servo_ultrasuoni;
const int pin_servo_ultrasuoni = 6;

// LED
const int led = 7;

// PIEZO
const int piezo = 8;
int startMelody[] = {
  NOTE_E4, NOTE_D4, NOTE_E4, 0, NOTE_F4, NOTE_D5, NOTE_C5};
int noteDurations[] = {
  8, 8, 8, 10, 4, 8, 4 };

// CONTROLLO IR
#define tasto_1 0x33B8A05F // AVANTI
#define tasto_2 0x33B8609F // INDIETRO
#define tasto_3 0x33B8E01F // SINISTRA
#define tasto_4 0x33B810EF // DESTRA
#define tasto_5 0x33B820DF // FERMO
#define tasto_6 0x33B8906F // LED ON
#define tasto_7 0x33B850AF // LED OFF
#define tasto_8 0x33B840BF // START FUNZIONE EVITA OSTACOLI
#define tasto_9 0x33B8C03F // STOP FUNZIONE EVITA OSTACOLI

const short RECV_PIN = 9;
IRrecv irrecv(RECV_PIN);
decode_results results;

// SENSORE ULTRASUONI HC-SR04
#define trigPin 10
#define echoPin 11
const int distanza_ostacolo = 20;
long duration, distance;
int leftDistance, rightDistance;

// Display LCD
LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display

// LED RGB
const int r = 15;
const int g = 16;
const int b = 17;

// SENSORE DI LUCE
int sensore_luce = A0;
int luce = 0;

// SET PRESCALE PORTE ANALOGICHE
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))

// VARIABILE PER LA FUNZIONE EVITA OSTACOLI
int funzione_evita_ostacoli = 0;

// VARIABILE PER LA FUNZIONE AUTO-LIGHT
int funzione_auto_light = 0;

// SETUP
void setup() {
  pinMode(led, OUTPUT);
  pinMode(piezo, OUTPUT);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(r, OUTPUT);
  pinMode(g, OUTPUT);
  pinMode(b, OUTPUT);
  pinMode(sensore_luce, INPUT);
  servo_ruota_destra.attach(pin_servo_ruota_destra);
  servo_ruota_sinistra.attach(pin_servo_ruota_sinistra);
  servo_ultrasuoni.attach(pin_servo_ultrasuoni);
  servo_ruota_destra.write(90);
  servo_ruota_sinistra.write(91);
  servo_ultrasuoni.write(90);
  lcd.init();
  lcd.backlight();
  lcd.print(nome);
  lcd.setCursor(0, 1);
  lcd.print(versione);
  for (int thisNote = 0; thisNote < 7; thisNote++) {
    int noteDuration = 1000/noteDurations[thisNote];
    tone(piezo, startMelody[thisNote],noteDuration);
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    noTone(piezo);
  }
  // Setta  prescale a 32
  // Riduci la durata della lettura analogica da 128 micros (standard) a 32
  sbi(ADCSRA,ADPS2);
  cbi(ADCSRA,ADPS1);
  sbi(ADCSRA,ADPS0);
  // Seriale
  Serial.begin(115200);
  bluetooth.begin(115200);
  Serial.println("ARDUROVER-MINI (c) 2013 Davide Gallo");
  // Avvia la ricezione IR
  //irrecv.enableIRIn();
}

void loop() {
  luce = analogRead(sensore_luce);

  if (funzione_evita_ostacoli == 0) {
    digitalWrite(b, HIGH);
    digitalWrite(r, LOW);
    digitalWrite(g, LOW);
  }

  /*-----DEBUG-----*/

  // SENSORE DI LUCE
  /*Serial.print("Sensore luce:");
   Serial.println(luce);
   lcd.clear();
   lcd.print("Sensore luce:");
   lcd.setCursor(0, 1);
   lcd.print(luce);
   delay(50);*/

  // SENSORE ULTRASUONI HC-SR04
  /*int distance = ping();
   distance = (duration/2) / 29.1;
   if (distance >= 200 || distance <= 0){
   Serial.println("Fuori distanza!");
   lcd.clear();
   lcd.print("Fuori distanza!");
   }
   else {
   Serial.print("DISTANZA:");
   Serial.print(distance);
   Serial.println(" cm");
   lcd.clear();
   lcd.print("Distanza:");
   lcd.setCursor(0, 1);
   lcd.print(distance);
   lcd.print("cm");
   delay(50);
   }*/

  /*-----FINE DEBUG-----*/

  // CONTROLLO REMOTO IR
  if (irrecv.decode(&results)) {
    Serial.println("Codice IR:");
    Serial.println(results.value, HEX);
    char cmd = results.value;
    switch (cmd) {
    case tasto_1:
      avanti();
      break;
    case tasto_2:
      indietro();
      break;
    case tasto_3:
      destra();
      break;
    case tasto_4:
      sinistra();
      break;
    case tasto_5:
      fermo();
      break;
    }
    irrecv.resume();
  }

  // CONTROLLO SERIALE/BLUETOOTH
  if (bluetooth.available()) {
    char cmd = bluetooth.read();
    switch (cmd) {
    case 'w':
      avanti();
      break;
    case 'x':
      indietro();
      break;
    case 'a':
      destra();
      break;
    case 'd':
      sinistra();
      break;
    case 's':
      fermo();
      break;
    case 'l':
      digitalWrite(led, HIGH);
      break;
    case 'L':
      digitalWrite(led, LOW);
      break;
    case 'o':
      if (funzione_auto_light == 0) {
        funzione_auto_light = 1;
      }
      break;
    case 'O':
      if (funzione_auto_light == 1) {
        funzione_auto_light = 0;
      }
      break;
    case 'e':
      if (funzione_evita_ostacoli == 0) {
        funzione_start();
      }
      break;
    case 'E':
      if (funzione_evita_ostacoli == 1) {
        funzione_stop();
      }
      break;
    }
  }
  // FUNZIONE AUTO-LIGHT
  if (funzione_auto_light == 1) {
    auto_light();
  }
  // FUNZIONE EVITA OSTACOLI
  if (funzione_evita_ostacoli == 1) {
    evita_ostacoli();
  }
}

// SENSORE ULTRASUONI HC-SR04
long ping()
{
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(1000);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distance = (duration/2) / 29.1;
}

manca la parte del codice che riguarda le funzioni di movimento evita ostacoli etc... non l'ho messo perché penso non serva.

[Reply #5 on:]

esattamente quello che ti ho scritto prima, tradotto in C.

inizi a salvare la stringa, non partire da questo codice ma da un progetto nuovo, poi ad unire i sorgenti è facile. se cerchi leggere stringa seriale sul forum trovi un sacco di esempi!

[Reply #6 on:]

capito, io non ho mai fatto niente di simile prima d'ora, parlo di salvare stringe ASCII
con int, oppure const int salva solo numeri interi cosa devo usare per salvare delle stringe in ASCII (lettere)?

[Reply #7 on:]

Chi ha mai parlato di int? Usa una String!

[Reply #8 on:]

Ciao, allora finalmente sono riuscito a fare ciò che voglio, ho scritto un codice di prova che mi permette di inviare una parola da seriale e poi visualizzarla sul display,
quindi ho fatto il primo passo, ora se ad esempio da seriale scrivo: ciao, sul display visualizzo correttamente la parola ciao,
però ora ho un problema, se dopo aver scritto una prima parola, ne scrivo un'altra e la invia sul display visualizzo tutte e due le parole
come faccio a cancellare il contenuto di una stringa dopo averla inviata al display?

questo è il codice che ho scritto:

Code:

#include <SoftwareSerial.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// BLUETOOTH
const int txPin = 2;
const int rxPin = 3;
SoftwareSerial bluetooth(rxPin, txPin);

// Display LCD
LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display
char nome[] = "ARDUROVER-MINI";
char versione[] = "VERSIONE 1.2";
String ContenutoTextLCD = "";
char TextLCD;

// SETUP
void setup() {
  lcd.init();
  lcd.backlight();
  lcd.print(nome);
  lcd.setCursor(0, 1);
  lcd.print(versione);
  // Seriale
  Serial.begin(115200);
  bluetooth.begin(115200);
  Serial.println("ARDUROVER-MINI (c) 2013 Davide Gallo");
  // Avvia la ricezione IR
  //irrecv.enableIRIn();
}

void loop() {
  if (Serial.available()) {
    TextLCD = Serial.read();
    ContenutoTextLCD.concat(TextLCD);
    if (ContenutoTextLCD != "") {
      Serial.println(ContenutoTextLCD);
      lcd.clear();
      lcd.print(ContenutoTextLCD);
    }
  }
}

Ciao.

[Reply #9 on:]

Aggiornamento, ho risolto inserendo una variabile che ho chiamato: inviato

Codice:

Code:

#include <SoftwareSerial.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// BLUETOOTH
const int txPin = 2;
const int rxPin = 3;
SoftwareSerial bluetooth(rxPin, txPin);

// Display LCD
LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display
char nome[] = "ARDUROVER-MINI";
char versione[] = "VERSIONE 1.2";
String ContenutoTextLCD = "";
char TextLCD;
int inviato = 0;

// SETUP
void setup() {
  lcd.init();
  lcd.backlight();
  lcd.print(nome);
  lcd.setCursor(0, 1);
  lcd.print(versione);
  // Seriale
  Serial.begin(115200);
  bluetooth.begin(115200);
  Serial.println("ARDUROVER-MINI (c) 2013 Davide Gallo");
  // Avvia la ricezione IR
  //irrecv.enableIRIn();
}

void loop() {
  if (Serial.available()) {
    TextLCD = Serial.read();
    ContenutoTextLCD.concat(TextLCD);
    if (ContenutoTextLCD != "") {
      Serial.println(ContenutoTextLCD);
      lcd.clear();
      lcd.print(ContenutoTextLCD);
      inviato = 1;
    }
  }
  else if (inviato == 1) {
    ContenutoTextLCD = "";
    inviato = 0;
  }
}

Adesso vorrei inserire un limite di caratteri, come faccio a contare quante lettere ho scritto nella stringa?

[Reply #10 on:]

non serve, sono byte di memoria sprecati basta che aggiungi dopo il print

lcd.print(ContenutoTextLCD);
TextLCD = "";

[Reply #11 on:]

Ciao Testato grazie per avermi risposto, non riesco a capire cosa vuoi dirmi,
e la stringa chiamata: ContenutoTextLCD = ""; che contiene i caratteri, se la provo ad inserisco dopo il print su display visualizzo solo l'ultima lettera,
esempio: scrivo "ciao" visualizzo solo "o", quindi ho dovuto creare una variabile chiamata: "inviato" come vedi nel codice che ho passato sopra,
in questo modo funziona perfettamente e mi cancella l'ultima parola contenuta nella stringa dopo il print sul display, se c'è un'altro modo per farlo gradisco correzioni...
Poi ora vorrei inserire un limite di caratteri, perché se scrivo una frase più lunga di 16 caratteri (che è il limite del display),
viene comunque salvata nella stringa, sul display visualizzo la frase incompleta visto il limite del display di 16 caratteri, e quindi in questo caso sarebbe uno spreco di byte

[Reply #12 on:]

prova cosi'  

Code:

void loop() {
  if (Serial.available()) {
    TextLCD = Serial.read();
    ContenutoTextLCD.concat(TextLCD);
    if (ContenutoTextLCD != "") {
      Serial.println(ContenutoTextLCD);
      lcd.clear();
      lcd.print(ContenutoTextLCD);
    }
  }
ContenutoTextLCD="";
}

per quanto riguarda il limite di caratteri mettilo su processing, non su arduino, in modo che non spedisci proprio i caratteri che poi non ti servirebbero, sono tutte funzioni che trovi in String su processing

[Reply #13 on:]

grazie per l'aiuto, comunque non mi funzionava ma bastava aggiungere un else 

Code:

void loop() {
  if (Serial.available()) {
    TextLCD = Serial.read();
    ContenutoTextLCD.concat(TextLCD);
    if (ContenutoTextLCD != "") {
      Serial.println(ContenutoTextLCD);
      lcd.clear();
      lcd.print(ContenutoTextLCD);
    }
  }
  else {
    ContenutoTextLCD="";
  }
}

adesso devo passare a processing e fare le prime prove, però non so come inviare poi il testo da processing ad arduino

devo usare port.write()?

[Reply #14 on:]

yes