Hi,
you can try something like


SoftwareSerial _gprs;

...

_gprs.println("AT+CCLK?");
_gprs.flush();
      
            
   while(_gprs.available()!=0)
   {   
      delay(300);
      Serial.print(_gprs.read());         
   }

Hi,
did you try to set the tx rx pin of 7 and 8

Nel wiki ho letto questo:
Quote
When using GPRS Shield with Seeeduino Stalker v2.0 please remember to dismount the OK_READ Jumper (i.e. open it). This will disconnect the Battery Charger IC's OK pin from the microcontrollers Digital Pin 7 and hence allow unhindered communication with GPRS Shield using NewSoftSerial Library.

dalla versione 2.2 in poi non c'è più quel jumper, a quanto pare è stata resa compatibile con il GPRS. Escludo anche un difetto della stalker perchè ne ho due e altri due di GPRS e non vanno.

Poi dovresti controllare i livelli dei segnali, perché Arduino lavora a 5V, la Stalker a 3.3V e il GPRS a 2.8V.   

dovrei essere apposto ho provato singolarmente ognuno e funzionano

Ciao, ho un problema con la Seeeduino Stalker v2.3, in pratica sembra non comunicare con la shield GPRS  1.4 sempre della Seeeduino, non ho capito se ci sono settaggi "particolari" da fare per l'uso della stalker, leggendo la pagine wiki non ho trovato niente (spero di sbagliarmi), fatto è che se uso Arduino UNO con questa shield GPRS funziona tutto, e lo sketch e sempre lo stesso.

Grazie per l'aiuto

Ciao, usare PROGMEM  per archiviare le stringhe in flash ti aiuta a risparmiare RAM, è utile se hai tante stringhe, ma per poter usare le stringhe devi recuperala dalla flash e caricarle in RAM, ad ogni modo provo a farti un piccolo esempio di come lo sto usando io, spero che il codice sia chiaro

Code:

#include <avr/pgmspace.h>
 
prog_char CIP [] PROGMEM = {"<a href='/accendi0'>Accendi LED 0</a><br/><a href='/spegni0'>Spegni LED 0</a><br/>"};
char *buf;


void setup() {   
  Serial.begin(9200); 
}

void loop() {
 
  SendATCmdWaitRespP(CIP);
  Serial.println(buf);
  delay(2000);
  free(buf); //importante
 
}

void SendATCmdWaitRespP(prog_char *str)
{
        buf = (char *) malloc(LenP(str)*sizeof(char));
byte i=0;
       
for (char c; (c = pgm_read_byte (str)); str++)
      buf[i++] = c;
       
        buf[i] = '\0';              
}

byte LenP(prog_char *str)
{
byte i=0;
       
        for (char c; (c = pgm_read_byte (str)); str++)
i++;               

return i;
}

magari c'è un modo migliore  e imparo anch'io.

usa direttamente la Stringa per creare un array char cosi puoi accodarlo alla stringa di invio

Code:

   
    ....
     char cVal[6];
     Z.toCharArray(cVal, 6) ;
   
      char *mychar = strcat("/data_rx/ricezione_data.php?seriale=98890211&campo=",cVal);
   
   
    Serial.println(mychar);

    inet.httpGET("www.miosito.it",80,mychar,msg,50);

devo aver fatto un po di pasticci... credevo di aver risposto ma non vedo il mio post 

allora il metodo che ti ho scritto prima lo devi mettere nella libreria, e come ti dicevo magari esiste già un metodo simile cmq... dopo nel tuo sketch dovresti scrivere una cosa del genere

Code:

   char res[30];

   ...
   gsm.SimpleWriteIn("AT+CSQ");
   delay(5000);
   gsm.WhileSimpleRead(res); //nella res trovi la stringa di risposta
   

dopo puoi cercare nel array "res" quello che ti serve, come ha detto cyberhs, il volore trovato puoi costruirti una nuova stringa e inviarla ("/pagina.php?segnale="+valore trovato) oppure usarlo nelle condizioni che dicevi prima.

ah dimenticavo magari nel metodo che aggiungi alla classe metti il fine stringa '\0' a ogni assegnazione

Ciao, prova ad aggiungere questo metodo nella classe SIM900

Code:

void SIMCOM900::WhileSimpleRead(char *res)
{
char datain;
while(_cell.available()>0){
datain=_cell.read();
if(datain>0){
*res = datain;
res++;
Serial.print(datain);
}
}
}

non so se esiste già un metodo di simile nella classe SIM900, cosi la risposta AT la metti nel buffer char che gli passi, poi lo leggi selezionando quello che ti serve come ha detto cyberhs

e se modifichi il metodo getString aggiungendo da quale punto vuoi iniziare a leggere, provo a fare un esempio

Code:

//questo nella libreria
int TextFinder::getString( char *pre_string, char *post_string, char *buffer,int start, int length)
  { 
    if( find(pre_string) ){
      int index = 0;   
      *buffer = 0;
      while(index < length-1 ){
       
char c = myRead();

if(start == 0)
{       
if( c == 0 ){
return 0;   // timeout returns 0 !
}
else if( c == *post_string ){
buffer[index] = 0; // terminate the string
return index;               // data got successfully
}
else{
buffer[index++] = c;   
}
}
else
{
start--;
}
      }
 
      buffer[index] = 0;
      return index; // Note: buffer full before the closing post_string encountered
    }   
    return 0;    //failed to find the prestring
  }

// le tuo codice fai una cosa tipo
 
char myAvviso[500];
  int len = 0; 
 
  while (client.available()) {             
len = len + finder.getString("title","studenti",myAvviso,len,500);
--aggiungo myAvviso[] i in una memoria + grande esempio SD
  }

non so se funziona non l'ho provato ma vedi se può esserti utile

Ciao, non credi che cosi corri il rischio di usare tutta la memoria? e se per lo stop del loop ti fai mandare il numero di caratteri che il client intende inviare?

Ciao

Ciao, sono d'accordo con Superp anche se in modo inverso, considerando Arduino_A come un master e usando il B come una periferica, comunque questi due modi hanno senso se l'applicazione deve avere un livello di affidabilità alto, se no corri il rischio di scrivere un sacco di codice.
Facendo conto che l'applicazione ha un altro livello di affidabilità, e vista la scarsa disponibilità di pin su Arduino_A la SD potresti metterla su Arduino_B, questo non ti aiuta perché se capita di non avere connessione seriare tra A e B questa dovrà essere gestita.

uhmmm posta il codice della liibreria che usi

la libreria è questa http://arduino.cc/playground/Code/AvailableMemory

per capire cosa realmente sta succedendo, ti consiglio di stampare gli indirizzi delle funzioni, degli array e anche delle variabili locali. così capiamo dove sta il problema.

ho fatto cosi e in effetti ho visto che, se il vet2 viene creato come un "normale" vettore il ciclo for(...)  assegna e stampa il vet2, anche se questo supera di gran lunga la memoria disponibile non si fa scrupoli a sovrascrivere gli stessi indirizzi, tutto cambia se alloco memoria al vettore con malloc, perché se supero la memoria disponibile ho un blocco del programma appena parte, diversamente quando ho spazio libero la freeMemory() ritorna i giusti valori.

Ho avuto lo stesso comportamento della malloc chiamando alla fine della funzione free(vet2).

grazie per l'aiuto

due cose:
-te stai dichiarando un vettore,lo riempi e non usi i valori..forse ti sega anche questo(se compilasse con l'opzoine -O3 nn me ne stupirei)
-sulla malloc con 9000 bisogna considerare che a volte può fallire..solitamente in questo caso ritorna NULL..ma se te non fai controlli del tipo puntatoreRitornato!=NULL,potresti andare a scrivere in qlk area di memoria..quindi andresti a scrivere dall'indirizzo 0 in poi..e dato che usi un'architettura harvard,non rischi di sovrascivere il codice,ma solo i dati..quindi non ti pianti subito..

Nel codice che ho postato la print del valore del vettore è commentata ma ho provato anche a stampare il valore quindi ci accedo e lo uso.

Per quanto riguarda l'esempio dei 9000byte non ho usato il codice della malloc ma quello in cui dichiaro il vettore come variabile nella funzione e oltre a scriverci dentro stampo anche i singoli valori, com'è possibile?

a occhio direi che il compilatore ignora il vettore2..tieni conto che nelle ottimizzazioni elimina variabili/array e funzioni non utilizzate,può cancellare di brutto i for e tante altre cose...
e te dichiari vettori non utilizzati..

Si ok ma come vedi nella funzione ho sia scritto nel vettore2 ed anche stampato, e il risultato non cambia. Ma la cosa più assurda è che se il vet2 lo dichiaro di 9000byte ed eseguo tutto funziona come prima! Dove le prende 9000byte?

Altra prova se nella funzione anziché allocare dichiarando il vettore lo vado ad allocare dinamicamente con la malloc tutto funziona seconda la logica.

Code:

#include <FreeMemory.h>

#define LEN_VET 1024
#define LEN_VET2 300

byte vet1[LEN_VET];


void setup() {                 
  Serial.begin(19200);
 
  Serial.println(freeMemory());
 
  for(int i=0;i<LEN_VET;i++) {
    vet1[i] = i;
  } 

  Serial.println(freeMemory()); 
  gen();   
  Serial.println(freeMemory());   
}

// the loop routine runs over and over again forever:
void loop() {        //...
}
void gen()
{
    byte *vet2;
    //byte vet2[LEN_VET2];   
    vet2 = (byte *) malloc(LEN_VET2 * sizeof(byte));
     
           
     for(int i=0;i<LEN_VET2;i++) {
        vet2[i] = 100;
        //Serial.println(vet2[i]);
     }
     Serial.println(freeMemory());
   
   free(vet2); 
}

Risultato:

810
810
504
810

il che è giusto.

dopo l'istanza del primo vettore sono disponibili 816 byte ?

Nei 2048 byte di SRAM non ci sta solo il vettore di 1024 byte che hai dichiarato ma anche tutte le altre variabili create dal programma (stai usando la seriale, che è una libreria contenuta nel core, poi stai usando la libreria esterna FreeMemory) nonché lo stack del programma.

Si ok su questo ci siamo. Quello che non capisco è: se io dichiaro vet1 come globale io mi aspetto che sia allocato staticamente ed infatti la freeMemory() mi dice che ho liberi solo 816byte, nel momento in cui io chiamo la funzione nella quale è dichiarato vet2 di 1024byte questo deve essere allocato in memoria e se chiamo la freeMemory() mi dovrebbe dare 0 o comunque dovrebbe bloccarsi ed invece la freeMemory mi dà 814byte, cioè come se avesse allocato solo un puntatore....Perchè?