STM32 + PPP (GSM) + LwIP

в 5:55, , рубрики: lwip, PPP, stm32, микроконтроллеры, Программирование, программирование микроконтроллеров, разработка, Си

Большинство GSM модулей работают по интерфейсу UART, посредством AT-команд. Но для серьезных проектов, использование AT команд несет определенные трудности:

• контроль и обработка ошибок
• результат выполнения команды возвращается с длительной задержкой
• необходимо разбирать входящие строки налету

Нужно понимать, что с результатом выполнения команды, в буфер может попасть URC-код от входящего звонка, SMS, принятые данные и пр. Входной буфер с принятыми строками, приходится разбирать опираясь лишь на символы переносов и «эхо» команды, а сами команды зачастую сильно отличаются форматом. По этим причинам, использование AT вносит дополнительную задержку, алгоритмически ее устранить практически невозможно, ведь причина находится в самом модуле и несовершенстве его встроенного ПО

В этом примере я использовал SIM800C. Посмотрев спецификацию и убедившись в поддержке PPP, стал изучать способы реализации. Для использования PPP, модуль переключается несколькими настроечными командами, после этого режим AT становится недоступным и фактически идет общение с вышкой оператора напрямую, минуя внутренний стек модуля, что позволяет значительно ускорить обмен данными.

Пример PPP-пакета:

STM32 + PPP (GSM) + LwIP - 1

Каждый пакет PPP начинается и заканчивается символом ~ (0x7E). Протокол поддерживает аутентификацию соединения, шифрование и сжатие данных, по этому довольно сложен для написания собственного решения. Логичнее использовать готовый стек, поддерживающий PPP, например LwIP. Он поддерживает PPPOS и PPPOE (Over serial и Ethernet), протоколы аутентификации PAP и CHAP, имеет хорошую репутацию и широко распространен.

Демо проект

Блок-схема:

STM32 + PPP (GSM) + LwIP - 2

Примеры разрабатывались для микроконтроллера STM32 под FreeRTOS.

Старт программы, настройка периферии, создание задач

int main(void) {
     HAL_Init();
     SystemClock_Config();
     MX_GPIO_Init();
     MX_DMA_Init();
     // Настройка gsm, периферии модуля и LwIP
     InitGsmUart();
     // Создание задачи по приему-отправке пакета и установки соединения
     xTaskCreate(StartThread, "Start", configMINIMAL_STACK_SIZE*2, 0, tskIDLE_PRIORITY+1, &taskInitHandle);
     // Старт процессов
     osKernelStart(NULL, NULL);
     while (1) {}
}

void StartThread(void * argument) {
     gsmTaskInit();
     // подлючение, отправка/прием данных
     xTaskCreate(connectTask, "connectTask", configMINIMAL_STACK_SIZE*1, 0, tskIDLE_PRIORITY+1, NULL);
     // После удаляем задачу
     vTaskDelete(NULL);
}

«Верхний» уровень. Установка соединения, прием данных и зеркальная отправка

// Кол-во соединений. В этом примере 1, может быть больше, ограничено размером RAM контроллера и возможностями LwIP (последний легко настраивается)
#define GSM_MAX_CONNECTION	1
// Структура для работы с данными
typedef struct{
     uint8_t *rxBuff;
     uint16_t rxLen;
}sBuff[GSM_MAX_CONNECTION];

sBuff buff = {0};
	
void connectTask(void *pServiceNum) {
     bool connectState = false;
     eRetComm status = eError;
     uint16_t delay = 0;
     uint8_t serviceNum = *(uint8_t*)pServiceNum;
     xSemaphoreHandle xRxPppData; // семафор на прием от ppp
     xRxPppData = GsmLLR_GetRxSemphorePoint(serviceNum);
	
     for(;;) {
     /* Основной код задачи */
     if(connectState == true) {
     //Если есть подключение к серверу
     while(GsmLLR_ConnectServiceStatus(serviceNum) == eOk) {
          //Читаем данные в буфер	
          buff[serviceNum].rxLen = getRxData(serviceNum, xRxPppData,&(buff[serviceNum].rxBuff));
          if(buff[serviceNum].rxLen != 0) {
                    //Если пришли данные то отправляем обратно
                    if(GsmLLR_TcpSend(serviceNum, buff[serviceNum].rxBuff, 
buff[serviceNum].rxLen) == eOk) {
                    printf("Connect:#%i SendData OKrn", serviceNum);
          }else{
                    printf("Connect:#%i SendData ERRORrn", serviceNum);
                    connectState = false;	          
                    }
          }
     }
     //Если разрыв соединения
     printf("Connect:#%i connection lostrn", serviceNum);
     GsmLLR_DisconnectService(serviceNum);
     connectState = false;	
     delay = 1000;
     } else {
     // соединение закрыто, настраиваем
     printf("Connect:#%i connecting...", serviceNum);
     // Устанавливаем соединение
     if(GsmLLR_ConnectService(serviceNum) == eOk) {
          printf("Connect:#%i connected", serviceNum);
          connectState = true;		
     } else { // не получилось сконнектиться
          printf("Connect:#%i ERROR", serviceNum);				
          delay = GSM_CONNECTION_ERROR_DELAY;
          connectState = false;
          }
     }
     vTaskDelay(delay/portTICK_RATE_MS);
     }
}
// Прием данных
uint16_t getRxData(uint8_t serviceNum, xSemaphoreHandle xRxPppData, uint8_t **ppBufPacket) {
     uint16_t retLen = 0;
     uint16_t size = 0;
     if(xSemaphoreTake(xRxPppData, 1000/portTICK_PERIOD_MS) == pdTRUE) {
          size = gsmLLR_TcpGetRxCount(serviceNum);
          if(size > 1512) {
           retLen = 0;
          }else {
          retLen = GsmLLR_TcpReadData(serviceNum, ppBufPacket, size);
          }
     }
return retLen;
}

Настройка GSM, подробно

void gsmTaskInit(void) {
     xTaskCreate(vGsmTask, "GSM", configMINIMAL_STACK_SIZE*2, 0, tskIDLE_PRIORITY+1, &gsmInitTaskId);
     while((!gsmState.init) || (!pppIsOpen)) {vTaskDelay(100/portTICK_PERIOD_MS);}
}

/* Задача инициализации и управления GSM модулем */
void vGsmTask( void * pvParameters ) {
     // никзкоуровневые инициализации
     GsmLLR_Init();
     GsmLLR2_Init();
     GsmPPP_Init();
     // пока переферия не готова
     while((gsmState.initLLR != true) && (gsmState.initLLR2 != true)){};
     if(GsmLLR_PowerUp() != eOk) {
          GsmLLR_ModuleLost();
     }
     for(;;) {		
          // инициализация
          if(gsmState.init == false) {
          // если модуль перестал отвечать
          if(gsmState.notRespond == true) {
               printf("GSM: INIT Module lostrn");
               GsmLLR_ModuleLost();
               continue;
          }
          // готовность модуля
          if(GsmLLR_ATAT() != eOk) {
               gsmState.notRespond = true;
               continue;
          }
          // отключение предупреждений по питанию
          if(GsmLLR_WarningOff() != eOk) {
               gsmState.notRespond = true;
               continue;
          }
          // настройки ответа
          if(GsmLLR_FlowControl() != eOk) {
               gsmState.notRespond = true;
               continue;
          }
          // читаем IMEI
          if(GsmLLR_GetIMEI(aIMEI) != eOk) {
               gsmState.notRespond = true;
               continue;
          }
          DBGInfo("GSM: module IMEI=%srn", aIMEI);
          // читаем IMSI
          if(GsmLLR_GetIMSI(aIMSI) != eOk) {
               gsmState.notRespond = true;
               continue;
          }			
          printf("GSM: module IMSI=%srn", aIMSI);
          // Версия Software
          if(GsmLLR_GetModuleSoftWareVersion(aVerionSoftware) != eOk) {
               gsmState.notRespond = true;
               continue;
          }
          // вывод сообщения о регистрации сети (URC)
          if(GsmLLR_AtCREG() != eOk) {
               gsmState.notRespond = true;
               continue;
          }
          printf("GSM: CREG OKrn");
          // читаем уровень сигнала
          if(GsmLLR_UpdateCSQ(&gsmCsqValue) != eOk) {
               printf("GSM: Get CSQ ERROR, -RELOADrn");
               gsmState.notRespond = true;
               continue;
          }else{
               printf("GSM: CSQ value %drn", gsmCsqValue);
               // формат SMS
               if(GsmLLR_SmsModeSelect(sms_TEXT) != eOk) {
                    gsmState.notRespond = true;
                    continue;
               }
               //удаляем sms
               vTaskDelay(DELAY_REPLY_INIT/portTICK_RATE_MS);
               if(GsmLLR_SmsClearAll() != eOk) {
                    printf("GSM: clear SMS ERROR, -RELOADrn");
                    gsmState.notRespond = true;
                    continue;
               }
		printf("GSM: Clear SMS Okrn");
			
               printf("GSM: INIT PPPPrn");
		if(GsmLLR_StartPPP(&connectionSettings.gsmSettings) == eOk) {
                    printf("GSM: INIT PPPP - PPP RUNrn");
                    xQueueReset(uartParcerStruct.uart.rxQueue);
                    uartParcerStruct.ppp.pppModeEnable = true;
                    uartParcerStruct.uart.receiveState = true;
                    gsmState.init = true;
               }else{
                    printf("GSM: INIT PPPP - PPP ERROR!!!rn");
                    gsmState.notRespond = true;
                    continue;
               }
          }
     }
     vTaskDelay(1000/portTICK_RATE_MS);
     }
}

Поднятие PPP.

Для начала сессии используется 4 команды — comPPP_0-4. Как они отправляются и разбирается ответ мы не рассматриваем, это тема для отдельной статьи. Рассмотрим лишь в общем виде:

Скрытый текст

char *comPPP_0[] = {"AT+CGDCONT=1,"IP","};
char *comPPP_2[] = {"AT+CGQMIN=1,0,0,0,0,0"};
char *comPPP_3[] = {"AT+CGQREQ=1,2,4,3,6,31"};
char *comPPP_4[] = {"ATD*99***1#"};

eRetComm GsmLLR_StartPPP(sGsmSettings *pSettings) {
	printf("StartPPPrn");
	sResultCommand resultCommand;
	char **comPPP_Mass[3] = {comPPP_2, comPPP_3, comPPP_4};
	uint8_t *pData = NULL;
	if(GsmLLR_GetMutex() == true) {
		pData = pvPortMalloc(GSM_MALLOC_COMMAND_SIZE);
		if(pData != NULL) {
			memset(pData, 0, GSM_MALLOC_COMMAND_SIZE);
			sprintf((char*)pData, "%s%s", comPPP_0[0], (char*)pSettings->gprsApn);
			RunAtCommand((char*)pData, &resultCommand);
			// Счетчик команд, пока не отправили все
			uint8_t stepIndex = 0;
			while(stepIndex != (3)) {
				uint16_t len = strlen((char*)*comPPP_Mass[stepIndex]);
				sprintf((char*)pData, "%s", (char*)*comPPP_Mass[stepIndex]);
				RunAtCommand((char*)pData, &resultCommand);
				stepIndex++;
			}
			memset(pData, 0, GSM_MALLOC_COMMAND_SIZE);
			vPortFree(pData);
		}
		GsmLLR_GiveMutex();
	}
	return eOk;
}

Из кода задачи vGsmTask, следуют, что в случае успешного выполнения «GsmLLR_StartPPP» — выставляется флаг pppModeEnable и очищается очередь uartParcerStruct.uart.rxQueue. Флаг pppModeEnable отображает текущий режим модуля. Обмен между прерыванием UART и стеком/разборщиком команд — идет через очередь.

Задача сессия PPP на уровне GSM

void GsmPPP_Tsk(void *pvParamter) {
	int timeout = 0;
	uint8_t i;
	bool stateInit = false;
	uint16_t tskStackInit;
	LwipStack_Init();
	pppInit();
	pppSetAuth(PPPAUTHTYPE_CHAP, connectionSettings.gsmSettings.gprsUser, connectionSettings.gsmSettings.gprsPass);
	sioWriteSemaphore = xSemaphoreCreateBinary();
	for(i=0; i<GSM_MAX_CONNECTION; i++) {
		connectionPppStruct.semphr[i] = xSemaphoreCreateBinary();
		connectionPppStruct.rxData[i].rxSemh = xSemaphoreCreateBinary();
	}
	
	for(;;) {
                // Если выставлен флаг о использовании PPP и все было настроено
		if(uartParcerStruct.ppp.pppModeEnable == true) {
			if(!pppIsOpen) {
				pppNumport = pppOverSerialOpen(0, linkStatusCB, &pppIsOpen);
				pppStop = 0;
				timeout = 0;
				stateInit = false;
				while(timeout < 300) {
					if(pppIsOpen) {
						printf("PPP init - OKrn");
						lwip_stats.link.drop = 0;
						lwip_stats.link.chkerr = 0;
						lwip_stats.link.err = 0;
						stateInit = true;
						break;
					}else{
						timeout ++;
						vTaskDelay(100/portTICK_RATE_MS);
					}
				}
				if(stateInit != true) {
					printf("PPP init - TIMEOUT-ERRORrn");
					pppClose(pppNumport);
					pppIsOpen = false;
					uartParcerStruct.ppp.pppModeEnable = false;
					gsmState.init = false;
					gsmState.notRespond = true;
				}
			}else{
				if((lwip_stats.link.drop !=0) || (lwip_stats.link.chkerr !=0)) {
					lwip_stats.link.drop = 0;
					lwip_stats.link.chkerr = 0;
					printf("GSMM: DROPING FAIL!!! RESTART PPPrn");
					for(i=0; i<SERVERS_COUNT; i++) {
						GsmPPP_Disconnect(i);
					}
					pppClose(pppNumport);
					pppIsOpen = false;
					uartParcerStruct.ppp.pppModeEnable = false;
					gsmState.init = false;
					gsmState.notRespond = true;
					vTaskDelay(500/portTICK_PERIOD_MS);
				}
			}
		}
		vTaskDelay(500/portTICK_RATE_MS);
	}
}

Общие функции, работающие с PPP

Connect-Disconnect, чтение статуса соединения, отправка и т.п.

bool GsmPPP_Connect(uint8_t numConnect, char *pDestAddr, uint16_t port) {	
	struct ip_addr resolved = {0};
	bool useDns = false;
	uint8_t ipCut[4] = {0};
	
	if(!pppIsOpen) {
		printf("GSMPPP: CONNECT ERROR - PPP closedrn");
		return false;
	}
	sscanf(pDestAddr, "%i.%i.%i.%i", &ipCut[0], &ipCut[1], &ipCut[2], &ipCut[3]);	
	if((ipCut[0]!=0)&&(ipCut[1]!=0)&&(ipCut[2]!=0)&&(ipCut[3]!=0)) {
		IP4_ADDR(&connectionPppStruct.ipRemoteAddr[numConnect], ipCut[0],ipCut[1],ipCut[2],ipCut[3]); //31,10,4,158);
		useDns = false;
	}else{
		useDns = true;
	}
	
	if(connectionPppStruct.connected[numConnect] == false) {
		connectionPppStruct.tcpClient[numConnect] = tcp_new();	// create tcpPcb	
		tcp_recv(connectionPppStruct.tcpClient[numConnect], server_recv);
		
		if(useDns == true) {
			switch(dns_gethostbyname(pDestAddr, &resolved, destServerFound, &numConnect)) {
			case ERR_OK: // numeric or cached, returned in resolved
				connectionPppStruct.ipRemoteAddr[numConnect].addr = resolved.addr;
				break;
			case ERR_INPROGRESS: // need to ask, will return data via callback
				if(xSemaphoreTake(connectionPppStruct.semphr[numConnect], 10000/portTICK_PERIOD_MS) != pdTRUE) {
					while(tcp_close(connectionPppStruct.tcpClient[numConnect]) != ERR_OK) { vTaskDelay(100/portTICK_PERIOD_MS); }
					connectionPppStruct.connected[numConnect] = false;
					printf("GSMPPP: dns-ERRORrn");
				return false;
				}else{ }
				break;
			}
		}
		tcp_connect(connectionPppStruct.tcpClient[numConnect], &connectionPppStruct.ipRemoteAddr[numConnect], port, &TcpConnectedCallBack);
		if(xSemaphoreTake(connectionPppStruct.semphr[numConnect], 10000/portTICK_PERIOD_MS) == pdTRUE) {
			connectionPppStruct.connected[numConnect] = true;
			printf("GSMPPP: connected %srn", inet_ntoa(connectionPppStruct.ipRemoteAddr));
			return true;
		}else{
tcp_abort(connectionPppStruct.tcpClient[numConnect]);//tcp_close(connectionPppStruct.tcpClient[numConnect]);
			while(tcp_close(connectionPppStruct.tcpClient[numConnect]) != ERR_OK) { vTaskDelay(100/portTICK_PERIOD_MS); }
			printf("GSMPPP: connectTimeout-ERRORrn");
			return false;
		}		
	}else{
		if(GsmLLR_ConnectServiceStatus(numConnect) == eOk) {
			printf("GSMPPP: CONNECT-already connected %srn", inet_ntoa(connectionPppStruct.ipRemoteAddr));
			return true;
		}else{
			printf("GSMPPP: CONNECT CLOSE!!!rn");
			return false;
		}
	}
	return false;
}

bool GsmPPP_Disconnect(uint8_t numConnect) {
	if(!pppIsOpen) {
		printf("GSMPPP: CONNECT ERROR - PPP closedrn");
		return false;
	}
	if(connectionPppStruct.tcpClient[numConnect] == NULL) {
		return false;
	}
	while(tcp_close(connectionPppStruct.tcpClient[numConnect]) != ERR_OK) { vTaskDelay(100/portTICK_PERIOD_MS); }
	connectionPppStruct.connected[numConnect] = false;
	return true;
}

bool GsmPPP_ConnectStatus(uint8_t numConnect) {
	if(!pppIsOpen) {
		printf("GSMPPP: CONNECT ERROR - PPP closedrn");
		return false;
	}
	if(connectionPppStruct.tcpClient[numConnect]->state == ESTABLISHED) {
		return true;
	}
	return false;
}

bool GsmPPP_SendData(uint8_t numConnect, uint8_t *pData, uint16_t len) {
	if(!pppIsOpen) {
		printf("GSMPPP: CONNECT ERROR - PPP closedrn");
		return false;
	}
	if(tcp_write(connectionPppStruct.tcpClient[numConnect], pData, len, NULL) == ERR_OK) {
		return true;
	}else {
		while(tcp_close(connectionPppStruct.tcpClient[numConnect]) != ERR_OK) { vTaskDelay(100/portTICK_PERIOD_MS); }
		connectionPppStruct.connected[numConnect] = false;
		connectionPppStruct.rxData[numConnect].rxBufferLen = 0;
		memset(connectionPppStruct.rxData[numConnect].rxBuffer,0, sizeof(connectionPppStruct.rxData[numConnect].rxBuffer));
	}
	return false;
}

uint16_t GsmPPP_GetRxLenData(uint8_t numConnect) {
	if(!pppIsOpen) {
		printf("GSMPPP: CONNECT ERROR - PPP closedrn");
		return false;
	}
	return connectionPppStruct.rxData[numConnect].rxBufferLen;
}

uint16_t GsmPPP_ReadRxData(uint8_t numConnect, uint8_t **ppData) {
	if(!pppIsOpen) {
		printf("GSMPPP: CONNECT ERROR - PPP closedrn");
		return false;
	}
	if(connectionPppStruct.rxData[numConnect].rxBufferLen != 0) {
		*ppData = (uint8_t *) connectionPppStruct.rxData[numConnect].rxBuffer;
		uint16_t retLen = connectionPppStruct.rxData[numConnect].rxBufferLen;
		connectionPppStruct.rxData[numConnect].rxBufferLen = 0;
		return retLen;
	}
	return false;
}

static void destServerFound(const char *name, struct ip_addr *ipaddr, void *arg)
{
	uint8_t *num = (uint8_t*)arg;
	if(*num < SERVERS_COUNT) {
		printf("GSMPPP: DEST FOUND %srn", inet_ntoa(ipaddr->addr));
		connectionPppStruct.ipRemoteAddr[*num].addr = ipaddr->addr;
		xSemaphoreGive(connectionPppStruct.semphr[*num]);	
	}else{
		printf("GSMPPP: DNS != SERVER%srn", inet_ntoa(ipaddr->addr));
	}
}

static err_t TcpConnectedCallBack(void *arg, struct tcp_pcb *tpcb, err_t err) {
	for(uint8_t i=0; i<SERVERS_COUNT; i++) {
		if(tpcb == connectionPppStruct.tcpClient[i]) {
			printf("GSMPPP: connected (callback)%srn", inet_ntoa(tpcb->local_ip.addr));
			xSemaphoreGive(connectionPppStruct.semphr[i]);
			break;
		}
	}
}

static err_t server_recv(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err)
{
   LWIP_UNUSED_ARG(arg);

	if(err == ERR_OK && p != NULL) {
		tcp_recved(pcb, p->tot_len);
		printf("GSMPPP:server_recv(): pbuf->len %d byten [%s]", p->len, inet_ntoa(pcb->remote_ip.addr));
    
		for(uint8_t i=0; i<SERVERS_COUNT; i++) {
			if(pcb->remote_ip.addr == connectionPppStruct.tcpClient[i]->remote_ip.addr) {
				printf("GSMPPP: server_recv (callback) [%s]rn", inet_ntoa(pcb->remote_ip.addr));
				if(p->len < sizeof(connectionPppStruct.rxData[i].rxBuffer)) {
					memcpy(connectionPppStruct.rxData[i].rxBuffer, p->payload, p->len);
					connectionPppStruct.rxData[i].rxBufferLen = p->len;
					xSemaphoreGive(connectionPppStruct.rxData[i].rxSemh);
					printf("GSMPPP: server_recv (callback) GIVE SEMPH[%s][%d]rn", inet_ntoa(pcb->remote_ip.addr), p->len);
				}else{
					printf("GSMPPP: server_recv p->len > sizeof(buf) -ERRORrn");
				}
			}
		}
    pbuf_free(p);
	}else{
		printf("nserver_recv(): Errors-> ");
    if (err != ERR_OK)
			printf("1) Connection is not on ERR_OK state, but in %d state->n", err);
		if (p == NULL)
			printf("2) Pbuf pointer p is a NULL pointer->n ");
    printf("server_recv(): Closing server-side connection...");
		pbuf_free(p);
    server_close(pcb);
	}
   return ERR_OK;
}

xSemaphoreHandle * GsmPPP_GetRxSemaphorePoint(uint8_t numService) {
	return (connectionPppStruct.rxData[numService].rxSemh);
}

Функции связанные с соединением TCP в LwIP, callback-s

static err_t server_poll(void *arg, struct tcp_pcb *pcb)
{
   static int counter = 1;
   LWIP_UNUSED_ARG(arg);
   LWIP_UNUSED_ARG(pcb);
   printf("nserver_poll(): Call number %dn", counter++);
   return ERR_OK;
}

static err_t server_err(void *arg, err_t err)
{
   LWIP_UNUSED_ARG(arg);
   LWIP_UNUSED_ARG(err);
   printf("nserver_err(): Fatal error, exiting...n");
   return ERR_OK;
}

static void server_close(struct tcp_pcb *pcb)
{
	tcp_arg(pcb, NULL);
	tcp_sent(pcb, NULL);
	tcp_recv(pcb, NULL);
while(tcp_close(pcb) != ERR_OK) { vTaskDelay(100/portTICK_PERIOD_MS); }
	for(uint8_t i=0; i<SERVERS_COUNT; i++) {
		if(pcb == connectionPppStruct.tcpClient[i]) {
			printf("GSMPPP: server_close (callback)%srn", inet_ntoa(pcb->local_ip.addr));
			connectionPppStruct.connected[i] = false;
		}else{
			printf("GSMPPP: server_recv p->len > sizeof(buf) -ERRORrn");
		}
	}
}

Функции соединяющие уровень LwIP с UART и GSM модулем, очень важный момент

// Прослойка на чтение из очереди - отправка данных в LwIP
u32_t sio_read(sio_fd_t fd, u8_t *data, u32_t len)
{
	unsigned long i = 0;
	if(uartParcerStruct.ppp.pppModeEnable) {
		while(xQueueReceive(uartParcerStruct.uart.rxQueue,&data[i], 0) == pdTRUE) {
			if(i==0) {
				printf("Reading PPP packet from UARTrn");
			}
			printf("%0.2x ", data[i]);
			i++;
			if (pppStop||(i==len)) {
				pppStop = false;
				return i;
			}
		}
		if (i>0) {
			printf("n");
		}
	}
	return i;
}
// Запись из LwIP в UART (GSM)
u32_t sio_write(sio_fd_t fd, u8_t *data, u32_t len)
{
	u32_t retLen = 0;
	if(uartParcerStruct.ppp.pppModeEnable) {
		if(HAL_UART_Transmit_IT(&huart3, data, len) == HAL_OK) {
			xSemaphoreTake(sioWriteSemaphore, portMAX_DELAY);
			retLen = len;
		}else{
			printf("HAL ERRROR WRITE [sio_write]rn");
		}
	}else{
		printf("sio_write not in PPP mode!rn");
	}
	return retLen;
}
// Прерывание сессии, очистка очереди
void sio_read_abort(sio_fd_t fd)
{
	pppStop = true;
	xQueueReset(uartParcerStruct.uart.rxQueue);
}

u32_t sys_jiffies(void) {
	return xTaskGetTickCount();
}
// Калбек вызывается после успешной или не успешной попытки соединения
static void linkStatusCB(void * ctx, int errCode, void * arg) {
	printf("GSMPP: linkStatusCBrn"); /* just wait */
	bool *connected = (bool*)ctx;
	struct ppp_addrs * addrs = arg;
	switch (errCode) {
		case PPPERR_NONE: { /* We are connected */
			printf("ip_addr = %srn", inet_ntoa(addrs->our_ipaddr));
			printf("netmask = %srn", inet_ntoa(addrs->netmask));
			printf("dns1 = %srn", inet_ntoa(addrs->dns1));
			printf("dns2 = %srn", inet_ntoa(addrs->dns2));
			*connected = 1;
			break;
		}
		case PPPERR_CONNECT: {
			printf("lost connectionrn"); /* just wait */
			*connected = 0;
			break;
		}
		default: { /* We have lost connection */
			printf("connection errorrn"); /* just wait */
			*connected = 0;
			break;
		}
	}
}

Отправляем данные через TCP терминал:

STM32 + PPP (GSM) + LwIP - 3

В структурах видно пришедший пакет:

STM32 + PPP (GSM) + LwIP - 4

Подведем итоги.

Отказавшись от AT-команд, удалось значительно уменьшить и упростить код по разбору и отправки команд, сложного (потенциально не надежного) разбора ответов, приема данных и URC кодов. AT-команды остались для первоначальной настройки модема и записи параметров APN.

Записанную логическим анализатором сессию PPP, для подробного изучения, можно взять здесь.

Автор: Khomin

Источник

Поделиться

* - обязательные к заполнению поля