next topic »

[Reply #15 on:]

Niki hai codice a disposizione? O comunque un po' di documentazione? E' una cosa interessante e potrebbe aiutare Wonder!

Comunque la cosa era assai semplice, leggevo lo stato logico del pin collegato alla gettoniera con debounce di 100ms
Ad ogni lettura a livello logico basso corrispondeva un impulso della gettoniera, in quella installazione gestivo solo monete da 50cent, 1 euro e 2 euro, 50 centesimi = 1 impulso , 1 euro 2 impulsi, 2 euro 4 implusi .
Nella peggiore ipotesi dei 2 euro impiega c.a. 400ms per leggere tutto il treno.Impostando diversamente la gettoniera ed il debounce si può anche scendere, ma mi sembrano tempi accettabili per un riconoscitore di denaro!


Sicuramente posso dirti che hai frainteso come funziona la modalità multiimpulso,i tempi che hai ipotizzato sono veramente biblici.

E probalile che abbia frainteso o non la chiamiamo allo stesso modo.
le differenze di tempo possono anche essere dovute all'unità di misura, mi sembra giusto che se usi 50 Cent e l'unita di conteggio è quella sono 400 ms
nel mio caso invece l'unità di misura è 10 cent  e l'accetttazione di una moneta di 2 euro dura almeno 2 sec con la modalità che usi tu
probabilmente non è la stessa che sto verificando io perchè in una configurazione con scheda  I/O=originale (relè che si eccita ad ogni impulso) una moneta da 2 euro viene acquisita in 6 sec. 

Scusa se mi permetto ancora wonder ma mi sembra veramente (come hai anche tu stesso ammesso) che ti stai veramente complicando tanto la vita per nulla!

si me la sto complicando sicuramente perchè in origine volevo la comunicazione rs232 dove  il dato che la gettoniera sputa è quello e non va interpretato.

se mi aiutate a risolvere il problema di comunicazione seriale elimino anche tutti i dubbi su come interfacciarmi alla gettoniera.

qui sotto il codice di base
è un esempio base dove in teoria trasferisco i dati seriali da serial monitor verso gettoniera e viceversa.

Code:

#include <SoftwareSerial.h>
#include <icrmacros.h>



SoftwareSerial mySerial(6, 7);

int inByte = 0;
int outByte = 0;
void setup() {
 
  Serial.begin(9600);
  mySerial.begin(9600);

}

void loop() {
  // read from port 0, send to port 1:
  if (Serial.available()) {
    int outByte = Serial.read();
  //  Serial.println("comando");
    mySerial.print(outByte,HEX);

  }
  // read from port 1, send to port 0:
 if (mySerial.available()) {
    int inByte = mySerial.read();
    Serial.println("Risp. gettoniera");
    Serial.print( inByte,HEX);
  }
}

beh non funziona proprio
quello che deve fare è questo:
da serial monitor spedendo il comando 00 1D metto la gettoniera in attesa moneta.
quando la moneta viene letta, la gettoniera dovrebbe rispondere con 2 byte in esadecimale con il valore della moneta.

già con il solo comando 00 la gettoniera dovrebbe risponde con 00 00 (verificato con un terminale e una connessione diretta tra rs232 pc e gettoniera)
da serial monitor tramite arduino ho provato a inserire 00, 0, 0x00, (0x00) ma non ottengo mai una risposta dalla gettoniera.

ditemi dove sto sbagliando per favore  perchè sta cosa mi sta facendo andare fuori di testa

ciao ciao

[Reply #16 on:]

Forse ho capito cosa non funziona , ma prendilo con le pinze!

A parte tutto il tuo ragionamento contorto che stai facendo che non voglio approfondire, forse il problema risiede sul fatto che tu scrivendo da serial monitor 00, col codice che hai poi non vai ad inviare il valore hex di 00, ma bensi 30 30 (che dovrebbe essere il valore ascii dei caratteri 0) e se cosi fosse la gettoniera è normale che non ti risponde.
Prova a modificare il codice forzando poi l'invio alla gettoniera di un byte 0 e vedi cosa succede.

Code:

#include <SoftwareSerial.h>
#include <icrmacros.h>



SoftwareSerial mySerial(6, 7);

int inByte = 0;
int outByte = 0;
void setup() {
 
  Serial.begin(9600);
  mySerial.begin(9600);

}

void loop() {
  // read from port 0, send to port 1:
  if (Serial.available()) {
    int outByte = Serial.read();
    outByte = 0;
  //  Serial.println("comando");
    mySerial.print(outByte,HEX);

  }
  // read from port 1, send to port 0:
 if (mySerial.available()) {
    int inByte = mySerial.read();
    Serial.println("Risp. gettoniera");
    Serial.print( inByte,HEX);
  }
}

[Reply #17 on:]

Forse ho capito cosa non funziona , ma prendilo con le pinze!

A parte tutto il tuo ragionamento contorto che stai facendo che non voglio approfondire, forse il problema risiede sul fatto che tu scrivendo da serial monitor 00, col codice che hai poi non vai ad inviare il valore hex di 00, ma bensi 30 30 (che dovrebbe essere il valore ascii dei caratteri 0) e se cosi fosse la gettoniera è normale che non ti risponde.
Prova a modificare il codice forzando poi l'invio alla gettoniera di un byte 0 e vedi cosa succede.

Code:

#include <SoftwareSerial.h>
#include <icrmacros.h>



SoftwareSerial mySerial(6, 7);

int inByte = 0;
int outByte = 0;
void setup() {
 
  Serial.begin(9600);
  mySerial.begin(9600);

}

void loop() {
  // read from port 0, send to port 1:
  if (Serial.available()) {
    int outByte = Serial.read();
    outByte = 0;
  //  Serial.println("comando");
    mySerial.print(outByte,HEX);

  }
  // read from port 1, send to port 0:
 if (mySerial.available()) {
    int inByte = mySerial.read();
    Serial.println("Risp. gettoniera");
    Serial.print( inByte,HEX);
  }
}

ho provato a fare come dici tu... nessun risultato positivo
se ho capito la tua modifica, qualsiasi cosa scrivo in serila monitor, viene trasmesso uno 0 alla gettoniera.

per scrupolo ho anche eliminato il cavo di connessione originale della gettoniera che è provvisto di max232 e mi sono collegato direttamente dai pin  6 7 di arduino ai pin rx tx della gettoniera
il collegamento che ho fatto in entrambi i casi sono i classici rx arduino >tx gett / tx arduino> rx gett.  + ground.
mannaggia che inghippo

[Reply #18 on:]

Bhe, pensandoci bene in effetti con serial.print la cosa non dovrebbe essere cambiata molto.

la cosa più corretta sarebbe usare Serial.write(0) , in questa maniera hai la certezza che viene inviato il byte 0 alla seriale.

Serial.print() secondo la documentazione recita : Prints data to the serial port as human-readable ASCII text.

Quindi in sostanza non va bene.

Parlo empiricamente basandomi sulla teoria, perchè in pratica al momento sono impossibilitato dal provare.

[Reply #19 on:]

Bhe, pensandoci bene in effetti con serial.print la cosa non dovrebbe essere cambiata molto.

la cosa più corretta sarebbe usare Serial.write(0) , in questa maniera hai la certezza che viene inviato il byte 0 alla seriale.

Serial.print() secondo la documentazione recita : Prints data to the serial port as human-readable ASCII text.

Quindi in sostanza non va bene.

Parlo empiricamente basandomi sulla teoria, perchè in pratica al momento sono impossibilitato dal provare.

anche io avevo provato il serial.write ma questo da un problema con compilazione, pare che non accetti valori di 2 byte,
ti allego l'errore compilando con serial.write

sketch_dec14a.cpp: In function ‘void loop()’:
sketch_dec14a:23: error: call of overloaded ‘write(int)’ is ambiguous
/home/pic/arduino-1.0/libraries/SoftwareSerial/SoftwareSerial.h:92: note: candidates are: virtual size_t SoftwareSerial::write(uint8_t)
/home/pic/arduino-1.0/hardware/arduino/cores/arduino/Print.h:49: note:                 size_t Print::write(const char*)

[Reply #20 on:]

Ma infatti non devi mandare dati di 2 byte !!
Devi mandare 0, un solo byte , poi eventualmente 13, che è il famoso OD.

Non a caso nell'esempio sopra ti avevo messo Serial.write(0).

Tu che hai messo?

P.S. se non compila prova con  Serial.write((byte)0)

[Reply #21 on:]

Ma infatti non devi mandare dati di 2 byte !!
Devi mandare 0, un solo byte , poi eventualmente 13, che è il famoso OD.

Non a caso nell'esempio sopra ti avevo messo Serial.write(0).

Tu che hai messo?

P.S. se non compila prova con  Serial.write((byte)0)

ti riporto qui sotto il codice scritto sotto tuo consiglio, cosi compila e funziaona se non altro risponde allo 0, ho lasciato le istruzioni commentate cosi tu possa vedere anche le varianti fatte.
se uso solo l invio dello 0 per farmi rispondere mi risponde con uno 0 e fin qui è fantastico..... GRAZIE
se tento di inviare un 13 che è 1D, prima di tutto devo mettere l'opzione "Carriage Return" su serial monitor altrimenti mi sputa fuori dati a caso senza aspettare l'introduzione della moneta.
comunque sia con CR i dati di risposta sono sempre diverisi
5

FF20

0B0

2D7D

053

FFFFFFFF5

FF1E

0B0

2F7F

050

FFFFFFFF
questi sono 2 introduzioni di moneta da 2 euro i tanti fffff sono la ultima riga scritta dopo l'introduzione della moneta

Code:

#include <SoftwareSerial.h>
#include <icrmacros.h>



SoftwareSerial mySerial(6, 7);

int inByte = 0;
int outByte = 0;
void setup() {
 
  Serial.begin(9600);
  mySerial.begin(9600);

}

void loop() {
 
  // read from port 0, send to port 1:
  if (Serial.available()) {
    int outByte = Serial.read();
    outByte = 0;
  //  Serial.println("comando");
      mySerial.write((byte)0); //comando di inizio comunicazione
     
     
      //mySerial.write(0);

  }
 
  // read from port 1, send to port 0:
 if (mySerial.available()) { //attesa risposta al 0 del serial monitor
 int inByte = mySerial.read();
 Serial.println ( inByte,HEX);
  mySerial.write((byte)13); //comando 1D
   
   
     inByte = mySerial.read();
   
   // Serial.print("Risp. gettoniera");
   // Serial.println ((byte)inByte);
     //mySerial.write((byte)13);
     Serial.print ( inByte,HEX);
     
     
  }
 
}

hai qualche idea? 

[Reply #22 on:]

mi sono accorto che 1D corrispondea a 29 e non 13 ho ricompilato con il nuovo valore e la risposta della gettoniera è comunque sempre diversa ......
 

[Reply #23 on:]

Code:

[code][quote author=Wonder link=topic=82767.msg624436#msg624436 date=1323888345]
[quote author=niki77 link=topic=82767.msg624310#msg624310 date=1323879992]
Ma infatti non devi mandare dati di 2 byte !!
Devi mandare 0, un solo byte , poi eventualmente 13, che è il famoso OD.

Non a caso nell'esempio sopra ti avevo messo Serial.write(0).

Tu che hai messo?

P.S. se non compila prova con  Serial.write((byte)0)
[/quote]

ti riporto qui sotto il codice scritto sotto tuo consiglio, cosi compila e funziaona :) se non altro risponde allo 0, ho lasciato le istruzioni commentate cosi tu possa vedere anche le varianti fatte.
se uso solo l invio dello 0 per farmi rispondere mi risponde con uno 0 e fin qui è fantastico..... GRAZIE
se tento di inviare un 13 che è 1D, prima di tutto devo mettere l'opzione "Carriage Return" su serial monitor altrimenti mi sputa fuori dati a caso senza aspettare l'introduzione della moneta.
comunque sia con CR i dati di risposta sono sempre diverisi
5

FF20

0B0

2D7D

053

FFFFFFFF5

FF1E

0B0

2F7F

050

FFFFFFFF
questi sono 2 introduzioni di moneta da 2 euro i tanti fffff sono la ultima riga scritta dopo l'introduzione della moneta


[code]
#include <SoftwareSerial.h>
#include <icrmacros.h>



SoftwareSerial mySerial(6, 7);

int inByte = 0;
int outByte = 0;
void setup() {
 
  Serial.begin(9600);
  mySerial.begin(9600);

}

void loop() {
 
  // read from port 0, send to port 1:
  if (Serial.available()) {
    int outByte = Serial.read();
    outByte = 0;
  //  Serial.println("comando");
      mySerial.write((byte)0); //comando di inizio comunicazione
     
     
      //mySerial.write(0);

  }
 
  // read from port 1, send to port 0:
 if (mySerial.available()) { //attesa risposta al 0 del serial monitor
 int inByte = mySerial.read();
 Serial.println ( inByte,HEX);
  mySerial.write((byte)13); //comando 1D
   
   
     inByte = mySerial.read();
   
   // Serial.print("Risp. gettoniera");
   // Serial.println ((byte)inByte);
     //mySerial.write((byte)13);
     Serial.print ( inByte,HEX);
     
     
  }
 
}

hai qualche idea? 
[/quote]


STUPENDO!!!!!
ho risolto il problema di lettura errata, avevo sbagliato la posizione della istruzione che invia 1D
una volta messo uno dietro l'altro senza attendere la risposta, i dati sono coerenti
[/code]
  if (Serial.available()) {
    int outByte = Serial.read();
    outByte = 0;
  //  Serial.println("comando");
      mySerial.write((byte)0); //comando di inizio comunicazione
     mySerial.write((byte)29); //comando 1D
[/code]

Voglio  ringraziarti niki77 per il supporto, per ora smanetto con quello che ho/abbiamo raggiunto... dovrò sicurmante scomodarti in futuro...
sto molto meglio ora

[Reply #24 on:]

Ciao,

HO un altro Problema ma penso che sia una stupidata anche se non riesco a risolverlo...

ho sviluppato il codice mescolando alcuni fatti tra loro e mi sono accorto di questo
quando faccio la lettura da mySerial (vedi asterischi)
dovrei leggere 2 byte di seguito per poi metterli in "inByte" e utilizzarlo per i miei calcoli...
però mi fa uno scherzo, prima mi legge un byte... poi continua il programma e poi torna al leggere il byte restante.
come posso ovviare a quato porblema ?

Code:

#include <SoftwareSerial.h>
#include <icrmacros.h>



SoftwareSerial mySerial(6, 7);
int c=0;
int cm = 0;
int cm1 = 0;
int cm2 = 0;
int cm3 = 0;
int cm4 = 0;
int cm5 = 0;
float val1;
float val2;
float val3;
int val4;
int val5;
float somma;
int inByte = 0;
int outByte = 0;
void setup() {
  val1 = 0;
  val2 = 0;
  val3 = 0;
  val4 = 0;
  val5 = 0;
  somma = 0;
 
  Serial.begin(9600);
  mySerial.begin(9600);

}


void loop() {

  // read from port 0, send to port 1:
  if (Serial.available())
  {

    int outByte = Serial.read();
    outByte = 0;
    //  Serial.println("comando");
    mySerial.write((byte)0); //comando di inizio comunicazione
    mySerial.write((byte)29); //comando 1D

    //mySerial.write(0);

  }

  // read from port 1, send to port 0:
  if (mySerial.available()) { //attesa risposta al 0 del serial monitor


*******     int inByte  = mySerial.read(); *********



     Serial.print ( inByte);

delay (10);





    if ( ( inByte) == 1281 ){

      val1 = val1 + 0.1; //somma i vaolri delle monete
      cm1 = cm1++;        //conta il numero di monete per ogni canale

    }




    if ( ( inByte) == 1282 ){

      val2 = val2 + 0.2;
      cm2= cm2++;

    }





    if ( ( inByte) == 1285 ){ 


      val3 = val3  + 0.5;
      cm3= cm3++;

    }




    if ( ( inByte) == 12810 ){

      val4 =  val4 + 1;
      cm4= cm4++;

    }





    if ( ( inByte) == 12820 ){
      //delay (40);
      val5 = val5 + 2;
      cm5= cm5++;

    }

    somma = (val1 + val2 + val3 + val4 + val5);


    Serial.println ("somma");
    Serial.println (somma);
    Serial.println ("Valore per moneta");
    Serial.println (val1);
    Serial.println (val2);
    Serial.println (val3);
    Serial.println (val4);
    Serial.println (val5);
    Serial.println ("n monete per tipo");
    Serial.println (cm1);
    Serial.println (cm2);
    Serial.println (cm3);
    Serial.println (cm4);
    Serial.println (cm5);
  }
}

il codice è un po "sporco" ma tecnicamente funziona con le dovute modifiche

[Reply #25 on:]

Bravo, vedi che alla fine hai risolto?

a questo punto io invece di usare

if(Serial.available())
{
blocco codice lettura
}

farei un bel:

while(Serial.available())
{
blocco codice lettura
l'iterazione a questo interno continuerà fintanto che ci saranno byte da leggere
}

ovviamente se la lunghezza dei dati da leggere è fissa e la sai prima è più consigliato un ciclo for

if(Serial.available())
{
for(int i = 0 ; i < lunghezzadaleggere ; i++)
{
lettura del byte
}
}

Invece se come ho capito devi solo leggere 2 byte è ancor più semplice:

if(Serial.available())
{
int hn = Serial.read();
int ln = Serial.read();
cosi hai in hn il primo valore ed in ln il secondo
}

Saluti.