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 MW32x AWS IoT Kit de iniciação
**Importante**
Essa integração de referência está hospedada no Amazon-FreeRTOS repositório que está obsoleto. Recomendamos [começar aqui](freertos-getting-started-modular.md) ao criar um novo projeto. Se você já tem um projeto FreeRTOS existente com base no repositório agora Amazon-FreeRTOS obsoleto, consulte o. [Amazon-FreeRTOS Guia de migração do repositório Github](github-repo-migration.md)
O AWS IoT Starter Kit é um kit de desenvolvimento baseado no mais recente microcontrolador Cortex M4 integrado da NXP 88MW320/88MW322, que integra 802. 11b/g/n Wi-Fi 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](https://devices.amazonaws.com/detail/a3G0h000000OaRnEAK/MW320-AWS-IoT-Starter-Kit) para comprar um de nosso parceiro. Os 88MW320/88MW322 módulos 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.
**Topics**
+ [Configuração do hardware](#gsg-mw32x-hardware)
+ [Configuração do ambiente de desenvolvimento](#gsg-mw32x-dev-env)
+ [Compilação e execução do projeto de demonstração do FreeRTOS](#gsg-mw32x-build-and-run)
+ [Depuração](#gsg-mw32x-debugging)
+ [Solução de problemas](#gsg-mw32x-troubleshooting)
## 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 tty/com porta 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](https://launchpad.net/gcc-arm-embedded/4.9/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 da cadeia de ferramentas gcc-arm integrada.
### 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](https://launchpad.net/gcc-arm-embedded/4.9/4.9-2015-q3-update). O arquivo é `gcc-arm-none-eabi-4_9-2015q3-20150921-linux.tar.bz2`.
1. Copie o arquivo para um diretório de sua escolha. Não deve haver espaços no nome do diretório.
1. Use o comando a seguir para descompactar o arquivo.
```
tar –vxf {{filename}}
```
1. 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
```
1. Baixe o código-fonte do openocd 0.9.0 em. [http://openocd.org/](http://openocd.org/)
1. Extraia o OpenOCD e navegue até o diretório em que você o extraiu.
1. Configure o OpenOCD com o comando a seguir.
```
./configure --enable-ftdi --enable-jlink
```
1. 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](#gsg-mw32x-dev-env-linux-host-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 bit) deve corresponder à versão do Eclipse (32/64 bit). Você pode baixar o JRE em [8 Downloads do Java SE Runtime Environment](http://www.oracle.com/technetwork/java/javase/downloads/jre8-downloads-2133155.html) no site da Oracle.
1. Baixe e instale o “Eclipse IDE for C/C \+\+ Developers” em. [http://www.eclipse.org](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 Wi-Fi de segurança:
`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.
1. Navegue até o diretório de compilação.
```
cd build
```
1. Execute o utilitário make para compilar a aplicação.
```
make all -j4
```
Obtenha a mesma saída mostrada na figura a seguir:
1. 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`.
1. 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.
1. O firmware usa o Wi-Fi chipset para sua funcionalidade, e o Wi-Fi chipset tem seu próprio firmware que também deve estar presente no flash. Você usa o `flashprog.py` utilitário para atualizar o Wi-Fi firmware da mesma forma que fez para atualizar o boot-loader Boot2 e o firmware do MCU. Use os comandos a seguir para atualizar o Wi-Fi firmware.
```
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.
1. 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
```
1. Redefina a placa. Você deve ver logs para a aplicação de demonstração.
1. 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.
1. Depois de instalar o firmware e reiniciar a placa, a aplicação de demonstração deve iniciar conforme mostrado na figura abaixo.
1. (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.
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`.
1. Abra o Eclipse e, quando solicitado, escolha a área de trabalho do Eclipse, conforme mostrado na figura abaixo.
1. Escolha a opção de criar um **projeto Makefile: com código existente**, conforme mostrado na figura abaixo.
1. Escolha **Procurar**, especifique o diretório do código existente e escolha **Concluir**.
1. No painel de navegação, escolha **aws\_demos** no explorador de projetos. Right-click **aws\_demos** **para abrir o menu e, em seguida, escolha Construir.**
Se houver êxito na compilação, ela gerará o arquivo `build/cmake/vendors/marvell/mw300_rd/aws_demos.bin`.
1. 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 Wi-Fi firmware.
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.
1. O firmware usa o Wi-Fi chipset para sua funcionalidade, e o Wi-Fi chipset tem seu próprio firmware que também deve estar presente no flash. Você usa o `flashprog.py` utilitário para atualizar o Wi-Fi firmware da mesma forma que fez para atualizar o boot-loader boot2 e o firmware da MCU. Use os comandos a seguir para atualizar o Wi-Fi firmware.
```
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.
1. 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
```
1. Redefina a placa. Você deve ver logs para a aplicação de demonstração.
1. 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.
## 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 **C/C\+\+ GDB Hardware Debugging** e instale o plug-in.
## 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](#gsg-mw32x-build-and-run).
**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.
+ Habilitando Wi-Fi registros
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
```