ramonjba

Boa noite pessoal, estou quebrando a cabeça para conseguir fazer funcionar a comunicação entre o  PIC 16F877A e um modulo GPRS SIM900. 

Inicialmente liguei o TX/RX do PIC no RX/TX do Shield GPRS SIM 900 e alimentei o GPRS com fonte externa de 5V. Estou utilizando um código USART, porém não consigo realizar a comunicação/configuração(comandos AT) para o GPRS, estou quebrando a cabeça e não sei qual o problema. A algum tempo atrás tive experiência com o Shield GPRS, porém com Arduino, ficando muito mais simples de realizar a atividade. 

Aqui vai o codigo que estou utilizando no meu microcontrolador para tentar fazer uma ligação com o GPRS.

#include <xc.h>
#include <stdlib.h>

// Configuração dos Fuses do Microcontrolador.
#define _XTAL_FREQ	   8000000 // Cristal de 8 Mhz.
#pragma config FOSC  = HS   	// Oscillator Selection bits (HS oscillator: High-speed crystal/resonator on RA6/OSC2/CLKOUT and RA7/OSC1/CLKIN).
#pragma config WDTE  = OFF  	// Watchdog Timer Enable bit (WDT disabled).
#pragma config PWRTE = ON   	// Power-up Timer Enable bit (PWRT enabled).
#pragma config BOREN = OFF		// Brown-out Detect Enable bit (BOD disabled).
#pragma config LVP   = OFF  	// Low-Voltage Programming Enable bit (RB4/PGM pin has digital I/O function, HV on MCLR must be used for programming).
#pragma config CPD   = OFF  	// Data EE Memory Code Protection bit (Data memory code protection off).
#pragma config CP    = OFF  	// Flash Program Memory Code Protection bit (Code protection off).

//-----------------------------------------------------------------------------
void USARTInit(long BaudRate, int Mode)
{
	unsigned char BR = 0;

	// Cálculo do valor para o registrador SPBRG para uma determinada velocidade em bps.	
	if (Mode == 0)			//Cálculo para baixa velocidade.
	{
		BR = (_XTAL_FREQ / (64 * BaudRate)) - 1;
		SPBRG = BR;
	}
	else					//Cálculo para alta velocidade.
	{
		BR = (_XTAL_FREQ / (16 * BaudRate)) - 1;
		SPBRG = BR;
	}

    // Configuração do Registrador TXSTA.
    TXSTAbits.CSRC	= 0;	// Seleção MASTER/SLAVE para o Modo Síncrono.
    TXSTAbits.TX9	= 0;	// Transmição de Dados em 8 Bits.
    TXSTAbits.TXEN	= 1; 	// Habilita a Transmição de Dados.
    TXSTAbits.SYNC	= 0; 	// Modo de Comunicação Assíncrono.
    TXSTAbits.BRGH	= Mode;	// Baud Rate em alta ou baixa velocidade.
    TXSTAbits.TRMT	= 1;	// Situação do Registrador Interno de Transmissão (TSR).
    TXSTAbits.TX9D	= 0;	// Valor a Ser Transmitido como 9º bit (Paridade/Endereçamento).

    // Configuração do Registrador RCSTA.
    RCSTAbits.SPEN	= 1;	// Habilita o Sistema USART.
    RCSTAbits.RX9	= 0;    // Recepção de Dados em 8 Bits.
    RCSTAbits.SREN	= 0;	// Desabilita Recepção Unitária (Somente Modo Síncrono em MASTER).
    RCSTAbits.CREN	= 1;   	// Habilita a Recepção Contínua de Dados.
    RCSTAbits.ADDEN	= 0;  	// Desabilita o Sistema de Endereçamento.
    RCSTAbits.FERR	= 0;	// Erro de Stop Bit.
    RCSTAbits.OERR	= 0;	// Erro de Muitos Bytes Recebidos sem Leitura.
    RCSTAbits.RX9D	= 0;	// Valor a Ser Recebido como 9º bit (Paridade/Endereçamento).

    // Configuração da Interrupção USART.
	PIE1bits.RCIE 	= 1;	// Habilita a Interrupção Serial.
	PIR1bits.RCIF 	= 0;	// Habilita a Interrupção Serial de Recepção.
}

//-----------------------------------------------------------------------------
void USARTWriteChar(unsigned char USARTData)
{
	while(!PIR1bits.TXIF);
	TXREG = USARTData;
}

//-----------------------------------------------------------------------------
void USARTWriteString(const char *str)
{
	// Efetua a transmissão da string para a USART.
	while(*str != '\0')
  	{
    	// Envio da string byte a byte.
		USARTWriteChar(*str);
      	str++;
  	}
}

//-----------------------------------------------------------------------------
unsigned char USARTReceiveChar(void)
{
	unsigned char USARTData;

	__delay_us(75);					// Tempo necessário para recepção do próximo byte.
	
	if (!OERR)						// Erro de Muitos Bytes Recebidos sem Nenhuma Leitura.
	{
		USARTData 		= RCREG;	// Recebe o byte da USART e atribui a variável USARTData.
    	PIR1bits.RCIF 	= 0;		// Limpa a Flag da Interrupção de Recepção.
	}
	else
	{
		USARTWriteString("\n\r ------- ESTOURO DE PILHA ------- \n\r ");

		RCSTAbits.CREN 	= 0;   		// Desabilita a Recepção Contínua de Dados Momentaneamente.
		USARTData 		= RCREG;	// Recebe o byte da USART e atribui a variável USARTData.
		RCSTAbits.CREN 	= 1;   		// Habilita a Recepção Contínua de Dados Novamente.
    	PIR1bits.RCIF 	= 0;		// Limpa a Flag da Interrupção de Recepção.				
	}
	
	return(USARTData);
}

//-----------------------------------------------------------------------------
void interrupt ISR(void)
{
	unsigned char byte;

	// Verifica se a interrupção foi causada pela recepção de bytes.
	if (PIR1bits.RCIF == 1)		
    {
		USARTWriteString("\n\r Entrou na funcao de Interrupcao da USART");
		USARTWriteString("\n\r Caracter Digitado : ");
		
		byte = USARTReceiveChar();
    	
		USARTWriteChar(byte);
    }		
}
//---------------------------+--------------------------------------------------
void main(void)
{
	TRISC = 0b10000000;		// Configura portC  RC7 (pino RX) como entrada.
    PORTC = 0b11000000; 	// Limpar as portas que estão configuradas como saidas.
	
	USARTInit(9600,1);	// Inicialização da USART passando a velocidade e o modo de transmissão.

	INTCONbits.PEIE	= 1;	// Habilita Interrupção de Periféricos do Microcontrolador.
	INTCONbits.GIE	= 1;	// Habilita Interrupção Global.
    
   	USARTWriteString("\n\r Inicializando o PIC...\n\r");

    USARTWriteString("ATD01449yyyyxxxx\n\r"); //yyyyxxxx é o telefone que estou colocando
    __delay_ms(1000);


}