bhe se non c'è nulla che setta quei valori cosa speri di ottenere?
lesto:
bhe se non c'è nulla che setta quei valori cosa speri di ottenere?
Ti ho dato solo il pezzo che si occupa di leggere!
Questo codice è scritto in gcc su un Raspberry!
(Il ciclo l'ho messo perchè mi sono reso conto che se invio due volte i dati li acquisisce).
La prova che riceve i dati è data dal fatto che quei tre dati servono:
fader1 a stabilire l'intensità di un gruppo di tre led bianchi
toggle1 accende/spegne quel gruppo
toggle2 fa lo stesso con un altro gruppo!
Non appena invio il comando per la lettura 'A' si spengono e mi invia 3 volte "-1"
int i = 0;
for(i = 0; i < 2; i++){
serialPutchar(fd, 'B');
serialPutchar(fd, fader1);
serialPutchar(fd, toggle1);
serialPutchar(fd, toggle2);
}
per favore metti i codici completi.
sicuro di non avere problemi di ram?
lesto:
per favore metti i codici completi.sicuro di non avere problemi di ram?
Arduino:
/*Controllo luci casa by Xfox, parte arduino master.
Questo programma permette di controllare tramite TouchOSC (android o iOS)
un Arduino Master e tre ATMega328 Slave. */
//Includo librerie
#include <Wire.h>
int fader1 = 0; //Valore fader uno
int toggle1 = 0; //Valore toggle uno
int toggle2 = 0; //Valore toggle due
int fader2 = 0; //Valore fader 2
int toggle3 = 0; //Valore toggle 3
int toggle4 = 0; //Valore toggle 4
int fader3 = 0; //Valore fader 3
int toggle5 = 0; //Valore toggle 5
int toggle6 = 0; //Valore toggle 6
int temp = 1;
int temporan = 0;
void setup(){
Serial.begin(9600);
//Inizializzo I2C Come master
Wire.begin();
}
long attesa = 0;
void loop(){
//Richiedo dati
if(attesa <= millis()){
attesa = millis() + 100;
Serial.print('B');
while(Serial.available() <= 0){}
delay(10);
Wire.beginTransmission(0x01); //Avvio trasferimento dati a Slave1
Wire.write(fader1);
Wire.write(toggle1);
Wire.write(toggle2);
Wire.endTransmission(); //Termino trasferimento a Slave1
delay(5);
/*
Wire.beginTransmission(0x02); //Avvio trasferimento dati a Slave2
Wire.write(fader2);
Wire.write(toggle3);
Wire.write(toggle4);
Wire.endTransmission(); //Termino trasferimento a Slave2
delay(5);
Wire.beginTransmission(0x03); //Avvio trasferimento dati a Slave3
Wire.write(fader3);
Wire.write(toggle5);
Wire.write(toggle6);
Wire.endTransmission(); //Termino trasferimento a Slave3
delay(5);
*/
}
}
void serialEvent(){
temporan = Serial.read();
if(temporan == 'A'){ //Richiesta dati iniziali
inviadatiiniziali();
Serial.flush();
}
else if (temporan == 'B'){ //Invio dati dal Raspberry
fader1 = Serial.read();
Serial.print(fader1);
delay(temp);
toggle1 = Serial.read();
Serial.print(toggle1);
delay(temp);
toggle2 = Serial.read();
Serial.print(toggle2);
delay(temp);
/*
fader2 = Serial.read();
delay(temp);
toggle3 = Serial.read();
delay(temp);
toggle4 = Serial.read();
delay(temp);
fader3 = Serial.read();
delay(temp);
toggle5 = Serial.read();
delay(temp);
toggle6 = Serial.read();
delay(temp);
*/
}
}
//Funzione di inizializzazione comunicazione
void inviadatiiniziali(){
Serial.print(fader1);
delay(temp);
Serial.print(toggle1);
delay(temp);
Serial.print(toggle2);
delay(temp);
}
Raspberry:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wiringPi.h>
#include <wiringSerial.h>
char fader1 = 0;
char toggle1 = 0;
char toggle2 = 0;
int fd;
int main(int argc, char *argv[]){
if ((fd = serialOpen ("/dev/ttyACM0", 9600)) < 0) { //Indirizzo Arduino via USB
// if ((fd = serialOpen ("/dev/ttyUSB0", 9600)) < 0) { //Indirizzo modulo xBee via USB
printf ("Unable to open serial device!!! \n");
return 1 ;
}
if (strcmp(argv[1], "Led") == 0){
if (strcmp(argv[2], "1") == 0){ //Primo gruppo di Led
if (strcmp(argv[3], "ON") == 0){ //Controllo sul Led bianchi
toggle1 = 1;
fader1 = atoi(argv[4]);
}
else if (strcmp(argv[3], "OFF") == 0)
toggle1 = 0;
else if(strcmp(argv[3], "RGB") == 0){ //Controllo Led RGB
if(strcmp(argv[4], "ON") == 0)
toggle2 = 1;
else if(strcmp(argv[4], "OFF") == 0)
toggle2 = 0;
}
}
int i = 0;
for(i = 0; i < 2; i++){
serialPutchar(fd, 'B');
serialPutchar(fd, fader1);
serialPutchar(fd, toggle1);
serialPutchar(fd, toggle2);
}
} //Fine comando Led
else if (strcmp(argv[1],"Status") == 0){
//Devo inviare un carattere per farmi ritornare i valori iniziali
serialPutchar(fd, 'A');
delay(250);
while(serialDataAvail(fd) > 0){
printf("Carattere: %c \n",serialGetchar(fd));
/*
fader1 = serialGetchar(fd);
delay(1);
toggle1 = serialGetchar(fd);
delay(1);
toggle2 = serialGetchar(fd);
delay(1);
*/
}
/*
else
printf("Dati non ricevuti!");
printf("Door status: Open/Close \tDoor lock: Y/N ");
printf("\nTemperature: X");
printf("\n\nLight status\tWhite \tRGB");
printf("\t\n1:%c \t\t%c \t%c", toggle1, fader1, toggle2);
printf("\t\n2: \t\t0-255 \t0-1");
printf("\t\n3: \t\t0-255 \t0-1");
*/
}
printf("\n");
serialClose(fd);
return 0;
}
No, non dovrei aver nessun problema di RAM!
Ad ogni modo, collegando l'arduino al raspberry ed inviando il comando per accendere le luci, ricoleggandolo (con le luci accese, è alimentato esternamente) al pc e aprendo il serial monitor dell'IDE (non si resetta poichè ho messo il condensatore come detto prima) e inviando il comando 'A' si spegne tutto e ricevo i 3 "-1"!
tu leggi -1 perchè -1 è quello che ritorna Serial.read() quando non ci sono dati in arrivo nel buffer seriale
quindi:
else if (temporan == 'B'){ //Invio dati dal Raspberry
fader1 = Serial.read();
Serial.print(fader1);
delay(temp);
toggle1 = Serial.read();
Serial.print(toggle1);
delay(temp);
toggle2 = Serial.read();
Serial.print(toggle2);
delay(temp);
/*
fader2 = Serial.read();
delay(temp);
toggle3 = Serial.read();
delay(temp);
toggle4 = Serial.read();
delay(temp);
fader3 = Serial.read();
delay(temp);
toggle5 = Serial.read();
delay(temp);
toggle6 = Serial.read();
delay(temp);
*/
}
diventa:
else if (temporan == 'B'){ //Invio dati dal Raspberry
while(Serial.available < 1){
;//non fa nulla, aspetta per almeno un carattere
}
fader1 = Serial.read();
Serial.print(fader1);
delay(temp);
while(Serial.available < 1){
;//non fa nulla, aspetta per almeno un carattere
}
toggle1 = Serial.read();
Serial.print(toggle1);
delay(temp);
while(Serial.available < 1){
;//non fa nulla, aspetta per almeno un carattere
}
toggle2 = Serial.read();
Serial.print(toggle2);
delay(temp);
}
Ma non è quello il problema!
Il problema è quando l'arduino riceve 'A' è deve inviare i dai tramite inviadatiiniziali() al raspberry!
E' appunto il raspberry che legge -1! Quando do il comando per dire al raspberry di richiedere i dati, l'arduino spegne le luci e invia tre volte "-1"
Edit.
L'attesa del carattere è inserita già nel loop:
while(Serial.available() <= 0){}
Dato che quel codice è inserito direttamente nella funzione serialEvent() quel codice viene eseguito solo quando c'è qualcosa nel buffer seriale no?
il problema non quando leggi A o B, ma quando leggi B dopo fai delle altre read che non aspettano.. ti ho pure postato il codice corretto.....................
lesto:
il problema non quando leggi A o B, ma quando leggi B dopo fai delle altre read che non aspettano.. ti ho pure postato il codice corretto.....................
Allora....
Quando il Raspberry invia il carattere 'A', l'arduino deve inviare le variabili "fader1","toggle1" e "toggle2" (il problema è che quando il raspberry legge questi valori legge -1 -1 -1).
Quando il Raspberry invia il carattere 'B' invia anche i valori che io decido di inviare dal pc! Dunque invierà per esempio B 130 1 1, dove 130 sarà il valore di fader1 e toggle1 e toggle2 avranno il valore 1;
Tutto funziona quando invio i dati DAL raspberry ALL' arduino! Si accendono le luci in maniera corretta!
Se io poi invio il carattere 'A', DAL raspberry ALL'arduino, quest'ultimo mi dovrebbe ritornare riinviare (al raspberry) gli ultimi valori di fader1, toggle1 e toggle2, ma come detto prima invia -1 -1 -1!
Edit.
E' come se a ogni volta che do un comando (e viene inviato il comando di apertura della porta seriale) si resettasse tutto! Nonostante ci sia il condensatore da 100uF!
allora si accende il led ul pin 13, perche esso lampeggia semrpe quando il chip è resettato
lesto:
sicuro che non lampeggi il led sul pin 13?
lesto:
allora si accende il led ul pin 13, perche esso lampeggia semrpe quando il chip è resettatolesto:
sicuro che non lampeggi il led sul pin 13?
No, non si accende! Ecco perchè è molto strano! Ogni volta che chiamo il comando sul raspberry per inviare i dati (e di conseguenza invia il comando per aprire la porta seriale e chiuerla) il programma resetta i valori! Infatti se fai caso al codice per il raspberry il comando per il toggle 2 è diviso dal toggle1 infatti quando accendo un gruppo di led, non posso accendere l'altro insieme perchè sull'arduino si resetta quella variabile!
non è come se si resetta!
int fader1 = 0; //Valore fader uno
int toggle1 = 0; //Valore toggle uno
int toggle2 = 0; //Valore toggle due
int fader2 = 0; //Valore fader 2
int toggle3 = 0; //Valore toggle 3
int toggle4 = 0; //Valore toggle 4
int fader3 = 0; //Valore fader 3
int toggle5 = 0; //Valore toggle 5
int toggle6 = 0; //Valore toggle 6
quindi resettando leggeresti 0... l'unico modo che hai per leggere -1 è che stai leggendo il buffer seriale quando è vuoto.
lesto:
non è come se si resetta!char fader1 = 0;
char toggle1 = 0;
char toggle2 = 0;
quindi resettando leggeresti 0... l'unico modo che hai per leggere -1 è che stai leggendo il buffer seriale quando è vuoto.
Lo pensavo io, dunque mentre le luci sono accese ho scollegato l'arduino dal raspberry e l'ho attaccato al pc, aperto il monitor seriale e inviato il carattere 'A', ricevo -1 -1 -1.
Con il monitor seriale, se fosse come dici tu, non dovrebbe succedere poichè lui legge solo quello che c'è!
Vuoi toglierti i dubbi? Metti nel setup la stampa di un messaggio:
void setup() {
........ il tuo codice
Serial.println("Avvio programma!");
}
Se compare quella scritta, l'Arduino si è resettato ed hai ragione tu. Se non ricompare mai, l'Arduino NON si è resettato ed ha ragione lesto... Su, prova... 
leo72:
Vuoi toglierti i dubbi? Metti nel setup la stampa di un messaggio:void setup() {
........ il tuo codice
Serial.println("Avvio programma!");
}
Se compare quella scritta, l'Arduino si è resettato ed hai ragione tu. Se non ricompare mai, l'Arduino NON si è resettato ed ha ragione lesto... Su, prova... ;)
NON si resetta! Allora dove sta il problema?
Perchè appena invio il comando A, le tre variabili assumono il valore -1.
-1 non equivale a null? Cioè non dichiarata/esistente?
Xfox:
NON si resetta! Allora dove sta il problema?
In quello che ti ha detto lesto.
Perchè appena invio il comando A, le tre variabili assumono il valore -1.
-1 non equivale a null? Cioè non dichiarata/esistente?
No. Il valore di "null" è zero, 0.
Un char può assumere valori da -128 a +127.
Il metodo read della seriale, come ti ha detto lesto, restituisce -1 quando non riesce a leggere nulla. Ecco l'estratto dal codice presente nel file HardwareSerial.cpp.
int HardwareSerial::read(void)
{
// if the head isn't ahead of the tail, we don't have any characters
if (_rx_buffer->head == _rx_buffer->tail) {
return -1;
} else {
unsigned char c = _rx_buffer->buffer[_rx_buffer->tail];
_rx_buffer->tail = (unsigned int)(_rx_buffer->tail + 1) % SERIAL_BUFFER_SIZE;
return c;
}
}
Non è l'arduino che legge "-1", l'arduino invia "-1".
Al primo avvio però se prima di inviare dati (tramite 'B') invio semplicemente 'A', mi risponde con i tre 0 com'è giusto che sia, dopo che invio i dati DAL RASPBERRY ALL'ARDUINO, e si accendono le luci, se invio 'A' per chiedere questi dati indietro, si spegne tutto e l'arduino invia tre volte -1.
Il problema è che sul serial monitor io non chiedo di leggere quando non ci sono dati, poichè il serial monitor, appunto, legge solo quello che viene inviato dall'arduino! E l'arduino invia tre volte "-1"
l'arduino INVIA -1 perchè a priori HA LETTO -1, altrimenti invierebbe 0 oppure il valore precedente
edit: prova a cmandarlo da serial monitor, vedrai come si comporta!
lesto:
l'arduino INVIA -1 perchè a priori HA LETTO -1, altrimenti invierebbe 0 oppure il valore precedente
Prendiamo in esame la funzione:
void serialEvent(){
temporan = Serial.read();
if(temporan == 'A'){ //Richiesta dati iniziali
inviadatiiniziali();
}
else if (temporan == 'B'){ //Invio dati dal Raspberry
fader1 = Serial.read();
delay(temp);
toggle1 = Serial.read();
delay(temp);
toggle2 = Serial.read();
delay(temp);
}
}
Io dal raspberry invio:
serialPutchar(fd, 'B');
serialPutchar(fd, fader1);
serialPutchar(fd, toggle1);
serialPutchar(fd, toggle2);
E l'arduino legge correttamente!
Successivamente io dal raspberry invio:
serialPutchar(fd, 'A');
delay(250);
while(serialDataAvail(fd) > 0){
printf("Carattere: %c \n",serialGetchar(fd));
Dunque l'arduino mi dovrebbe ritornare indietro i valori precedentemente inviati!
Così il raspberry mostra a video tramite il printf ciò che legge! CARATTERE PER CARATTERE!
Ecco quello che esce:
-
1
-
1
-
1
Xfox:
Io dal raspberry invio:
tira il freno a mano e analizza quello che invii dal Rasp PRIMA di inviare quel comando.
lesto:
Xfox:
Io dal raspberry invio:tira il freno a mano e analizza quello che invii dal Rasp PRIMA di inviare quel comando.
Invia il carattere 'A'.
Come fa con il carattere 'B', e poi invia i dati, correttamente ricevuti dall'arduino (dico che sono correttamente ricevuti perchè le luci si accendono e posso anche variare la luminosità modificando il valore di fader1).
Ripeto che se invio per esempio il comando per accendere un gruppo di led (impostando toggle1 a 1), e poi invio un altro comando per accendere un secondo gruppo (impostando toggle2 a 1), il primo gruppo si spegne! Come se le variabili, sull'arduino, ripartissero da zero!