MEGA2560 and SIM900 doesn't answer

Hi
I have a Mega2560 and a GSM900 shield like so:http://www.ebay.com/itm/SIM900-GSM-GPRS-Shield-module-ATmega2560-board-kit-for-ARDUINO-IDE-/231204636686?pt=LH_DefaultDomain_0&hash=item35d4dec80e
I have been trying to communicate with the GSM shield. The programmer is “Arduino as an ISP.”
The arduino-1.0.5-r2 folder uses the GSM3 library which I couldn’t get to work so I replaced it with the latest one found here: GitHub - MarcoMartines/GSM-GPRS-GPS-Shield: GSM/GPRS & GPS Shield Library for modules using SIM900/SIM908 Please see bottom of page “Instal notes.” I amended the library for the Mega2560 board per the Istructions.txt, in addition I included Mega in the HWSerial.h.
The example sketches compile; however the COM message is a follows for GSM_GPRSLibrary_Client:
115200
ATT: OK
RIC: AT+IPR=9600
AT
ATT: OK
RIC: AT
ERROR: SIM900 doesn’t answer. Check power and serial pins in GSM.cpp
status=IDLE
Can you please help
Thanks
Luke

Try the following (not tested so may need a tweak!)

//Serial Relay - Version for Mega

unsigned char buffer[64];  // buffer array for data recieve over serial port
int count=0;               // counter for buffer array 

void setup()
{
  Serial1.begin(19200);
  Serial.begin(19200);
}

void loop()
{
  if (Serial1.available())
  {
    while(Serial1.available())
    {
      buffer[count++]=Serial1.read();
      if(count == 64)break;
    }
    Serial.write(buffer,count);
    clearBufferArray();
    count = 0;
  }
  if (Serial.available())
    Serial1.write(Serial.read());
}

void clearBufferArray()
{
  for (int i=0; i<count;i++)
  {
    buffer[i]=NULL;
  }
}

Open up Serial Monitor at 19200 baud - anything you type into Serial Monitor will be relayed to the SIM900, any reply will be sent to screen.

Hi
Thanks
Where would you insert this in HWSerial.cpp?
Thanks
Regards
Luke

Hi Dannable Here is HWSerial.cpp:

#include "HWSerial.h"
#ifdef MEGA
	HWSerial::HWSerial(){
			Serial1.begin(9600);
			
	}
	/*
	bool HWSerial::listen(){
		return Serial1.listen();
	}
	*/
	void HWSerial::end(){
		Serial1.end();
	}
	/*
	bool HWSerial::isListening(){
		return Serial1.isListening();
	}

	bool HWSerial::overflow(){
		return Serial1.overflow();
	}
	*/
	void HWSerial::begin(long baud_rate){
		Serial1.begin(baud_rate);
	}
	
	int HWSerial::peek(){
		return Serial1.peek();
	}

	 size_t HWSerial::write(uint8_t byte){
		return Serial1.write(byte);
	}

	 int HWSerial::read(){
		return Serial1.read();
	}
		
	 int HWSerial::available(){
		return Serial1.available();
	}

	 void HWSerial::flush(){
		Serial1.flush();
	}
	
	
	/**************************************/
	
	
	
size_t HWSerial::print(const __FlashStringHelper *ifsh)
{
  const prog_char *p = (const prog_char *)ifsh;
  size_t n = 0;
  while (1) {
    unsigned char c = pgm_read_byte(p++);
    if (c == 0) break;
    n += write(c);
  }
  return n;
}

size_t HWSerial::print(const String &s)
{
  size_t n = 0;
  for (uint16_t i = 0; i < s.length(); i++) {
    n += write(s[i]);
  }
  return n;
}

size_t HWSerial::print(const char str[])
{
  return write(str);
}

size_t HWSerial::print(char c)
{
  return write(c);
}

size_t HWSerial::print(unsigned char b, int base)
{
  return print((unsigned long) b, base);
}

size_t HWSerial::print(int n, int base)
{
  return print((long) n, base);
}

size_t HWSerial::print(unsigned int n, int base)
{
  return print((unsigned long) n, base);
}

size_t HWSerial::print(long n, int base)
{
  if (base == 0) {
    return write(n);
  } else if (base == 10) {
    if (n < 0) {
      int t = print('-');
      n = -n;
      return printNumber(n, 10) + t;
    }
    return printNumber(n, 10);
  } else {
    return printNumber(n, base);
  }
}

size_t HWSerial::print(unsigned long n, int base)
{
  if (base == 0) return write(n);
  else return printNumber(n, base);
}

size_t HWSerial::print(double n, int digits)
{
  return printFloat(n, digits);
}

size_t HWSerial::println(const __FlashStringHelper *ifsh)
{
  size_t n = print(ifsh);
  n += println();
  return n;
}


size_t HWSerial::println(void)
{
  size_t n = print('\r');
  n += print('\n');
  return n;
}

size_t HWSerial::println(const String &s)
{
  size_t n = print(s);
  n += println();
  return n;
}


size_t HWSerial::println(const char c[])
{
  size_t n = print(c);
  n += println();
  return n;
}

size_t HWSerial::println(char c)
{
  size_t n = print(c);
  n += println();
  return n;
}

size_t HWSerial::println(unsigned char b, int base)
{
  size_t n = print(b, base);
  n += println();
  return n;
}

size_t HWSerial::println(int num, int base)
{
  size_t n = print(num, base);
  n += println();
  return n;
}

size_t HWSerial::println(unsigned int num, int base)
{
  size_t n = print(num, base);
  n += println();
  return n;
}

size_t HWSerial::println(long num, int base)
{
  size_t n = print(num, base);
  n += println();
  return n;
}

size_t HWSerial::println(unsigned long num, int base)
{
  size_t n = print(num, base);
  n += println();
  return n;
}

size_t HWSerial::println(double num, int digits)
{
  size_t n = print(num, digits);
  n += println();
  return n;
}


/******************************/
size_t HWSerial::write(const uint8_t *buffer, size_t size)
{
  size_t n = 0;
  while (size--) {
    n += write(*buffer++);
  }
  return n;
}

size_t HWSerial::printNumber(unsigned long n, uint8_t base) {
  char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
  char *str = &buf[sizeof(buf) - 1];

  *str = '\0';

  // prevent crash if called with base == 1
  if (base < 2) base = 10;

  do {
    unsigned long m = n;
    n /= base;
    char c = m - base * n;
    *--str = c < 10 ? c + '0' : c + 'A' - 10;
  } while(n);

  return write(str);
}

size_t HWSerial::printFloat(double number, uint8_t digits) 
{ 
  size_t n = 0;
  
  // Handle negative numbers
  if (number < 0.0)
  {
     n += print('-');
     number = -number;
  }

  // Round correctly so that print(1.999, 2) prints as "2.00"
  double rounding = 0.5;
  for (uint8_t i=0; i<digits; ++i)
    rounding /= 10.0;
  
  number += rounding;

  // Extract the integer part of the number and print it
  unsigned long int_part = (unsigned long)number;
  double remainder = number - (double)int_part;
  n += print(int_part);

  // Print the decimal point, but only if there are digits beyond
  if (digits > 0) {
    n += print("."); 
  }

  // Extract digits from the remainder one at a time
  while (digits-- > 0)
  {
    remainder *= 10.0;
    int toPrint = int(remainder);
    n += print(toPrint);
    remainder -= toPrint; 
  } 
  
  return n;
}



boolean  HWSerial::find(char *target)
{
return findUntil(target, NULL);
}


boolean  HWSerial::findUntil(char *target, char *terminate)
{
byte targetLen = strlen(target); 
byte index = 0;  // maximum target string length is 255 bytes
byte termIndex = 0;
byte termLen = (terminate == NULL ? 0 : strlen(terminate));  
char c;

if( *target == 0)
   return true;   // return true if target is a null string 
while( (c = read()) != 0){   
  if( c == target[index]){        
	if(++index >= targetLen){ // return true if all chars in the target match
	  return true;    
	}
  }
  else{        
	index = 0;  // reset index if any char does not match   
  }
  if(termLen > 0 && c == terminate[termIndex]){
	 if(++termIndex >= termLen)  
	   return false;       // return false if terminate string found before target string
  }
  else
	  termIndex = 0;
}
return false;
}

 

int HWSerial::getString( char *pre_string, char *post_string, char *buffer, int length)
  {  
    if( find(pre_string) ){ 
      int index = 0;   
      *buffer = 0;
      while(index < length-1 ){
        char c = read();
        if( c == 0 ){
          return 0;   // timeout returns 0 !
        }
        else if( c == *post_string ){
	  
          while (index < length){
          	buffer[index] = '\0'; // terminate the string !!!!!!!!!!!IT DOESN'T WORK!!!!!!!!!!!!!!!!!
		index++;
		}
          
	  //buffer[index]=0;
          return index;               // data got successfully
        }
        else{
          buffer[index++] = c;   
        }
      }
      buffer[index] = 0;
      return index; // Note: buffer full before the closing post_string encountered
    }   
    return 0;    //failed to find the prestring
  } 
#endif

No, load onto the Arduino in place of any other sketch. Then you can try just simply communicating with it to ensure that the connections are correct and it responds. Once you know that then you can try more advanced sketches in the knowledge that any errors are not due to a lack of communication with the SIM900.

The MEGA2560 has 4 serial ports. Connect a cable from the SIM900 TX, to the MEGA2560 RX1 (for example) and SIM900 RX to MEGA TX1.

Then change your code to use Serial1 for communications.