Problema invio dati modulo SIM900

Salve a tutti, dovrei realizzare un programma che mediante il GSM Shield di futura elettronica si logghi ad un server custom realizzato in c# e gli trasmetta dei dati. Quindi mi sono creato un nuovo metodo nella classe inetGSM analogo ad httpGET che invece di inviare comandi standard http invia i dati ricevuti in ingresso. Il metodo è il seguente:

int InetGSM::askSEND(const char* server, int port, char* message, char* result, int resultlength)
{
    boolean connected=false;
    int n_of_at=0;
    int length_write;
    char end_c[2];
    end_c[0]=0x1a;
    end_c[1]='\0';
    
    /*
     Status = ATTACHED.
     if(gsm.getStatus()!=GSM::ATTACHED)
     return 0;
     */
    while(n_of_at<3){
        if(!connectTCP(server, port)){
#ifdef DEBUG_ON
			Serial.println("DB:NOT CONN");
#endif	
	    	n_of_at++;
        }
        else{
            connected=true;
            n_of_at=3;
        }
    }
    
    if(!connected) return 0;
	
    gsm.SimpleWrite(message);
    gsm.SimpleWrite(end_c);
    
    switch(gsm.WaitResp(10000, 100, "SEND")){
        case RX_TMOUT_ERR: 
            return 0;
            break;
        case RX_FINISHED_STR_NOT_RECV: 
            return 0; 
            break;
    }
    
#ifdef DEBUG_ON
    Serial.println("DB:SENT");
#endif	
    int res= gsm.read(result, resultlength);
    
    //gsm.disconnectTCP();
    
    //int res=1;
    return res;
}

Il problema è che quando il parametro “message” è una stringa composta da parecchi caratteri l’arduino si blocca. Sapete per caso a cosa può essere dovuto? Grazie per le eventuali risposte.

quani caratteri? l'arduino ha poca ram, un array di 200 caratteri (più il peso delle altre variabili) potrebbe essere più che sufficiente a farlo crashare. se cerchi nel reference ci sono vari modi per sapere la ram disponibile a runtime!

Magari 200, inviando più di 11 caratteri rimane fermo a "correct br" mentre con 10-9 caratteri ottiene l'ip ma poi non riporta a video più nulla (anche se i dati li invia), sotto i 9 caratteri invece va tutto ok... Non riesco proprio a capire da cosa possa dipendere!

metti il codice per il test della ram, trust me :)

L'ho messo e in effetti con 9 caratteri mi da 0 byte liberi... però non riesco a capire il perché la funzione httpGET, già presente nella libreria, funzioni correttamente anche se invia stringhe molto più lunghe :~

bisogna vedere cosa fa il resto del codice, magari si tratta di ram pre-alocata, magari c'è un errore in quello che fai che ti fa sprecare ram, etc..

Il resto del codice è questo:

#include "SIM900.h"
#include <SoftwareSerial.h>
#include "inetGSM.h"
//#include "sms.h"
//#include "call.h"

//To change pins for Software Serial, use the two lines in GSM.cpp.

//GSM Shield for Arduino
//www.open-electronics.org
//this code is based on the example of Arduino Labs.

//Simple sketch to start a connection as client.

InetGSM inet;
//CallGSM call;
//SMSGSM sms;

char msg[50];
int numdata;
char inSerial[50];
int i=0;
boolean started=false;

void setup() 
{
  //Serial connection.
  Serial.begin(9600);
  Serial.println("GSM Shield testing.");
  //Start configuration of shield with baudrate.
  //For http uses is raccomanded to use 4800 or slower.
  
  //TEST RAM
  int result = memoryTest();
  Serial.print("Memory test results: ");
  Serial.print(result,DEC);
  Serial.print(" bytes free");
  //__________________________________
  
  if (gsm.begin(2600)){
    Serial.println("\nstatus=READY");
    started=true;  
  }
  else Serial.println("\nstatus=IDLE");
  
   //TEST RAM
  int result = memoryTest();
  Serial.print("Memory test results: ");
  Serial.print(result,DEC);
  Serial.print(" bytes free");
  //__________________________________
  
  if(started){
    //GPRS attach, put in order APN, username and password.
    //If no needed auth let them blank.
    if (inet.attachGPRS("ibox.tim.it", "", ""))
      Serial.println("status=ATTACHED");
    else Serial.println("status=ERROR");
    delay(1000);
    
    //Read IP address.
    gsm.SimpleWriteln("AT+CIFSR");
    delay(5000);
    //Read until serial buffer is empty.
    gsm.WhileSimpleRead();
  
    //TCP Client GET, send a GET request to the server and
    //save the reply.
    //numdata=inet.httpGET("www.nic.it", 80, "/", msg, 50);
    numdata=inet.askSEND("74.52.29.145", 9000,"STRINGASUPERIOREANOVECARATTERI", msg, 50);
    
     //TEST RAM
    int result = memoryTest();
    Serial.print("Memory test results: ");
    Serial.print(result,DEC);
    Serial.print(" bytes free");
    //__________________________________
    
    //Print the results.
    Serial.println("\nNumber of data received:");
    Serial.println(numdata);  
    Serial.println("\nData received:"); 
    Serial.println(msg); 
  }
};

void loop() 
{
  //Read for new byte on serial hardware,
  //and write them on NewSoftSerial.
  serialhwread();
  //Read for new byte on NewSoftSerial.
  serialswread();
};

void serialhwread(){
  i=0;
  if (Serial.available() > 0){            
    while (Serial.available() > 0) {
      inSerial[i]=(Serial.read());
      delay(10);
      i++;      
    }
    
    inSerial[i]='\0';
    if(!strcmp(inSerial,"/END")){
      Serial.println("_");
      inSerial[0]=0x1a;
      inSerial[1]='\0';
      gsm.SimpleWriteln(inSerial);
    }
    //Send a saved AT command using serial port.
    if(!strcmp(inSerial,"TEST")){
      Serial.println("SIGNAL QUALITY");
      gsm.SimpleWriteln("AT+CSQ");
    }
    //Read last message saved.
    if(!strcmp(inSerial,"MSG")){
      Serial.println(msg);
    }
    else{
      Serial.println(inSerial);
      gsm.SimpleWriteln(inSerial);
    }    
    inSerial[0]='\0';
  }
}

void serialswread(){
  gsm.SimpleRead();
}

// this function will return the number of bytes currently free in RAM
int memoryTest() {
  int byteCounter = 0; // initialize a counter
  byte *byteArray; // create a pointer to a byte array
  // More on pointers here: http://en.wikipedia.org/wiki/Pointer#C_pointers

  // use the malloc function to repeatedly attempt allocating a certain number of bytes to memory
  // More on malloc here: http://en.wikipedia.org/wiki/Malloc
  while ( (byteArray = (byte*) malloc (byteCounter * sizeof(byte))) != NULL ) {
    byteCounter++; // if allocation was successful, then up the count for the next try
    free(byteArray); // free memory after allocating it
  }
  
  free(byteArray); // also free memory after the function finishes
  return byteCounter; // send back the highest number of bytes successfully allocated
}

askSEND è il metodo che ho postato in precedenza, molto simile ad httpGET… per il resto non ho modificato granché il codice di esempio.