Introdução ao kit inicial MW32x AWS IoT - Gratuito RTOS
Configuração do hardwareConfiguração do ambiente de desenvolvimentoCompilação e execução do projeto de demonstração do FreeRTOSDepuraçãoSolução de problemas

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Introdução ao kit inicial MW32x AWS IoT

Importante

Essa integração de referência está hospedada no repositório Amazon-FreeRTOS, que está preterido. Recomendamos começar aqui ao criar um novo projeto. Se você já tem um projeto FreeRTOS existente baseado no repositório Amazon-FreeRTOS que está preterido, consulte o Guia de migração do repositório Github do Amazon FreeRTOS.

O AWS IoT Starter Kit é um kit de desenvolvimento baseado no 88MW320/88MW322, o mais recente microcontrolador Cortex M4 integrado da NXP, que integra Wi-Fi 802.11b/g/n em um único chip microcontrolador. O kit de desenvolvimento é certificado pela FCC. Para obter mais informações, consulte o catálogo do AWS Partner Device para comprar um de nosso parceiro. Os módulos 88MW320/88MW322 também são certificados pela FCC e estão disponíveis para personalização e venda por volume.

Este guia de conceitos básicos mostra como fazer a compilação cruzada da aplicação junto com o SDK em um computador host e, em seguida, carregar o arquivo binário gerado na placa usando as ferramentas fornecidas com o SDK. Quando a aplicação começa a ser executada na placa, é possível depurá-la ou interagir com ela a partir do console serial do computador host.

O Ubuntu 16.04 é a plataforma host compatível para desenvolvimento e depuração. Será possível usar outras plataformas, mas não há suporte oficial para elas. Você deve ter permissões para instalar o software na plataforma host. As ferramentas externas a seguir são necessárias para criar o SDK:

  • Plataforma host do Ubuntu 16.04

  • Cadeia de ferramentas do ARM versão 4_9_2015q3

  • IDE do Eclipse 4.9.0

A cadeia de ferramentas do ARM é necessária para fazer a compilação cruzada da aplicação e do SDK. O SDK aproveita as versões mais recentes da cadeia de ferramentas para otimizar a marca da imagem e encaixar mais funcionalidades em menos espaço. Este guia considera que você esteja usando a versão 4_9_2015q3 da cadeia de ferramentas. Não é recomendável usar versões mais antigas da cadeia de ferramentas. O kit de desenvolvimento é pré-instalado com o firmware do projeto de demonstração do microcontrolador sem fios.

Configuração do hardware

Conecte a placa MW32x ao laptop usando um cabo mini-USB para USB. Conecte o cabo mini-USB ao único conector mini-USB presente na placa. Não é necessário alterar o jumper.

Se a placa estiver conectada a um laptop ou computador desktop, não será necessário obter uma fonte de alimentação externa.

Essa conexão USB fornece o seguinte:

  • Console de acesso à placa. Uma porta tty/com virtual é registrada no host de desenvolvimento que pode ser usada para acessar o console.

  • Acesso JTAG à placa. Isso pode ser usado para carregar ou descarregar imagens de firmware na memória RAM ou flash da placa, ou para fins de depuração.

Configuração do ambiente de desenvolvimento

Para fins de desenvolvimento, o requisito mínimo é a cadeia de ferramentas do ARM e as ferramentas fornecidas com o SDK. As seções a seguir fornecem detalhes sobre a configuração da cadeia de ferramentas do ARM.

Conjunto de ferramentas para GNU

O SDK oferece suporte oficial à cadeia de ferramentas do compilador GCC. A cadeia de ferramentas de compilação cruzada para GNU do ARM está disponível na cadeia de ferramentas integradas do ARM para GNU 4.9-2015-q3-update.

O sistema de compilação é configurado para usar a cadeia de ferramentas do GNU por padrão. Os Makefiles consideram os binários da cadeia de ferramentas do compilador GNU como disponíveis no CAMINHO do usuário e podem ser invocados a partir dos Makefiles. Os Makefiles também consideram os nomes dos arquivos dos binários da cadeia de ferramentas do GNU como prefixados com arm-none-eabi-.

A cadeia de ferramentas do GCC pode ser usada com o GDB para depurar com o OpenOCD (incluído no SDK). Isso fornece o software que interage com o JTAG.

Recomendamos a versão 4_9_2015q3 do conjunto de ferramentas. gcc-arm-embedded

Procedimento de configuração da cadeia de ferramentas do Linux

Siga estas etapas para configurar a cadeia de ferramentas do GCC no Linux.

  1. Faça o download da cadeia de ferramentas tarball disponível na cadeia de ferramentas integradas do ARM para GNU 4.9-2015-q3-update. O arquivo é gcc-arm-none-eabi-4_9-2015q3-20150921-linux.tar.bz2.

  2. Copie o arquivo para um diretório de sua escolha. Não deve haver espaços no nome do diretório.

  3. Use o comando a seguir para descompactar o arquivo.

    tar –vxf filename

  4. Adicione o caminho da cadeia de ferramentas instalada ao PATH do sistema. Por exemplo, anexe a linha a seguir no final do arquivo .profile localizado no diretório /home/user-name.

    PATH=$PATH:path to gcc-arm-none-eabit-4_9_2015_q3/bin
nota

Novas distribuições do Ubuntu podem ter uma versão do Debian do Compilador cruzado do GCC. Nesse caso, você deve remover o Compilador cruzado nativo e seguir o procedimento de configuração acima.

Trabalho com um host de desenvolvimento do Linux

Toda distribuição moderna do desktop Linux, como o Ubuntu ou Fedora, pode ser usada. No entanto, recomendamos atualizar para a versão mais recente. As etapas a seguir foram verificadas para funcionar no Ubuntu 16.04 e consideram que você está usando essa versão.

Instalação de pacotes

O SDK inclui um script para permitir a configuração rápida do ambiente de desenvolvimento em uma máquina Linux configurada recentemente. O script tenta detectar o tipo de máquina e instalar o software adequado automaticamente, incluindo bibliotecas C, biblioteca USB, biblioteca FTDI, ncurses, python e latex. Nesta seção, o nome genérico do diretório amzsdk_bundle-x.y.z indica o diretório raiz do AWS SDK. O nome real do diretório pode ser diferente. Você deve ter privilégios de root.

  • Navegue até o diretório amzsdk_bundle-x.y.z/ e execute esse comando.

    ./lib/third_party/mcu_vendor/marvell/WMSDK/mw320/sdk/tools/bin/installpkgs.sh

Evitando o sudo

Neste guia, a operação flashprog usa o script flashprog.py para instalar o NAND da placa, conforme explicado abaixo. Da mesma forma, a operação ramload usa o script ramload.py para copiar a imagem do firmware do host diretamente para a RAM do microcontrolador, sem instalar o NAND.

Você pode configurar seu host de desenvolvimento Linux para realizar as operações flashprog e ramload sem exigir o comando sudo todas as vezes. Para fazer isso, execute o comando a seguir.

./lib/third_party/mcu_vendor/marvell/WMSDK/mw320/sdk/tools/bin/perm_fix.sh
nota

Você deve configurar suas permissões de host de desenvolvimento Linux dessa forma para garantir uma experiência suave no IDE do Eclipse.

Configuração do console serial

Insira o cabo USB no slot USB do host Linux. Isso aciona a detecção do dispositivo. Você deve ver mensagens como as seguintes no arquivo /var/log/messages ou depois de executar o comando dmesg.


Jan 6 20:00:51 localhost kernel: usb 4-2: new full speed USB device using uhci_hcd and address 127
Jan 6 20:00:51 localhost kernel: usb 4-2: configuration #1 chosen from 1 choice
Jan 6 20:00:51 localhost kernel: ftdi_sio 4-2:1.0: FTDI USB Serial Device converter detected
Jan 6 20:00:51 localhost kernel: ftdi_sio: Detected FT2232C
Jan 6 20:00:51 localhost kernel: usb 4-2: FTDI USB Serial Device converter now attached to ttyUSB0
Jan 6 20:00:51 localhost kernel: ftdi_sio 4-2:1.1: FTDI USB Serial Device converter detected
Jan 6 20:00:51 localhost kernel: ftdi_sio: Detected FT2232C
Jan 6 20:00:51 localhost kernel: usb 4-2: FTDI USB Serial Device converter now attached to ttyUSB1

Verifique se dois dispositivos ttyUSB foram criados. O segundo ttyUSB é o console de série. No exemplo acima, isso é chamado de "ttyUSB1".

Neste guia, usamos o minicom para ver a saída do console de série. Você também pode usar outros programas seriais, como putty. Execute o comando a seguir para executar o minicom no modo de configuração.

minicom –s

No minicom, navegue até Configuração de porta serial e capture as seguintes configurações.

| A - Serial Device : /dev/ttyUSB1
| B – Lockfile Location : /var/lock
| C - Callin Program :
| D - Callout Program :
| E - Bps/Par/Bits : 115200 8N1
| F – Hardware Flow Control : No
| G – Software Flow Control : No

Você pode salvar essas configurações no minicom para uso futuro. A janela do minicom agora exibe mensagens do console de série.

Escolha a janela do console de série e pressione a tecla Enter. Isso exibe um hash (#) na tela.

nota

As placas de desenvolvimento incluem um dispositivo de chip FTDI. O dispositivo FTDI expõe duas interfaces USB para o host. A primeira interface está associada à funcionalidade JTAG do MCU e a segunda interface está associada à porta física UARTx do MCU.

Instalação do OpenOCD

O OpenOCD é um software que fornece depuração, programação no sistema e teste de verificação de limites para dispositivos de destino incorporados.

É necessário ter o OpenOCD versão 0.9. Também é necessário para a funcionalidade do Eclipse. Se uma versão anterior, como a versão 0.7, foi instalada em seu host Linux, remova esse repositório com o comando apropriado para a distribuição Linux que você está usando atualmente.

Execute o comando padrão do Linux para instalar o OpenOCD,

apt-get install openocd

Se o comando acima não instalar a versão 0.9 ou posterior, use o procedimento a seguir para baixar e compilar o código-fonte do openocd.

Como instalar o OpenOCD

  1. Execute o comando a seguir para instalar libusb-1.0.

    sudo apt-get install libusb-1.0

  2. Faça download do código-fonte do OpenOCD 0.9.0 em http://openocd.org/.

  3. Extraia o OpenOCD e navegue até o diretório em que você o extraiu.

  4. Configure o OpenOCD com o comando a seguir.

    ./configure --enable-ftdi --enable-jlink

  5. Execute o utilitário make para compilar o OpenOCD.

    make install

Configuração do Eclipse

nota

Esta seção considera que você concluiu as etapas em Evitando o sudo

O Eclipse é o IDE preferido para desenvolvimento e depuração de aplicações. Ele fornece um IDE avançado e fácil de usar com suporte à depuração integrado, incluindo depuração com reconhecimento de threads. Esta seção descreve a configuração comum do Eclipse para todos os hosts de desenvolvimento que são compatíveis.

Como configurar o Eclipse

  1. Baixe e instale o Java Run Time Environment (JRE).

    O Eclipse exige a instalação do JRE. Recomendamos que você instale isso primeiro, embora ele possa ser instalado depois de instalar o Eclipse. A versão do JRE (32/64 bits) deverá corresponder à versão do Eclipse (32/64 bits). Você pode baixar o JRE em 8 Downloads do Java SE Runtime Environment no site da Oracle.

  2. Baixe e instale o "IDE do Eclipse para desenvolvedores C/C++" do http://www.eclipse.org. A versão do Eclipse 4.9.0 ou posterior é compatível. A instalação exige apenas que você extraia o arquivo baixado. Você executa o executável Eclipse específico da plataforma para iniciar a aplicação.

Compilação e execução do projeto de demonstração do FreeRTOS

Há duas maneiras de executar o projeto de demonstração do FreeRTOS:

  • Usar a linha de comando.

  • Abra o IDE do Eclipse.

Este tópico aborda as duas opções.

Provisionamento

  • Dependendo se você usa a aplicação de teste ou de demonstração, defina os dados de provisionamento em um dos seguintes arquivos:

    • ./tests/common/include/aws_clientcredential.h

    • ./demos/common/include/aws_clientcredential.h

    Por exemplo: .

    #define clientcredentialWIFI_SSID "Wi-Fi SSID"
#define clientcredentialWIFI_PASSWORD "Wi-Fi password"
#define clientcredentialWIFI_SECURITY "Wi-Fi security"
    nota

    Você pode inserir os seguintes valores de segurança de Wi-Fi:

    • eWiFiSecurityOpen

    • eWiFiSecurityWEP

    • eWiFiSecurityWPA

    • eWiFiSecurityWPA2

    O SSID e a senha devem ser colocados entre aspas duplas.

Compilação e execução da demonstração do FreeRTOS usando a linha de comando

  1. Use o comando a seguir para começar a compilar a aplicação de demonstração.

    
cmake -DVENDOR=marvell -DBOARD=mw320 -DCOMPILER=arm-gcc -S .  -Bbuild -DAFR_ENABLE_TESTS=0

    Obtenha a mesma saída mostrada no exemplo a seguir.

    Saída do terminal de comando mostrando detalhes da configuração de compilação do FreeRTOS para uma placa de microcontrolador sem fio Marvell mw300_rd.

  2. Navegue até o diretório de compilação.

    cd build

  3. Execute o utilitário make para compilar a aplicação.

    make all -j4

    Obtenha a mesma saída mostrada na figura a seguir:

    Saída do terminal mostrando o processo de construção de arquivos de objetos C e vinculados a uma biblioteca estática e executável para AWS demonstrações.

  4. Use os comandos a seguir para compilar uma aplicação de teste.

    
cmake -DVENDOR=marvell -DBOARD=mw320 -DCOMPILER=arm-gcc -S .  -Bbuild -DAFR_ENABLE_TESTS=1
cd build
make all -j4

    Execute o comando cmake toda vez que você alternar entre o aws_demos project e o aws_tests project.

  5. Grave a imagem do firmware na instalação da placa de desenvolvimento. O firmware será executado após a redefinição da placa de desenvolvimento. Você deve criar o SDK antes de instalar a imagem para o microcontrolador.

    1. Antes de instalar a imagem do firmware, prepare a instalação da placa de desenvolvimento com os componentes comuns Layout e Boot2. Use os seguintes comandos.

      cd amzsdk_bundle-x.y.z
./vendors/marvell/WMSDK/mw320/sdk/tools/OpenOCD/flashprog.py -l ./vendors/marvell/WMSDK/mw320/sdk/tools/OpenOCD/mw300/layout.txt --boot2 ./vendors/marvell/WMSDK/mw320/boot2/bin/boot2.bin

      O comando flashprog inicia o seguinte:

      • Layout: o utilitário flashprog é instruído primeiro a gravar um layout na instalação. O layout é semelhante às informações de partição da instalação. O layout padrão está localizado em /lib/third_party/mcu_vendor/marvell/WMSDK/mw320/sdk/tools/OpenOCD/mw300/layout.txt.

      • Boot2: este é o carregador de inicialização usado pelo WMSDK. O script flashprog também grava um carregador de inicialização na instalação. O carregador de inicialização carrega a imagem do firmware do microcontrolador depois que ela é instalada na placa. Obtenha a mesma saída mostrada na figura abaixo.

      Saída do comando para atualizar os elementos Layout e boot2.

    2. O firmware usa o chipset Wi-Fi para sua funcionalidade, e o chipset Wi-Fi tem seu próprio firmware que também deve estar presente na instalação. Você usa o utilitário flashprog.py para atualizar o firmware Wi-Fi da mesma forma que fez para atualizar o carregador de inicialização Boot2 e o firmware do MCU. Use os comandos a seguir para instalar o firmware do Wi-Fi.

      cd amzsdk_bundle-x.y.z
./vendors/marvell/WMSDK/mw320/sdk/tools/OpenOCD/flashprog.py --wififw ./vendors/marvell/WMSDK/mw320/wifi-firmware/mw30x/mw30x_uapsta_W14.88.36.p135.bin

      A saída do comando deve ser semelhante à figura abaixo.

      Atualizando o firmware do Wi-Fi

    3. Use os comandos a seguir para instalar o firmware da MCU.

      cd amzsdk_bundle-x.y.z 
./vendors/marvell/WMSDK/mw320/sdk/tools/OpenOCD/flashprog.py --mcufw build/cmake/vendors/marvell/mw300_rd/aws_demos.bin -r

    4. Redefina a placa. Você deve ver logs para a aplicação de demonstração.

    5. Para executar a aplicação de teste, atualize o binário aws_tests.bin localizado no mesmo diretório.

      cd amzsdk_bundle-x.y.z
./vendors/marvell/WMSDK/mw320/sdk/tools/OpenOCD/flashprog.py --mcufw build/cmake/vendors/marvell/mw300_rd/aws_tests.bin -r

      A saída de comando deve ser parecida com a mostrada na figura abaixo.

      Atualizando o firmware do MCU

  6. Depois de instalar o firmware e reiniciar a placa, a aplicação de demonstração deve iniciar conforme mostrado na figura abaixo.

    Início do aplicativo de demonstração

  7. (Opcional) Como método alternativo para testar a imagem, use o utilitário flashprog para copiar a imagem do microcontrolador do host diretamente na RAM do microcontrolador. A imagem não é copiada na instalação, então ela será perdida após a reinicialização do microcontrolador.

    Carregar a imagem do firmware na SRAM é uma operação mais rápida porque inicia o arquivo de execução imediatamente. Esse método é usado principalmente para desenvolvimento iterativo.

    Use os comandos a seguir para carregar o firmware na SRAM.

    cd amzsdk_bundle-x.y.z
./lib/third_party/mcu_vendor/marvell/WMSDK/mw320/sdk/tools/OpenOCD/ramload.py build/cmake/vendors/marvell/mw300_rd/aws_demos.axf

    A saída do comando é mostrada na figura abaixo.

    Carregando a imagem do firmware na SRAM

    Quando a execução do comando for concluída, você deverá ver os logs da aplicação de demonstração.

Compilação e execução da demonstração do FreeRTOS usando o IDE do Eclipse

  1. Antes de configurar um espaço de trabalho do Eclipse, você deve executar o comando cmake.

    Execute o comando a seguir para trabalhar com o projeto Eclipse do aws_demos.

    
cmake -DVENDOR=marvell -DBOARD=mw320 -DCOMPILER=arm-gcc -S .  -Bbuild -DAFR_ENABLE_TESTS=0

    Execute o comando a seguir para trabalhar com o projeto Eclipse do aws_tests.

    
cmake -DVENDOR=marvell -DBOARD=mw320 -DCOMPILER=arm-gcc -S .  -Bbuild -DAFR_ENABLE_TESTS=1
    dica

    Execute o comando cmake toda vez que você alternar entre o projeto aws_demos e o aws_tests.

  2. Abra o Eclipse e, quando solicitado, escolha a área de trabalho do Eclipse, conforme mostrado na figura abaixo.

    Seleção da área de trabalho do Eclipse

  3. Escolha a opção de criar um projeto Makefile: com código existente, conforme mostrado na figura abaixo.

    Criando um projeto Makefile com código existente

  4. Escolha Procurar, especifique o diretório do código existente e escolha Concluir.

    Navegando para localizar o código existente

  5. No painel de navegação, escolha aws_demos no explorador de projetos. Clique com o botão direito do mouse em aws_demos para abrir o menu e escolha Compilar.

    Construindo o projeto aws_demos

    Se houver êxito na compilação, ela gerará o arquivo build/cmake/vendors/marvell/mw300_rd/aws_demos.bin.

  6. Use as ferramentas da linha de comando para atualizar o arquivo de layout (layout.txt), o binário Boot2 (boot2.bin), o binário do firmware MCU (aws_demos.bin) e o firmware Wi-Fi.

    1. Antes de instalar a imagem do firmware, prepare a instalação da placa de desenvolvimento com os componentes comuns, Layout e Boot2. Use os seguintes comandos.

      cd amzsdk_bundle-x.y.z
./vendors/marvell/WMSDK/mw320/sdk/tools/OpenOCD/flashprog.py -l ./vendors/marvell/WMSDK/mw320/sdk/tools/OpenOCD/mw300/layout.txt --boot2 ./vendors/marvell/WMSDK/mw320/boot2/bin/boot2.bin

      O comando flashprog inicia o seguinte:

      • Layout: o utilitário flashprog é instruído primeiro a gravar um layout na instalação. O layout é semelhante às informações de partição da instalação. O layout padrão está localizado em /lib/third_party/mcu_vendor/marvell/WMSDK/mw320/sdk/tools/OpenOCD/mw300/layout.txt.

      • Boot2: este é o carregador de inicialização usado pelo WMSDK. O flashprog também grava um carregador de inicialização na instalação. O carregador de inicialização carrega a imagem do firmware do microcontrolador depois que ela é instalada na placa. Obtenha a mesma saída mostrada na figura abaixo.

      Saída do comando para flash dos elementos Layout e boot2

    2. O firmware usa o chipset Wi-Fi para sua funcionalidade, e o chipset Wi-Fi tem seu próprio firmware que também deve estar presente na instalação. Você usa o utilitário flashprog.py para atualizar o firmware Wi-Fi da mesma forma que fez para atualizar o carregador de inicialização boot2 e o firmware do MCU. Use os comandos a seguir para instalar o firmware do Wi-Fi.

      cd amzsdk_bundle-x.y.z
./vendors/marvell/WMSDK/mw320/sdk/tools/OpenOCD/flashprog.py --wififw ./vendors/marvell/WMSDK/mw320/wifi-firmware/mw30x/mw30x_uapsta_W14.88.36.p135.bin

      A saída do comando deve ser semelhante à figura abaixo.

      Atualizando o firmware do Wi-Fi

    3. Use os comandos a seguir para instalar o firmware da MCU.

      cd amzsdk_bundle-x.y.z
./vendors/marvell/WMSDK/mw320/sdk/tools/OpenOCD/flashprog.py --mcufw build/cmake/vendors/marvell/mw300_rd/aws_demos.bin -r

    4. Redefina a placa. Você deve ver logs para a aplicação de demonstração.

    5. Para executar a aplicação de teste, atualize o binário aws_tests.bin localizado no mesmo diretório.

      cd amzsdk_bundle-x.y.z
./vendors/marvell/WMSDK/mw320/sdk/tools/OpenOCD/flashprog.py --mcufw build/cmake/vendors/marvell/mw300_rd/aws_tests.bin -r

      A saída de comando deve ser parecida com a mostrada na figura abaixo.

      Atualizando o firmware do MCU

Depuração

  • Inicie o Eclipse e escolha Ajuda, em seguida, escolha Instalar novo software. No menu Trabalhar com, escolha Todos os sites disponíveis. Insira o texto do filtro GDB Hardware. Selecione a opção Depuração de hardware GDB C/C++ e instale o plug-in.

    Captura de tela da janela de instalação na interface do software, mostrando o item GDB Hardware Debugging selecionado para instalação na categoria de hardware gdb.

Solução de problemas

Problemas de rede

Verifique suas credenciais de rede. Consulte "Provisionamento" em Compilação e execução do projeto de demonstração do FreeRTOS.

Habilitação de logs adicionais

  • Habilitar logs específicos da placa.

    Habilite chamadas para wmstdio_init(UART0_ID, 0) na função prvMiscInitialization no arquivo main.c em testes ou demonstrações.

  • Habilitação de logs de Wi-Fi

    Ative a macro CONFIG_WLCMGR_DEBUG no arquivo freertos/vendors/marvell/WMSDK/mw320/sdk/src/incl/autoconf.h.

Uso do GDB

Recomendamos que você use os arquivos de comando arm-none-eabi-gdb e gdb empacotados junto com o SDK. Navegue até o diretório .

cd freertos/lib/third_party/mcu_vendor/marvell/WMSDK/mw320

Execute o comando a seguir (em uma única linha) para se conectar ao GDB.


arm-none-eabi-gdb -x ./sdk/tools/OpenOCD/gdbinit ../../../../../../build/cmake/vendors/marvell/mw300 _rd/aws_demos.axf