Chiarificazione inserimento nuovi metodi in libreria

Salve a tutti,

ho necessità di inserire dei nuovi metodi nella libreria sim900,in particolare mi servono dei metodi per inviare dati tramite un modulo gsm, ho scritto dei metodi per inviare questi dati, ma nella fase di compilazione del mio programma ho degli errori, da quello che riesco a capire è come se i metodo che ho scritto nella libreria non li leggesse proprio vi posto un pò di codice:

il metodo che ho scritto è il seguente:

void SIM900::SimpleWrite(uint8_t *&comm, uint16_t &comm1){ _cell.print(comm,comm1); }

questo nel fil .cpp e logicamente poi riportato nel file .h

void SimpleWrite(uint8_t *&comm, uint16_t &comm1);

non sono un esperto di programmazione quindi sicuramente ho commesso degli errori,vorrei capire quali e come risolvere

Questo è uno degli errori che mi dà in fase di compilazione del mio programma:

C:\Users\Gianni\Documents\arduino-1.0.1\libraries\PubSubCLientGSM\PubSubClientGSM.cpp:203: error: no matching function for call to 'SIMCOM900::SimpleWrite(uint8_t*&, uint16_t&)' C:\Users\Gianni\Documents\arduino-1.0.1\libraries\PubSubCLientGSM\/SIM900.h:30: note: candidates are: void SIMCOM900::SimpleWrite(char*) C:\Users\Gianni\Documents\arduino-1.0.1\libraries\PubSubCLientGSM\/SIM900.h:31: note: void SIMCOM900::SimpleWrite(const char*) C:\Users\Gianni\Documents\arduino-1.0.1\libraries\PubSubCLientGSM\/SIM900.h:32: note: void SIMCOM900::SimpleWrite(int) C:\Users\Gianni\Documents\arduino-1.0.1\libraries\PubSubCLientGSM\/SIM900.h:33: note: void SIMCOM900::SimpleWrite(const __FlashStringHelper*)

Grazie in anticipo a chi mi vorrà dare supporto.

Mi sa che hai fatto un pò di confusione...

che tipo di parametri ti aspetti per un prototipo scritto in questa maniera ?

SimpleWrite(uint8_t *&comm, uint16_t &comm1)

cosa sono comm e comm1 ?

Si hai ragione, non sono un programmatore, ho cercato di creare questo metodo a causa dell'errore in fase di compilazione e cioè:

C:\Users\Gianni\Documents\arduino-1.0.1\libraries\PubSubCLientGSM\PubSubClientGSM.cpp:203: error: no matching function for call to 'SIMCOM900::SimpleWrite(uint8_t*&, uint16_t&)'

questo simbolo "&" è la e commerciale.

In cosa sbaglio???

Grazie per il supporto sei molto gentile e spero anche paziente :cold_sweat:

Praticamente sbagli a non sapere cosa scrivi!

Dovresti dare una bella studiata a C++ , puntatori e operatori relativi.

Si lo so che & è la e commerciale, solo che tu non sai a cosa serve! Questo è il problema.

Per farla breve

SIMCOM900::SimpleWrite(uint8_t *&comm, uint16_t &comm1)

suona un pò male...

L'operatore * (dereference) è un pò la traduzione di : il valore contenuto all'indirizzo XXX

L'operatore & (reference) è un pò la traduzione di : l'indirizzo di ...

praticamente nel tuo caso il metodo sarà sia nell'implementazione che nel ptototipo:

SIMCOM900::SimpleWrite(uint8_t *comm, uint16_t * comm1)

mentre nel richiamarlo

SimWrite(&valore,&valore1)

Claro?

Sei stato chiarissimo grazie, e si hai ragione di c non so praticamente nulla, mi sono andato a leggere un pò di documentazione inerente puntatori ecc. come mi hai consigliato e mi sono accorto di quanto sono beota =(, in tutti i casi non riesco a capire il messaggio di errore del compilatore:

no matching function for call to 'SIMCOM900::SimpleWrite(int, uint8_t [128], uint8_t&)'

questo è uno in questo caso dovrei costruire un metodo così?:

void SimpleWrite(int var,uint8_t var1,uint8_t *var2);

inoltre potresti dirmi il significato di questo sibolo ->

il codice è questo:

rc = _client->write(header);

grazie ancora e se hai altri consigli(oltre a studiarmi il c) sono ben accetti XD

Guarda, dovresti postare tutto il codice della classe per capirci qualcosa, ad intuito è difficile.

Si usa '->' invece che il '.' quando vuoi selezionare un elemento della classe tramite puntatore invece che per riferimento.

Questo è il codice della classe che utilizza le classi della gsmShied per arduino

/*
PubSubClientGSMGSM.cpp - Client per MQTT con modulo GSM.

*/

#include “PubSubClientGSM.h”

#include <string.h>

PubSubClientGSM::PubSubClientGSM() : _client() {
}

PubSubClientGSM::PubSubClientGSM(uint8_t ip, uint16_t port, void (callback)(char,uint8_t,unsigned int)) : _client() {
this->callback = callback;
this->ip = ip;
this->port = port;
}

PubSubClientGSM::PubSubClientGSM(char* domain, uint16_t port, void (callback)(char,uint8_t*,unsigned int)) : _client() {
this->callback = callback;
this->domain = domain;
this->port = port;
}

boolean PubSubClientGSM::connect(char *id) {
return connect(id,0,0,0,0);
}

boolean PubSubClientGSM::connect(char id, char willTopic, uint8_t willQos, uint8_t willRetain, char* willMessage) {
if (!connected()) {
int result = 0;

if (domain != NULL) {
result = _client.connectTCP(this->domain, this->port);
} else {
result = _client.connectTCP(this->domain, this->port);
}

if (result) {
nextMsgId = 1;
uint8_t d[9] = {0x00,0x06,‘M’,‘Q’,‘I’,‘s’,‘d’,‘p’,MQTTPROTOCOLVERSION};
uint8_t length = 0;
unsigned int j;
for (j = 0;j<9;j++) {
buffer[length++] = d[j];
}
if (willTopic) {
buffer[length++] = 0x06|(willQos<<3)|(willRetain<<5);
} else {
buffer[length++] = 0x02;
}
buffer[length++] = ((MQTT_KEEPALIVE) >> 8);
buffer[length++] = ((MQTT_KEEPALIVE) & 0xff);
length = writeString(id,buffer,length);
if (willTopic) {
length = writeString(willTopic,buffer,length);
length = writeString(willMessage,buffer,length);
}
gsm.SimpleWrite(MQTTCONNECT,buffer,length);
lastOutActivity = millis();
lastInActivity = millis();

unsigned long t= millis();
if (t-lastInActivity > MQTT_KEEPALIVE*1000) {
_client.disconnectTCP();
return false;
}

uint16_t len = readPacket();

if (len == 4 && buffer[3] == 0) {
lastInActivity = millis();
pingOutstanding = false;
return true;
}
}
_client.disconnectTCP();

}
return false;
}

uint8_t PubSubClientGSM::readByte() {

return gsm.read();
}

uint16_t PubSubClientGSM::readPacket() {
uint16_t len = 0;
buffer[len++] = readByte();
uint8_t multiplier = 1;
uint16_t length = 0;
uint8_t digit = 0;
do {
digit = readByte();
buffer[len++] = digit;
length += (digit & 127) * multiplier;
multiplier *= 128;
} while ((digit & 128) != 0);

for (uint16_t i = 0;i<length;i++)
{
if (len < MQTT_MAX_PACKET_SIZE) {
buffer[len++] = readByte();
} else {
readByte();
len = 0; // This will cause the packet to be ignored.
}
}

return len;
}

boolean PubSubClientGSM::loop() {
if (!connected()) {
unsigned long t = millis();
if ((t - lastInActivity > MQTT_KEEPALIVE1000) || (t - lastOutActivity > MQTT_KEEPALIVE1000)) {
if (pingOutstanding) {
_client.disconnectTCP();
return false;
} else {
gsm.SimpleWrite(MQTTPINGREQ);
gsm.SimpleWrite((uint8_t)0);
lastOutActivity = t;
lastInActivity = t;
pingOutstanding = true;
}
}
if (connected()) {
uint16_t len = readPacket();
if (len > 0) {
lastInActivity = t;
uint8_t type = buffer[0]&0xF0;
if (type == MQTTPUBLISH) {
if (callback) {
uint16_t tl = (buffer[2]<<8)+buffer[3];
char topic[tl+1];
for (uint16_t i=0;i<tl;i++) {
topic = buffer[4+i];

  • }*
  • topic[tl] = 0;*
  • // ignore msgID - only support QoS 0 subs*
    uint8_t *payload = buffer+4+tl;
  • callback(topic,payload,len-4-tl);*
  • }*
  • } else if (type == MQTTPINGREQ) {*
  • gsm.SimpleWrite(MQTTPINGRESP);*
  • gsm.SimpleWrite((uint8_t)0);*
  • } else if (type == MQTTPINGRESP) {*
  • pingOutstanding = false;*
  • }*
  • }*
  • }*
  • return true;*
  • }*
  • return false;*
    }
    boolean PubSubClientGSM::publish(char* topic, char* payload) {
    return publish(topic,(uint8_t*)payload,strlen(payload),false);
    }
    boolean PubSubClientGSM::publish(char* topic, uint8_t* payload, unsigned int plength) {
  • return publish(topic, payload, plength, false);*
    }
    boolean PubSubClientGSM::publish(char* topic, uint8_t* payload, unsigned int plength, boolean retained) {
  • if (connected()) {*
  • uint16_t length = writeString(topic,buffer,false);*
  • uint16_t i;*
  • for (i=0;i<plength;i++) {*
    _ buffer[length++] = payload*;_
    _
    }_
    uint8_t header = MQTTPUBLISH;
    _
    if (retained) {_
    _
    header |= 1;_
    _
    }_
    _
    return write(header,buffer,length);_
    _
    }_
    _
    return false;_
    _
    }_
    boolean PubSubClientGSM::write(uint8_t header, uint8_t buf, uint16_t length) {

    * uint8_t lenBuf[4];
    uint8_t llen = 0;
    uint8_t digit;
    uint8_t pos = 0;
    uint8_t rc;
    uint8_t len = length;
    _
    do {_
    _
    digit = len % 128;_
    _
    len = len / 128;_
    _
    if (len > 0) {_
    _
    digit |= 0x80;_
    _
    }_
    _
    lenBuf[pos++] = digit;_
    _
    llen++;_
    _
    } while(len>0);_
    rc = client->write(header);
    rc += client->write(lenBuf,llen);
    rc += client->write(buf,length);
    _
    lastOutActivity = millis();*

    * return (rc == 1+llen+length);*
    }
    boolean PubSubClientGSM::subscribe(char* topic) {
    * if (connected()) {*
    * uint16_t length = 2;
    _
    nextMsgId++;*

    * if (nextMsgId == 0) {*
    * nextMsgId = 1;*
    * }*
    * buffer[0] = nextMsgId >> 8;*
    * buffer[1] = nextMsgId - (buffer[0]<<8);*
    * length = writeString(topic, buffer,length);*
    * buffer[length++] = 0; // Only do QoS 0 subs*
    * return write(MQTTSUBSCRIBE|MQTTQOS1,buffer,length);*
    * }*
    * return false;*
    }
    void PubSubClientGSM::disconnect() {
    * gsm.SimpleWrite(MQTTDISCONNECT);*
    * gsm.SimpleWrite((uint8_t)0);
    client.disconnectTCP();
    _
    lastInActivity = millis();*

    * lastOutActivity = millis();*
    }
    uint16_t PubSubClientGSM::writeString(char* string, uint8_t* buf, uint16_t pos) {
    char* idp = string;
    * uint16_t i = 0;
    _
    pos += 2;*

    _ while (idp) {
    buf[pos++] = idp++;_
    _
    i++;
    _
    * }*
    * buf[pos-i-2] = 0;*
    * buf[pos-i-1] = i;*
    * return pos;*
    }
    boolean PubSubClientGSM::connected() {
    * int rc = (int)_client.connectedClient();
    if (!rc) client.disconnectTCP();
    _
    return rc;*

    }

mettilo tra i tag [ CODE ] e [ /CODE ] altrimenti non si legge una cippa.

Togli gli spazi, li ho dovuti mettere altrimenti avrebbe creato un blocco CODE e non avresti letto niente!.

sei come giobbe hai una pazienza infinita :stuck_out_tongue:

/*
 PubSubClientGSMGSM.cpp - Client per MQTT con modulo GSM.
  
*/

#include "PubSubClientGSM.h"

#include <string.h>

PubSubClientGSM::PubSubClientGSM() : _client() {
}

PubSubClientGSM::PubSubClientGSM(uint8_t *ip, uint16_t port, void (*callback)(char*,uint8_t*,unsigned int)) : _client() {
   this->callback = callback;
   this->ip = ip;
   this->port = port;
}

PubSubClientGSM::PubSubClientGSM(char* domain, uint16_t port, void (*callback)(char*,uint8_t*,unsigned int)) : _client() {
   this->callback = callback;
   this->domain = domain;
   this->port = port;
}

boolean PubSubClientGSM::connect(char *id) {
   return connect(id,0,0,0,0);
}

boolean PubSubClientGSM::connect(char *id, char* willTopic, uint8_t willQos, uint8_t willRetain, char* willMessage) {
   if (!connected()) {
      int result = 0;
      
      if (domain != NULL) {
        result = _client.connectTCP(this->domain, this->port);
      } else {
        result = _client.connectTCP(this->domain, this->port);
      }
      
      if (result) {
         nextMsgId = 1;
         uint8_t d[9] = {0x00,0x06,'M','Q','I','s','d','p',MQTTPROTOCOLVERSION};
         uint8_t length = 0;
         unsigned int j;
         for (j = 0;j<9;j++) {
            buffer[length++] = d[j];
         }
         if (willTopic) {
            buffer[length++] = 0x06|(willQos<<3)|(willRetain<<5);
         } else {
            buffer[length++] = 0x02;
         }
         buffer[length++] = ((MQTT_KEEPALIVE) >> 8);
         buffer[length++] = ((MQTT_KEEPALIVE) & 0xff);
         length = writeString(id,buffer,length);
         if (willTopic) {
            length = writeString(willTopic,buffer,length);
            length = writeString(willMessage,buffer,length);
         }
         gsm.SimpleWrite(MQTTCONNECT,buffer,length);
         lastOutActivity = millis();
         lastInActivity = millis();
         
            unsigned long t= millis();
            if (t-lastInActivity > MQTT_KEEPALIVE*1000) {
               _client.disconnectTCP();
               return false;
            }
         
         uint16_t len = readPacket();
         
         if (len == 4 && buffer[3] == 0) {
            lastInActivity = millis();
            pingOutstanding = false;
            return true;
         }
      }
      _client.disconnectTCP();
	  
}   
   return false;
}

uint8_t PubSubClientGSM::readByte() {
   
   return gsm.read();
}

uint16_t PubSubClientGSM::readPacket() {
   uint16_t len = 0;
   buffer[len++] = readByte();
   uint8_t multiplier = 1;
   uint16_t length = 0;
   uint8_t digit = 0;
   do {
      digit = readByte();
      buffer[len++] = digit;
      length += (digit & 127) * multiplier;
      multiplier *= 128;
   } while ((digit & 128) != 0);
   
   for (uint16_t i = 0;i<length;i++)
   {
      if (len < MQTT_MAX_PACKET_SIZE) {
         buffer[len++] = readByte();
      } else {
         readByte();
         len = 0; // This will cause the packet to be ignored.
      }
   }

   return len;
}

boolean PubSubClientGSM::loop() {
   if (!connected()) {
      unsigned long t = millis();
      if ((t - lastInActivity > MQTT_KEEPALIVE*1000) || (t - lastOutActivity > MQTT_KEEPALIVE*1000)) {
         if (pingOutstanding) {
            _client.disconnectTCP();
            return false;
         } else {
            gsm.SimpleWrite(MQTTPINGREQ);
            gsm.SimpleWrite((uint8_t)0);
            lastOutActivity = t;
            lastInActivity = t;
            pingOutstanding = true;
         }
      }
      if (connected()) {
         uint16_t len = readPacket();
         if (len > 0) {
            lastInActivity = t;
            uint8_t type = buffer[0]&0xF0;
            if (type == MQTTPUBLISH) {
               if (callback) {
                  uint16_t tl = (buffer[2]<<8)+buffer[3];
                  char topic[tl+1];
                  for (uint16_t i=0;i<tl;i++) {
                     topic[i] = buffer[4+i];
                  }
                  topic[tl] = 0;
                  // ignore msgID - only support QoS 0 subs
                  uint8_t *payload = buffer+4+tl;
                  callback(topic,payload,len-4-tl);
               }
            } else if (type == MQTTPINGREQ) {
               gsm.SimpleWrite(MQTTPINGRESP);
              gsm.SimpleWrite((uint8_t)0);
            } else if (type == MQTTPINGRESP) {
               pingOutstanding = false;
            }
         }
      }
      return true;
   }
   return false;
}

boolean PubSubClientGSM::publish(char* topic, char* payload) {
   return publish(topic,(uint8_t*)payload,strlen(payload),false);
}

boolean PubSubClientGSM::publish(char* topic, uint8_t* payload, unsigned int plength) {
   return publish(topic, payload, plength, false);
}

boolean PubSubClientGSM::publish(char* topic, uint8_t* payload, unsigned int plength, boolean retained) {
   if (connected()) {
      uint16_t length = writeString(topic,buffer,false);
      uint16_t i;
      for (i=0;i<plength;i++) {
         buffer[length++] = payload[i];
      }
      uint8_t header = MQTTPUBLISH;
      if (retained) {
         header |= 1;
      }
      return write(header,buffer,length);
   }
   return false;
}


boolean PubSubClientGSM::write(uint8_t header, uint8_t* buf, uint16_t length) {
   uint8_t lenBuf[4];
   uint8_t llen = 0;
   uint8_t digit;
   uint8_t pos = 0;
   uint8_t rc;
   uint8_t len = length;
   do {
      digit = len % 128;
      len = len / 128;
      if (len > 0) {
         digit |= 0x80;
      }
      lenBuf[pos++] = digit;
      llen++;
   } while(len>0);

   rc = _client->write(header);
   rc += _client->write(lenBuf,llen);
   rc += _client->write(buf,length);
   lastOutActivity = millis();
   return (rc == 1+llen+length);
}


boolean PubSubClientGSM::subscribe(char* topic) {
   if (connected()) {
      uint16_t length = 2;
      nextMsgId++;
      if (nextMsgId == 0) {
         nextMsgId = 1;
      }
      buffer[0] = nextMsgId >> 8;
      buffer[1] = nextMsgId - (buffer[0]<<8);
      length = writeString(topic, buffer,length);
      buffer[length++] = 0; // Only do QoS 0 subs
      return write(MQTTSUBSCRIBE|MQTTQOS1,buffer,length);
   }
   return false;
}

void PubSubClientGSM::disconnect() {
   gsm.SimpleWrite(MQTTDISCONNECT);
   gsm.SimpleWrite((uint8_t)0);
   _client.disconnectTCP();
   lastInActivity = millis();
   lastOutActivity = millis();
}

uint16_t PubSubClientGSM::writeString(char* string, uint8_t* buf, uint16_t pos) {
   char* idp = string;
   uint16_t i = 0;
   pos += 2;
   while (*idp) {
      buf[pos++] = *idp++;
      i++;
   }
   buf[pos-i-2] = 0;
   buf[pos-i-1] = i;
   return pos;
}


boolean PubSubClientGSM::connected() {
   int rc = (int)_client.connectedClient();
   if (!rc) _client.disconnectTCP();
   return rc;





}

Mi sa che ti sei sbagliato, sopra si stava parlando di SIM900.h mi aspettavo un SIM900.cpp :grin:

Hai ragione ho postato il codice della libreria per il protocollo mqtt, che usa la sim900

#include "SIM900.h"  
#include "Streaming.h"

#define _GSM_CONNECTION_TOUT_ 5
#define _TCP_CONNECTION_TOUT_ 20
#define _GSM_DATA_TOUT_ 10

//#define RESETPIN 7

SIMCOM900 gsm;
SIMCOM900::SIMCOM900(){};
SIMCOM900::~SIMCOM900(){};


int SIMCOM900::read(char* result, int resultlength)
{
  // Or maybe do it with AT+QIRD

  int charget;
  //_tf.setTimeout(3);
  // Not well. This way we read whatever comes in one second. If a CLOSED 
  // comes, we have spent a lot of time
    //charget=_tf.getString("",'\0',result, resultlength);
    //charget=_tf.getString("","",result, resultlength);
  /*if(strtok(result, "CLOSED")) // whatever chain the Q10 returns...
  {
    // TODO: use strtok to delete from the chain everything from CLOSED
    if(getStatus()==TCPCONNECTEDCLIENT)
      setStatus(ATTACHED);
    else
      setStatus(TCPSERVERWAIT);
  }  */
  
  return charget;
}

 int SIMCOM900::readCellData(int &mcc, int &mnc, long &lac, long &cellid)
{
  if (getStatus()==IDLE)
    return 0;
    
   //_tf.setTimeout(_GSM_DATA_TOUT_);
   //_cell.flush();
  SimpleWriteln(F("AT+QENG=1,0")); 
  SimpleWriteln(F("AT+QENG?")); 
  if(gsm.WaitResp(5000, 50, "+QENG")!=RX_FINISHED_STR_NOT_RECV)
    return 0;

  //mcc=_tf.getValue(); // The first one is 0
  mcc=_cell.read();
  //mcc=_tf.getValue();
  mcc=_cell.read();
  //mnc=_tf.getValue();
  mnc=_cell.read();
  //lac=_tf.getValue();
  lac=_cell.read();
  //cellid=_tf.getValue();
  cellid=_cell.read();
  
  gsm.WaitResp(5000, 50, "+OK");
  SimpleWriteln(F("AT+QENG=1,0")); 
  gsm.WaitResp(5000, 50, "+OK");
  return 1;
}

boolean SIMCOM900::readSMS(char* msg, int msglength, char* number, int nlength)
{
  long index;
  char *p_char; 
  char *p_char1;

  /*
  if (getStatus()==IDLE)
    return false;
  */
  _tf.setTimeout(_GSM_DATA_TOUT_);
  //_cell.flush();
  SimpleWriteln(F("AT+CMGL=\"REC UNREAD\",1"));
  
  //gsm.WaitResp(5000, 100, "OK");
  //if(gsm.IsStringReceived("+CMGL"))
  if(_tf.find("+CMGL: "))
  {
    Serial.println("TEST");
    /*
    //index
    p_char = strchr((char *)(gsm.comm_buf),':');
    p_char1 = p_char+2;  //we are on the first char of string
    p_char = strchr((char *)(p_char1), ',');
    if (p_char != NULL) {
          *p_char = 0; 
    }
    //strcpy(msg, (char *)(p_char1));   

    // rec unread
    p_char++;
    p_char1 = strchr((char *)(p_char), ',');
    if (p_char1 != NULL) {
          *p_char1 = 0; 
    } 

    // number
    p_char1++;
    p_char1++;
    p_char = strchr((char *)(p_char1), '\"');
    if (p_char != NULL) {
          *p_char = 0; 
    } 
    strcpy(number, (char *)(p_char1));

    // UTC time
    p_char = strchr((char *)(p_char), '\n');
    p_char1 = strchr((char *)(p_char), '\n');
    if (p_char1 != NULL) {
          *p_char1 = 0; 
    } 
    strcpy(msg, (char *)(p_char));  
    */

    index=_tf.getValue();
    //index=_cell.read();
    #ifdef UNO
        _tf.getString("\",\"", "\"", number, nlength);
    #endif
    #ifdef MEGA
        _cell.getString("\",\"", "\"", number, nlength);
    #endif
    #ifdef UNO
        _tf.getString("\n", "\nOK", msg, msglength);
    #endif
    #ifdef MEGA
        _cell.getString("\n", "\nOK", msg, msglength);
    #endif
    SimpleWrite(F("AT+CMGD="));
    SimpleWriteln(index);
    // Serial.print("VAL= ");
    // Serial.println(index);
    gsm.WaitResp(5000, 50, "OK"); 
    return true;
  };
  return false;
};

boolean SIMCOM900::readCall(char* number, int nlength)
{
  int index;

  if (getStatus()==IDLE)
    return false;
  
  //_tf.setTimeout(_GSM_DATA_TOUT_);
  if(gsm.WaitResp(5000, 50, "+CLIP: \"")!=RX_FINISHED_STR_RECV)
  //if(_tf.find("+CLIP: \""))
  {
    #ifdef UNO
        _tf.getString("", "\"", number, nlength);
    #endif
    #ifdef MEGA
        _cell.getString("", "\"", number, nlength);
    #endif
    SimpleWriteln("ATH");
    delay(1000);
    //_cell.flush();
    return true;
  };
  return false;
};

boolean SIMCOM900::call(char* number, unsigned int milliseconds)
{ 
  if (getStatus()==IDLE)
    return false;
  
  //_tf.setTimeout(_GSM_DATA_TOUT_);

  SimpleWrite("ATD");
  SimpleWrite(number);
  SimpleWriteln(";");
  delay(milliseconds);
  SimpleWriteln("ATH");

  return true;

}

int SIMCOM900::setPIN(char *pin)
{
  //Status = READY or ATTACHED.
  if((getStatus() != IDLE))
    return 2;
      
  //_tf.setTimeout(_GSM_DATA_TOUT_);   //Timeout for expecting modem responses.

  //_cell.flush();

  //AT command to set PIN.
  SimpleWrite(F("AT+CPIN="));
  SimpleWriteln(pin);

  //Expect "OK".
  
  if(gsm.WaitResp(5000, 50, "OK")!=RX_FINISHED_STR_NOT_RECV)
    return 0;
  else  
    return 1;
}

int SIMCOM900::changeNSIPmode(char mode)
{
    //_tf.setTimeout(_TCP_CONNECTION_TOUT_);
    
    //if (getStatus()!=ATTACHED)
    //    return 0;

    //_cell.flush();

    SimpleWrite(F("AT+QIDNSIP="));
    SimpleWriteln(mode);
    if(gsm.WaitResp(5000, 50, "OK")!=RX_FINISHED_STR_NOT_RECV) return 0;
    //if(!_tf.find("OK")) return 0;
    
    return 1;
}

int SIMCOM900::getCCI(char *cci)
{
  //Status must be READY
  if((getStatus() != READY))
    return 2;
      
  //_tf.setTimeout(_GSM_DATA_TOUT_);   //Timeout for expecting modem responses.

  //_cell.flush();

  //AT command to get CCID.
  SimpleWriteln(F("AT+QCCID"));
  
  //Read response from modem
  #ifdef UNO
    _tf.getString("AT+QCCID\r\r\r\n","\r\n",cci, 21);
  #endif
  #ifdef MEGA
    _cell.getString("AT+QCCID\r\r\r\n","\r\n",cci, 21);
  #endif
  
  //Expect "OK".
  if(gsm.WaitResp(5000, 50, "OK")!=RX_FINISHED_STR_NOT_RECV)
    return 0;
  else  
    return 1;
}
  
int SIMCOM900::getIMEI(char *imei)
{
      
  //_tf.setTimeout(_GSM_DATA_TOUT_);   //Timeout for expecting modem responses.

  //_cell.flush();

  //AT command to get IMEI.
  SimpleWriteln(F("AT+GSN"));
  
  //Read response from modem
  #ifdef UNO
    _tf.getString("\r\n","\r\n",imei, 16);
  #endif
  #ifdef MEGA
    _cell.getString("\r\n","\r\n",imei, 16);
  #endif
  
  //Expect "OK".
  if(gsm.WaitResp(5000, 50, "OK")!=RX_FINISHED_STR_NOT_RECV)
    return 0;
  else  
    return 1;
}

uint8_t SIMCOM900::read()
{
  return _cell.read();
}

void SIMCOM900::SimpleRead()
{
    char datain;
    if(_cell.available()>0){
        datain=_cell.read();
        if(datain>0){
            Serial.print(datain);
        }
    }
}

void SIMCOM900::SimpleWrite(char *comm)
{
    _cell.print(comm);
}

void SIMCOM900::SimpleWrite(const char *comm)
{
    _cell.print(comm);
}

void SIMCOM900::SimpleWrite(int comm)
{
    _cell.print(comm);
}
void SIMCOM900::SimpleWrite(int comm1,uint8_t comm,uint8_t &comm2)
{
    _cell.print(comm1,comm,comm2);
}
void SIM900::SimpleWrite(uint8_t *comm, uint8_t &comm1){
    _cell.print(comm,comm1);
}
void SIM900::SimpleWrite(uint8_t *&comm, uint16_t &comm1){
    _cell.print(comm,comm1);
}
void SIM900::SimpleWrite(uint8_t comm, uint8_t &comm1){
    _cell.print(comm,comm1);
}
void SIMCOM900::SimpleWrite(const __FlashStringHelper *pgmstr)
{
    _cell.print(pgmstr);
}
void SIMCOM900::SimpleWrite(uint8_t *comm,int length)
{
    _cell.print(comm,length);
}
void SIMCOM900::SimpleWrite(uint8_t *comm,uint8_t *comm1,int length)
{
    _cell.print(comm,com1,length);
}

void SIMCOM900::SimpleWriteln(char *comm)
{
    _cell.println(comm);
}

void SIMCOM900::SimpleWriteln(const __FlashStringHelper *pgmstr)
{
    _cell.println(pgmstr);
}

void SIMCOM900::SimpleWriteln(char const *comm)
{
    _cell.println(comm);
}

void SIMCOM900::SimpleWriteln(int comm)
{
    _cell.println(comm);
}

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

//---------------------------------------------
/**********************************************************

Quello che mi interessa è implementare dei metodi per quell'errore che ho in fase di compilazione

Si ma cosa devono fare i nuovi metodi di diverso dagli altri SimpleWrite?

Dovrebbe inviare dei dati di tipo uint8_t idee???

void SIMCOM900::SimpleWrite(uint8_t comm)
{
    _cell.write(comm);
}

vedi mbò...

Purtroppo nulla mi dà questo errore:

C:\Users\Gianni\Documents\arduino-1.0.1\libraries\PubSubCLientGSM\SIM900.cpp: In member function 'void SIMCOM900::SimpleWrite(uint8_t*)':
C:\Users\Gianni\Documents\arduino-1.0.1\libraries\PubSubCLientGSM\SIM900.cpp:371: error: call of overloaded 'write(uint8_t*&)' is ambiguous
C:\Users\Gianni\Documents\arduino-1.0.1\libraries\PubSubCLientGSM/SoftwareSerial.h:92: note: candidates are: virtual size_t SoftwareSerial::write(uint8_t) <near match>
C:\Users\Gianni\Documents\arduino-1.0.1\hardware\arduino\cores\arduino/Print.h:49: note:                 size_t Print::write(const char*) <near match>

Sembra che la libreria mal digerisca le variazioni alla libreria print e al write apportati con l'IDE 1.0 e 1.0.1 Stai già provando con la nuova libreria? --> http://code.google.com/p/gsm-shield-arduino/downloads/list

Si ho provato anche con la nuova libreria a me sembra che non riconosca uint8_t in quanto nell'errore di compilazione mi dà ambiguos che ne pensi?

Mi correggo il problema non è con uint8_t ma quando si cerca di scrivere un metodo uint8_t *comm, qualcuno saprebbe spiegarmi il perchè? e cosa più importante, come eventualmente risolvere???

Ma tu vuoi come parametro * uint_8t o uint8_t ? Non è la stessa cosa. E poi a questo punto penso che ti dia ambiguos perchè alla fine *uint8_t e *char è pressochè la stessa cosa. Pre vedere se è questo il problema aggiungi un parametro fittizio sia sul prototipo che sull'implementazione

void SIMCOM900::SimpleWrite(uint8_t * comm,boolean flag) { _cell.write(comm); }

e poi ovviamente aggiungi un valore true o false fittizio anche sulla chiamata.

Ti spiego il mio problema,praticamente stò cercando di implementare una libreria per il protocollo mqtt,esiste già una versione per ethernet, io stò cercando di modificare questa per utilizzarla con il modulo gsm, quello che devo fare inviare alcuni dati al server per farmi accettare la connessione tramite questo tipo di protocollo,quindi stò utilizzando il SimpleWrite per mandare questi dati ti posto il codice di un metodo che ho scritto:

boolean PubSubClientGSM::connect(char *id, char* willTopic, uint8_t willQos, uint8_t willRetain, char* willMessage) {
   if (!connected()) {
      int result = 0;
      
      if (domain != NULL) {
        result = _client.connectTCP(this->domain, this->port);
      } else {
        result = _client.connectTCP(this->domain, this->port);
      }
      
      if (result) {
         nextMsgId = 1;
         uint8_t d[9] = {0x00,0x06,'M','Q','I','s','d','p',MQTTPROTOCOLVERSION};
         uint8_t length = 0;
         unsigned int j;
         for (j = 0;j<9;j++) {
            buffer[length++] = d[j];
         }
         if (willTopic) {
            buffer[length++] = 0x06|(willQos<<3)|(willRetain<<5);
         } else {
            buffer[length++] = 0x02;
         }
         buffer[length++] = ((MQTT_KEEPALIVE) >> 8);
         buffer[length++] = ((MQTT_KEEPALIVE) & 0xff);
         length = writeString(id,buffer,length);
         if (willTopic) {
            length = writeString(willTopic,buffer,length);
            length = writeString(willMessage,buffer,length);
         }
         gsm.WriteMQTT(MQTTCONNECT,buffer,length);
         lastOutActivity = millis();
         lastInActivity = millis();
         
            unsigned long t= millis();
            if (t-lastInActivity > MQTT_KEEPALIVE*1000) {
               _client.disconnectTCP();
               return false;
            }
         
         uint16_t len = readPacket();
         
         if (len == 4 && buffer[3] == 0) {
            lastInActivity = millis();
            pingOutstanding = false;
            return true;
         }
      }
      _client.disconnectTCP();
	  
}   
   return false;
}

ho scritto anche un metodo

void SIMCOM900::WriteMQTT(int mqttcn, uint8_t* buff, int len)
{
        SimpleWrite(mqttcn);
        delay(500);               
        SimpleWrite(buff);
        delay(500);
        SimpleWrite(len);
}

il problema sorge sull’invio di quel buffer che,come puoi vedere dal codice dovrebbe essere un uint8_t*,da qui il mio problema.
Scusa la mia dilungazione ma ho pensato che avendo tutto il problema ben chiaro ti possa essere più facile suggerirmi una soluzione.