Eagleye 530s

A Seeed é uma desenvolvedora experiente de kits de desenvolvimento para plataformas de tecnologia de IoT. Nosso mais recente kit de desenvolvimento — o Eagleye 530s — foi projetado para ajudar você a começar a desenvolver produtos e serviços para a plataforma IoT Samsung ARTIK™.

O Eagleye 530s é um kit de desenvolvimento de alto desempenho, pré-testado, econômico e pronto para produção, que incorpora o Samsung ARTIK™ 530s — um sistema-em-módulo (SoM) de 1GB — em uma placa personalizada do tamanho de um cartão de crédito. Para mais informações sobre o ARTIK™ 530s, clique aqui.

O que é o Samsung ARTIK™? O Samsung ARTIK™ é uma plataforma IoT pré-integrada composta por sistemas‑em‑módulos (SoMs) de nível empresarial, serviços em nuvem e segurança ponta a ponta para o design e desenvolvimento de soluções IoT robustas. Desenvolvedores frequentemente subestimam a importância da segurança ao projetar e construir produtos de IoT. Os serviços de segurança integrados do ARTIK para SoMs e nuvem tornam mais fácil para você tornar seus produtos seguros.

Como mencionado acima, o Eagleye530s é baseado no ARTIK 530s 1GB SoM, que é um Quad Core Cortex® A9 rodando a 1,2 GHz com memória Flash de 4 B, recursos de segurança baseados em hardware e sistema operacional Linux (Ubuntu). O Eagleye 530s também fornece um conector de 40 pinos GPIO e interface de acessórios para Micro SD, Ethernet 10/100/1000, Wi‑Fi 802.11 a/b/g/n, Bluetooth BLE 4.2 802.15.4 e ZigBee/Thread. Ele também oferece suporte a HDMI completo, interfaces de câmera MIPI, vídeo e mídia de áudio.

Como o Eagleye 530s é compatível em pinos com muitos acessórios de hardware de “maker”, ele permite que desenvolvedores do Samsung ARTIK™ aproveitem facilmente o amplo mercado de acessórios “maker” e criem protótipos e construam com sensores prontos para uso (por exemplo, GrovePi+,sensores Grove), reconhecimento de voz (por exemplo, ReSpeaker 2-mic array e ReSpeaker 4-mic array), relés, GPS, conectividade celular e muito mais, oferecendo muitas opções para desenvolvedores corporativos que criam provas de conceito (PoC) ricas em recursos ou produtos prontos para produção.

Versão

Versão do Produto	Alterações	Data de Lançamento
Eagleye 530s Rev1.0	Inicial	28 Fev 2018

Recursos

• Alimentado pela plataforma IoT Samsung ARTIK™.
• Incorpora o ARTIK 530s 1GB SoM, um Quad Core Cortex® A9 rodando a 1,2 GHz.
• Inclui conector GPIO de 40 pinos e interface para acessórios.
• Suporte para Micro SD, Ethernet 10/100/1000, Wi‑Fi 802.11 a/b/g/n, Bluetooth BLE 4.2 802.15.4 e ZigBee/Thread.
• Suporta HDMI completo, interface de câmera MIPI, vídeo e mídia de áudio.

Especificação

Parâmetro		Valor/Faixa
Processador
	CPU	Quad core ARM® Cortex®[email protected]
	GPU	Acelerador de gráficos 3D
Mídia
	Camera I/F	MIPI CSI de 4 vias até 5M (1920x1080@30fps)
	Display	MIPI DSI de 4 vias e HDMI1.4a (1920x1080p@60fps) ou LVDS (1280x720p@60fps)
	Áudio	Duas entradas/saídas de áudio I2S
Memória
	DRAM	512MB/1GB DDR3
	FLASH	4GB eMMC v4.5
Segurança
	Secure Element	Autenticação ponto a ponto segura e transferência de dados
Rádio
	WLAN	IEEE 802.11a/b/g/n, banda dupla SISO
	Bluetooth®	4.2 (BLE+Clássico)
	802.15.4	ZigBee®/Thread
Gerenciamento de Energia
	PMIC	Fornece toda a alimentação do Módulo ARTIK 530 usando reguladores buck e LDOs na placa
Interfaces
	Ethernet	10/100/1000Base-T MAC (requer PHY externo)
	I/O Analógico e Digital	GPIO, UART, I2C, SPI, USB Host, USB OTG, HSIC, ADC, PWM, I2S, JTAG

Visão Geral do Hardware

Diagrama de Blocos

Interfaces

As figuras abaixo mostram a visualização geral da PARTE SUPERIOR e INFERIOR do Eagleye 530s.

• ⓐ Alimentação CC: fonte de alimentação de 5V CC.

• ⓑ Interface USB Host 2.0: possui duas interfaces USB 2.0.

• ⓒ Ethernet: a interface Ethernet é baseada na 802.3az-2010 em conformidade com o padrão Energy Efficient Ethernet (EEE). A velocidade teórica máxima da interface é de 1000 Mbps.

• ⓓ Conector de Fone de Ouvido: possui uma interface de fone de ouvido de 4 pinos com suporte a áudio estéreo

• ⓔ Chave de Boot: Quando 'eMMc 1st Boot' é selecionado como opção de boot, o sistema tentará primeiro inicializar a partir do eMMc; se isso falhar, o sistema procurará por um Cartão SD para inicializar. Se a inicialização a partir do Cartão SD também falhar, o sistema tentará inicializar por USB. Ao escolher a opção de boot pelo Cartão SD, o sistema inicia tentando inicializar pelo SD e, se isso falhar, continuará tentando um boot por USB. Quando USB é selecionado como o mecanismo de boot preferido, somente um boot por USB será tentado.

SW402	eMMc 1st Boot	SD Card 1st Boot	USB 1st Boot
1	Off	Off	On
2	Off	Off	On
3	X	X	X
4	Off	On	X

• ⓕ HDMI: possui um conector HDMI 1.4a. Os seguintes formatos de vídeo são suportados:

  • 480p/480i @59.94Hz/60Hz, 576p/576i@50Hz
  • 720p/720i @50Hz/59.94Hz/60Hz
  • 1080p/1080i @50Hz/59.94Hz/60Hz

• ⓖ USB OTG: possui uma porta USB OTG.

• ⓗ USB UART: possui uma porta USB UART.

• ⓘ Botão de Usuário S4: chave chamada S4, mapeada para GPIO 54.

• ⓚ LED de Ligar: o LED será aceso quando a placa for ligada.

• ⓛ LED de Entrada de Energia: o LED será aceso quando a placa receber alimentação.

• ⓜ LED de Cartão SD Inserido: o LED será aceso quando o SD for inserido na placa.

• ⓝ Botão de Usuário S3: chave chamada S3, mapeada para GPIO 50.

• ⓞ MIPI CSI: a interface MIPI CSI pode ter uma resolução estática de 5M pixels ou uma resolução dinâmica para captura de vídeo de 1080P.

• ⓟ ANT(802.11): se a funcionalidade 802.11 ou Bluetooth® for necessária, a antena que acompanha o Eagleye 530s deve ser conectada.

• ⓠ Reset: reinicialização da placa.

• ⓡ Alimentação: depois que a chave de alimentação for ligada, pressione o botão de energia (S1) por cerca de 1 segundo.

• ⓢ ANT(802.11): Se a funcionalidade 802.11 ou Bluetooth® for necessária, a antena que está incluída como parte do Eagleye 530s deve ser conectada.

• ⓣ Pinos de Usuário: Para torná-los dispositivos versáteis de controle e monitoramento, o Eagleye 530s fornece muitos pinos de sinal programáveis. Esses pinos lidam diretamente com tarefas como controlar relés, gerar tensões analógicas e monitorar sensores analógicos, bem como tarefas complexas envolvendo comunicação paralela e serial com dispositivos de controle e sensores mais sofisticados.

• ⓤ ANT(Zigbee): Se a funcionalidade Zigbee for necessária, a antena que está incluída como parte do Eagleye 530s deve ser conectada.

• ⓥ Interruptor de Alimentação: Através da seleção dos jumpers JP1 e JP2, a fonte de alimentação pode ser selecionada. Quando a alimentação é fornecida por um Adaptador DC-5V, o jumper JP2 será colocado e a posição 3-4 será conectada. Quando os jumpers JP1 estiverem na posição 1-2, a alimentação será fornecida pela usb-uart. Quando o Eagleye 530s for usado com um adaptador de alimentação externo, certifique-se de usar um adaptador de 5V-2.5A com um conector de 2.1x5.5mm.

atenção

NUNCA conecte ambos ao mesmo tempo!

• ⓦ Slot para cartão SD: possui uma interface SD-CARD com suporte a SD3.0.

• ⓧ JTAG: possui uma interface JTAG.

Desenho Mecânico

nota

Em Desenho Mecânico todas as dimensões estão em [mm].

Ideias de Aplicação

• DIY
• IoT e Casa Inteligente
• Robô

Primeiros Passos

Demo de Unboxing

Esta seção descreverá como começar a trabalhar com o seu Ambiente de Desenvolvimento Eagleye 530s configurando uma conexão serial no seu PC de desenvolvimento e inicializando o Ambiente de Desenvolvimento Eagleye 530s.

Hardware

• Passo 1. Ajuste o interruptor de alimentação (nomeado como número 21 na visão geral de hardware) para USB.

• Passo 2. Conecte o cabo USB do PC ao USB UART (nomeado como número 8 na visão geral de hardware).

• Passo 3. Pressione o botão de alimentação por mais de 1 segundo e veremos os LEDs Verde/Vermelho (consulte o Número 10/11 na visão geral de hardware) acenderem.

  

Software

Configurar uma conexão com o Módulo Eagleye 530s pode ser feito de forma com fio ou sem fio. Aqui escolhemos instalar o PuTTY, um console serial gratuito. O software pode ser baixado em http://www.putty.org/. Uma vez baixado, siga os passos abaixo:

• Passo 1. Abra o gerenciador de dispositivos no painel de controle.
• Passo 2. Ao usar um PC, instale o driver USB para Serial. O driver pode ser encontrado no seguinte local: https://www.ftdichip.com/Drivers/CDM/CDM21218_Setup.zip. Para outros drivers, visite https://www.ftdichip.com/Drivers/D2XX.htm.
• Passo 3. Verifique o número da porta COM no seu PC quando você conectar o cabo serial USB. No nosso caso, a porta COM alocada é a COM9.

• Passo 4. Defina a configuração do PuTTY da seguinte forma:
  • Defina a "Serial line" como o número da porta COM encontrado no passo 3.
  • Defina a velocidade da COM para "115200".
  • Defina o tipo de conexão para "Serial".
  • Salve a sessão como Eagleye 530s.
• Passo 5. Selecione sua sessão salva e clique no botão "Open".

• Passo 6. O nome de usuário e a senha são root.
• Passo 7. Veremos o terminal como abaixo.

Brincar com os LEDs onboard

• Passo 1. Baixe blink_led.py ou copie o código abaixo e cole em blink_led.py.

#!/usr/bin/python

import time
import sys

print "Blink an LED"
ledpin = 159 # Blink the blue led, please change to 43 for red led

#export GPIO pin by opening file and writing the pin number to it
pinctl = open("/sys/class/gpio/export", "wb", 0)
try:
    pinctl.write( str(ledpin))
    print "Exported pin", str(ledpin)
except:
    print "Pin ", str(ledpin), " has been exported"
pinctl.close()

#set GPIO pin to be digital output
filename = '/sys/class/gpio/gpio%d/direction' % ledpin
pinctldir = open(filename, "wb", 0)
try:
    pinctldir.write("out")
    print "Set pin ", str(ledpin), " as digital output"
except:
    print "Failed to set pin direction"
pinctldir.close()

#unexport GPIO pin when we are done
def exit_gpio():
    pinctl = open("/sys/class/gpio/unexport", "wb", 0)
    try:
        pinctl.write( str(ledpin))
        print "Unexported pin", str(ledpin)
    except:
        print "Pin ", str(ledpin), " has been unexported"
    pinctl.close()

#change GPIO pin value every 10 seconds
filename = '/sys/class/gpio/gpio%d/value' % ledpin
while True:
    try:
        pin = open(filename, "wb", 0)
        pin.write( str(1) )
        time.sleep(1)

        pin.write( str(0) )
        time.sleep(1)
        pin.close()
    except:
        exit_gpio()
        sys.exit(0)

• Passo 2. Execute 'python blink_led.py'
• Passo 3. Veremos o LED piscar.

Brincar com os Botões onboard

• Passo 1. Baixe read_button.py ou copie o código abaixo para read_button.py.

#!/usr/bin/python

import time
import sys

print "Toggle a button"
buttonpin = 54 # Read S4 button, please change to 50 for S3 button

#export pin 8 by opening file and writing the pin number to it
pinctl = open("/sys/class/gpio/export", "wb", 0)
try:
    pinctl.write( str(buttonpin))
    print "Exported pin", str(buttonpin)
except:
    print "Pin ", str(buttonpin), " has been exported"
pinctl.close()

#set pin to be digital input
filename = '/sys/class/gpio/gpio%d/direction' % buttonpin
pinctldir = open(filename, "wb", 0)
try:
    pinctldir.write("in")
    print "Set pin ", str(buttonpin), " as digital input"
except:
    print "Failed to set pin direction"
pinctldir.close()

def exit_gpio():
    #unexport pin
    pinctl = open("/sys/class/gpio/unexport", "wb", 0)
    try:
        pinctl.write( str(buttonpin))
        print "Unexported pin", str(buttonpin)
    except:
        print "Pin ", str(buttonpin), " has been unexported"
    pinctl.close()

#pin value changes when the button is pressed
filename = '/sys/class/gpio/gpio%d/value' % buttonpin
while True:
    try:
        pin = open(filename, "rb", 0)
        print pin.read()
        time.sleep(1)
        pin.close()
    except KeyboardInterrupt:
        exit_gpio()
        sys.exit(0)

• Passo 2. Execute 'python read_button.py'
• Passo 3. Veremos as informações do terminal como abaixo.

[root@artik ~]# python read_button.py
Toggle a button
Pin  54  has been exported
Set pin  54  as digital input
1
1
0
0

Redes Ethernet e Wi-Fi

As instruções abaixo discutem a configuração de uma rede de área local (LAN) com fio ou sem fio. A porta LAN Ethernet (com fio) está sempre disponível. Um circuito de LAN sem fio (WLAN) está disponível separadamente e pode ser configurado pelo Connection Manager.

• Passo 1. Procure por pontos de acesso sem fio. Digite os comandos a seguir. connmanctl para obter o prompt >.
• Passo 2. scan wifi para procurar pontos de acesso disponíveis (aguarde até terminar).
• Passo 3. services para listá-los.
• Passo 4. Selecione um ponto de acesso. Ainda dentro do prompt >, digite os comandos a seguir.
• Passo 5. agent on se você quiser que o Connection Manager solicite uma senha.
• Passo 6. connect wifi_xxxx para escolher o ponto de acesso desejado (você pode usar a tecla tab para começar e para autocompletar sua entrada).
• Passo 7. Responda à solicitação de senha do agente, se necessário.
• Passo 8. quit quando terminar.
• Passo 9. Não será necessário repetir esse processo no futuro: a conexão acontece automaticamente a partir de agora.

Aqui estão as informações do terminal.

[root@artik ~]# connmanctl
Error getting VPN connections: The name net.connman.vpn was not provided by any connmanctl> scan wifi
Scan completed for wifi
connmanctl> scan wifi
connmanctl> services
*AO Wired                ethernet_000000000000_cable
    seeed                wifi_722c1f37ca11_XXXXXXXX_managed_psk
    ReSpeaker1DD346      wifi_722c1f37ca11_XXXXXXXX_managed_none
connmanctl> agent on
Agent registered
connmanctl> connect wifi_722c1f37ca11_XXXXXXXX_managed_psk
Agent RequestInput wifi_722c1f37ca11_XXXXXXXX_managed_psk
  Passphrase = [ Type=psk, Requirement=mandatory ]
Passphrase? 2018seeed
connmanctl> quit
[root@artik ~]#

Atualização de Firmware

• Passo 1. Baixe o firmware, os arquivos para o "ARTIK 530s 1G".
• Passo 2. Use a ferramenta Etcher para gravar o firmware no cartão SD.
• Passo 3. Conecte o cartão SD ao slot SD do Eagleye 530s.
• Passo 4. Altere a chave de boot (nomeada como número 21 na visão geral de hardware) para colocar o Pino 4 em on.
• Passo 5. Conecte o cabo USB do PC ao USB UART (nomeado como número 8 na visão geral de hardware).
• Passo 6. Pressione o botão de alimentação por mais de 1 segundo e veremos os LEDs Verde/Vermelho/Azul (consulte o Número 10/11/12 na visão geral de hardware) acenderem.
• Passo 7. Veremos a mensagem abaixo e o firmware será baixado com sucesso.

• Passo 8. Desligue a placa, remova o cartão SD e coloque novamente o pino 4 da chave de boot na posição off.

Brincar com Programação de Pinos

As placas Eagleye fornecem muitos pinos de sinal programáveis. Alguns destes são pinos de Entrada/Saída de Uso Geral (GPIO), enquanto outros são pinos de propósito fixo para entrada analógica, saída modulada por largura de pulso e comunicação serializada.

• Entrada Digital (GPIO) – detectando um nível de sinal CC em baixo (GND) ou alto (Vcc)
• Saída Digital (GPIO) – acionando um nível CC (GND ou Vcc) que pode ser controlado dinamicamente
• Saída de Forma de Onda (PWM) – comutando níveis CC por um circuito de Modulação por Largura de Pulso com frequência e ciclo de trabalho que podem ser programados dinamicamente.
• Portas Seriais (I2C e UART) – enviando e recebendo dados de acordo com protocolos padrão da indústria.
• Entrada Analógica (ADC) – lendo um nível de sinal variável e processando através de um conversor analógico‑digital

A funcionalidade sysfs do kernel Linux fornece bibliotecas para controlar e monitorar pinos programáveis. Detalhes estão disponíveis na referência.

Aqui está o pinout dos conectores com seus significados.

Descrição	Nome do Pino	Número do Pino	Número do Pino	Nome do Pino	Descrição
3.3V	3.3V	1	2	5V	5V
I2C	XI2C0_SDA	3	4	5V	5V
I2C	XI2C0_SCL	5	6	GND	GND
GPIO_161	XAGPIO0	7	8	XUART0_TX	UART
GND	GND	9	10	XUART0_RX	UART
GPIO_128	XGPIO0	11	12	I2SBCK1	I2S
GPIO_129	XGPIO1	13	14	GND	GND
PWM	PWM2	15	16	XGPIO2	GPIO_130
3.3V	3.3V	17	18	XGPIO3	GPIO_46
SPI	XSPIO_MOSI	19	20	GND	GND
SPI	XSPIO_MISO	21	22	PWM0	PWM
SPI	XSPIO_CLK	23	24	XSPIO0_CS	SPI
GND	GND	25	26	XGPIO4	GPIO_14
NC	NC	27	28	NC	NC
GPIO_27	XGPIO9	29	30	GND	GND
GPIO_25	XGPIO6	31	32	XGPIO7	GPIO_0
GPIO_26	XGPIO8	33	34	GND	GND
I2S	I2SLRCLK1	35	36	XADC0	ADC
ADC	XADC1	37	38	I2SDIN1	I2S
GND	GND	39	40	I2SDOUT1	I2S

Controle de GPIO via Sysfs

Por exemplo, o pino 11 é GPIO e pode ser usado como entrada ou saída digital. Para usar um GPIO específico, primeiro definimos sua direção (modo) como entrada ou saída e então lemos ou escrevemos nele conforme necessário.

Os tutoriais Brincar com LEDs onboard e Brincar com botões onboard fornecem exemplos da programação necessária para pinos de E/S digitais.

cuidado

Altere o número específico do pino GPIO no programa python do led/botão.

Controle de PWM via Sysfs

Por exemplo, o pino 22 é PWM. Podemos conectar o PWM do LED ao PWM dos 40 pinos e também ao GND. Podemos definir period e duty_cycle (o limite máximo é 1.000.000.000, expresso em ns). duty_cycle deve sempre ser menor que period.

O exercício a seguir demonstra o uso de um pino PWM, definindo uma taxa de piscada fixa.

• Passo 1. Exportar PWM0

  echo 0 > /sys/class/pwm/pwmchip0/export

Um subdiretório pwm0 é criado. (Podemos usar echo 0 para criar pwm0, echo 2 para criar pwm2.)

• Passo 2. Definir atributos

  • a) Definir period (Unidade: ns) para 1 s

    echo 1000000000 > /sys/class/pwm/pwmchip0/pwm0/period

  • b) Definir duty_cycle (Unidade: ns) para 500 ms

    echo 500000000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle

  • c) Habilitar PWM0

    echo 1 > /sys/class/pwm/pwmchip0/pwm0/enable

  • d) Desabilitar PWM0

    echo 0 > /sys/class/pwm/pwmchip0/pwm0/enable

• Passo 3. Unexport PWM0

  echo 0 > /sys/class/pwm/pwmchip0/unexport

Aqui estão as informações do terminal para pwm0.

[root@artik pwmchip0]# echo 0 > /sys/class/pwm/pwmchip0/export    # please change to echo 2 for pwm2
[root@artik pwmchip0]# echo 1000000000 > /sys/class/pwm/pwmchip0/pwm0/period # please change to pwm2 from pwm0 for pwm2
[root@artik pwmchip0]# echo 500000000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle # please change to pwm2 from pwm0 for pwm2
[root@artik pwmchip0]# echo 1 > /sys/class/pwm/pwmchip0/pwm0/enable  # please change to pwm2 from pwm0 for pwm2
[root@artik pwmchip0]# echo 0 > /sys/class/pwm/pwmchip0/pwm0/enable # please change to pwm2 from pwm0 for pwm2

Controle de ADC via Sysfs

Por exemplo, o pino 36 é ADC0. Os exemplos de linha de comando a seguir demonstram como ler o valor atual de ADC0.

[root@artik dev]# cat /sys/devices/platform/c0000000.soc/c0053000.adc/iio:device0/in_voltage0_raw
0
[root@artik dev]# cat /sys/devices/platform/c0000000.soc/c0053000.adc/iio:device0/in_voltage0_raw
1211
[root@artik dev]# cat /sys/devices/platform/c0000000.soc/c0053000.adc/iio:device0/in_voltage0_raw
2027
[root@artik dev]# cat /sys/devices/platform/c0000000.soc/c0053000.adc/iio:device0/in_voltage0_raw
3017
[root@artik dev]# cat /sys/devices/platform/c0000000.soc/c0053000.adc/iio:device0/in_voltage0_raw
4095

nota

Altere in_voltage0_raw para in_voltage1_raw se usarmos o pino 37 (ADC1).

Controle de UART

• Passo 1. Execute o comando abaixo para habilitar UART0, e podemos ver ttyAMA4 na lista, testado com ARTIK 530s 1G Secure Module Firmware (Ubuntu): A533s_os_18.05.00.

cd /sys/kernel/config/device-tree/overlays/
mkdir ttyAMA4
cd /boot/overlays
cat s5p4418-artik533-compy-serial4.dtbo  > /sys/kernel/config/device-tree/overlays/ttyAMA4/dtbo
cd /dev
ls tty*

• Passo 2. Conecte o UART0 TX/RX ao adaptador USB2Serial.

Número do Pino	Nome do Pino	Adaptador USB2Serial
6	GND	GND
8	XUART0_TX	RX
10	XUART0_RX	TX

• Passo 3. Enviar "hello" para UART0

stty -F /dev/ttyAMA4 
echo "hello .." > /dev/ttyAMA4

• Passo 4. Podemos ver o monitor serial como abaixo.

hello ..
hello ..
hello ..

Brincar com Microfones ReSpeaker

Brincar com 2 Mics Pi HAT

Hardware

Instalar o Driver de 2 Mics

• Passo 1. Baixar o driver Seeed-Voicecard.

[root@artik ~]# apt update
[root@artik ~]# apt install git
[root@artik ~]# git clone https://github.com/respeaker/seeed-voicecard
[root@artik ~]# cd seeed-voicecard
[root@artik seeed-voicecard]# git checkout remotes/origin/artikpi -b artiki

• Passo 2. Instalar o driver Seeed-Voicecard.

[root@artik ~]# cd seeed-voicecard/
[root@artik seeed-voicecard]# mount -o remount,rw /lib/modules
[root@artik seeed-voicecard]# sudo mkdir -p /lib/modules/4.4.113-0533GS0F-44U-01Q5/kernel/sound/soc/codecs/
[root@artik seeed-voicecard]# sudo cp snd-soc-ac108.ko.0533GS0F-44U-01Q5 /lib/modules/4.4.113-0533GS0F-44U-01Q5/kernel/sound/soc/codecs/snd-soc-ac108.ko
[root@artik seeed-voicecard]# sudo cp snd-soc-wm8960.ko.0533GS0F-44U-01Q5 /lib/modules/4.4.113-0533GS0F-44U-01Q5/kernel/sound/soc/codecs/snd-soc-wm8960.ko
[root@artik seeed-voicecard]# sudo depmod -a

• Passo 3. Habilitar 2 Mics.

[root@artik ~]# cd seeed-voicecard
[root@artik seeed-voicecard]# su root
[root@artik seeed-voicecard]# mkdir /sys/kernel/config/device-tree/overlays/seeed-voicecard
[root@artik seeed-voicecard]# cat seeed-2mic-voicecard-artik.dtbo > /sys/kernel/config/device-tree/overlays/seeed-voicecard/dtbo
[root@artik seeed-voicecard]# cp wm8960_asound.state /var/lib/alsa/asound.state
[root@artik seeed-voicecard]# alsactl --file=wm8960_asound.state restore

atenção

Execute o Passo 3 novamente após reiniciar, caso contrário ele não conseguirá detectar a Seeed Voicecard.

• Passo 4. Use o arecord para listar os dispositivos de gravação.

[root@artik seeed-voicecard]# arecord -L
null
    Discard all samples (playback) or generate zero samples (capture)
pulse
    PulseAudio Sound Server
default
    Playback/recording through the PulseAudio sound server
playback
dmixed
ac108
sysdefault:CARD=Audio
    Artik530 raptor Audio,
    Default Audio Device
dmix:CARD=Audio,DEV=0
    Artik530 raptor Audio,
    Direct sample mixing device
dsnoop:CARD=Audio,DEV=0
    Artik530 raptor Audio,
    Direct sample snooping device
hw:CARD=Audio,DEV=0
    Artik530 raptor Audio,
    Direct hardware device without any conversions
plughw:CARD=Audio,DEV=0
    Artik530 raptor Audio,
    Hardware device with all software conversions
sysdefault:CARD=seeed2micvoicec
    seeed-2mic-voicecard,
    Default Audio Device
dmix:CARD=seeed2micvoicec,DEV=0
    seeed-2mic-voicecard,
    Direct sample mixing device
dsnoop:CARD=seeed2micvoicec,DEV=0
    seeed-2mic-voicecard,
    Direct sample snooping device
hw:CARD=seeed2micvoicec,DEV=0
    seeed-2mic-voicecard,
    Direct hardware device without any conversions
plughw:CARD=seeed2micvoicec,DEV=0
    seeed-2mic-voicecard,
    Hardware device with all software conversions

Capturar/Reproduzir Áudio

• Iniciar gravação usando a Linha de Comando

arecord -f cd -Dplughw:1,0 /tmp/test.wav
aplay -Dplughw:1,0 /tmp/test.wav

Aqui está a configuração de hardware. Podemos ouvir a reprodução pelo conector de áudio dos 2 microfones.

• Iniciar a gravação usando Python

  • Etapa 1. Instale o pacote pyaudio com os comandos abaixo

    apt install python-pyaudio

  • Etapa 2. Use um editor de texto como vi para criar este arquivo de código recorder_2Mics.py, que grava um clipe de áudio de 10 s chamado test.wav.

import pyaudio
import wave

FORMAT = pyaudio.paInt16
CHANNELS = 2
RATE = 48000
CHUNK = 1024
RECORD_SECONDS = 10
WAVE_OUTPUT_FILENAME = "test.wav"

audio = pyaudio.PyAudio()

# start Recording
stream = audio.open(format=FORMAT, channels=CHANNELS, rate=RATE, input=True, frames_per_buffer=CHUNK)
print "recording audio..."
frames = []

threshold = 800
for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
   data = stream.read(CHUNK)
   frames.append(data)
print "done recording"

# stop Recording
stream.stop_stream()
stream.close()
audio.terminate()

waveFile = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
waveFile.setnchannels(CHANNELS)
waveFile.setsampwidth(audio.get_sample_size(FORMAT))
waveFile.setframerate(RATE)
waveFile.writeframes(b''.join(frames))
waveFile.close()

cuidado

Para mais informações, como por exemplo brincar com o Google Assistant, consulte ReSpeaker 2-Mics Pi HAT.

Brincar com 4 Mics Pi HAT

Hardware

Instalar driver de 4 Mics

• Etapa 1. Baixe o driver Seeed-Voicecard.

[root@artik ~]# apt update
[root@artik ~]# apt install git
[root@artik ~]# git clone https://github.com/respeaker/seeed-voicecard
[root@artik ~]# cd seeed-voicecard
[root@artik seeed-voicecard]# git checkout remotes/origin/artikpi -b artiki

• Etapa 2. Instale o driver Seeed-Voicecard.

[root@artik seeed-voicecard]# mount -o remount,rw /lib/modules
[root@artik seeed-voicecard]# sudo mkdir -p /lib/modules/4.4.113-0533GS0F-44U-01Q5/kernel/sound/soc/codecs/
[root@artik seeed-voicecard]# sudo cp snd-soc-ac108.ko.0533GS0F-44U-01Q5 /lib/modules/4.4.113-0533GS0F-44U-01Q5/kernel/sound/soc/codecs/snd-soc-ac108.ko
[root@artik seeed-voicecard]# sudo cp snd-soc-wm8960.ko.0533GS0F-44U-01Q5 /lib/modules/4.4.113-0533GS0F-44U-01Q5/kernel/sound/soc/codecs/snd-soc-wm8960.ko
[root@artik seeed-voicecard]# sudo depmod -a

• Etapa 3. Habilite 4 Mics.

[root@artik ~]# cd seeed-voicecard
[root@artik seeed-voicecard]# su root
[root@artik seeed-voicecard]# mkdir /sys/kernel/config/device-tree/overlays/seeed-voicecard
[root@artik seeed-voicecard]# cat seeed-4mic-voicecard-artik.dtbo > /sys/kernel/config/device-tree/overlays/seeed-voicecard/dtbo
[root@artik seeed-voicecard]#
[  574.305000] Please set data-protocol.
[  574.310000]  i2c_id number :0
[  574.310000]  ac108  codec_index :0
[  574.315000]  ac108  I2S data protocol type :1
[  574.335000] ac108_write error->[REG-0x00,val-0x12]
[  574.550000] AC108 PLL freq_in match:24000000, freq_out:24576000
[  574.550000]
[  574.640000] AC108 PLL freq_in match:24000000, freq_out:24576000
[  574.640000]

[root@artik seeed-voicecard]# cp ac108_asound.state /var/lib/alsa/asound.state
[root@artik seeed-voicecard]# cp ac108_plugin/libasound_module_pcm_ac108.so  /usr//lib/arm-linux-gnueabihf/alsa-lib/
[root@artik seeed-voicecard]# cp  asound_4mic.conf   /etc/asound.conf
[root@artik seeed-voicecard]# alsactl --file=ac108_asound.state restore

cuidado

Execute a Etapa 3 novamente após a reinicialização, caso contrário não será possível detectar a seeed voicecard.

• Etapa 4. Use o arecord para listar os dispositivos de gravação.

[root@artik seeed-voicecard]# arecord -L
null
    Discard all samples (playback) or generate zero samples (capture)
pulse
    PulseAudio Sound Server
default
    Playback/recording through the PulseAudio sound server
playback
dmixed
ac108
sysdefault:CARD=Audio
    Artik530 raptor Audio,
    Default Audio Device
dmix:CARD=Audio,DEV=0
    Artik530 raptor Audio,
    Direct sample mixing device
dsnoop:CARD=Audio,DEV=0
    Artik530 raptor Audio,
    Direct sample snooping device
hw:CARD=Audio,DEV=0
    Artik530 raptor Audio,
    Direct hardware device without any conversions
plughw:CARD=Audio,DEV=0
    Artik530 raptor Audio,
    Hardware device with all software conversions
sysdefault:CARD=seeed4micvoicec
    seeed-4mic-voicecard,
    Default Audio Device
dmix:CARD=seeed4micvoicec,DEV=0
    seeed-4mic-voicecard,
    Direct sample mixing device
dsnoop:CARD=seeed4micvoicec,DEV=0
    seeed-4mic-voicecard,
    Direct sample snooping device
hw:CARD=seeed4micvoicec,DEV=0
    seeed-4mic-voicecard,
    Direct hardware device without any conversions
plughw:CARD=seeed4micvoicec,DEV=0
    seeed-4mic-voicecard,
    Hardware device with all software conversions

Capturar Áudio

• Iniciar a gravação usando a linha de comando

arecord -Dac108 -f S16_LE -r 48000  -c 4 /tmp/test.wav

• Iniciar a gravação usando Python

  • Etapa 1. Instale o pacote pyaudio com os comandos abaixo

    apt install python-pyaudio

  • Etapa 2. Use um editor de texto como vi para criar este arquivo de código recorder_4Mics.py, que grava um clipe de áudio de 10 s chamado test.wav.

import pyaudio
import wave

FORMAT = pyaudio.paInt16
CHANNELS = 4
RATE = 48000
CHUNK = 1024
RECORD_SECONDS = 10
WAVE_OUTPUT_FILENAME = "test.wav"

audio = pyaudio.PyAudio()

# start Recording
stream = audio.open(format=FORMAT, channels=CHANNELS, rate=RATE, input=True, frames_per_buffer=CHUNK)
print "recording audio..."
frames = []

threshold = 800
for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
   data = stream.read(CHUNK)
   frames.append(data)
print "done recording"

# stop Recording
stream.stop_stream()
stream.close()
audio.terminate()

waveFile = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
waveFile.setnchannels(CHANNELS)
waveFile.setsampwidth(audio.get_sample_size(FORMAT))
waveFile.setframerate(RATE)
waveFile.writeframes(b''.join(frames))
waveFile.close()

cuidado

Para mais informações, como por exemplo brincar com Alexa/DuerOS, consulte ReSpeaker 4-Mic Array for Raspberry Pi.

Brincar com Mic Array v2.0

Hardware

Capturar Áudio

• Iniciar a gravação usando a linha de comando

arecord -D plughw:1,0 -f cd test.wav # record, please use the arecord -l to check the card and hardware first
aplay -D plughw:1,0 -f cd test.wav # play, please use the aplay -l to check the card and hardware first
arecord -D plughw:1,0 -f cd |aplay -D plughw:1,0 -f cd # record and play at the same time

• Iniciar a gravação usando Python

  • Etapa 1, precisamos executar o seguinte script para obter o número de índice do dispositivo do Mic Array:

    apt install python-pip
    pip install pyaudio
    cd ~
    nano get_index.py

  • Etapa 2, copie o código abaixo e cole em get_index.py.

import pyaudio

p = pyaudio.PyAudio()
info = p.get_host_api_info_by_index(0)
numdevices = info.get('deviceCount')

for i in range(0, numdevices):
        if (p.get_device_info_by_host_api_device_index(0, i).get('maxInputChannels')) > 0:
            print "Input Device id ", i, " - ", p.get_device_info_by_host_api_device_index(0, i).get('name')

• Etapa 3, pressione Ctrl + X para sair e pressione Y para salvar.

• Etapa 4, execute 'sudo python get_index.py' e veremos o ID do dispositivo como abaixo.

Input Device id  0  -  Artik530 raptor Audio: - (hw:0,0)
Input Device id  2  -  ReSpeaker 4 Mic Array (UAC1.0): USB Audio (hw:1,0)
Input Device id  3  -  sysdefault
Input Device id  4  -  pulse
Input Device id  8  -  default

• Etapa 5, altere RESPEAKER_INDEX = 2 para o número de índice. Execute o script python record.py para gravar uma fala.

import pyaudio
import wave

RESPEAKER_RATE = 16000
RESPEAKER_CHANNELS = 1 # change base on firmwares, default_firmware.bin as 1 or i6_firmware.bin as 6
RESPEAKER_WIDTH = 2
# run getDeviceInfo.py to get index
RESPEAKER_INDEX = 2  # refer to input device id
CHUNK = 1024
RECORD_SECONDS = 5
WAVE_OUTPUT_FILENAME = "output.wav"

p = pyaudio.PyAudio()

stream = p.open(
            rate=RESPEAKER_RATE,
            format=p.get_format_from_width(RESPEAKER_WIDTH),
            channels=RESPEAKER_CHANNELS,
            input=True,
            input_device_index=RESPEAKER_INDEX,)

print("* recording")

frames = []

for i in range(0, int(RESPEAKER_RATE / CHUNK * RECORD_SECONDS)):
    data = stream.read(CHUNK)
    frames.append(data)

print("* done recording")

stream.stop_stream()
stream.close()
p.terminate()

wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
wf.setnchannels(RESPEAKER_CHANNELS)
wf.setsampwidth(p.get_sample_size(p.get_format_from_width(RESPEAKER_WIDTH)))
wf.setframerate(RESPEAKER_RATE)
wf.writeframes(b''.join(frames))
wf.close()

cuidado

Para mais informações, como por exemplo brincar com DOA/LEDs, consulte ReSpeaker Mic Array v2.0.

Brincar com GrovePi+

Instalar dependências

apt install g++ libi2c-dev
apt install python-dev
apt install python-smbus
apt install libffi-dev
apt install python-pip
pip install setuptools
pip install smbus-cffi
pip install numpy

I2C usando Python com GrovePi+ Shield

• Etapa 1. Baixe os arquivos do GitHub.

cd ~
git clone https://github.com/DexterInd/GrovePi.git

• Etapa 2. Modifique o código-fonte /root/GrovePi/Software/Cpp/grovepi.cpp e adicione uma linha como mostrado.

void GrovePi::SMBusName(char *smbus_name)
{
 unsigned int hw_revision = gpioHardwareRevision();
 unsigned int smbus_rev;

 if(hw_revision < 4)
  // type 1
  smbus_rev = 1;
 else if(hw_revision < 16)
  // type 2
  smbus_rev = 2;
 else
  // type 3
  smbus_rev = 3;

 if(smbus_rev == 2 || smbus_rev == 3)
  strcpy(smbus_name, "/dev/i2c-1");
 else
  strcpy(smbus_name, "/dev/i2c-0");
  strcpy(smbus_name, "/dev/i2c-1"); //add this line to enable the I2C for eagleye_530s
}

• Etapa 3. Modifique o código-fonte /root/GrovePi/Software/Python/grovepi.py e comente conforme mostrado.

if sys.platform == 'uwp':
 import winrt_smbus as smbus
 bus = smbus.SMBus(1)
else:
 import smbus
# import RPi.GPIO as GPIO
# rev = GPIO.RPI_REVISION
# if rev == 2 or rev == 3:
 bus = smbus.SMBus(1)
# else:
#  bus = smbus.SMBus(0)

• Etapa 4. Toda vez que reiniciarmos a placa, execute os dois comandos a seguir. Coloque-os em um arquivo bash para torná-los automáticos.

mkdir /sys/kernel/config/device-tree/overlays/i2c
cat /boot/overlays/s5p4418-artik533-compy-i2c1.dtbo > /sys/kernel/config/device-tree/overlays/i2c/dtbo

cuidado

Execute os comandos da Etapa 4 após reiniciar.

• Etapa 5. Conecte o Grove-Led e o Grove-Rotary Angle Sensor ao GrovePi como abaixo.

• Etapa 6. Execute python grove_rotary_angle_sensor.py.

cd ~/GrovePi/Software/Python/
python grove_rotary_angle_sensor.py

Aqui está o código.

import time
import grovepi

# Connect the Grove Rotary Angle Sensor to analog port A0
# SIG,NC,VCC,GND
potentiometer = 0

# Connect the LED to digital port D5
# SIG,NC,VCC,GND
led = 5

grovepi.pinMode(potentiometer,"INPUT")
grovepi.pinMode(led,"OUTPUT")
time.sleep(1)

# Reference voltage of ADC is 5v
adc_ref = 5

# Vcc of the grove interface is normally 5v
grove_vcc = 5

# Full value of the rotary angle is 300 degrees, as per it's specs (0 to 300)
full_angle = 300

while True:
    try:
        # Read sensor value from potentiometer
        sensor_value = grovepi.analogRead(potentiometer)

        # Calculate voltage
        voltage = round((float)(sensor_value) * adc_ref / 1023, 2)

        # Calculate rotation in degrees (0 to 300)
        degrees = round((voltage * full_angle) / grove_vcc, 2)

        # Calculate LED brightess (0 to 255) from degrees (0 to 300)
        brightness = int(degrees / full_angle * 255)

        # Give PWM output to LED
        grovepi.analogWrite(led,brightness)

        print("sensor_value = %d voltage = %.2f degrees = %.1f brightness = %d" %(sensor_value, voltage, degrees, brightness))
    except KeyboardInterrupt:
        grovepi.analogWrite(led,0)
        break
    except IOError:
        print ("Error")

• Etapa 7. O LED mudará o brilho enquanto o sensor de ângulo rotativo estiver girando. Também veremos as informações do terminal como abaixo.

[root@artik Python]# python grove_rotary_angle_sensor.py
sensor_value = 246 voltage = 1.20 degrees = 72.0 brightness = 61
sensor_value = 247 voltage = 1.21 degrees = 72.6 brightness = 61
sensor_value = 258 voltage = 1.26 degrees = 75.6 brightness = 64
sensor_value = 274 voltage = 1.34 degrees = 80.4 brightness = 68
sensor_value = 296 voltage = 1.45 degrees = 87.0 brightness = 73
sensor_value = 318 voltage = 1.55 degrees = 93.0 brightness = 79
sensor_value = 340 voltage = 1.66 degrees = 99.6 brightness = 84
sensor_value = 363 voltage = 1.77 degrees = 106.2 brightness = 90
sensor_value = 387 voltage = 1.89 degrees = 113.4 brightness = 96

:::caution: Para mais sensores Grove, consulte DexterInd Python Library. Nós não testamos a compatibilidade de todos os sensores com o Eagleye 530s. Entre em contato com o suporte técnico se houver qualquer problema.
:::

Brincar com Shield

Brincar com Placas de Relé

Hardware

Software

• Etapa 1. Execute o comando abaixo para habilitar o I2C.

mkdir /sys/kernel/config/device-tree/overlays/i2c
cat /boot/overlays/s5p4418-artik533-compy-i2c1.dtbo > /sys/kernel/config/device-tree/overlays/i2c/dtbo

cuidado

Toda vez que reiniciarmos a placa, execute os dois comandos a seguir. Coloque-os em um arquivo bash para torná-los automáticos.

• Etapa 2. Execute i2cdetect para detectar o shield de relé.

[root@artik ~]# i2cdetect -y -r 1
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: 20 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

• Etapa 3. Execute os comandos abaixo para rodar o relay_lib_seeed_test.py.

[root@artik ~]# cd ~
[root@artik ~]# git clone https://github.com/johnwargo/Seeed-Studio-Relay-Board.git
[root@artik ~]# cd Seed-Studio-Relay-Board/
[root@artik Seed-Studio-Relay-Board]# python relay_lib_seeed_test.py
Turning all relays ON
Turning all relays OFF
Turning relay 1 ON
Turning relay 1 OFF
Turning relay 2 ON
Turning relay 2 OFF
Turning relay 3 ON
Turning relay 3 OFF
Turning relay 4 ON
Turning relay 4 OFF

cuidado

Para mais informações, consulte Raspberry Pi Relay Board v1.0.

Brincar com Placas RS232

Hardware

• Etapa 1. Conecte o cabo USB à fonte de alimentação.
• Etapa 2. Conecte o cabo RS232 entre o shield RS232 e o PC.

Software

• Etapa 1. Abra o putty no PC e configure como abaixo. A porta COM deve ser definida conforme o gerenciador de dispositivos. No nosso caso, a porta COM alocada é COM9.

• Etapa 2. Defina a configuração do PuTTY da seguinte forma:
  • Defina a "Serial line" como o número da porta COM encontrado na etapa 3.
  • Defina a velocidade da porta COM para "115200".
  • Defina o tipo de conexão como "Serial".
  • Salve a sessão como Eagleye 530s.
• Etapa 3. Selecione sua sessão salva e clique no botão "Open".

• Etapa 4. O nome de usuário e a senha são root.
• Etapa 5. Veremos o terminal como abaixo.

cuidado

Para mais informações, consulte Raspberry Pi RS232 Board v1.0.

Brincar com Breakout Board

A Raspberry Pi Breakout Board também fornece alimentação, luz indicadora de estado, botão e transistores universais, tais como NPN, PNP, N-MOS, P-MOS. Ela funciona bem com o Eagleye_530s.

cuidado

Para mais informações, consulte Raspberry Pi Breakout Board v1.0.

Perguntas Frequentes

• P1: O Eagleye 530s é compatível com gabinetes para Raspberry Pi?

R1: Sim. Aqui está a lista de compatibilidade.

SKU	Description	Comments
103010002	GrovePi+	Consulte Brincar com Grovepi+
103030030	Raspberry Pi Breakout Board v1.0	Consulte Brincar com Shield
103030029	Raspberry Pi Relay Board v1.0	Consulte Brincar com Shield
103030028	Raspberry Pi RS232 Board v1.0	Consulte Brincar com Shield
114990835	Raspberry Pi HDMI LCD (7 inch)	O display funciona bem, exceto o toque.

• P2: Como configurar a função de inicialização automática?

R2: Encontre o diodo D401 conforme a figura abaixo, remova o diodo D401 dessoldando-o e faça um curto entre os dois pinos do D401 soldando um ponto de solda.

Recursos

• [PDF] ARTIK™ 530s SoM Module Datasheet
• [Certification] CE Certificate&Report
• [Certification] IC Certificate&Report
• [Certification] FCC Certificate&Report
• [PDF] Eagleye 530s User Guide
• [More Reading] ARTIK™ 530s
• [More Reading] Samsung ARTIK™ IoT platform
• [More Reading] Facial-Recog Project

Suporte Técnico & Discussão sobre o Produto

Obrigado por escolher nossos produtos! Estamos aqui para fornecer diferentes tipos de suporte para garantir que sua experiência com nossos produtos seja a mais tranquila possível. Oferecemos vários canais de comunicação para atender a diferentes preferências e necessidades.