Android Arduino GPRS http未响应

我将arduino uno与itead 3G屏蔽一起使用，我的屏蔽工作正常，但无法正确响应http命令

在发送

“AT+chttact=…”

后，它返回给我

+chttact:REQUEST

，然后当它发送GET命令时，它根本不响应

有什么问题吗

这里是真实的响应和代码：

GSM : Registered to network
GSM : Ready for AT command

*** Start HTTP Transaction ***

+CHTTPACT: REQUEST
AT+CHTTPACT="jsonplaceholder.typicode.com",80
Sends Request:
GET /posts/1/ HTTP/1.1
Host:jsonplaceholder.typicode.com:80
Content-Length:0



*** End HTTP Transaction ***

Memory Free : 1216

代码：

// Included header files
#include <SoftwareSerial.h>


// AT command related
#define AT_CREG_QUERY ("AT+CREG?")
#define AT_CHTTPACT_COMMAND ("AT+CHTTPACT="%s",%d")
#define AT_CHTTPACT_INIT_RESPONSE ("+CHTTPACT: REQUEST")
#define AT_CHTTPACT_DATA_RESPONSE ("+CHTTPACT: DATA,")
#define AT_CHTTPACT_DONE_RESPONSE ("+CHTTPACT:0")

#define EOS ('\0')
#define ESC (0x1A)
#define OK ("OK")

// GSM definitions
#define unoTXPin (7) // Uno -> GSM
#define unoRXPin (6) // Uno <- GSM
#define powerGSMPin (8)
#define GSMBaudRate (9600)
#define UnoBaudRate (9600)

SoftwareSerial gsmSerial(unoRXPin,unoTXPin);

#define TEST_REQUEST ("GET /posts/1/ HTTP/1.1\r\nHost:jsonplaceholder.typicode.com:80\r\nContent-Length:0\r\n\r\n")

char aux_str [100];

int8_t answer;
int aux = 0;
int data_size = 0;


#define HOST_NAME ("jsonplaceholder.typicode.com")
#define HOST_PORT (80)

void setup() {


  // init sequence
  Serial.begin(UnoBaudRate);
  gsmSerial.begin(UnoBaudRate);

  gsm_power_on();
  while( (sendATcommand(AT_CREG_QUERY, "+CREG: 0,1", 500) || 
    sendATcommand(AT_CREG_QUERY, "+CREG: 0,5", 500)) == 0 );
  Serial.println(F("GSM : Registered to network"));
  Serial.println(F("GSM : Ready for AT command"));
}
void loop () {

    sprintf(aux_str, AT_CHTTPACT_COMMAND, HOST_NAME, HOST_PORT);
    Serial.println(F("\n*** Start HTTP Transaction ***\n"));
    Serial.println(AT_CHTTPACT_INIT_RESPONSE);

    answer = sendATcommand(aux_str, AT_CHTTPACT_INIT_RESPONSE, 60000);
    Serial.println(aux_str);
    if (answer == 1)
    {  

      data_size = 0;

      Serial.println(F("Sends Request:"));
      Serial.println(TEST_REQUEST);    
      gsmSerial.println(TEST_REQUEST);
      // Sends 
      aux_str[0] = ESC;
      aux_str[1] = 0x00;
      answer = sendATcommand(aux_str, AT_CHTTPACT_DATA_RESPONSE, 300000);

      if(answer == 1)
      {
        Serial.println(AT_CHTTPACT_DATA_RESPONSE);

          while(gsmSerial.available() > 0) {
            Serial.print((char)gsmSerial.read());
          }

        }

      Serial.println(F("\n*** End HTTP Transaction ***\n"));
      Serial.print(F("Memory Free : "));
      Serial.println(memoryFree());
      while(1); // halt
    }




}
// variables created by the build process when compiling the sketch
extern int __bss_end;
extern void *__brkval;
// function to return the amount of free RAM
int memoryFree(){
  int freeValue;
  if((int)__brkval == 0) 
    freeValue = ((int)&freeValue) - ((int)&__bss_end);
  else 
    freeValue = ((int)&freeValue) - ((int)__brkval);
  return freeValue;
}

void gsm_power_on(){

  uint8_t answer=0;

  // checks if the module is started
  answer = sendATcommand("AT", "OK", 2000);
  if (answer == 0)
  {
    // power on pulse
    digitalWrite(powerGSMPin,HIGH);
    delay(200);
    digitalWrite(powerGSMPin,LOW);
    delay(6000);
    // waits for an answer from the module
    while(answer == 0){    
      // Send AT every two seconds and wait for the answer
      answer = sendATcommand("AT", OK, 2000);    
    }
  }

}

int8_t sendATcommand(char* ATcommand, char* expected_answer1,
unsigned int timeout)
{

  uint8_t x=0,  answer=0;
  char response[100];
  unsigned long previous;

  memset(response, EOS, 100);    // Initialize the string

  delay(100);

  while( gsmSerial.available() > 0) gsmSerial.read();    // Clean the input buffer

  gsmSerial.println(ATcommand);    // Send the AT command 


    x = 0;
  previous = millis();

  // this loop waits for the answer
  do{

    if(gsmSerial.available() != 0){    
      response[x] = gsmSerial.read();
      x++;
      // check if the desired answer is in the response of the module
      if (strstr(response, expected_answer1) != NULL)    
      {
        answer = 1;
      }
    }
    // Waits for the asnwer with time out
  }
  while((answer == 0) && ((millis() - previous) < timeout));    

  return answer;
}

int8_t sendATcommand2(char* ATcommand, char* expected_answer1,
char* expected_answer2, unsigned int timeout)
{

  uint8_t x=0,  answer=0;
  char response[100];
  unsigned long previous;

  memset(response, EOS, 100);    // Initialize the string

  delay(100);

  while( gsmSerial.available() > 0) gsmSerial.read();    // Clean the input buffer

  Serial.println(ATcommand);    // Send the AT command 


    x = 0;
  previous = millis();

  // this loop waits for the answer
  do{

    if(gsmSerial.available() != 0){    
      response[x] = gsmSerial.read();
      x++;
      // check if the desired answer is in the response of the module
      if (strstr(response, expected_answer1) != NULL)    
      {
        answer = 1;
      }
      // check if the desired answer is in the response of the module
      if (strstr(response, expected_answer2) != NULL)    
      {
        answer = 2;
      }
    }
    // Waits for the asnwer with time out
  }
  while((answer == 0) && ((millis() - previous) < timeout));    

  return answer;
}

//包含的头文件
#包括
//与指挥有关
#定义AT_CREG_查询（“AT+CREG？”）
#定义AT_CHTTPACT_命令（“AT+CHTTPACT=“%s”，“%d”）
#定义AT_CHTTACT_INIT_响应（“+CHTTACT:请求”）
#定义AT_CHTTPACT_DATA_响应（“+CHTTPACT:DATA，”）
#在响应（+CHTTACT:0）时定义
#定义EOS（“\0”）
#定义ESC（0x1A）
#定义OK（“OK”）
//GSM定义
#定义unoTXPin（7）//Uno->GSM
#定义unoRXPin（6）//Uno 0）{
Serial.print（（char）gsmSerial.read（））；
}
}
Serial.println（F（“\n***结束HTTP事务***\n”）；
串行打印（F（“无内存：”）；
Serial.println（memoryFree（））；
while（1）；//停止
}
}
//编译草图时由生成过程创建的变量
外部内部bss\U end；
外部无效*\uuu brkval；
//函数返回可用RAM的数量
int memoryFree（）{
int自由值；
如果（（int）uu brkval==0）
自由值=（（int）和自由值）-（int）和（bss）end）；
其他的
自由值=（（int）和自由值）-（int）brkval）；
返回自由值；
}
无效gsm_电源_开启（）{
uint8_t answer=0；
//检查模块是否已启动
答案=sendATcommand（“AT”，“OK”，2000）；
如果（答案=0）
{
//通电脉冲
数字写入（powerGSMPin，高）；
延迟（200）；
数字写入（powerGSMPin，低位）；
延迟（6000）；
//等待模块的答复
而（答案==0）{
//每两秒钟发送一次，等待答复
答案=sendATcommand（“AT”，OK，2000）；
}
}
}
int8\u t sendATcommand（char*ATcommand，char*expected\u answer1，
无符号整数（超时）
{
uint8_t x=0，答案=0；
字符响应[100]；
长前未签名；
memset（response，EOS，100）；//初始化字符串
延迟（100）；
while（gsmSerial.available（）>0）gsmSerial.read（）；//清除输入缓冲区
gsmSerial.println（ATcommand）；//发送AT命令
x=0；
上一个=毫秒（）；
//这个循环等待答案
做{
如果（gsmSerial.available（）！=0）{
响应[x]=gsmSerial.read（）；
x++；
//检查模块的响应中是否有所需答案
if（strstr（响应，预期回答1）！=NULL）
{
答案=1；
}
}
//等待asnwer超时
}
而（（answer==0）和（（millis（）-previous）0）gsmSerial.read（）；//清除输入缓冲区
Serial.println（ATcommand）；//发送AT命令
x=0；
上一个=毫秒（）；
//这个循环等待答案
做{
如果（gsmSerial.available（）！=0）{
响应[x]=gsmSerial.read（）；
x++；
//检查模块的响应中是否有所需答案
if（strstr（响应，预期回答1）！=NULL）
{
答案=1；
}
//检查模块的响应中是否有所需答案
if（strstr（响应，预期回答2）！=NULL）
{
答案=2；
}
}
//等待asnwer超时
}
而（（answer==0）和（（millis（）-previous）