Geekly articles weekly

Micropython no módulo GSM + GPS A9G

Desta vez, pensei em esconder um rastreador GPS na minha bicicleta como precaução. Existem toneladas de dispositivos autônomos no mercado para rastrear carros, cargas, bicicletas, malas, crianças e animais. A grande maioria deles interage com o usuário via SMS. Opções mais caras fornecem a funcionalidade Localizar meu telefone, mas estão vinculadas a um serviço online específico.
Idealmente, eu gostaria de ter controle total sobre o rastreador: use-o em um modo conveniente, sem SMS e registro. O google superficial me trouxe alguns módulos da China, um dos quais eu pedi (placa de pudim A9G) (~ $ 15).


Módulo


Este artigo é sobre como eu fiz o python funcionar neste módulo.


Se o A9G for um análogo do ESP (a propósito, o fabricante é o mesmo), a placa de pudim em si é uma analogia da placa NodeMCU, exceto que a placa de pudim não possui um conversor USB-UART embutido. Mas há muitas outras coisas interessantes. Especificações do Fabricante :


  • Núcleo de 32 bits (RISC), até 312 MHz
  • GPIO 29x (todos são soldados, todas as interfaces estão incluídas neste número)
  • relógios e cão de guarda
  • 1x interface USB 1.1 (não a encontrei lá, mas copie do local) e microUSB para alimentação
  • 2x UART (serviço +1)
  • 2x SPI (não tentado)
  • 3x I2C (não tentei)
  • 1x SDMMC (com slot físico)
  • 2x entradas analógicas (10 bits, possivelmente uma delas é usada pelos controladores de bateria de lítio)
  • Flash de 4 Mb
  • PSRAM de 4Mb
  • ADC (microfone, existe fisicamente no quadro) e DAC (alto-falante, ausente)
  • controlador de carga da bateria (não há bateria propriamente dita)
  • de fato, GSM (800, 900, 1800, 1900 MHz) com SMS, voz e GPRS
  • GPS conectado via UART2 (existe um módulo "A9" sem ele)
  • Slot SIM (nanoSIM)
  • dois botões (um reset, outro - inclusão e função programável)
  • dois LEDs

A tensão operacional é de 3,3V, a tensão de entrada é de 5-3,8V (dependendo da conexão). Em geral, o módulo possui todo o hardware necessário para montar um simples dispositivo móvel com botão de pressão. Mas a partir dos exemplos, parece que os chineses estão comprando-o para venda em máquinas caça-níqueis ou caça-níqueis ou algo assim. Alternativas ao módulo são os bastante populares módulos SIM800, que, infelizmente, não têm um SDK no domínio público (ou seja, os módulos são vendidos como modems AT).


SDK


O módulo vem com um SDK em inglês satisfatório. Instala no Ubuntu, mas Windows e containers são os preferidos. Tudo funciona através da cutucada na GUI: ESPtool para este módulo ainda não foi revertida. O firmware em si é construído pelo Makefile. O depurador está presente: antes do congelamento, o módulo lança o rastreamento de pilha na porta de serviço. Mas, pessoalmente, não consegui traduzir os endereços em linhas de código (o gdb relata que os endereços não correspondem a nada). É possível que isso se deva ao pouco suporte ao Linux como tal. Portanto, se você quiser mexer no módulo - tente fazê-lo no Windows (e cancele a inscrição no github). Caso contrário, aqui está a instrução para Linux. Após a instalação, é necessário verificar a correção dos caminhos no arquivo .bashrc e excluir (renomear) todos os CSDTK/lib/libQt* : caso contrário, o pisca-pisca (também conhecido como depurador) simplesmente não será iniciado devido a um conflito com o libQt instalado, provavelmente.


Flasher


Para o pisca-pisca há uma instrução .


Ligação


Tudo é mais complicado do que no NodeMCU. Os módulos parecem semelhantes, mas não há chip USB-TTY na placa de pudim e o microUSB é usado apenas para energia. Assim, você precisará de USB-TTY em 3.3V. Dois são melhores: um para porta de depuração e outro para UART1: o primeiro é usado para fazer upload de firmware e o segundo que você pode usar como um terminal comum. Para não arrastar todos esses obstáculos para o computador, comprei adicionalmente um divisor USB de 4 portas com um cabo de dois metros e uma fonte de alimentação externa (necessária). O custo total deste kit com o próprio módulo será de US $ 25 a 30 (sem fonte de alimentação: use pelo telefone).


Firmware


O módulo vem com firmware AT: você pode conectar-se a um arduino de 3.3V e usá-lo como modem via UART1. Seu firmware está escrito em C. make cria dois arquivos de firmware: um é costurado por cerca de um minuto, o outro é rápido o suficiente. Somente um desses arquivos pode ser costurado: a primeira vez é grande, os tempos subsequentes são pequenos. No total, durante o processo de desenvolvimento, tenho o SDK chinês ( coolwatcher ) aberto na área de trabalho para gerenciar o módulo, o miniterm como stdio e o editor de código.


API


O conteúdo da API reflete a lista acima e se assemelha ao ESP8266 nos primeiros dias: levei cerca de 3 horas para lançar o HelloWorld. Infelizmente, o conjunto de funções disponíveis para o usuário é muito limitado: por exemplo, não há acesso à lista telefônica no cartão SIM, informações de baixo nível sobre a conexão à rede celular e assim por diante. A documentação da API é ainda menos completa, portanto, você deve confiar em exemplos (dos quais existem duas dúzias) e incluir arquivos. No entanto, o módulo pode fazer muitas coisas até conexões SSL: obviamente, o fabricante focou nas funções mais prioritárias.


No entanto, a programação de microcontroladores chineses por meio da API chinesa deve ser amada. Para todos os outros, o fabricante começou a portar micropython para este módulo. Decidi me testar em um projeto de código aberto e continuar esse bom trabalho (link no final do artigo).


micropython


logo


Micropython é um projeto de código aberto que transporta o cPython para microcontroladores. O desenvolvimento é realizado em duas direções. O primeiro é o suporte e o desenvolvimento de bibliotecas principais comuns a todos os microcontroladores que descrevem o trabalho com os principais tipos de dados em python: objetos, funções, classes, strings, tipos atômicos e muito mais. A segunda é, de fato, as portas: para cada microcontrolador é necessário "ensinar" a biblioteca a trabalhar com o UART para entrada e saída, selecionar uma pilha para uma máquina virtual, especificar um conjunto de otimizações. Opcionalmente, o trabalho com hardware é descrito: GPIO, energia, sem fio, sistema de arquivos.
Tudo isso é escrito em C puro com macros: o micropython possui um conjunto de receitas recomendadas, desde a declaração de strings na ROM até a gravação de módulos. Além disso, os módulos auto-escritos python são totalmente suportados (o principal é não esquecer o tamanho da memória). Os curadores do projeto estabeleceram como objetivo a oportunidade de lançar uma dzhanga (figura com um pedaço de pão). Como anúncio publicitário: o projeto vende sua própria placa para estudantes de pyboard , mas as portas para os módulos ESP8266 e ESP32 também são populares.


Quando o firmware estiver pronto e carregado - basta conectar-se ao microcontrolador via UART e entrar no Python REPL.


 $ miniterm.py /dev/ttyUSB1 115200 --raw MicroPython cd2f742 on 2017-11-29; unicorn with Cortex-M3 Type "help()" for more information. >>> print("hello") hello

Depois disso, você pode começar a escrever em python3 quase normal, sem esquecer as limitações de memória.


O módulo A9G não é oficialmente suportado (uma lista de módulos oficialmente suportados está disponível em micropython/ports , existem cerca de uma dúzia deles). No entanto, o fabricante de ferro bifurcou o micropython e criou o ambiente para a porta micropython/ports/gprs_a9 : micropython/ports/gprs_a9 , pela qual muitos agradecimentos a ele. No momento em que me interessei por esse problema, a porta foi compilada com êxito e o microcontrolador me recebeu com REPL. Infelizmente, a partir de módulos de terceiros, havia apenas trabalho com o sistema de arquivos e o GPIO: nada relacionado à rede sem fio e ao GPS estava disponível. Decidi consertar esse defeito e estabeleci o objetivo de portar todas as funções necessárias para um rastreador GPS. A documentação oficial para este caso é desnecessariamente concisa: portanto, tive que vasculhar o código.


Por onde começar


Primeiro, vá para micropython/ports e copie micropython/ports/minimal para a nova pasta em que a porta estará localizada. Em seguida, edite main.c para sua plataforma. Lembre-se de que todo o gostoso está na função main , onde você precisa chamar o inicializador mp_init() , tendo preparado previamente o microcontrolador e as configurações de pilha para ele. Em seguida, para a API orientada a eventos, você precisa chamar pyexec_event_repl_init() e alimentar os caracteres digitados via UART para a função pyexec_event_repl_process_char(char) . Isso fornecerá interoperabilidade através do REPL. O segundo arquivo, micropython/ports/minimal/uart_core.c descreve o bloqueio de entrada e saída no UART. Eu trago o código original do STM32 para aqueles que estão com preguiça de procurar.


main.c


 int main(int argc, char **argv) { int stack_dummy; stack_top = (char*)&stack_dummy; #if MICROPY_ENABLE_GC gc_init(heap, heap + sizeof(heap)); #endif mp_init(); #if MICROPY_ENABLE_COMPILER #if MICROPY_REPL_EVENT_DRIVEN pyexec_event_repl_init(); for (;;) { int c = mp_hal_stdin_rx_chr(); if (pyexec_event_repl_process_char(c)) { break; } } #else pyexec_friendly_repl(); #endif //do_str("print('hello world!', list(x+1 for x in range(10)), end='eol\\n')", MP_PARSE_SINGLE_INPUT); //do_str("for i in range(10):\r\n print(i)", MP_PARSE_FILE_INPUT); #else pyexec_frozen_module("frozentest.py"); #endif mp_deinit(); return 0; }

uart_core.c


 // Receive single character int mp_hal_stdin_rx_chr(void) { unsigned char c = 0; #if MICROPY_MIN_USE_STDOUT int r = read(0, &c, 1); (void)r; #elif MICROPY_MIN_USE_STM32_MCU // wait for RXNE while ((USART1->SR & (1 << 5)) == 0) { } c = USART1->DR; #endif return c; } // Send string of given length void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) { #if MICROPY_MIN_USE_STDOUT int r = write(1, str, len); (void)r; #elif MICROPY_MIN_USE_STM32_MCU while (len--) { // wait for TXE while ((USART1->SR & (1 << 7)) == 0) { } USART1->DR = *str++; } #endif }

Depois disso, você precisa reescrever o Makefile usando as recomendações / compilador do fabricante: tudo aqui é individual. Tudo, idealmente, deve ser suficiente: coletamos, preenchemos o firmware e vemos REPL no UART.
Após reviver o micropython você precisa cuidar do seu bem-estar: configurar o coletor de lixo, a reação correta ao Ctrl-D (reinicialização suave) e algumas outras coisas nas quais não vou me debruçar: consulte o arquivo mpconfigport.h .


Crie um módulo


O mais interessante é escrever seus próprios módulos. Portanto, o módulo (não necessário, mas desejável) começa com seu próprio arquivo mod[].c , que é adicionado pelo Makefile (variável SRC_C , se você seguir a convenção). Um módulo vazio é o seguinte:


 // nlr - non-local return:  C  ,      goto-  . //  nlr_raise             . #include "py/nlr.h" //   .  ,  mp_map_elem_t,  ,   . #include "py/obj.h" //   . mp_raise_ValueError(char* msg)  mp_raise_OSError(int errorcode)   . //  ,   mp_call_function_*     Callable (  callback-). #include "py/runtime.h" #include "py/binary.h" //  header   :       #include "portmodules.h" //    --  .     MP_QSTR_[ ]. MP_OBJ_NEW_QSTR   . //             RAM. //      -      __name__ STATIC const mp_map_elem_t mymodule_globals_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_mymodule) }, }; //      STATIC MP_DEFINE_CONST_DICT (mp_module_mymodule_globals, mymodule_globals_table); //   :             const mp_obj_module_t mp_module_mymodule = { .base = { &mp_type_module }, .globals = (mp_obj_dict_t*)&mp_module_mymodule_globals, };

Obviamente, a porta em si não reconhece a constante mp_module_mymodule : ela deve ser adicionada à variável MICROPY_PORT_BUILTIN_MODULES nas mpconfigport.h porta mpconfigport.h . By the way papéis de parede chatos o nome do chip e o nome da porta também mudam por lá. Após todas essas alterações, você pode tentar compilar o módulo e importá-lo do REPL. Somente um atributo __name__ com o nome do módulo estará disponível para o módulo (um ótimo caso para verificar a conclusão automática no REPL via guia).


 >>> import mymodule >>> mymodule.__name__ 'mymodule'

Constantes


O próximo estágio da complexidade é adicionar constantes. As constantes geralmente são necessárias para configurações ( INPUT , OUTPUT , HIGH , LOW etc.) Tudo aqui é bem simples. Aqui, por exemplo, a constante magic_number = 10 :


 STATIC const mp_map_elem_t mymodule_globals_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_mymodule) }, { MP_OBJ_NEW_QSTR(MP_QSTR_magic_number), MP_OBJ_NEW_SMALL_INT(10) }, };

Teste:


 >>> import mymodule >>> mymodule.magic_number 10

Funções


A adição de uma função a um módulo segue o princípio geral: declarar, quebrar, adicionar (eu dou um exemplo um pouco mais complexo do que na documentação).


 //  STATIC mp_obj_t conditional_add_one(mp_obj_t value) { //   int.         -  :   . int value_int = mp_obj_get_int(value); value_int ++; if (value_int == 10) { //  None return mp_const_none; } //   int return mp_obj_new_int(value); } //    .     // runtime.h   . STATIC MP_DEFINE_CONST_FUN_OBJ_1(conditional_add_one_obj, conditional_add_one); //  STATIC const mp_map_elem_t mymodule_globals_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_mymodule) }, { MP_OBJ_NEW_QSTR(MP_QSTR_magic_number), MP_OBJ_NEW_SMALL_INT(10) }, { MP_OBJ_NEW_QSTR(MP_QSTR_conditional_add_one), (mp_obj_t)&conditional_add_one_obj }, };

Teste:


 >>> import mymodule >>> mymodule.conditional_add_one(3) 4 >>> mymodule.conditional_add_one(9) >>>

Classes (Tipos)


Com as classes (tipos), tudo também é relativamente simples. Aqui está um exemplo da documentação (bem, quase):


 //     STATIC const mp_map_elem_t mymodule_hello_locals_dict_table[] = {}; //   STATIC MP_DEFINE_CONST_DICT(mymodule_hello_locals_dict, mymodule_hello_locals_dict_table); // ,  ,   const mp_obj_type_t mymodule_helloObj_type = { //    { &mp_type_type }, // : helloObj .name = MP_QSTR_helloObj, //  .locals_dict = (mp_obj_dict_t*)&mymodule_hello_locals_dict, }; //    STATIC const mp_map_elem_t mymodule_globals_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_mymodule) }, { MP_OBJ_NEW_QSTR(MP_QSTR_magic_number), MP_OBJ_NEW_SMALL_INT(10) }, { MP_OBJ_NEW_QSTR(MP_QSTR_conditional_add_one), (mp_obj_t)&conditional_add_one_obj }, { MP_OBJ_NEW_QSTR(MP_QSTR_conditional_add_one), (mp_obj_t)&mymodule_helloObj_type }, };

Teste:


 >>> mymodule.helloObj <type 'helloObj'>

O tipo resultante pode ser herdado, comparado, mas não possui um construtor ou dados associados. Os dados são adicionados "ao lado" do construtor: propõe-se criar uma estrutura separada na qual o tipo Python será armazenado separadamente e separadamente - um conjunto de dados arbitrário.


 //  -. ,    typedef struct _mymodule_hello_obj_t { //   mp_obj_base_t base; // -  uint8_t hello_number; } mymodule_hello_obj_t;

Como interagir com esses dados? Uma das maneiras mais difíceis é através do construtor.


 // -,   (,  ,   mymodule_helloObj_type //   ,     - ),   (args  kwargs)  //        : args, kwargs STATIC mp_obj_t mymodule_hello_make_new( const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args ) { //    mp_arg_check_num(n_args, n_kw, 1, 1, true); //   mymodule_hello_obj_t *self = m_new_obj(mymodule_hello_obj_t); //     self->base.type = &mymodule_hello_type; //   self->hello_number = mp_obj_get_int(args[0]) //   return MP_OBJ_FROM_PTR(self); //    __init__, ,  } //      make_new const mp_obj_type_t mymodule_helloObj_type = { { &mp_type_type }, .name = MP_QSTR_helloObj, .locals_dict = (mp_obj_dict_t*)&mymodule_hello_locals_dict, //  .make_new = mymodule_hello_make_new, };

Dos outros campos, há também .print , e acho que o resto da magia do Python3 .


Mas make_new não é necessário para obter uma instância de um objeto: a inicialização pode ser feita em uma função arbitrária. Aqui está um bom exemplo de micropython/ports/esp32/modsocket.c :


 //   :       STATIC mp_obj_t get_socket(size_t n_args, const mp_obj_t *args) { socket_obj_t *sock = m_new_obj_with_finaliser(socket_obj_t); sock->base.type = &socket_type; sock->domain = AF_INET; sock->type = SOCK_STREAM; sock->proto = 0; sock->peer_closed = false; if (n_args > 0) { sock->domain = mp_obj_get_int(args[0]); if (n_args > 1) { sock->type = mp_obj_get_int(args[1]); if (n_args > 2) { sock->proto = mp_obj_get_int(args[2]); } } } sock->fd = lwip_socket(sock->domain, sock->type, sock->proto); if (sock->fd < 0) { exception_from_errno(errno); } _socket_settimeout(sock, UINT64_MAX); return MP_OBJ_FROM_PTR(sock); } //     0-3  STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(get_socket_obj, 0, 3, get_socket);

Métodos vinculados


O próximo passo é adicionar os métodos vinculados. No entanto, isso não é muito diferente de todos os outros métodos. Retornamos ao exemplo da documentação:


 //    :     1 (self) STATIC mp_obj_t mymodule_hello_increment(mp_obj_t self_in) { mymodule_hello_obj_t *self = MP_OBJ_TO_PTR(self_in); self->hello_number += 1; return mp_const_none; } //     MP_DEFINE_CONST_FUN_OBJ_1(mymodule_hello_increment_obj, mymodule_hello_increment); //      'inc' STATIC const mp_map_elem_t mymodule_hello_locals_dict_table[] = { { MP_OBJ_NEW_QSTR(MP_QSTR_inc), (mp_obj_t)&mymodule_hello_increment_obj }, }

Isso é tudo!


 >>> x = mymodule.helloObj(12) >>> x.inc()

Todos os outros atributos: getattr , setattr


Que tal adicionar não funções, usando @property e geralmente seu próprio __getattr__ ? Por favor: isso é feito manualmente ignorando mymodule_hello_locals_dict_table .


 //     ... STATIC void mymodule_hello_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) { mymodule_hello_obj_t *self = MP_OBJ_TO_PTR(self_in); if (dest[0] != MP_OBJ_NULL) { // __setattr__ if (attr == MP_QSTR_val) { self->val = dest[1]; dest[0] = MP_OBJ_NULL; } } else { // __getattr__ if (attr == MP_QSTR_val) { dest[0] = self->val; } } } // ...     attr const mp_obj_type_t mymodule_helloObj_type = { { &mp_type_type }, .name = MP_QSTR_helloObj, //     //.locals_dict = (mp_obj_dict_t*)&mymodule_hello_locals_dict, .make_new = mymodule_hello_make_new, //   - attr .attr = mymodule_hello_attr, };

Algo dolorosamente conciso acabou, você diz. Onde estão todos esses mp_raise_AttributeError ( nota : essa função não existe)? De fato, um AttributeError será chamado automaticamente. O segredo é que dest é uma matriz de dois elementos. O primeiro elemento tem o significado de "saída", somente gravação: ele assume o valor MP_OBJ_SENTINEL se o valor precisar ser gravado e MP_OBJ_NULL se precisar ser lido. Assim, na saída da função, MP_OBJ_NULL é esperado no primeiro caso e algo mp_obj_t no segundo. O segundo elemento é entrada, somente leitura: pega o valor do objeto a ser gravado se o valor precisar ser gravado e MP_OBJ_NULL se precisar ser lido. Você não precisa mudar isso.


Isso é tudo, você pode verificar:


 >>> x = mymodule.helloObj(12) >>> x.val = 3 >>> x.val 3

O mais interessante é que a conclusão da guia no REPL ainda funciona e oferece .val ! Para ser sincero, não sou especialista em C, portanto, só posso adivinhar como isso acontece (redefinindo o operador '==').


Port


Voltando ao módulo A9G, descrevi o suporte de todas as funções básicas, como SMS, GPRS (usockets), GPS, gerenciamento de energia. Agora você pode enviar algo assim para o módulo e ele funcionará:


 import cellular as c import usocket as sock import time import gps import machine #   print("Waiting network registration ...") while not c.is_network_registered(): time.sleep(1) time.sleep(2) #  GPRS print("Activating ...") c.gprs_activate("internet", "", "") print("Local IP:", sock.get_local_ip()) #  GPS gps.on() #    thingspeak host = "api.thingspeak.com" api_key = "some-api-key" fields = ('latitude', 'longitude', 'battery', 'sat_visible', 'sat_tracked') #  ,      ! fields = dict(zip(fields, map(lambda x: "field{}".format(x+1), range(len(fields))) )) x, y = gps.get_location() level = machine.get_input_voltage()[1] sats_vis, sats_tracked = gps.get_satellites() s = sock.socket() print("Connecting ...") s.connect((host, 80)) print("Sending ...") #      ,     HTTP.           HTTP, SSL   print("Sent:", s.send("GET /update?api_key={}&{latitude}={:f}&{longitude}={:f}&{battery}={:f}&{sat_visible}={:d}&{sat_tracked}={:d} HTTP/1.1\r\nHost: {}\r\nConnection: close\r\n\r\n".format( api_key, x, y, level, sats_vis, sats_tracked, host, **fields ))) print("Receiving ...") print("Received:", s.recv(128)) s.close()

O projeto agradece qualquer ajuda possível. Se você gostou do projeto e / ou deste artigo, não se esqueça de deixar um like no github .

Source: https://habr.com/ru/post/pt446090/

More articles:


All Articles