Caninos Loucos - Contribuições do usuário [pt-br]

Apresentação Geral e Especificações Técnicas

2020-08-25T20:11:28Z

Thalyson: /* Labrador 64 bits */

[[Arquivo:Core_v2_base_v1.jpg|thumb|400px|Coreboard v2 e Baseboard v1]]

[[Arquivo:Core_v3_base_v2.jpg|thumb|400px|Coreboard v3 e Baseboard v2]]
A placa Labrador é a primeira Single Board Computer da Caninos Loucos, aberta e com as funcionalidades de um computador. É capaz de rodar em um sistema operacional Linux, acessar a internet, reproduzir vídeos e executar programas de edição de texto. Esse conjunto possui proteção ESD, é compacta, resistente e serve para as mais diversas aplicações, desde projetos pessoais até aplicações profissionais.

A Labrador é uma combinação de 2 placas: a coreboard, uma placa de tamanho reduzido e alta capacidade de processamento, e a baseboard, onde encontramos as diversas interfaces de comunicação.

Estão disponíveis duas versões de coreboards para a Labrador: a Labrador Core v2 que possui um poderoso processador ARM de 32 bits e, para as aplicações que necessitam de ainda mais desempenho, a Labrador Core v3, possui um processador ARM de 64 bits com capacidade de processamento de IA com deep learning.

Modelos da Labrador Baseboard podem desenvolvidos para diferentes aplicações. Estão disponíveis duas versões para o público maker. A Labrador Base M v1 foi uma primeira versão que disponibiliza uma ampla gama de interfaces, incluindo diferentes tipos de interfaces USB, de áudio e vídeo, cartão de expansão de memória, GPIOs, etc. A Labrador Base M v2 que traz uma série de melhorias mecânicas e amplia as possibilidades de comunicação sem fio incluindo o sistema LoRa/LoRaWAN e Bluetooth 5.0.

A Labrador padroniza a interface entre coreboard e baseboard, permitindo a compatibilidade entre seus vários modelos.

= Especificações =

== Labrador Core v2==

[http://caninosloucos.org/downloads/caninos_loucos_datasheet_labradorV2_001.pdf Fazer o download do folder de especificações]

{| class="wikitable"
|-
! scope="row"| CPU
| 32-bit quad-core ARM® Cortex™ 1,3GHz A9R4 CPU (ARM v7 instruction set)
|-
! scope="row"| GPU
| Imagination PowerVR SGX544. Suporta: OpenGL-ES 1.1 e 2.0, OpenGL 1.2.1, OpenCL 1.1
|-
! scope="row"| Memória
| 2 GB DDR3 SDRAM 16GB eMMC
|-
! scope="row"| Sistema operacional
| Debian 10 Linux Kernel 4.14.13 32-bits
|-
! scope="row"| PMU
| ATC2306C - Gerenciamento de energia e subsistema de áudio
|-
! scope="row"| Vídeo
| 1080p@60fps com suporte a codificação de vídeo (incluindo H264, H263, MPEG-4)
|-
! scope="row"| Interface de expansão
| Conector DDR3 SODIMM 204 pinos (macho)
|-
! scope="row"| Botão
| ADFU
|-
! scope="row"| Dimensões
| 67.6 x 42.2 mm
|-
! scope="row"| Peso
| 13.6g
|}

==Labrador Core v3==

{| class="wikitable"
|-
! scope="row"| CPU
| 64-bit quad-Core ARM Cortex A53 1,3GHz CPU (ARM v8 instruction set)
|-
! scope="row"| GPU
| ARM Mali450 MP6 (4PP + 2GP). Suporta: OpenGL-ES 1.1 e 2.0, OpenVG 1.1, EGL 1.5
|-
! scope="row"| Memória
| 2 GB LPDDR3 SDRAM 16GB eMMC
|-
! scope="row"| Sistema operacional
| Debian 10 Linux Kernel 4.19
|-
! scope="row"| PMU
| ATC2306C - Gerenciamento de energia e subsistema de áudio
|-
! scope="row"| Vídeo
| 2160p@30fps ou 1080p@60fps com suporte a codificação de vídeo (incluindo H264, H263, MPEG-4)
|-
! scope="row"| Interface de expansão
| Conector DDR3 SODIMM 204 pinos (macho)
|-
! scope="row"| Botão
| ADFU
|-
! scope="row"| Dimensões
| 67.6 x 31.0 mm
|-
! scope="row"| Peso
| 10.1g
|}

==Labrador Base M v1==

{| class="wikitable"
|-
! scope="row"| Armazenamento
| MicroSD Card Slot SD/SDHC/SDXC
|-
! scope="row"| Ethernet
| 10/100Mbps (RJ45)
|-
! scope="row"| Wireless
| Wi-Fi 802.11 b/g/n 2.4GHz Bluetooth 4.0 1 x receptor infravermelho (38kHz)
|-
! scope="row"| USB
| 2 x USB2.0 HOST (tipo A) 1 x USB3.0 OTG (micro-B)
|-
! scope="row"| Display
| 1 x HDMI 1.4 (tipo A), até 1920x1080@60Hz 1 x LVDS-DSI para LCDs, até 1920x1080@60Hz 1 x CVBS PAL/NTSC (PJ342 3,5mm)
|-
! scope="row"| Áudio
| Saída no HDMI Saída analógica estéreo (PJ342 3,5mm) I2S entrada/saída Microfone embutido
|-
! scope="row"| Câmera
| 1 x interface paralela de 8-bits
|-
! scope="row"| LED
| 1 x ligar/desligar (vermelho) 1 x programável (verde) 1 x programável (azul)
|-
! scope="row"| Botões
| 1x ligar/desligar 1x reiniciar 1x programável
|-
! scope="row"| Alimentação
| 5~12V @ 3W (diâmetro interno 2,1mm, externo de 5,5mm, centro positivo).
|-
! scope="row"| Expansão
| Conector SODIMM de 204 pinos (fêmea) 40-pin header: 28 GPIOs (compatível com Raspberry Pi / suporta UART, I2C, SPI, PWM e I2S) ADC input
|-
! scope="row"| Debug
| UART
|-
! scope="row"| Dimensões
| 88 x 81,3 mm
|-
! scope="row"| Peso
| 52,6g
|}

==Labrador Base M v2==

{| class="wikitable"
|-
! scope="row"| Armazenamento
| MicroSD Card Slot SD/SDHC/SDXC
|-
! scope="row"| Ethernet
| 10/100Mbps (RJ45)
|-
! scope="row"| Wireless
| Wi-Fi 802.11 b/g/n 2.4GHz Bluetooth LE 5.0 LoRaWAN™** 1 x receptor infravermelho (38kHz)
|-
! scope="row"| USB
| 2 x USB2.0 HOST (tipo A) 1 x USB3.0 OTG (micro-B)
|-
! scope="row"| Display
| 1 x HDMI 1.4 (tipo A), até 1920x1080@60Hz 1 x LVDS-DSI para LCDs, até 1920x1080@60Hz 1 x CVBS PAL/NTSC (PJ342 3,5mm)**
|-
! scope="row"| Áudio
| saída no HDMI Saída analógica estéreo (PJ342 3,5mm) I2S entrada/saída Microfone embutido
|-
! scope="row"| Câmera
| 1 x interface paralela de 8-bits
|-
! scope="row"| LED
| 1 x ligar/desligar (vermelho) 1 x programável (verde) 1 x programável (azul)
|-
! scope="row"| Botões
| 1x ligar/desligar 1x reiniciar 1x programável
|-
! scope="row"| Alimentação
| 5~12V @ 3W (diâmetro interno 2,1mm, externo de 5,5mm, centro positivo).
|-
! scope="row"| Expansão
| Conector SODIMM de 204 pinos (fêmea) 40-pin header: 28 GPIOs (compatível com Raspberry Pi / suporta UART, I2C, SPI**e PWM) ADC input
|-
! scope="row"| Debug
| UART
|-
! scope="row"| Dimensões
| 92,7 x 88.0 mm
|-
! scope="row"| Peso
| 59,4g
|}

" ** Funcionalidade não disponível na Labrador Core v3.1 "

= Limitações das imagens de software disponíveis =
==Labrador 32 bits==
Atualmente a imagem do Debian 10, disponibilizada para a Labrador Core v2, de 32 bits, possui algumas limitações de suporte às funcionalidades da Baseboard. Estamos continuamente trabalhando para ampliar a disponibilidade e qualidade dos Drivers das plataformas e contamos com a comunidade para colaborar com estes aprimoramentos.

As seguintes funcionalidades ainda não estão disponíveis no último release:
* GPU
* Áudio
* Câmera
* USB 3.0
* LoRa / LoRaWAN
* Temperatura da CPU
* Receptor Infravermelho
* Aceleração gráfica de encoding/decoding por hardware

Além disso, existem os seguintes bugs conhecidos:
* Resolução de vídeo só alcança 1080p caso o cabo HDMI seja conectado após a Labrador ligar. Caso a placa seja ligada com o cabo HDMI já conectado, a resolução será 720p.
* A Labrador não funciona com todos os monitores. Foi observado até agora que monitores e TVs HDMI funcionam normalmente e a maioria dos adaptadores VGA também apresenta bom funcionamento. No entanto, ao usá-las com adaptadores DVI alguns monitores não funcionam corretamente.

A imagem da Labrador 32 bits pode ser encontrada em: [http://downloads.caninosloucos.org.br/labrador_32_bits/ Labrador 32 bits]

Caso você queira compilar sua própria versão, pode encontrar os arquivos em nosso [https://github.com/caninos-loucos/labrador-linux GitHub].

==Labrador 64 bits==

Atualmente a imagem do Debian 10, kernel Linux 4.19, disponibilizada para a Labrador Core v3, de 64 bits, possui algumas limitações de suporte às funcionalidades da Baseboard. Estamos continuamente trabalhando para ampliar a disponibilidade e qualidade dos Drivers das plataformas e contamos com a comunidade para colaborar com estes aprimoramentos.

O driver aberto da GPU está sendo desenvolvido no projeto Lima, disponível em "https://gitlab.freedesktop.org/lima", mas ainda não está finalizado. A imagem disponibilizada já possui todas as dependências resolvidas para a execução do Lima.

As seguintes funcionalidades ainda não estão disponíveis no último release:
* Câmera
* USB 3.0
* Botão programável
* Áudio (saída HDMI)
* Receptor Infravermelho
* Set Mode do HDMI (seleção de resolução de vídeo)

As seguintes funcionalidades não estão disponíveis no hardware da Labrador Core v3.1:
* CVBS
* LoRa / LoRaWAN
* SPI

A imagem da Labrador 64 bits pode ser encontrada em: [http://downloads.caninosloucos.org.br/labrador_64_bits/ Labrador 64 bits].

Caso você queira compilar sua própria versão, pode encontrar os arquivos em nosso [https://github.com/caninos-loucos/labrador-linux-64 GitHub].

Começando com a Labrador

2020-08-25T20:09:20Z

Thalyson: /* Controlando um LED */

= O que vem na caixa =

Neste capítulo vamos conhecer um pouco mais sobre o hardware e o software contido na caixa da Labrador.

== Hardware e acessórios inclusos ==

Ao abrir a caixa da Labrador, você irá encontrar uma Labrador dentro de um case de acrílico e uma fonte de alimentação. Note que a Labrador é composta de duas placas: a Core e a Base. A Tabela abaixo descreve e ilustra cada um dos componentes inclusos.

{| class="wikitable"
! style="background-color:#c0c0c0;" | Item
! style="background-color:#c0c0c0;" | Descrição
! style="background-color:#c0c0c0; text-align: center" | Foto
|-
| Labrador Coreboard
| Núcleo da Labrador, contém Processador e Memória.
| style="text-align: center" | [[Arquivo:CoreBoard-v2-front.png|300px]]
|-
| Labrador Baseboard
| Placa com periféricos, ex.: USB, HDMI, GPIO, conector de energia.
| style="text-align: center" | [[Arquivo:Base-frente.png|300px]]
|-
| Case de acrílico com espaçadores de nylon e parafusos
| Item para proteção da placa.
| style="text-align: center" | [[Arquivo:Case-labrador.jpeg|300px]]
|-
| Fonte de alimentação 12V @ 1A
| Fornece energia elétrica na tensão e corrente corretas.
| style="text-align: center" | [[Arquivo:Fonte-labrador.jpg|200px]]
|}

= Ligando a Labrador =

A principal maneira de usar a placa Labrador é conectando-a a um monitor HDMI e a um teclado e mouse USB, além da fonte de alimentação, para que possa ser usada como um dispositivo Linux comum. As próximas seções ensinam passo a passo como fazer isso.

== Conectando teclado e mouse - USB ==

Para poder interagir com a Labrador, basta conectar teclado e mouse às interfaces USB disponíveis. Em geral, você poderá usar qualquer teclado e mouse USB.

== Conectando o monitor - HDMI ==

A principal forma de visualizar a saída gráfica da Labrador é através de um monitor HDMI (High Definition Multimedia Interface). Você irá precisar de um cabo HDMI comum e de um monitor HDMI.

Caso seu monitor não possua entrada HDMI, mas possua DVI, a Labrador também funciona com adaptadores HDMI-para-DVI. Também já foram testadas entradas analógicas, como o VGA, que funciona com adaptadores HDMI-VGA que façam internamente a conversão digital-analógica.

== Conectando a fonte de alimentação ==

O último passo relacionado à conexão de componentes físicos, antes de usar a placa, é conectar a fonte de alimentação. A fonte enviada na caixa aceita ambas as tensões 110V e 220V, e tem como saída 12V 1A de corrente contínua. Caso necessário, fontes alternativas com especificação equivalente podem ser usadas.

Agora, com o mouse, teclado e monitor já conectados, coloque a fonte de alimentação na tomada e conecte-a à Labrador. Se tudo ocorreu bem, você deverá ver o logo do Caninos Loucos, seguido da tela de login.

= Usando o Debian =

O sistema operacional incluso na placa Labrador é o Debian, uma distribuição Linux utilizada no mundo todo. Para o leitor leigo no assunto, [http://www.devfuria.com.br/linux/como-iniciar-no-linux/ há vários tutoriais de Linux na internet], ensinando o básico de [https://sempreupdate.com.br/como-funciona-a-linha-de-comando-do-linux/ como mexer na linha de comando], e até mesmo [https://hacker-tools.github.io/lectures/ guias avançados para aproveitar o Linux ao máximo].

== Login ==

Para começar, assumindo que você já ligou a placa e está na tela de login, o próximo passo é digitar "caninos" (sem as aspas), tanto para o usuário quanto para a senha, e clicar em "Login".

== Acesso à Internet ==

Apesar de a Labrador possuir muitas aplicações para uso offline, conectá-la à Internet nos permite acessar websites, instalar bibliotecas e manter o sistema atualizado. Há duas formas principais, usando cabo de rede (Ethernet) ou a conexão sem-fio (Wi-Fi).

=== Ethernet ===

Para acessar a Internet usando cabo de rede, basta conectar o seu cabo de internet à entrada RJ45. Ao fazer isso com a placa ligada, observe também que o ícone de rede, no lado inferior direito da tela, irá carregar, até apontar que a conexão foi realizada com sucesso.

=== Wi-Fi ===

Como a Labrador já tem Wi-Fi embutido, basta acessar o menu de redes, escolher a sua rede, digitar a senha, e habilitar a conexão. Se for necessário especificar o tipo de segurança da rede, provavelmente será a opção "WPA2 Personal". Caso isso não funcione, peça ajuda à pessoa que realizou a configuração do seu roteador para descobrir os parâmetros corretos de configuração.

=== Verifique a conexão ===

Independente da forma como você se conectou à Internet, você agora pode testar a sua conexão. Uma forma simples de fazer isso é abrindo o Firefox e acessando o site http://caninosloucos.org. Já uma forma mais avançada é abrindo o terminal, digitando <code>ip address</code> e verificando se você tem um endereço IP válido. É útil saber o endereço IP, pois permite que nos comuniquemos com a Labrador, seja em uma aplicação IoT, seja durante o desenvolvimento. Por exemplo podemos acessar o terminal da Labrador via SSH (Secure Shell), evitando assim a necessidade de mantê-la sempre conectada a um teclado, mouse e monitor.

== Crie seus próprios programas ==

A Labrador tem suporte para uma variedade de linguagens de programação, desde as mais baixo nível, como o C, até as mais alto nível e expressivas, como Python e NodeJS. Portanto deixe a sua criatividade florescer e crie seus próprios programas usando a Labrador. Ah, e não esqueça de compartilhar os seus projetos com a comunidade, no [https://forum.caninosloucos.org.br/ fórum Caninos Loucos]!

=== Controlando um LED ===

Se ao aprender programar imprimimos "Hello World" na tela, na programação de SBCs vamos além: vamos fazer controlar um LED (Light Emitting Diode). Este exemplo é interessante pois demonstra que nossos programas, além de controlarem caracteres na tela ou bytes na rede, também podem controlar componentes físicos.

Para ligar os LEDs azul e verde da Labrador, abra o terminal e execute o seguinte comando:

Na Labrador 32 bits:
<pre>sudo echo 63 > /sys/class/gpio/export</pre>
<pre>sudo echo 44 > /sys/class/gpio/export</pre>
<pre>sudo echo out > /sys/class/gpio/gpio63/direction</pre>
<pre>sudo echo out > /sys/class/gpio/gpio44/direction</pre>
<pre>sudo echo 1 > /sys/class/gpio/gpio63/value</pre>
<pre>sudo echo 1 > /sys/class/gpio/gpio44/value</pre>

Também é possível fazer os LEDs azul e verde da Labrador piscarem em um ritmo de batimento cardíaco (de acordo com a demanda de processamento da Labrador).

Na Labrador 64 bits:
<pre>sudo chmod 777 /sys/class/leds/led1/trigger</pre>
<pre>sudo chmod 777 /sys/class/leds/led2/trigger</pre>
<pre>sudo echo heartbeat > /sys/class/leds/led1/trigger</pre>
<pre>sudo echo heartbeat > /sys/class/leds/led2/trigger</pre>

=== Programação GPIO ===

Uma interface interessante da Labrador são os pinos GPIO (General Purpose Input/Output), que são basicamente fios nos quais você pode enviar e receber dados. Para aprender como usar esta interface, confira o artigo principal [[Programação GPIO]].

=== UART ===

Através dos pinos de GPIO é possível utilizar a comunicação serial UART na Labrador. Segue um pequeno exemplo de como acessar esse recurso:

1. Conectar um adaptador tty-usb em um computador e a Labrador, através dos pinos 8 e 10 e um GND.

2. Abrir um emulador de terminal no computador e definir o baud rate como 115200bps.

3. No terminal da Labrador entrar com os seguintes comandos:

<pre>sudo stty -F /dev/ttyS0 115200</pre>
<pre>sudo echo "Teste" > /dev/ttyS0</pre>

4. No emulador de terminal do computador aparecerá a palavra “Teste”

=== ADC ===

A Labrador também possui ADC, que significa Analogic-Digital Converter (Conversor Analógico-Digital). A ideia é ler um valor analógico, entre 0v e 3v e converter para digital, representado por um valor de 10 bits (1024 valores possíveis).

Para ler o valor do ADC, entre com o seguinte comando no terminal:
<pre>cat /sys/kernel/auxadc/adc0</pre>
A primeira parte do resultado é o timestamp do sistema, enquanto a segunda parte é o resultado em si.

=== PWM ===

No pino 12 do header de 40 pinos da Labrador é possível encontrar o PWM. Um exemplo de utilização desse recurso pode ser encontrado abaixo. Utilizando o terminal, digite:

<pre>sudo su</pre>
<pre>echo 0 > /sys/class/pwm/pwmchip0/export</pre>

Selecione o período do sinal PWM (em nanosegundos):
<pre>echo 2000000000 > /sys/class/pwm/pwmchip0/pwm0/period</pre>

Selecione o duty cycle (em nanosegundos).
<pre>echo 1000000000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle</pre>

Ative (1) ou desative (0) o sinal PWM:
<pre>echo 1 > /sys/class/pwm/pwmchip0/pwm0/enable</pre>

Com isso, a tensão no pino 12 variará entre 0v e 3v3 a cada 1 segundo.

=== I2C ===

Também encontramos pinos I2C na Labrador. A conexão é feita através dos pinos 3 (dados) e 5 (clock) do header de 40 pinos. Uma maneira de testar essa conexão e descobrir o endereço do seu dispositivo I2C é mostrada abaixo. No terminal, entrar com os seguintes comandos:

<pre>sudo apt install i2c-tools</pre>
<pre>sudo i2cdetect -y 2</pre>

A saída terá o seguinte formato onde, no exemplo, o endereço do dispositivo i2c é 60 (hexadecimal):

<pre> 0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: 60 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
</pre>

Começando com a Labrador

2020-08-25T20:09:00Z

Thalyson: /* Piscando um LED */

= O que vem na caixa =

Neste capítulo vamos conhecer um pouco mais sobre o hardware e o software contido na caixa da Labrador.

== Hardware e acessórios inclusos ==

Ao abrir a caixa da Labrador, você irá encontrar uma Labrador dentro de um case de acrílico e uma fonte de alimentação. Note que a Labrador é composta de duas placas: a Core e a Base. A Tabela abaixo descreve e ilustra cada um dos componentes inclusos.

{| class="wikitable"
! style="background-color:#c0c0c0;" | Item
! style="background-color:#c0c0c0;" | Descrição
! style="background-color:#c0c0c0; text-align: center" | Foto
|-
| Labrador Coreboard
| Núcleo da Labrador, contém Processador e Memória.
| style="text-align: center" | [[Arquivo:CoreBoard-v2-front.png|300px]]
|-
| Labrador Baseboard
| Placa com periféricos, ex.: USB, HDMI, GPIO, conector de energia.
| style="text-align: center" | [[Arquivo:Base-frente.png|300px]]
|-
| Case de acrílico com espaçadores de nylon e parafusos
| Item para proteção da placa.
| style="text-align: center" | [[Arquivo:Case-labrador.jpeg|300px]]
|-
| Fonte de alimentação 12V @ 1A
| Fornece energia elétrica na tensão e corrente corretas.
| style="text-align: center" | [[Arquivo:Fonte-labrador.jpg|200px]]
|}

= Ligando a Labrador =

A principal maneira de usar a placa Labrador é conectando-a a um monitor HDMI e a um teclado e mouse USB, além da fonte de alimentação, para que possa ser usada como um dispositivo Linux comum. As próximas seções ensinam passo a passo como fazer isso.

== Conectando teclado e mouse - USB ==

Para poder interagir com a Labrador, basta conectar teclado e mouse às interfaces USB disponíveis. Em geral, você poderá usar qualquer teclado e mouse USB.

== Conectando o monitor - HDMI ==

A principal forma de visualizar a saída gráfica da Labrador é através de um monitor HDMI (High Definition Multimedia Interface). Você irá precisar de um cabo HDMI comum e de um monitor HDMI.

Caso seu monitor não possua entrada HDMI, mas possua DVI, a Labrador também funciona com adaptadores HDMI-para-DVI. Também já foram testadas entradas analógicas, como o VGA, que funciona com adaptadores HDMI-VGA que façam internamente a conversão digital-analógica.

== Conectando a fonte de alimentação ==

O último passo relacionado à conexão de componentes físicos, antes de usar a placa, é conectar a fonte de alimentação. A fonte enviada na caixa aceita ambas as tensões 110V e 220V, e tem como saída 12V 1A de corrente contínua. Caso necessário, fontes alternativas com especificação equivalente podem ser usadas.

Agora, com o mouse, teclado e monitor já conectados, coloque a fonte de alimentação na tomada e conecte-a à Labrador. Se tudo ocorreu bem, você deverá ver o logo do Caninos Loucos, seguido da tela de login.

= Usando o Debian =

O sistema operacional incluso na placa Labrador é o Debian, uma distribuição Linux utilizada no mundo todo. Para o leitor leigo no assunto, [http://www.devfuria.com.br/linux/como-iniciar-no-linux/ há vários tutoriais de Linux na internet], ensinando o básico de [https://sempreupdate.com.br/como-funciona-a-linha-de-comando-do-linux/ como mexer na linha de comando], e até mesmo [https://hacker-tools.github.io/lectures/ guias avançados para aproveitar o Linux ao máximo].

== Login ==

Para começar, assumindo que você já ligou a placa e está na tela de login, o próximo passo é digitar "caninos" (sem as aspas), tanto para o usuário quanto para a senha, e clicar em "Login".

== Acesso à Internet ==

Apesar de a Labrador possuir muitas aplicações para uso offline, conectá-la à Internet nos permite acessar websites, instalar bibliotecas e manter o sistema atualizado. Há duas formas principais, usando cabo de rede (Ethernet) ou a conexão sem-fio (Wi-Fi).

=== Ethernet ===

Para acessar a Internet usando cabo de rede, basta conectar o seu cabo de internet à entrada RJ45. Ao fazer isso com a placa ligada, observe também que o ícone de rede, no lado inferior direito da tela, irá carregar, até apontar que a conexão foi realizada com sucesso.

=== Wi-Fi ===

Como a Labrador já tem Wi-Fi embutido, basta acessar o menu de redes, escolher a sua rede, digitar a senha, e habilitar a conexão. Se for necessário especificar o tipo de segurança da rede, provavelmente será a opção "WPA2 Personal". Caso isso não funcione, peça ajuda à pessoa que realizou a configuração do seu roteador para descobrir os parâmetros corretos de configuração.

=== Verifique a conexão ===

Independente da forma como você se conectou à Internet, você agora pode testar a sua conexão. Uma forma simples de fazer isso é abrindo o Firefox e acessando o site http://caninosloucos.org. Já uma forma mais avançada é abrindo o terminal, digitando <code>ip address</code> e verificando se você tem um endereço IP válido. É útil saber o endereço IP, pois permite que nos comuniquemos com a Labrador, seja em uma aplicação IoT, seja durante o desenvolvimento. Por exemplo podemos acessar o terminal da Labrador via SSH (Secure Shell), evitando assim a necessidade de mantê-la sempre conectada a um teclado, mouse e monitor.

== Crie seus próprios programas ==

A Labrador tem suporte para uma variedade de linguagens de programação, desde as mais baixo nível, como o C, até as mais alto nível e expressivas, como Python e NodeJS. Portanto deixe a sua criatividade florescer e crie seus próprios programas usando a Labrador. Ah, e não esqueça de compartilhar os seus projetos com a comunidade, no [https://forum.caninosloucos.org.br/ fórum Caninos Loucos]!

=== Controlando um LED ===

Se ao aprender programar imprimimos "Hello World" na tela, na programação de SBCs vamos além: vamos fazer controlar um LED (Light Emitting Diode). Este exemplo é interessante pois demonstra que nossos programas, além de controlarem caracteres na tela ou bytes na rede, também podem controlar componentes físicos.

Para ligar os LEDs azul e verde da Labrador, abra o terminal e execute o seguinte comando:

Na Labrador 32 bits:
<pre>sudo echo 63 > /sys/class/gpio/export</pre>
<pre>sudo echo 44 > /sys/class/gpio/export</pre>
<pre>sudo echo out > /sys/class/gpio/gpio63/direction</pre>
<pre>sudo echo out > /sys/class/gpio/gpio44/direction</pre>
<pre>sudo echo heartbeat > /sys/class/gpio/gpio63/value</pre>
<pre>sudo echo heartbeat > /sys/class/gpio/gpio44/value</pre>

Também é possível fazer os LEDs azul e verde da Labrador piscarem em um ritmo de batimento cardíaco (de acordo com a demanda de processamento da Labrador).

Na Labrador 64 bits:
<pre>sudo chmod 777 /sys/class/leds/led1/trigger</pre>
<pre>sudo chmod 777 /sys/class/leds/led2/trigger</pre>
<pre>sudo echo heartbeat > /sys/class/leds/led1/trigger</pre>
<pre>sudo echo heartbeat > /sys/class/leds/led2/trigger</pre>

=== Programação GPIO ===

Uma interface interessante da Labrador são os pinos GPIO (General Purpose Input/Output), que são basicamente fios nos quais você pode enviar e receber dados. Para aprender como usar esta interface, confira o artigo principal [[Programação GPIO]].

=== UART ===

Através dos pinos de GPIO é possível utilizar a comunicação serial UART na Labrador. Segue um pequeno exemplo de como acessar esse recurso:

1. Conectar um adaptador tty-usb em um computador e a Labrador, através dos pinos 8 e 10 e um GND.

2. Abrir um emulador de terminal no computador e definir o baud rate como 115200bps.

3. No terminal da Labrador entrar com os seguintes comandos:

<pre>sudo stty -F /dev/ttyS0 115200</pre>
<pre>sudo echo "Teste" > /dev/ttyS0</pre>

4. No emulador de terminal do computador aparecerá a palavra “Teste”

=== ADC ===

A Labrador também possui ADC, que significa Analogic-Digital Converter (Conversor Analógico-Digital). A ideia é ler um valor analógico, entre 0v e 3v e converter para digital, representado por um valor de 10 bits (1024 valores possíveis).

Para ler o valor do ADC, entre com o seguinte comando no terminal:
<pre>cat /sys/kernel/auxadc/adc0</pre>
A primeira parte do resultado é o timestamp do sistema, enquanto a segunda parte é o resultado em si.

=== PWM ===

No pino 12 do header de 40 pinos da Labrador é possível encontrar o PWM. Um exemplo de utilização desse recurso pode ser encontrado abaixo. Utilizando o terminal, digite:

<pre>sudo su</pre>
<pre>echo 0 > /sys/class/pwm/pwmchip0/export</pre>

Selecione o período do sinal PWM (em nanosegundos):
<pre>echo 2000000000 > /sys/class/pwm/pwmchip0/pwm0/period</pre>

Selecione o duty cycle (em nanosegundos).
<pre>echo 1000000000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle</pre>

Ative (1) ou desative (0) o sinal PWM:
<pre>echo 1 > /sys/class/pwm/pwmchip0/pwm0/enable</pre>

Com isso, a tensão no pino 12 variará entre 0v e 3v3 a cada 1 segundo.

=== I2C ===

Também encontramos pinos I2C na Labrador. A conexão é feita através dos pinos 3 (dados) e 5 (clock) do header de 40 pinos. Uma maneira de testar essa conexão e descobrir o endereço do seu dispositivo I2C é mostrada abaixo. No terminal, entrar com os seguintes comandos:

<pre>sudo apt install i2c-tools</pre>
<pre>sudo i2cdetect -y 2</pre>

A saída terá o seguinte formato onde, no exemplo, o endereço do dispositivo i2c é 60 (hexadecimal):

<pre> 0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: 60 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
</pre>

Começando com a Labrador

2020-08-19T17:13:21Z

Thalyson: /* Piscando um LED */

= O que vem na caixa =

Neste capítulo vamos conhecer um pouco mais sobre o hardware e o software contido na caixa da Labrador.

== Hardware e acessórios inclusos ==

Ao abrir a caixa da Labrador, você irá encontrar uma Labrador dentro de um case de acrílico e uma fonte de alimentação. Note que a Labrador é composta de duas placas: a Core e a Base. A Tabela abaixo descreve e ilustra cada um dos componentes inclusos.

{| class="wikitable"
! style="background-color:#c0c0c0;" | Item
! style="background-color:#c0c0c0;" | Descrição
! style="background-color:#c0c0c0; text-align: center" | Foto
|-
| Labrador Coreboard
| Núcleo da Labrador, contém Processador e Memória.
| style="text-align: center" | [[Arquivo:CoreBoard-v2-front.png|300px]]
|-
| Labrador Baseboard
| Placa com periféricos, ex.: USB, HDMI, GPIO, conector de energia.
| style="text-align: center" | [[Arquivo:Base-frente.png|300px]]
|-
| Case de acrílico com espaçadores de nylon e parafusos
| Item para proteção da placa.
| style="text-align: center" | [[Arquivo:Case-labrador.jpeg|300px]]
|-
| Fonte de alimentação 12V @ 1A
| Fornece energia elétrica na tensão e corrente corretas.
| style="text-align: center" | [[Arquivo:Fonte-labrador.jpg|200px]]
|}

= Ligando a Labrador =

A principal maneira de usar a placa Labrador é conectando-a a um monitor HDMI e a um teclado e mouse USB, além da fonte de alimentação, para que possa ser usada como um dispositivo Linux comum. As próximas seções ensinam passo a passo como fazer isso.

== Conectando teclado e mouse - USB ==

Para poder interagir com a Labrador, basta conectar teclado e mouse às interfaces USB disponíveis. Em geral, você poderá usar qualquer teclado e mouse USB.

== Conectando o monitor - HDMI ==

A principal forma de visualizar a saída gráfica da Labrador é através de um monitor HDMI (High Definition Multimedia Interface). Você irá precisar de um cabo HDMI comum e de um monitor HDMI.

Caso seu monitor não possua entrada HDMI, mas possua DVI, a Labrador também funciona com adaptadores HDMI-para-DVI. Também já foram testadas entradas analógicas, como o VGA, que funciona com adaptadores HDMI-VGA que façam internamente a conversão digital-analógica.

== Conectando a fonte de alimentação ==

O último passo relacionado à conexão de componentes físicos, antes de usar a placa, é conectar a fonte de alimentação. A fonte enviada na caixa aceita ambas as tensões 110V e 220V, e tem como saída 12V 1A de corrente contínua. Caso necessário, fontes alternativas com especificação equivalente podem ser usadas.

Agora, com o mouse, teclado e monitor já conectados, coloque a fonte de alimentação na tomada e conecte-a à Labrador. Se tudo ocorreu bem, você deverá ver o logo do Caninos Loucos, seguido da tela de login.

= Usando o Debian =

O sistema operacional incluso na placa Labrador é o Debian, uma distribuição Linux utilizada no mundo todo. Para o leitor leigo no assunto, [http://www.devfuria.com.br/linux/como-iniciar-no-linux/ há vários tutoriais de Linux na internet], ensinando o básico de [https://sempreupdate.com.br/como-funciona-a-linha-de-comando-do-linux/ como mexer na linha de comando], e até mesmo [https://hacker-tools.github.io/lectures/ guias avançados para aproveitar o Linux ao máximo].

== Login ==

Para começar, assumindo que você já ligou a placa e está na tela de login, o próximo passo é digitar "caninos" (sem as aspas), tanto para o usuário quanto para a senha, e clicar em "Login".

== Acesso à Internet ==

Apesar de a Labrador possuir muitas aplicações para uso offline, conectá-la à Internet nos permite acessar websites, instalar bibliotecas e manter o sistema atualizado. Há duas formas principais, usando cabo de rede (Ethernet) ou a conexão sem-fio (Wi-Fi).

=== Ethernet ===

Para acessar a Internet usando cabo de rede, basta conectar o seu cabo de internet à entrada RJ45. Ao fazer isso com a placa ligada, observe também que o ícone de rede, no lado inferior direito da tela, irá carregar, até apontar que a conexão foi realizada com sucesso.

=== Wi-Fi ===

Como a Labrador já tem Wi-Fi embutido, basta acessar o menu de redes, escolher a sua rede, digitar a senha, e habilitar a conexão. Se for necessário especificar o tipo de segurança da rede, provavelmente será a opção "WPA2 Personal". Caso isso não funcione, peça ajuda à pessoa que realizou a configuração do seu roteador para descobrir os parâmetros corretos de configuração.

=== Verifique a conexão ===

Independente da forma como você se conectou à Internet, você agora pode testar a sua conexão. Uma forma simples de fazer isso é abrindo o Firefox e acessando o site http://caninosloucos.org. Já uma forma mais avançada é abrindo o terminal, digitando <code>ip address</code> e verificando se você tem um endereço IP válido. É útil saber o endereço IP, pois permite que nos comuniquemos com a Labrador, seja em uma aplicação IoT, seja durante o desenvolvimento. Por exemplo podemos acessar o terminal da Labrador via SSH (Secure Shell), evitando assim a necessidade de mantê-la sempre conectada a um teclado, mouse e monitor.

== Crie seus próprios programas ==

A Labrador tem suporte para uma variedade de linguagens de programação, desde as mais baixo nível, como o C, até as mais alto nível e expressivas, como Python e NodeJS. Portanto deixe a sua criatividade florescer e crie seus próprios programas usando a Labrador. Ah, e não esqueça de compartilhar os seus projetos com a comunidade, no [https://forum.caninosloucos.org.br/ fórum Caninos Loucos]!

=== Piscando um LED ===

Se ao aprender programar imprimimos "Hello World" na tela, na programação de SBCs vamos além: vamos fazer piscar um LED (Light Emitting Diode). Este exemplo é interessante pois demonstra que nossos programas, além de controlarem caracteres na tela ou bytes na rede, também podem controlar componentes físicos.

Para fazer os LEDs azul e verde da Labrador piscarem em um ritmo de batimento cardíaco (de acordo com a demanda de processamento da Labrador), abra o terminal e execute o seguinte comando:

Na Labrador 32 bits:
<pre>sudo echo 63 > /sys/class/gpio/export</pre>
<pre>sudo echo 44 > /sys/class/gpio/export</pre>
<pre>sudo echo out > /sys/class/gpio/gpio63/direction</pre>
<pre>sudo echo out > /sys/class/gpio/gpio44/direction</pre>
<pre>sudo echo heartbeat > /sys/class/gpio/gpio63/value</pre>
<pre>sudo echo heartbeat > /sys/class/gpio/gpio44/value</pre>

Na Labrador 64 bits:
<pre>sudo chmod 777 /sys/class/leds/led1/trigger</pre>
<pre>sudo chmod 777 /sys/class/leds/led2/trigger</pre>
<pre>sudo echo heartbeat > /sys/class/leds/led1/trigger</pre>
<pre>sudo echo heartbeat > /sys/class/leds/led2/trigger</pre>

=== Programação GPIO ===

Uma interface interessante da Labrador são os pinos GPIO (General Purpose Input/Output), que são basicamente fios nos quais você pode enviar e receber dados. Para aprender como usar esta interface, confira o artigo principal [[Programação GPIO]].

=== UART ===

Através dos pinos de GPIO é possível utilizar a comunicação serial UART na Labrador. Segue um pequeno exemplo de como acessar esse recurso:

1. Conectar um adaptador tty-usb em um computador e a Labrador, através dos pinos 8 e 10 e um GND.

2. Abrir um emulador de terminal no computador e definir o baud rate como 115200bps.

3. No terminal da Labrador entrar com os seguintes comandos:

<pre>sudo stty -F /dev/ttyS0 115200</pre>
<pre>sudo echo "Teste" > /dev/ttyS0</pre>

4. No emulador de terminal do computador aparecerá a palavra “Teste”

=== ADC ===

A Labrador também possui ADC, que significa Analogic-Digital Converter (Conversor Analógico-Digital). A ideia é ler um valor analógico, entre 0v e 3v e converter para digital, representado por um valor de 10 bits (1024 valores possíveis).

Para ler o valor do ADC, entre com o seguinte comando no terminal:
<pre>cat /sys/kernel/auxadc/adc0</pre>
A primeira parte do resultado é o timestamp do sistema, enquanto a segunda parte é o resultado em si.

=== PWM ===

No pino 12 do header de 40 pinos da Labrador é possível encontrar o PWM. Um exemplo de utilização desse recurso pode ser encontrado abaixo. Utilizando o terminal, digite:

<pre>sudo su</pre>
<pre>echo 0 > /sys/class/pwm/pwmchip0/export</pre>

Selecione o período do sinal PWM (em nanosegundos):
<pre>echo 2000000000 > /sys/class/pwm/pwmchip0/pwm0/period</pre>

Selecione o duty cycle (em nanosegundos).
<pre>echo 1000000000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle</pre>

Ative (1) ou desative (0) o sinal PWM:
<pre>echo 1 > /sys/class/pwm/pwmchip0/pwm0/enable</pre>

Com isso, a tensão no pino 12 variará entre 0v e 3v3 a cada 1 segundo.

=== I2C ===

Também encontramos pinos I2C na Labrador. A conexão é feita através dos pinos 3 (dados) e 5 (clock) do header de 40 pinos. Uma maneira de testar essa conexão e descobrir o endereço do seu dispositivo I2C é mostrada abaixo. No terminal, entrar com os seguintes comandos:

<pre>sudo apt install i2c-tools</pre>
<pre>sudo i2cdetect -y 2</pre>

A saída terá o seguinte formato onde, no exemplo, o endereço do dispositivo i2c é 60 (hexadecimal):

<pre> 0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: 60 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
</pre>

Começando com a Labrador

2020-08-19T17:13:08Z

Thalyson: /* Piscando um LED */

= O que vem na caixa =

Neste capítulo vamos conhecer um pouco mais sobre o hardware e o software contido na caixa da Labrador.

== Hardware e acessórios inclusos ==

Ao abrir a caixa da Labrador, você irá encontrar uma Labrador dentro de um case de acrílico e uma fonte de alimentação. Note que a Labrador é composta de duas placas: a Core e a Base. A Tabela abaixo descreve e ilustra cada um dos componentes inclusos.

{| class="wikitable"
! style="background-color:#c0c0c0;" | Item
! style="background-color:#c0c0c0;" | Descrição
! style="background-color:#c0c0c0; text-align: center" | Foto
|-
| Labrador Coreboard
| Núcleo da Labrador, contém Processador e Memória.
| style="text-align: center" | [[Arquivo:CoreBoard-v2-front.png|300px]]
|-
| Labrador Baseboard
| Placa com periféricos, ex.: USB, HDMI, GPIO, conector de energia.
| style="text-align: center" | [[Arquivo:Base-frente.png|300px]]
|-
| Case de acrílico com espaçadores de nylon e parafusos
| Item para proteção da placa.
| style="text-align: center" | [[Arquivo:Case-labrador.jpeg|300px]]
|-
| Fonte de alimentação 12V @ 1A
| Fornece energia elétrica na tensão e corrente corretas.
| style="text-align: center" | [[Arquivo:Fonte-labrador.jpg|200px]]
|}

= Ligando a Labrador =

A principal maneira de usar a placa Labrador é conectando-a a um monitor HDMI e a um teclado e mouse USB, além da fonte de alimentação, para que possa ser usada como um dispositivo Linux comum. As próximas seções ensinam passo a passo como fazer isso.

== Conectando teclado e mouse - USB ==

Para poder interagir com a Labrador, basta conectar teclado e mouse às interfaces USB disponíveis. Em geral, você poderá usar qualquer teclado e mouse USB.

== Conectando o monitor - HDMI ==

A principal forma de visualizar a saída gráfica da Labrador é através de um monitor HDMI (High Definition Multimedia Interface). Você irá precisar de um cabo HDMI comum e de um monitor HDMI.

Caso seu monitor não possua entrada HDMI, mas possua DVI, a Labrador também funciona com adaptadores HDMI-para-DVI. Também já foram testadas entradas analógicas, como o VGA, que funciona com adaptadores HDMI-VGA que façam internamente a conversão digital-analógica.

== Conectando a fonte de alimentação ==

O último passo relacionado à conexão de componentes físicos, antes de usar a placa, é conectar a fonte de alimentação. A fonte enviada na caixa aceita ambas as tensões 110V e 220V, e tem como saída 12V 1A de corrente contínua. Caso necessário, fontes alternativas com especificação equivalente podem ser usadas.

Agora, com o mouse, teclado e monitor já conectados, coloque a fonte de alimentação na tomada e conecte-a à Labrador. Se tudo ocorreu bem, você deverá ver o logo do Caninos Loucos, seguido da tela de login.

= Usando o Debian =

O sistema operacional incluso na placa Labrador é o Debian, uma distribuição Linux utilizada no mundo todo. Para o leitor leigo no assunto, [http://www.devfuria.com.br/linux/como-iniciar-no-linux/ há vários tutoriais de Linux na internet], ensinando o básico de [https://sempreupdate.com.br/como-funciona-a-linha-de-comando-do-linux/ como mexer na linha de comando], e até mesmo [https://hacker-tools.github.io/lectures/ guias avançados para aproveitar o Linux ao máximo].

== Login ==

Para começar, assumindo que você já ligou a placa e está na tela de login, o próximo passo é digitar "caninos" (sem as aspas), tanto para o usuário quanto para a senha, e clicar em "Login".

== Acesso à Internet ==

Apesar de a Labrador possuir muitas aplicações para uso offline, conectá-la à Internet nos permite acessar websites, instalar bibliotecas e manter o sistema atualizado. Há duas formas principais, usando cabo de rede (Ethernet) ou a conexão sem-fio (Wi-Fi).

=== Ethernet ===

Para acessar a Internet usando cabo de rede, basta conectar o seu cabo de internet à entrada RJ45. Ao fazer isso com a placa ligada, observe também que o ícone de rede, no lado inferior direito da tela, irá carregar, até apontar que a conexão foi realizada com sucesso.

=== Wi-Fi ===

Como a Labrador já tem Wi-Fi embutido, basta acessar o menu de redes, escolher a sua rede, digitar a senha, e habilitar a conexão. Se for necessário especificar o tipo de segurança da rede, provavelmente será a opção "WPA2 Personal". Caso isso não funcione, peça ajuda à pessoa que realizou a configuração do seu roteador para descobrir os parâmetros corretos de configuração.

=== Verifique a conexão ===

Independente da forma como você se conectou à Internet, você agora pode testar a sua conexão. Uma forma simples de fazer isso é abrindo o Firefox e acessando o site http://caninosloucos.org. Já uma forma mais avançada é abrindo o terminal, digitando <code>ip address</code> e verificando se você tem um endereço IP válido. É útil saber o endereço IP, pois permite que nos comuniquemos com a Labrador, seja em uma aplicação IoT, seja durante o desenvolvimento. Por exemplo podemos acessar o terminal da Labrador via SSH (Secure Shell), evitando assim a necessidade de mantê-la sempre conectada a um teclado, mouse e monitor.

== Crie seus próprios programas ==

A Labrador tem suporte para uma variedade de linguagens de programação, desde as mais baixo nível, como o C, até as mais alto nível e expressivas, como Python e NodeJS. Portanto deixe a sua criatividade florescer e crie seus próprios programas usando a Labrador. Ah, e não esqueça de compartilhar os seus projetos com a comunidade, no [https://forum.caninosloucos.org.br/ fórum Caninos Loucos]!

=== Piscando um LED ===

Se ao aprender programar imprimimos "Hello World" na tela, na programação de SBCs vamos além: vamos fazer piscar um LED (Light Emitting Diode). Este exemplo é interessante pois demonstra que nossos programas, além de controlarem caracteres na tela ou bytes na rede, também podem controlar componentes físicos.

Para fazer os LED azul e verde da Labrador piscarem em um ritmo de batimento cardíaco (de acordo com a demanda de processamento da Labrador), abra o terminal e execute o seguinte comando:

Na Labrador 32 bits:
<pre>sudo echo 63 > /sys/class/gpio/export</pre>
<pre>sudo echo 44 > /sys/class/gpio/export</pre>
<pre>sudo echo out > /sys/class/gpio/gpio63/direction</pre>
<pre>sudo echo out > /sys/class/gpio/gpio44/direction</pre>
<pre>sudo echo heartbeat > /sys/class/gpio/gpio63/value</pre>
<pre>sudo echo heartbeat > /sys/class/gpio/gpio44/value</pre>

Na Labrador 64 bits:
<pre>sudo chmod 777 /sys/class/leds/led1/trigger</pre>
<pre>sudo chmod 777 /sys/class/leds/led2/trigger</pre>
<pre>sudo echo heartbeat > /sys/class/leds/led1/trigger</pre>
<pre>sudo echo heartbeat > /sys/class/leds/led2/trigger</pre>

=== Programação GPIO ===

Uma interface interessante da Labrador são os pinos GPIO (General Purpose Input/Output), que são basicamente fios nos quais você pode enviar e receber dados. Para aprender como usar esta interface, confira o artigo principal [[Programação GPIO]].

=== UART ===

Através dos pinos de GPIO é possível utilizar a comunicação serial UART na Labrador. Segue um pequeno exemplo de como acessar esse recurso:

1. Conectar um adaptador tty-usb em um computador e a Labrador, através dos pinos 8 e 10 e um GND.

2. Abrir um emulador de terminal no computador e definir o baud rate como 115200bps.

3. No terminal da Labrador entrar com os seguintes comandos:

<pre>sudo stty -F /dev/ttyS0 115200</pre>
<pre>sudo echo "Teste" > /dev/ttyS0</pre>

4. No emulador de terminal do computador aparecerá a palavra “Teste”

=== ADC ===

A Labrador também possui ADC, que significa Analogic-Digital Converter (Conversor Analógico-Digital). A ideia é ler um valor analógico, entre 0v e 3v e converter para digital, representado por um valor de 10 bits (1024 valores possíveis).

Para ler o valor do ADC, entre com o seguinte comando no terminal:
<pre>cat /sys/kernel/auxadc/adc0</pre>
A primeira parte do resultado é o timestamp do sistema, enquanto a segunda parte é o resultado em si.

=== PWM ===

No pino 12 do header de 40 pinos da Labrador é possível encontrar o PWM. Um exemplo de utilização desse recurso pode ser encontrado abaixo. Utilizando o terminal, digite:

<pre>sudo su</pre>
<pre>echo 0 > /sys/class/pwm/pwmchip0/export</pre>

Selecione o período do sinal PWM (em nanosegundos):
<pre>echo 2000000000 > /sys/class/pwm/pwmchip0/pwm0/period</pre>

Selecione o duty cycle (em nanosegundos).
<pre>echo 1000000000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle</pre>

Ative (1) ou desative (0) o sinal PWM:
<pre>echo 1 > /sys/class/pwm/pwmchip0/pwm0/enable</pre>

Com isso, a tensão no pino 12 variará entre 0v e 3v3 a cada 1 segundo.

=== I2C ===

Também encontramos pinos I2C na Labrador. A conexão é feita através dos pinos 3 (dados) e 5 (clock) do header de 40 pinos. Uma maneira de testar essa conexão e descobrir o endereço do seu dispositivo I2C é mostrada abaixo. No terminal, entrar com os seguintes comandos:

<pre>sudo apt install i2c-tools</pre>
<pre>sudo i2cdetect -y 2</pre>

A saída terá o seguinte formato onde, no exemplo, o endereço do dispositivo i2c é 60 (hexadecimal):

<pre> 0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: 60 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
</pre>

Começando com a Labrador

2020-07-24T21:18:49Z

Thalyson: /* Hello World - Piscando um LED */

= O que vem na caixa =

Neste capítulo vamos conhecer um pouco mais sobre o hardware e o software contido na caixa da Labrador.

== Hardware e acessórios inclusos ==

Ao abrir a caixa da Labrador, você irá encontrar uma Labrador dentro de um case de acrílico e uma fonte de alimentação. Note que a Labrador é composta de duas placas: a Core e a Base. A Tabela abaixo descreve e ilustra cada um dos componentes inclusos.

{| class="wikitable"
! style="background-color:#c0c0c0;" | Item
! style="background-color:#c0c0c0;" | Descrição
! style="background-color:#c0c0c0; text-align: center" | Foto
|-
| Labrador Coreboard
| Núcleo da Labrador, contém Processador e Memória.
| style="text-align: center" | [[Arquivo:CoreBoard-v2-front.png|300px]]
|-
| Labrador Baseboard
| Placa com periféricos, ex.: USB, HDMI, GPIO, conector de energia.
| style="text-align: center" | [[Arquivo:Base-frente.png|300px]]
|-
| Case de acrílico com espaçadores de nylon e parafusos
| Item para proteção da placa.
| style="text-align: center" | [[Arquivo:Case-labrador.jpeg|300px]]
|-
| Fonte de alimentação 12V @ 1A
| Fornece energia elétrica na tensão e corrente corretas.
| style="text-align: center" | [[Arquivo:Fonte-labrador.jpg|200px]]
|}

= Ligando a Labrador =

A principal maneira de usar a placa Labrador é conectando-a a um monitor HDMI e a um teclado e mouse USB, além da fonte de alimentação, para que possa ser usada como um dispositivo Linux comum. As próximas seções ensinam passo a passo como fazer isso.

== Conectando teclado e mouse - USB ==

Para poder interagir com a Labrador, basta conectar teclado e mouse às interfaces USB disponíveis. Em geral, você poderá usar qualquer teclado e mouse USB.

== Conectando o monitor - HDMI ==

A principal forma de visualizar a saída gráfica da Labrador é através de um monitor HDMI (High Definition Multimedia Interface). Você irá precisar de um cabo HDMI comum e de um monitor HDMI.

Caso seu monitor não possua entrada HDMI, mas possua DVI, a Labrador também funciona com adaptadores HDMI-para-DVI. Também já foram testadas entradas analógicas, como o VGA, que funciona com adaptadores HDMI-VGA que façam internamente a conversão digital-analógica.

== Conectando a fonte de alimentação ==

O último passo relacionado à conexão de componentes físicos, antes de usar a placa, é conectar a fonte de alimentação. A fonte enviada na caixa aceita ambas as tensões 110V e 220V, e tem como saída 12V 1A de corrente contínua. Caso necessário, fontes alternativas com especificação equivalente podem ser usadas.

Agora, com o mouse, teclado e monitor já conectados, coloque a fonte de alimentação na tomada e conecte-a à Labrador. Se tudo ocorreu bem, você deverá ver o logo do Caninos Loucos, seguido da tela de login.

= Usando o Debian =

O sistema operacional incluso na placa Labrador é o Debian, uma distribuição Linux utilizada no mundo todo. Para o leitor leigo no assunto, [http://www.devfuria.com.br/linux/como-iniciar-no-linux/ há vários tutoriais de Linux na internet], ensinando o básico de [https://sempreupdate.com.br/como-funciona-a-linha-de-comando-do-linux/ como mexer na linha de comando], e até mesmo [https://hacker-tools.github.io/lectures/ guias avançados para aproveitar o Linux ao máximo].

== Login ==

Para começar, assumindo que você já ligou a placa e está na tela de login, o próximo passo é digitar "caninos" (sem as aspas), tanto para o usuário quanto para a senha, e clicar em "Login".

== Acesso à Internet ==

Apesar de a Labrador possuir muitas aplicações para uso offline, conectá-la à Internet nos permite acessar websites, instalar bibliotecas e manter o sistema atualizado. Há duas formas principais, usando cabo de rede (Ethernet) ou a conexão sem-fio (Wi-Fi).

=== Ethernet ===

Para acessar a Internet usando cabo de rede, basta conectar o seu cabo de internet à entrada RJ45. Ao fazer isso com a placa ligada, observe também que o ícone de rede, no lado inferior direito da tela, irá carregar, até apontar que a conexão foi realizada com sucesso.

=== Wi-Fi ===

Como a Labrador já tem Wi-Fi embutido, basta acessar o menu de redes, escolher a sua rede, digitar a senha, e habilitar a conexão. Se for necessário especificar o tipo de segurança da rede, provavelmente será a opção "WPA2 Personal". Caso isso não funcione, peça ajuda à pessoa que realizou a configuração do seu roteador para descobrir os parâmetros corretos de configuração.

=== Verifique a conexão ===

Independente da forma como você se conectou à Internet, você agora pode testar a sua conexão. Uma forma simples de fazer isso é abrindo o Firefox e acessando o site http://caninosloucos.org. Já uma forma mais avançada é abrindo o terminal, digitando <code>ip address</code> e verificando se você tem um endereço IP válido. É útil saber o endereço IP, pois permite que nos comuniquemos com a Labrador, seja em uma aplicação IoT, seja durante o desenvolvimento. Por exemplo podemos acessar o terminal da Labrador via SSH (Secure Shell), evitando assim a necessidade de mantê-la sempre conectada a um teclado, mouse e monitor.

== Crie seus próprios programas ==

A Labrador tem suporte para uma variedade de linguagens de programação, desde as mais baixo nível, como o C, até as mais alto nível e expressivas, como Python e NodeJS. Portanto deixe a sua criatividade florescer e crie seus próprios programas usando a Labrador. Ah, e não esqueça de compartilhar os seus projetos com a comunidade, no [https://forum.caninosloucos.org.br/ fórum Caninos Loucos]!

=== Hello World - Piscando um LED ===

Se ao aprender programar imprimimos "Hello World" na tela, na programação de SBCs vamos além: vamos fazer piscar um LED (Light Emitting Diode). Este exemplo é interessante pois demonstra que nossos programas, além de controlarem caracteres na tela ou bytes na rede, também podem controlar componentes físicos.

Para fazer o LED azul da Labrador piscar em um ritmo de batimento cardíaco (de acordo com a demanda de processamento da Labrador), abra o terminal e execute o seguinte comando:

Na Labrador 32 bits com Kernel 3:
<pre>sudo echo heartbeat > /sys/class/leds/blue:GPIOB31/trigger</pre>

Na Labrador 64 bits:
<pre>sudo chmod 777 /sys/class/leds/led2/trigger</pre>
<pre>sudo echo heartbeat > /sys/class/leds/led2/trigger</pre>

=== Programação GPIO ===

Uma interface interessante da Labrador são os pinos GPIO (General Purpose Input/Output), que são basicamente fios nos quais você pode enviar e receber dados. Para aprender como usar esta interface, confira o artigo principal [[Programação GPIO]].

=== UART ===

Através dos pinos de GPIO é possível utilizar a comunicação serial UART na Labrador. Segue um pequeno exemplo de como acessar esse recurso:

1. Conectar um adaptador tty-usb em um computador e a Labrador, através dos pinos 8 e 10 e um GND.

2. Abrir um emulador de terminal no computador e definir o baud rate como 115200bps.

3. No terminal da Labrador entrar com os seguintes comandos:

<pre>sudo stty -F /dev/ttyS0 115200</pre>
<pre>sudo echo "Teste" > /dev/ttyS0</pre>

4. No emulador de terminal do computador aparecerá a palavra “Teste”

=== ADC ===

A Labrador também possui ADC, que significa Analogic-Digital Converter (Conversor Analógico-Digital). A ideia é ler um valor analógico, entre 0v e 3v e converter para digital, representado por um valor de 10 bits (1024 valores possíveis).

Para ler o valor do ADC, entre com o seguinte comando no terminal:
<pre>cat /sys/kernel/auxadc/adc0</pre>
A primeira parte do resultado é o timestamp do sistema, enquanto a segunda parte é o resultado em si.

=== PWM ===

No pino 12 do header de 40 pinos da Labrador é possível encontrar o PWM. Um exemplo de utilização desse recurso pode ser encontrado abaixo. Utilizando o terminal, digite:

<pre>sudo su</pre>
<pre>echo 0 > /sys/class/pwm/pwmchip0/export</pre>

Selecione o período do sinal PWM (em nanosegundos):
<pre>echo 2000000000 > /sys/class/pwm/pwmchip0/pwm0/period</pre>

Selecione o duty cycle (em nanosegundos).
<pre>echo 1000000000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle</pre>

Ative (1) ou desative (0) o sinal PWM:
<pre>echo 1 > /sys/class/pwm/pwmchip0/pwm0/enable</pre>

Com isso, a tensão no pino 12 variará entre 0v e 3v3 a cada 1 segundo.

=== I2C ===

Também encontramos pinos I2C na Labrador. A conexão é feita através dos pinos 3 (dados) e 5 (clock) do header de 40 pinos. Uma maneira de testar essa conexão e descobrir o endereço do seu dispositivo I2C é mostrada abaixo. No terminal, entrar com os seguintes comandos:

<pre>sudo apt install i2c-tools</pre>
<pre>sudo i2cdetect -y 2</pre>

A saída terá o seguinte formato onde, no exemplo, o endereço do dispositivo i2c é 60 (hexadecimal):

<pre> 0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: 60 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
</pre>

Começando com a Labrador

2020-07-24T21:18:27Z

Thalyson: /* Crie seus próprios programas */

= O que vem na caixa =

Neste capítulo vamos conhecer um pouco mais sobre o hardware e o software contido na caixa da Labrador.

== Hardware e acessórios inclusos ==

Ao abrir a caixa da Labrador, você irá encontrar uma Labrador dentro de um case de acrílico e uma fonte de alimentação. Note que a Labrador é composta de duas placas: a Core e a Base. A Tabela abaixo descreve e ilustra cada um dos componentes inclusos.

{| class="wikitable"
! style="background-color:#c0c0c0;" | Item
! style="background-color:#c0c0c0;" | Descrição
! style="background-color:#c0c0c0; text-align: center" | Foto
|-
| Labrador Coreboard
| Núcleo da Labrador, contém Processador e Memória.
| style="text-align: center" | [[Arquivo:CoreBoard-v2-front.png|300px]]
|-
| Labrador Baseboard
| Placa com periféricos, ex.: USB, HDMI, GPIO, conector de energia.
| style="text-align: center" | [[Arquivo:Base-frente.png|300px]]
|-
| Case de acrílico com espaçadores de nylon e parafusos
| Item para proteção da placa.
| style="text-align: center" | [[Arquivo:Case-labrador.jpeg|300px]]
|-
| Fonte de alimentação 12V @ 1A
| Fornece energia elétrica na tensão e corrente corretas.
| style="text-align: center" | [[Arquivo:Fonte-labrador.jpg|200px]]
|}

= Ligando a Labrador =

A principal maneira de usar a placa Labrador é conectando-a a um monitor HDMI e a um teclado e mouse USB, além da fonte de alimentação, para que possa ser usada como um dispositivo Linux comum. As próximas seções ensinam passo a passo como fazer isso.

== Conectando teclado e mouse - USB ==

Para poder interagir com a Labrador, basta conectar teclado e mouse às interfaces USB disponíveis. Em geral, você poderá usar qualquer teclado e mouse USB.

== Conectando o monitor - HDMI ==

A principal forma de visualizar a saída gráfica da Labrador é através de um monitor HDMI (High Definition Multimedia Interface). Você irá precisar de um cabo HDMI comum e de um monitor HDMI.

Caso seu monitor não possua entrada HDMI, mas possua DVI, a Labrador também funciona com adaptadores HDMI-para-DVI. Também já foram testadas entradas analógicas, como o VGA, que funciona com adaptadores HDMI-VGA que façam internamente a conversão digital-analógica.

== Conectando a fonte de alimentação ==

O último passo relacionado à conexão de componentes físicos, antes de usar a placa, é conectar a fonte de alimentação. A fonte enviada na caixa aceita ambas as tensões 110V e 220V, e tem como saída 12V 1A de corrente contínua. Caso necessário, fontes alternativas com especificação equivalente podem ser usadas.

Agora, com o mouse, teclado e monitor já conectados, coloque a fonte de alimentação na tomada e conecte-a à Labrador. Se tudo ocorreu bem, você deverá ver o logo do Caninos Loucos, seguido da tela de login.

= Usando o Debian =

O sistema operacional incluso na placa Labrador é o Debian, uma distribuição Linux utilizada no mundo todo. Para o leitor leigo no assunto, [http://www.devfuria.com.br/linux/como-iniciar-no-linux/ há vários tutoriais de Linux na internet], ensinando o básico de [https://sempreupdate.com.br/como-funciona-a-linha-de-comando-do-linux/ como mexer na linha de comando], e até mesmo [https://hacker-tools.github.io/lectures/ guias avançados para aproveitar o Linux ao máximo].

== Login ==

Para começar, assumindo que você já ligou a placa e está na tela de login, o próximo passo é digitar "caninos" (sem as aspas), tanto para o usuário quanto para a senha, e clicar em "Login".

== Acesso à Internet ==

Apesar de a Labrador possuir muitas aplicações para uso offline, conectá-la à Internet nos permite acessar websites, instalar bibliotecas e manter o sistema atualizado. Há duas formas principais, usando cabo de rede (Ethernet) ou a conexão sem-fio (Wi-Fi).

=== Ethernet ===

Para acessar a Internet usando cabo de rede, basta conectar o seu cabo de internet à entrada RJ45. Ao fazer isso com a placa ligada, observe também que o ícone de rede, no lado inferior direito da tela, irá carregar, até apontar que a conexão foi realizada com sucesso.

=== Wi-Fi ===

Como a Labrador já tem Wi-Fi embutido, basta acessar o menu de redes, escolher a sua rede, digitar a senha, e habilitar a conexão. Se for necessário especificar o tipo de segurança da rede, provavelmente será a opção "WPA2 Personal". Caso isso não funcione, peça ajuda à pessoa que realizou a configuração do seu roteador para descobrir os parâmetros corretos de configuração.

=== Verifique a conexão ===

Independente da forma como você se conectou à Internet, você agora pode testar a sua conexão. Uma forma simples de fazer isso é abrindo o Firefox e acessando o site http://caninosloucos.org. Já uma forma mais avançada é abrindo o terminal, digitando <code>ip address</code> e verificando se você tem um endereço IP válido. É útil saber o endereço IP, pois permite que nos comuniquemos com a Labrador, seja em uma aplicação IoT, seja durante o desenvolvimento. Por exemplo podemos acessar o terminal da Labrador via SSH (Secure Shell), evitando assim a necessidade de mantê-la sempre conectada a um teclado, mouse e monitor.

== Crie seus próprios programas ==

A Labrador tem suporte para uma variedade de linguagens de programação, desde as mais baixo nível, como o C, até as mais alto nível e expressivas, como Python e NodeJS. Portanto deixe a sua criatividade florescer e crie seus próprios programas usando a Labrador. Ah, e não esqueça de compartilhar os seus projetos com a comunidade, no [https://forum.caninosloucos.org.br/ fórum Caninos Loucos]!

=== Hello World - Piscando um LED ===

Se ao aprender programar imprimimos "Hello World" na tela, na programação de SBCs vamos além: vamos fazer piscar um LED (Light Emitting Diode). Este exemplo é interessante pois demonstra que nossos programas, além de controlarem caracteres na tela ou bytes na rede, também podem controlar componentes físicos.

Para fazer o LED azul da Labrador piscar em um ritmo de batimento cardíaco (de acordo com a demanda de processamento da Labrador), abra o terminal e execute o seguinte comando:

Na Labrador 32 bits com Kernel 3:
<pre>sudo echo heartbeat > /sys/class/leds/blue:GPIOB31/trigger</pre>

Na labrador 64 bits:
<pre>sudo chmod 777 /sys/class/leds/led2/trigger</pre>
<pre>sudo echo heartbeat > /sys/class/leds/led2/trigger</pre>

=== Programação GPIO ===

Uma interface interessante da Labrador são os pinos GPIO (General Purpose Input/Output), que são basicamente fios nos quais você pode enviar e receber dados. Para aprender como usar esta interface, confira o artigo principal [[Programação GPIO]].

=== UART ===

Através dos pinos de GPIO é possível utilizar a comunicação serial UART na Labrador. Segue um pequeno exemplo de como acessar esse recurso:

1. Conectar um adaptador tty-usb em um computador e a Labrador, através dos pinos 8 e 10 e um GND.

2. Abrir um emulador de terminal no computador e definir o baud rate como 115200bps.

3. No terminal da Labrador entrar com os seguintes comandos:

<pre>sudo stty -F /dev/ttyS0 115200</pre>
<pre>sudo echo "Teste" > /dev/ttyS0</pre>

4. No emulador de terminal do computador aparecerá a palavra “Teste”

=== ADC ===

A Labrador também possui ADC, que significa Analogic-Digital Converter (Conversor Analógico-Digital). A ideia é ler um valor analógico, entre 0v e 3v e converter para digital, representado por um valor de 10 bits (1024 valores possíveis).

Para ler o valor do ADC, entre com o seguinte comando no terminal:
<pre>cat /sys/kernel/auxadc/adc0</pre>
A primeira parte do resultado é o timestamp do sistema, enquanto a segunda parte é o resultado em si.

=== PWM ===

No pino 12 do header de 40 pinos da Labrador é possível encontrar o PWM. Um exemplo de utilização desse recurso pode ser encontrado abaixo. Utilizando o terminal, digite:

<pre>sudo su</pre>
<pre>echo 0 > /sys/class/pwm/pwmchip0/export</pre>

Selecione o período do sinal PWM (em nanosegundos):
<pre>echo 2000000000 > /sys/class/pwm/pwmchip0/pwm0/period</pre>

Selecione o duty cycle (em nanosegundos).
<pre>echo 1000000000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle</pre>

Ative (1) ou desative (0) o sinal PWM:
<pre>echo 1 > /sys/class/pwm/pwmchip0/pwm0/enable</pre>

Com isso, a tensão no pino 12 variará entre 0v e 3v3 a cada 1 segundo.

=== I2C ===

Também encontramos pinos I2C na Labrador. A conexão é feita através dos pinos 3 (dados) e 5 (clock) do header de 40 pinos. Uma maneira de testar essa conexão e descobrir o endereço do seu dispositivo I2C é mostrada abaixo. No terminal, entrar com os seguintes comandos:

<pre>sudo apt install i2c-tools</pre>
<pre>sudo i2cdetect -y 2</pre>

A saída terá o seguinte formato onde, no exemplo, o endereço do dispositivo i2c é 60 (hexadecimal):

<pre> 0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: 60 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
</pre>

Começando com a Labrador

2020-07-24T21:07:28Z

Thalyson: /* Hello World - Piscando um LED (Kernel 3) */

= O que vem na caixa =

Neste capítulo vamos conhecer um pouco mais sobre o hardware e o software contido na caixa da Labrador.

== Hardware e acessórios inclusos ==

Ao abrir a caixa da Labrador, você irá encontrar uma Labrador dentro de um case de acrílico e uma fonte de alimentação. Note que a Labrador é composta de duas placas: a Core e a Base. A Tabela abaixo descreve e ilustra cada um dos componentes inclusos.

{| class="wikitable"
! style="background-color:#c0c0c0;" | Item
! style="background-color:#c0c0c0;" | Descrição
! style="background-color:#c0c0c0; text-align: center" | Foto
|-
| Labrador Coreboard
| Núcleo da Labrador, contém Processador e Memória.
| style="text-align: center" | [[Arquivo:CoreBoard-v2-front.png|300px]]
|-
| Labrador Baseboard
| Placa com periféricos, ex.: USB, HDMI, GPIO, conector de energia.
| style="text-align: center" | [[Arquivo:Base-frente.png|300px]]
|-
| Case de acrílico com espaçadores de nylon e parafusos
| Item para proteção da placa.
| style="text-align: center" | [[Arquivo:Case-labrador.jpeg|300px]]
|-
| Fonte de alimentação 12V @ 1A
| Fornece energia elétrica na tensão e corrente corretas.
| style="text-align: center" | [[Arquivo:Fonte-labrador.jpg|200px]]
|}

= Ligando a Labrador =

A principal maneira de usar a placa Labrador é conectando-a a um monitor HDMI e a um teclado e mouse USB, além da fonte de alimentação, para que possa ser usada como um dispositivo Linux comum. As próximas seções ensinam passo a passo como fazer isso.

== Conectando teclado e mouse - USB ==

Para poder interagir com a Labrador, basta conectar teclado e mouse às interfaces USB disponíveis. Em geral, você poderá usar qualquer teclado e mouse USB.

== Conectando o monitor - HDMI ==

A principal forma de visualizar a saída gráfica da Labrador é através de um monitor HDMI (High Definition Multimedia Interface). Você irá precisar de um cabo HDMI comum e de um monitor HDMI.

Caso seu monitor não possua entrada HDMI, mas possua DVI, a Labrador também funciona com adaptadores HDMI-para-DVI. Também já foram testadas entradas analógicas, como o VGA, que funciona com adaptadores HDMI-VGA que façam internamente a conversão digital-analógica.

== Conectando a fonte de alimentação ==

O último passo relacionado à conexão de componentes físicos, antes de usar a placa, é conectar a fonte de alimentação. A fonte enviada na caixa aceita ambas as tensões 110V e 220V, e tem como saída 12V 1A de corrente contínua. Caso necessário, fontes alternativas com especificação equivalente podem ser usadas.

Agora, com o mouse, teclado e monitor já conectados, coloque a fonte de alimentação na tomada e conecte-a à Labrador. Se tudo ocorreu bem, você deverá ver o logo do Caninos Loucos, seguido da tela de login.

= Usando o Debian =

O sistema operacional incluso na placa Labrador é o Debian, uma distribuição Linux utilizada no mundo todo. Para o leitor leigo no assunto, [http://www.devfuria.com.br/linux/como-iniciar-no-linux/ há vários tutoriais de Linux na internet], ensinando o básico de [https://sempreupdate.com.br/como-funciona-a-linha-de-comando-do-linux/ como mexer na linha de comando], e até mesmo [https://hacker-tools.github.io/lectures/ guias avançados para aproveitar o Linux ao máximo].

== Login ==

Para começar, assumindo que você já ligou a placa e está na tela de login, o próximo passo é digitar "caninos" (sem as aspas), tanto para o usuário quanto para a senha, e clicar em "Login".

== Acesso à Internet ==

Apesar de a Labrador possuir muitas aplicações para uso offline, conectá-la à Internet nos permite acessar websites, instalar bibliotecas e manter o sistema atualizado. Há duas formas principais, usando cabo de rede (Ethernet) ou a conexão sem-fio (Wi-Fi).

=== Ethernet ===

Para acessar a Internet usando cabo de rede, basta conectar o seu cabo de internet à entrada RJ45. Ao fazer isso com a placa ligada, observe também que o ícone de rede, no lado inferior direito da tela, irá carregar, até apontar que a conexão foi realizada com sucesso.

=== Wi-Fi ===

Como a Labrador já tem Wi-Fi embutido, basta acessar o menu de redes, escolher a sua rede, digitar a senha, e habilitar a conexão. Se for necessário especificar o tipo de segurança da rede, provavelmente será a opção "WPA2 Personal". Caso isso não funcione, peça ajuda à pessoa que realizou a configuração do seu roteador para descobrir os parâmetros corretos de configuração.

=== Verifique a conexão ===

Independente da forma como você se conectou à Internet, você agora pode testar a sua conexão. Uma forma simples de fazer isso é abrindo o Firefox e acessando o site http://caninosloucos.org. Já uma forma mais avançada é abrindo o terminal, digitando <code>ip address</code> e verificando se você tem um endereço IP válido. É útil saber o endereço IP, pois permite que nos comuniquemos com a Labrador, seja em uma aplicação IoT, seja durante o desenvolvimento. Por exemplo podemos acessar o terminal da Labrador via SSH (Secure Shell), evitando assim a necessidade de mantê-la sempre conectada a um teclado, mouse e monitor.

== Crie seus próprios programas ==

A Labrador tem suporte para uma variedade de linguagens de programação, desde as mais baixo nível, como o C, até as mais alto nível e expressivas, como Python e NodeJS. Portanto deixe a sua criatividade florescer e crie seus próprios programas usando a Labrador. Ah, e não esqueça de compartilhar os seus projetos com a comunidade, no [https://forum.caninosloucos.org.br/ fórum Caninos Loucos]!

=== Hello World - Piscando um LED ===

Se ao aprender programar imprimimos "Hello World" na tela, na programação de SBCs vamos além: vamos fazer piscar um LED (Light Emitting Diode). Este exemplo é interessante pois demonstra que nossos programas, além de controlarem caracteres na tela ou bytes na rede, também podem controlar componentes físicos.

Para fazer o LED azul da Labrador piscar em um ritmo de batimento cardíaco (de acordo com a demanda de processamento da Labrador), abra o terminal e execute o seguinte comando:

Na Labrador 32 bits com Kernel 3:
<pre>sudo echo heartbeat > /sys/class/leds/blue:GPIOB31/trigger</pre>

Na labrador 64 bits:
<pre>sudo chmod 777 /sys/class/leds/led2/trigger</pre>
<pre>sudo echo heartbeat > /sys/class/leds/led2/trigger</pre>

=== Programação GPIO ===

Uma interface interessante da Labrador são os pinos GPIO (General Purpose Input/Output), que são basicamente fios nos quais você pode enviar e receber dados. Para aprender como usar esta interface, confira o artigo principal [[Programação GPIO]].

=== UART ===

Através dos pinos de GPIO é possível utilizar a comunicação serial UART na Labrador. Segue um pequeno exemplo de como acessar esse recurso:

1. Conectar um adaptador tty-usb em um computador e a Labrador, através dos pinos 8 e 10 e um GND.

2. Abrir um emulador de terminal no computador e definir o baud rate como 115200bps.

3. No terminal da Labrador entrar com os seguintes comandos:

<pre>sudo stty -F /dev/ttyS0 115200</pre>
<pre>sudo echo "Teste" > /dev/ttyS0</pre>

4. No emulador de terminal do computador aparecerá a palavra “Teste”

=== ADC ===

A Labrador também possui ADC, que significa Analogic-Digital Converter (Conversor Analógico-Digital). A ideia é ler um valor analógico, entre 0v e 3v e converter para digital, representado por um valor de 10 bits (1024 valores possíveis).

Para ler o valor do ADC, entre com o seguinte comando no terminal:
<pre>cat /sys/kernel/auxadc/adc0</pre>
A primeira parte do resultado é o timestamp do sistema, enquanto a segunda parte é o resultado em si.

=== PWM ===

No pino 12 do header de 40 pinos da Labrador é possível encontrar o PWM. Um exemplo de utilização desse recurso pode ser encontrado abaixo. Utilizando o terminal, digite:

<pre>$ sudo su</pre>
<pre>$ echo 0 > /sys/class/pwm/pwmchip0/export</pre>

Selecione o período do sinal PWM (em nanosegundos):
<pre>$ echo 2000000000 > /sys/class/pwm/pwmchip0/pwm0/period</pre>

Selecione o duty cycle (em nanosegundos).
<pre>$ echo 1000000000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle</pre>

Ative (1) ou desative (0) o sinal PWM:
<pre>$ echo 1 > /sys/class/pwm/pwmchip0/pwm0/enable</pre>

Com isso, a tensão no pino 12 variará entre 0v e 3v3 a cada 1 segundo.

=== I2C ===

Também encontramos pinos I2C na Labrador. A conexão é feita através dos pinos 3 (dados) e 5 (clock) do header de 40 pinos. Uma maneira de testar essa conexão e descobrir o endereço do seu dispositivo I2C é mostrada abaixo. No terminal, entrar com os seguintes comandos:

<pre>$ sudo apt install i2c-tools</pre>
<pre>$ sudo i2cdetect -y 2</pre>

A saída terá o seguinte formato onde, no exemplo, o endereço do dispositivo i2c é 60 (hexadecimal):

<pre> 0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: 60 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
</pre>

Começando com a Labrador

2020-07-24T21:03:44Z

Thalyson: /* Crie seus próprios programas */

= O que vem na caixa =

Neste capítulo vamos conhecer um pouco mais sobre o hardware e o software contido na caixa da Labrador.

== Hardware e acessórios inclusos ==

Ao abrir a caixa da Labrador, você irá encontrar uma Labrador dentro de um case de acrílico e uma fonte de alimentação. Note que a Labrador é composta de duas placas: a Core e a Base. A Tabela abaixo descreve e ilustra cada um dos componentes inclusos.

{| class="wikitable"
! style="background-color:#c0c0c0;" | Item
! style="background-color:#c0c0c0;" | Descrição
! style="background-color:#c0c0c0; text-align: center" | Foto
|-
| Labrador Coreboard
| Núcleo da Labrador, contém Processador e Memória.
| style="text-align: center" | [[Arquivo:CoreBoard-v2-front.png|300px]]
|-
| Labrador Baseboard
| Placa com periféricos, ex.: USB, HDMI, GPIO, conector de energia.
| style="text-align: center" | [[Arquivo:Base-frente.png|300px]]
|-
| Case de acrílico com espaçadores de nylon e parafusos
| Item para proteção da placa.
| style="text-align: center" | [[Arquivo:Case-labrador.jpeg|300px]]
|-
| Fonte de alimentação 12V @ 1A
| Fornece energia elétrica na tensão e corrente corretas.
| style="text-align: center" | [[Arquivo:Fonte-labrador.jpg|200px]]
|}

= Ligando a Labrador =

A principal maneira de usar a placa Labrador é conectando-a a um monitor HDMI e a um teclado e mouse USB, além da fonte de alimentação, para que possa ser usada como um dispositivo Linux comum. As próximas seções ensinam passo a passo como fazer isso.

== Conectando teclado e mouse - USB ==

Para poder interagir com a Labrador, basta conectar teclado e mouse às interfaces USB disponíveis. Em geral, você poderá usar qualquer teclado e mouse USB.

== Conectando o monitor - HDMI ==

A principal forma de visualizar a saída gráfica da Labrador é através de um monitor HDMI (High Definition Multimedia Interface). Você irá precisar de um cabo HDMI comum e de um monitor HDMI.

Caso seu monitor não possua entrada HDMI, mas possua DVI, a Labrador também funciona com adaptadores HDMI-para-DVI. Também já foram testadas entradas analógicas, como o VGA, que funciona com adaptadores HDMI-VGA que façam internamente a conversão digital-analógica.

== Conectando a fonte de alimentação ==

O último passo relacionado à conexão de componentes físicos, antes de usar a placa, é conectar a fonte de alimentação. A fonte enviada na caixa aceita ambas as tensões 110V e 220V, e tem como saída 12V 1A de corrente contínua. Caso necessário, fontes alternativas com especificação equivalente podem ser usadas.

Agora, com o mouse, teclado e monitor já conectados, coloque a fonte de alimentação na tomada e conecte-a à Labrador. Se tudo ocorreu bem, você deverá ver o logo do Caninos Loucos, seguido da tela de login.

= Usando o Debian =

O sistema operacional incluso na placa Labrador é o Debian, uma distribuição Linux utilizada no mundo todo. Para o leitor leigo no assunto, [http://www.devfuria.com.br/linux/como-iniciar-no-linux/ há vários tutoriais de Linux na internet], ensinando o básico de [https://sempreupdate.com.br/como-funciona-a-linha-de-comando-do-linux/ como mexer na linha de comando], e até mesmo [https://hacker-tools.github.io/lectures/ guias avançados para aproveitar o Linux ao máximo].

== Login ==

Para começar, assumindo que você já ligou a placa e está na tela de login, o próximo passo é digitar "caninos" (sem as aspas), tanto para o usuário quanto para a senha, e clicar em "Login".

== Acesso à Internet ==

Apesar de a Labrador possuir muitas aplicações para uso offline, conectá-la à Internet nos permite acessar websites, instalar bibliotecas e manter o sistema atualizado. Há duas formas principais, usando cabo de rede (Ethernet) ou a conexão sem-fio (Wi-Fi).

=== Ethernet ===

Para acessar a Internet usando cabo de rede, basta conectar o seu cabo de internet à entrada RJ45. Ao fazer isso com a placa ligada, observe também que o ícone de rede, no lado inferior direito da tela, irá carregar, até apontar que a conexão foi realizada com sucesso.

=== Wi-Fi ===

Como a Labrador já tem Wi-Fi embutido, basta acessar o menu de redes, escolher a sua rede, digitar a senha, e habilitar a conexão. Se for necessário especificar o tipo de segurança da rede, provavelmente será a opção "WPA2 Personal". Caso isso não funcione, peça ajuda à pessoa que realizou a configuração do seu roteador para descobrir os parâmetros corretos de configuração.

=== Verifique a conexão ===

Independente da forma como você se conectou à Internet, você agora pode testar a sua conexão. Uma forma simples de fazer isso é abrindo o Firefox e acessando o site http://caninosloucos.org. Já uma forma mais avançada é abrindo o terminal, digitando <code>ip address</code> e verificando se você tem um endereço IP válido. É útil saber o endereço IP, pois permite que nos comuniquemos com a Labrador, seja em uma aplicação IoT, seja durante o desenvolvimento. Por exemplo podemos acessar o terminal da Labrador via SSH (Secure Shell), evitando assim a necessidade de mantê-la sempre conectada a um teclado, mouse e monitor.

== Crie seus próprios programas ==

A Labrador tem suporte para uma variedade de linguagens de programação, desde as mais baixo nível, como o C, até as mais alto nível e expressivas, como Python e NodeJS. Portanto deixe a sua criatividade florescer e crie seus próprios programas usando a Labrador. Ah, e não esqueça de compartilhar os seus projetos com a comunidade, no [https://forum.caninosloucos.org.br/ fórum Caninos Loucos]!

=== Hello World - Piscando um LED (Kernel 3) ===

Se ao aprender programar imprimimos "Hello World" na tela, na programação de SBCs vamos além: vamos fazer piscar um LED (Light Emitting Diode). Este exemplo é interessante pois demonstra que nossos programas, além de controlarem caracteres na tela ou bytes na rede, também podem controlar componentes físicos.

Para fazer o LED azul da Labrador piscar em um ritmo de batimento cardíaco (de acordo com a demanda de processamento da Labrador), abra o terminal e execute o seguinte comando:

<pre>sudo echo heartbeat > /sys/class/leds/blue:GPIOB31/trigger</pre>

=== Programação GPIO ===

Uma interface interessante da Labrador são os pinos GPIO (General Purpose Input/Output), que são basicamente fios nos quais você pode enviar e receber dados. Para aprender como usar esta interface, confira o artigo principal [[Programação GPIO]].

=== UART ===

Através dos pinos de GPIO é possível utilizar a comunicação serial UART na Labrador. Segue um pequeno exemplo de como acessar esse recurso:

1. Conectar um adaptador tty-usb em um computador e a Labrador, através dos pinos 8 e 10 e um GND.

2. Abrir um emulador de terminal no computador e definir o baud rate como 115200bps.

3. No terminal da Labrador entrar com os seguintes comandos:

<pre>sudo stty -F /dev/ttyS0 115200</pre>
<pre>sudo echo "Teste" > /dev/ttyS0</pre>

4. No emulador de terminal do computador aparecerá a palavra “Teste”

=== ADC ===

A Labrador também possui ADC, que significa Analogic-Digital Converter (Conversor Analógico-Digital). A ideia é ler um valor analógico, entre 0v e 3v e converter para digital, representado por um valor de 10 bits (1024 valores possíveis).

Para ler o valor do ADC, entre com o seguinte comando no terminal:
<pre>cat /sys/kernel/auxadc/adc0</pre>
A primeira parte do resultado é o timestamp do sistema, enquanto a segunda parte é o resultado em si.

=== PWM ===

No pino 12 do header de 40 pinos da Labrador é possível encontrar o PWM. Um exemplo de utilização desse recurso pode ser encontrado abaixo. Utilizando o terminal, digite:

<pre>$ sudo su</pre>
<pre>$ echo 0 > /sys/class/pwm/pwmchip0/export</pre>

Selecione o período do sinal PWM (em nanosegundos):
<pre>$ echo 2000000000 > /sys/class/pwm/pwmchip0/pwm0/period</pre>

Selecione o duty cycle (em nanosegundos).
<pre>$ echo 1000000000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle</pre>

Ative (1) ou desative (0) o sinal PWM:
<pre>$ echo 1 > /sys/class/pwm/pwmchip0/pwm0/enable</pre>

Com isso, a tensão no pino 12 variará entre 0v e 3v3 a cada 1 segundo.

=== I2C ===

Também encontramos pinos I2C na Labrador. A conexão é feita através dos pinos 3 (dados) e 5 (clock) do header de 40 pinos. Uma maneira de testar essa conexão e descobrir o endereço do seu dispositivo I2C é mostrada abaixo. No terminal, entrar com os seguintes comandos:

<pre>$ sudo apt install i2c-tools</pre>
<pre>$ sudo i2cdetect -y 2</pre>

A saída terá o seguinte formato onde, no exemplo, o endereço do dispositivo i2c é 60 (hexadecimal):

<pre> 0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: 60 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
</pre>

Kernel

2020-05-20T14:55:31Z

Thalyson: /* Atualização Do Kernel */

Como a Labrador suporta Linux, ela precisa prover a interface entre entre o sistema operacional e o hardware, essa interface é chamada de Linux Kernel.

== Versão Do Kernel ==

Para verificar qual é a versão atual do Kernel, abra o LXTerminal e digite:

$ cat /proc/version

[[Arquivo:cat_proc_version.png|none|658px|Versão do Kernel]]

Pode-se verificar que neste caso a versão do Kernel é a 4.14.13.

== Atualização Do Kernel ==

Por diversas razões pode ser necessário trocar ou atualizar o Kernel, seja para suportar novos hardwares ou mesmo melhorar o desempenho com hardwares já suportados ou ainda prover novas funcionalidades a esses hardwares já suportados. É valido observar que este processo pode causar problemas ao seu sistema.

É possível realizar a troca do Kernel de algumas maneiras, a mais simples é utilizando a versão já compilada para a Labrador, que pode ser encontrada no GitHub da [https://github.com/caninos-loucos/labrador-linux Caninos Loucos]. Procure os arquivos na pasta "output".

'''Troca De Kernel Compilado'''

Para realizar a troca do Kernel siga os passos a seguir;

1 - Baixar o arquivo contendo o Kernel_x_y.zip do repositório.

2 - Extrair o conteúdo para um diretório, /*caminho qualquer de diretórios*/src/

3 - Copiar “kernel.dtb” e “uImage” para a raíz da partição BOOT

<code>$ sudo cp -r /src/kernel.dtb /media/caninos/BOOT
$ sudo cp -r /src/uImage /media/caninos/BOOT</code>

4 - Copiar “lib/modules” para “lib/modules” da partição SYSTEM:

<code>$ sudo cp -r /src/lib/modules /lib/</code>

5 - Reiniciar a Labrador

$ sudo reboot

Após esse processo a labrador já será inicializada com o Kernel desejado.

Instalando um sistema 64 bits

2020-05-20T14:55:23Z

Thalyson: /* Labrador 64 bits */

Para instalar um novo sistema na sua placa Labrador você vai precisar de:
* Labrador Coreboard + Baseboard
* Imagem do sistema em formato .img
* Cartão microSD de pelo menos 8Gb

*Verifique o modelo da Labrador Coreboard, caso a versão seja LABRADOR CORE V3.x siga as instruções de Labrador 64 bits, caso seja LABRADOR CORE V2.x siga as instruções contidas em [[Instalando um sistema 32 bits]].

== Labrador 64 bits ==
[[Arquivo:recovery64.jpg|thumb|400px|Botão Recovery]]
A instalação deve seguir conforme abaixo:

1. Primeiramente você deve baixar a imagem em [http://downloads.caninosloucos.org.br/labrador_64_bits/ Labrador 64 bits].

2. Depois você deve descompactar os arquivos.

3. Após descompactar deve escrever a imagem em um cartão microSD utilizando o comando dd no Linux ou o software [https://sourceforge.net/projects/win32diskimager/ Win32 Disk Imager] no Windows.

4. Remova a labrador da fonte de alimentação, insira o cartão SD na Labrador, mantenha o botão de recuperação da Coreboard (no canto superior esquerdo da Coreboard, próximo à etiqueta de número de série) pressionado, conecte a fonte de alimentação, espere próximo de 3 segundos ou até o logo aparecer na tela e solte o botão de recuperação.

5. O sistema será iniciado a partir do cartão. Para conferir utilize o comando <code>$lsblk</code>, o dispositivo em mmcblk0p1 (Cartão SD) deverá estar montado na raiz do sistema, e o dispositivo mmcblk2 (memória interna da labrador) pode estar ou não montada.

6. Para instalar o sistema abra o terminal e execute o comando;

<code>$ cd install

$ sudo ./install.sh</code>

7. Caso a Labrador já possua um sistema instalado previamente em sua memória interna, será necessário confirmar para que o processo de atualização continue.

8. Aguarde o processo ser finalizado, remova o cartão SD e reinicie a Labrador.

Instalando um sistema 64 bits

2020-05-20T14:54:52Z

Thalyson:

Para instalar um novo sistema na sua placa Labrador você vai precisar de:
* Labrador Coreboard + Baseboard
* Imagem do sistema em formato .img
* Cartão microSD de pelo menos 8Gb

*Verifique o modelo da Labrador Coreboard, caso a versão seja LABRADOR CORE V3.x siga as instruções de Labrador 64 bits, caso seja LABRADOR CORE V2.x siga as instruções contidas em [[Instalando um sistema 32 bits]].

== Labrador 64 bits ==
[[Arquivo:recovery64.jpg|thumb|400px|Botão Recovery]]
A instalação deve seguir conforme abaixo:

1. Primeiramente você deve baixar a imagem em [http://downloads.caninosloucos.org.br/labrador64_test_image/ lab64_vX.X.7z].

2. Depois você deve descompactar os arquivos.

3. Após descompactar deve escrever a imagem em um cartão microSD utilizando o comando dd no Linux ou o software [https://sourceforge.net/projects/win32diskimager/ Win32 Disk Imager] no Windows.

4. Remova a labrador da fonte de alimentação, insira o cartão SD na Labrador, mantenha o botão de recuperação da Coreboard (no canto superior esquerdo da Coreboard, próximo à etiqueta de número de série) pressionado, conecte a fonte de alimentação, espere próximo de 3 segundos ou até o logo aparecer na tela e solte o botão de recuperação.

5. O sistema será iniciado a partir do cartão. Para conferir utilize o comando <code>$lsblk</code>, o dispositivo em mmcblk0p1 (Cartão SD) deverá estar montado na raiz do sistema, e o dispositivo mmcblk2 (memória interna da labrador) pode estar ou não montada.

6. Para instalar o sistema abra o terminal e execute o comando;

<code>$ cd install

$ sudo ./install.sh</code>

7. Caso a Labrador já possua um sistema instalado previamente em sua memória interna, será necessário confirmar para que o processo de atualização continue.

8. Aguarde o processo ser finalizado, remova o cartão SD e reinicie a Labrador.

Instalando um sistema 32 bits

2020-05-20T14:54:38Z

Thalyson:

Para instalar um novo sistema na sua placa Labrador você vai precisar de:
* Labrador Coreboard + Baseboard
* Imagem do sistema em formato .img
* Cartão microSD de pelo menos 8Gb
* Conversor Serial-TTL (não obrigatório)

[[Arquivo:recovery.png|thumb|400px|Botão Recovery]]

*Verifique o modelo da Labrador Coreboard, caso a versão seja LABRADOR CORE V2.x siga as instruções de Labrador 32 bits, caso seja LABRADOR CORE V3.x siga as instruções contidas em [[Instalando um sistema 64 bits]].

= Gravando uma nova imagem =

Apesar de a Labrador já vir com o Debian instalado na memória interna, você pode gravar uma nova imagem, feita por você mesmo, ou baixada do site Caninos Loucos. A Labrador suporta boot a partir da memória interna e a partir de um SD Card, e as seções a seguir ensinam como gravar uma imagem em cada uma dessas mídias. A imagem atual disponibilizada pela Caninos Loucos está em: [http://downloads.caninosloucos.org.br/labrador_32_bits/ Labrador 32 bits].

== Gravando no SD Card ==

Tendo uma imagem compatível com a Labrador (ver http://downloads.caninosloucos.org.br/), siga os passos abaixo para gravá-la em um SD Card, de acordo com o sistema operacional do seu computador.

=== Usando Linux ===

<dl>
<dt>Passo 1</dt>
<dd>Insira um cartão MicroSD no seu computador. O cartão deve ser maior que a imagem que você deseja gravar (geralmente 8 GB ou maior).</dd>
<dt>Passo 2</dt>
<dd>Execute no terminal o seguinte comando: <pre> $ sudo dd if=<caminho/pra/imagem>.img of=/dev/<nome do device> status=progress bs=4M conv=fsync </pre>
<dl>

Onde <code><image></code> deve ser substituído pelo nome da imagem, e <code><device></code> pelo nome do seu SD Card (algo como sda, ou sdb).

'''Importante: Se você não sabe qual o <code><nome do device></code> correto, peça ajuda! Um erro neste comando pode formatar o seu computador.'''

=== Usando Windows ===

<dl>
<dt>Passo 1</dt>
<dd>Insira um cartão MicroSD no seu computador. O cartão deve ser maior que a imagem que você deseja gravar (geralmente 8 GB ou maior).</dd>
<dt>Passo 2</dt>
<dd>Formate o cartão MicroSD. Recomenda-se que seja utilizado um software de formatação adequado, neste tutorial estamos usando o SDFormatter v4.0, disponível [https://www.sdcard.org/downloads/formatter_4/ neste website]. Execute o software como administrador e clique no botão “Opção”. Na nova janela aberta, selecione a opção “RÁPIDA” em “FORMAT TYPE” e “ON” em “FORMAT SIZE ADJUSTMENT” e pressione “OK” para voltar à tela anterior. Selecione o Drive equivalente ao seu cartão SD e clique em “Formatar” para iniciar o processo.
'''Importante: Se você não sabe qual o Drive correto, peça ajuda! Um erro neste comando pode formatar o seu computador.'''
[[File:win1.png|frame|none|alt=| Tela inicial do SDFormatter.]]

[[File:win2.png|frame|none|alt=| Tela com as opções do SDFormatter.]]
</dd>
<dt>Passo 3</dt>
<dd>Para gravar a imagem no cartão SD, recomenda-se o uso de uma ferramenta de gravação. Neste tutorial, estamos usando o Win32DiskImager, encontrado [https://sourceforge.net/projects/win32diskimager/files/latest/download neste link]. Execute o programa como administrador, selecione o arquivo de imagem (descompactado) e clique no botão Write para iniciar o processo de gravação. Quando a barra de carregamento termina, o processo é concluído.
[[File:win3.png|frame|none|alt=| Tela do Win32DiskImager (botão para selecionar o caminho em vermelho).]]
</dd></dl>

== Gravando na memória interna ==

1. Caso tenha o conversor serial-ttl, conecte ele na labrador de acordo com as instruções em [https://wiki.caninosloucos.org.br/index.php/Labrador/Debug Debug].

2. Remova a labrador da fonte de alimentação, insira o cartão SD na Labrador, mantenha o botão de recuperação da Coreboard (no canto superior esquerdo da Coreboard, próximo à etiqueta de número de série) pressionado, conecte a fonte de alimentação, espere próximo de dois segundos e solte o botão de recuperação.

===Com o conversor serial-tty===
3.1 Caso veja a seguinte mensagem 'Booting Proccess Aborted' na saída de debug, retire novamente a labrador da fonte, faça o passo anterior novamente, mas mantendo por menos tempo o botão de recuperação pressionado.

[[Arquivo:labrador32_flash_aborted.png|600px|Falha ao realizar boot]]

3.2 O processo de flash começará automaticamente e deve levar cerca de 90 minutos. Para verificar o progresso use o Debug pela serial.

[[Arquivo:labrador32_flash_finished.png|400px|Instalação completa]]

3.3 Após o fim do boot basta retirar o cartão SD e ligar a placa normalmente.

===Sem o conversor serial-tty(Em edição, não utilizar)===

1. Ao ligar a placa, entre no ''lxterminal''.

1.1 Em ''/media/caninos'', se existir, copie todo conteúdo do diretório '''BOOT2''' para o diretório '''BOOT1'''.
$ cp -r /media/caninos/BOOT2/* /media/caninos/BOOT1/
Caso não exista, copie o conteúdo de '''BOOT1''' para '''BOOT'''.

2. Aguarde o processo ser finalizado, remova o cartão SD e reinicie a Labrador.

Apresentação Geral e Especificações Técnicas

2020-05-20T14:54:24Z

Thalyson: /* Labrador 64 bits */

[[Arquivo:Core_v2_base_v1.jpg|thumb|400px|Coreboard v2 e Baseboard v1]]

[[Arquivo:Core_v3_base_v2.jpg|thumb|400px|Coreboard v3 e Baseboard v2]]
A placa Labrador é a primeira Single Board Computer da Caninos Loucos, aberta e com as funcionalidades de um computador. É capaz de rodar em um sistema operacional Linux, acessar a internet, reproduzir vídeos e executar programas de edição de texto. Esse conjunto possui proteção ESD, é compacta, resistente e serve para as mais diversas aplicações, desde projetos pessoais até aplicações profissionais.

A Labrador é uma combinação de 2 placas: a coreboard, uma placa de tamanho reduzido e alta capacidade de processamento, e a baseboard, onde encontramos as diversas interfaces de comunicação.

Estão disponíveis duas versões de coreboards para a Labrador: a Labrador Core v2 que possui um poderoso processador ARM de 32 bits e, para as aplicações que necessitam de ainda mais desempenho, a Labrador Core v3, possui um processador ARM de 64 bits com capacidade de processamento de IA com deep learning.

Modelos da Labrador Baseboard podem desenvolvidos para diferentes aplicações. Estão disponíveis duas versões para o público maker. A Labrador Base M v1 foi uma primeira versão que disponibiliza uma ampla gama de interfaces, incluindo diferentes tipos de interfaces USB, de áudio e vídeo, cartão de expansão de memória, GPIOs, etc. A Labrador Base M v2 que traz uma série de melhorias mecânicas e amplia as possibilidades de comunicação sem fio incluindo o sistema LoRa/LoRaWAN e Bluetooth 5.0.

A Labrador padroniza a interface entre coreboard e baseboard, permitindo a compatibilidade entre seus vários modelos.

= Especificações =

== Labrador Core v2==

[http://caninosloucos.org/downloads/caninos_loucos_datasheet_labradorV2_001.pdf Fazer o download do folder de especificações]

{| class="wikitable"
|-
! scope="row"| CPU
| 32-bit quad-core ARM® Cortex™ 1,3GHz A9R4 CPU (ARM v7 instruction set)
|-
! scope="row"| GPU
| Imagination PowerVR SGX544. Suporta: OpenGL-ES 1.1 e 2.0, OpenGL 1.2.1, OpenCL 1.1
|-
! scope="row"| Memória
| 2 GB DDR3 SDRAM 16GB eMMC
|-
! scope="row"| Sistema operacional
| Debian 10 Linux Kernel 4.14.13 32-bits
|-
! scope="row"| PMU
| ATC2306C - Gerenciamento de energia e subsistema de áudio
|-
! scope="row"| Vídeo
| 1080p@60fps com suporte a codificação de vídeo (incluindo H264, H263, MPEG-4)
|-
! scope="row"| Interface de expansão
| Conector DDR3 SODIMM 204 pinos (macho)
|-
! scope="row"| Botão
| ADFU
|-
! scope="row"| Dimensões
| 67.6 x 42.2 mm
|-
! scope="row"| Peso
| 13.6g
|}

==Labrador Core v3==

{| class="wikitable"
|-
! scope="row"| CPU
| 64-bit quad-Core ARM Cortex A53 1,3GHz CPU (ARM v8 instruction set)
|-
! scope="row"| GPU
| ARM Mali450 MP6 (4PP + 2GP). Suporta: OpenGL-ES 1.1 e 2.0, OpenVG 1.1, EGL 1.5
|-
! scope="row"| Memória
| 2 GB LPDDR3 SDRAM 16GB eMMC
|-
! scope="row"| Sistema operacional
| Debian 10 Linux Kernel 4.19
|-
! scope="row"| PMU
| ATC2306C - Gerenciamento de energia e subsistema de áudio
|-
! scope="row"| Vídeo
| 2160p@30fps ou 1080p@60fps com suporte a codificação de vídeo (incluindo H264, H263, MPEG-4)
|-
! scope="row"| Interface de expansão
| Conector DDR3 SODIMM 204 pinos (macho)
|-
! scope="row"| Botão
| ADFU
|-
! scope="row"| Dimensões
| 67.6 x 31.0 mm
|-
! scope="row"| Peso
| 10.1g
|}

==Labrador Base M v1==

{| class="wikitable"
|-
! scope="row"| Armazenamento
| MicroSD Card Slot SD/SDHC/SDXC - até: 32GB
|-
! scope="row"| Ethernet
| 10/100Mbps (RJ45)
|-
! scope="row"| Wireless
| Wi-Fi 802.11 b/g/n 2.4GHz Bluetooth 4.0 1 x receptor infravermelho (38kHz)
|-
! scope="row"| USB
| 2 x USB2.0 HOST (tipo A) 1 x USB3.0 OTG (micro-B)
|-
! scope="row"| Display
| 1 x HDMI 1.4 (tipo A), até 1920x1080@60Hz 1 x LVDS-DSI para LCDs, até 1920x1080@60Hz 1 x CVBS PAL/NTSC (PJ342 3,5mm)
|-
! scope="row"| Áudio
| Saída no HDMI Saída analógica estéreo (PJ342 3,5mm) I2S entrada/saída Microfone embutido
|-
! scope="row"| Câmera
| 1 x interface paralela de 8-bits
|-
! scope="row"| LED
| 1 x ligar/desligar (vermelho) 1 x programável (verde) 1 x programável (azul)
|-
! scope="row"| Botões
| 1x ligar/desligar 1x reiniciar 1x programável
|-
! scope="row"| Alimentação
| 5~12V @ 3W (diâmetro interno 2,1mm, externo de 5,5mm, centro positivo).
|-
! scope="row"| Expansão
| Conector SODIMM de 204 pinos (fêmea) 40-pin header: 28 GPIOs (compatível com Raspberry Pi / suporta UART, I2C, SPI, PWM e I2S) ADC input
|-
! scope="row"| Debug
| UART
|-
! scope="row"| Dimensões
| 88 x 81,3 mm
|-
! scope="row"| Peso
| 52,6g
|}

==Labrador Base M v2==

{| class="wikitable"
|-
! scope="row"| Armazenamento
| MicroSD Card Slot SD/SDHC/SDXC - até: 32GB
|-
! scope="row"| Ethernet
| 10/100Mbps (RJ45)
|-
! scope="row"| Wireless
| Wi-Fi 802.11 b/g/n 2.4GHz Bluetooth LE 5.0* LoRaWAN™* 1 x receptor infravermelho (38kHz)
|-
! scope="row"| USB
| 2 x USB2.0 HOST (tipo A) 1 x USB3.0 OTG (micro-B)
|-
! scope="row"| Display
| 1 x HDMI 1.4 (tipo A), até 1920x1080@60Hz 1 x LVDS-DSI para LCDs, até 1920x1080@60Hz 1 x CVBS PAL/NTSC (PJ342 3,5mm)
|-
! scope="row"| Áudio
| saída no HDMI Saída analógica estéreo (PJ342 3,5mm) I2S entrada/saída Microfone embutido
|-
! scope="row"| Câmera
| 1 x interface paralela de 8-bits
|-
! scope="row"| LED
| 1 x ligar/desligar (vermelho) 1 x programável (verde) 1 x programável (azul)
|-
! scope="row"| Botões
| 1x ligar/desligar 1x reiniciar 1x programável
|-
! scope="row"| Alimentação
| 5~12V @ 3W (diâmetro interno 2,1mm, externo de 5,5mm, centro positivo).
|-
! scope="row"| Expansão
| Conector SODIMM de 204 pinos (fêmea) 40-pin header: 28 GPIOs (compatível com Raspberry Pi / suporta UART, I2C, SPI, PWM e I2S) ADC input
|-
! scope="row"| Debug
| UART
|-
! scope="row"| Dimensões
| 92,7 x 88.0 mm
|-
! scope="row"| Peso
| 59,4g
|}

= Limitações das imagens de software disponíveis =
==Labrador 32 bits==
Atualmente a imagem do Debian 10, disponibilizada para a Labrador Core v2, de 32 bits, possui algumas limitações de suporte às funcionalidades da Baseboard. Estamos continuamente trabalhando para ampliar a disponibilidade e qualidade dos Drivers das plataformas e contamos com a comunidade para colaborar com estes aprimoramentos.

As seguintes funcionalidades ainda não estão disponíveis no último release:
* Áudio
* Câmera
* USB 3.0
* LoRa / LoRaWAN
* Temperatura da CPU
* Receptor Infravermelho
* Aceleração gráfica por hardware

Além disso, existem os seguintes bugs conhecidos:
* Resolução de vídeo só alcança 1080p caso o cabo HDMI seja conectado após a Labrador ligar. Caso a placa seja ligada com o cabo HDMI já conectado, a resolução será 720p.
* A Labrador não funciona com todos os monitores. Foi observado até agora que monitores e TVs HDMI funcionam normalmente e a maioria dos adaptadores VGA também apresenta bom funcionamento. No entanto, ao usá-las com adaptadores DVI alguns monitores não funcionam corretamente.

A imagem da Labrador 32 bits pode ser encontrada em: [http://downloads.caninosloucos.org.br/labrador_32_bits/ Labrador 32 bits]

Caso você queira compilar sua própria versão, pode encontrar os arquivos em nosso [https://github.com/caninos-loucos/labrador-linux GitHub].

==Labrador 64 bits==

Atualmente a imagem do Debian 10, kernel Linux 4.19, disponibilizada para a Labrador Core v3, de 64 bits, possui algumas limitações de suporte às funcionalidades da Baseboard. Estamos continuamente trabalhando para ampliar a disponibilidade e qualidade dos Drivers das plataformas e contamos com a comunidade para colaborar com estes aprimoramentos.

As seguintes funcionalidades ainda não estão disponíveis no último release:

* CVBS
* HDCP
* Câmera
* USB 3.0
* WiringK9
* LoRa / LoRaWAN
* Botão programável
* Áudio (saída HDMI)
* Receptor Infravermelho
* Set Mode do HDMI (seleção de resolução de vídeo)
* Sensores (carga de bateria, consumo de energia e temperatura do PMIC e do processador)

A imagem da Labrador 64 bits pode ser encontrada em: [http://downloads.caninosloucos.org.br/labrador_64_bits/ Labrador 64 bits].

Caso você queira compilar sua própria versão, pode encontrar os arquivos em nosso [https://github.com/caninos-loucos/labrador-linux-64 GitHub].

Apresentação Geral e Especificações Técnicas

2020-05-20T14:54:08Z

Thalyson: /* Labrador 64 bits */

[[Arquivo:Core_v2_base_v1.jpg|thumb|400px|Coreboard v2 e Baseboard v1]]

[[Arquivo:Core_v3_base_v2.jpg|thumb|400px|Coreboard v3 e Baseboard v2]]
A placa Labrador é a primeira Single Board Computer da Caninos Loucos, aberta e com as funcionalidades de um computador. É capaz de rodar em um sistema operacional Linux, acessar a internet, reproduzir vídeos e executar programas de edição de texto. Esse conjunto possui proteção ESD, é compacta, resistente e serve para as mais diversas aplicações, desde projetos pessoais até aplicações profissionais.

A Labrador é uma combinação de 2 placas: a coreboard, uma placa de tamanho reduzido e alta capacidade de processamento, e a baseboard, onde encontramos as diversas interfaces de comunicação.

Estão disponíveis duas versões de coreboards para a Labrador: a Labrador Core v2 que possui um poderoso processador ARM de 32 bits e, para as aplicações que necessitam de ainda mais desempenho, a Labrador Core v3, possui um processador ARM de 64 bits com capacidade de processamento de IA com deep learning.

Modelos da Labrador Baseboard podem desenvolvidos para diferentes aplicações. Estão disponíveis duas versões para o público maker. A Labrador Base M v1 foi uma primeira versão que disponibiliza uma ampla gama de interfaces, incluindo diferentes tipos de interfaces USB, de áudio e vídeo, cartão de expansão de memória, GPIOs, etc. A Labrador Base M v2 que traz uma série de melhorias mecânicas e amplia as possibilidades de comunicação sem fio incluindo o sistema LoRa/LoRaWAN e Bluetooth 5.0.

A Labrador padroniza a interface entre coreboard e baseboard, permitindo a compatibilidade entre seus vários modelos.

= Especificações =

== Labrador Core v2==

[http://caninosloucos.org/downloads/caninos_loucos_datasheet_labradorV2_001.pdf Fazer o download do folder de especificações]

{| class="wikitable"
|-
! scope="row"| CPU
| 32-bit quad-core ARM® Cortex™ 1,3GHz A9R4 CPU (ARM v7 instruction set)
|-
! scope="row"| GPU
| Imagination PowerVR SGX544. Suporta: OpenGL-ES 1.1 e 2.0, OpenGL 1.2.1, OpenCL 1.1
|-
! scope="row"| Memória
| 2 GB DDR3 SDRAM 16GB eMMC
|-
! scope="row"| Sistema operacional
| Debian 10 Linux Kernel 4.14.13 32-bits
|-
! scope="row"| PMU
| ATC2306C - Gerenciamento de energia e subsistema de áudio
|-
! scope="row"| Vídeo
| 1080p@60fps com suporte a codificação de vídeo (incluindo H264, H263, MPEG-4)
|-
! scope="row"| Interface de expansão
| Conector DDR3 SODIMM 204 pinos (macho)
|-
! scope="row"| Botão
| ADFU
|-
! scope="row"| Dimensões
| 67.6 x 42.2 mm
|-
! scope="row"| Peso
| 13.6g
|}

==Labrador Core v3==

{| class="wikitable"
|-
! scope="row"| CPU
| 64-bit quad-Core ARM Cortex A53 1,3GHz CPU (ARM v8 instruction set)
|-
! scope="row"| GPU
| ARM Mali450 MP6 (4PP + 2GP). Suporta: OpenGL-ES 1.1 e 2.0, OpenVG 1.1, EGL 1.5
|-
! scope="row"| Memória
| 2 GB LPDDR3 SDRAM 16GB eMMC
|-
! scope="row"| Sistema operacional
| Debian 10 Linux Kernel 4.19
|-
! scope="row"| PMU
| ATC2306C - Gerenciamento de energia e subsistema de áudio
|-
! scope="row"| Vídeo
| 2160p@30fps ou 1080p@60fps com suporte a codificação de vídeo (incluindo H264, H263, MPEG-4)
|-
! scope="row"| Interface de expansão
| Conector DDR3 SODIMM 204 pinos (macho)
|-
! scope="row"| Botão
| ADFU
|-
! scope="row"| Dimensões
| 67.6 x 31.0 mm
|-
! scope="row"| Peso
| 10.1g
|}

==Labrador Base M v1==

{| class="wikitable"
|-
! scope="row"| Armazenamento
| MicroSD Card Slot SD/SDHC/SDXC - até: 32GB
|-
! scope="row"| Ethernet
| 10/100Mbps (RJ45)
|-
! scope="row"| Wireless
| Wi-Fi 802.11 b/g/n 2.4GHz Bluetooth 4.0 1 x receptor infravermelho (38kHz)
|-
! scope="row"| USB
| 2 x USB2.0 HOST (tipo A) 1 x USB3.0 OTG (micro-B)
|-
! scope="row"| Display
| 1 x HDMI 1.4 (tipo A), até 1920x1080@60Hz 1 x LVDS-DSI para LCDs, até 1920x1080@60Hz 1 x CVBS PAL/NTSC (PJ342 3,5mm)
|-
! scope="row"| Áudio
| Saída no HDMI Saída analógica estéreo (PJ342 3,5mm) I2S entrada/saída Microfone embutido
|-
! scope="row"| Câmera
| 1 x interface paralela de 8-bits
|-
! scope="row"| LED
| 1 x ligar/desligar (vermelho) 1 x programável (verde) 1 x programável (azul)
|-
! scope="row"| Botões
| 1x ligar/desligar 1x reiniciar 1x programável
|-
! scope="row"| Alimentação
| 5~12V @ 3W (diâmetro interno 2,1mm, externo de 5,5mm, centro positivo).
|-
! scope="row"| Expansão
| Conector SODIMM de 204 pinos (fêmea) 40-pin header: 28 GPIOs (compatível com Raspberry Pi / suporta UART, I2C, SPI, PWM e I2S) ADC input
|-
! scope="row"| Debug
| UART
|-
! scope="row"| Dimensões
| 88 x 81,3 mm
|-
! scope="row"| Peso
| 52,6g
|}

==Labrador Base M v2==

{| class="wikitable"
|-
! scope="row"| Armazenamento
| MicroSD Card Slot SD/SDHC/SDXC - até: 32GB
|-
! scope="row"| Ethernet
| 10/100Mbps (RJ45)
|-
! scope="row"| Wireless
| Wi-Fi 802.11 b/g/n 2.4GHz Bluetooth LE 5.0* LoRaWAN™* 1 x receptor infravermelho (38kHz)
|-
! scope="row"| USB
| 2 x USB2.0 HOST (tipo A) 1 x USB3.0 OTG (micro-B)
|-
! scope="row"| Display
| 1 x HDMI 1.4 (tipo A), até 1920x1080@60Hz 1 x LVDS-DSI para LCDs, até 1920x1080@60Hz 1 x CVBS PAL/NTSC (PJ342 3,5mm)
|-
! scope="row"| Áudio
| saída no HDMI Saída analógica estéreo (PJ342 3,5mm) I2S entrada/saída Microfone embutido
|-
! scope="row"| Câmera
| 1 x interface paralela de 8-bits
|-
! scope="row"| LED
| 1 x ligar/desligar (vermelho) 1 x programável (verde) 1 x programável (azul)
|-
! scope="row"| Botões
| 1x ligar/desligar 1x reiniciar 1x programável
|-
! scope="row"| Alimentação
| 5~12V @ 3W (diâmetro interno 2,1mm, externo de 5,5mm, centro positivo).
|-
! scope="row"| Expansão
| Conector SODIMM de 204 pinos (fêmea) 40-pin header: 28 GPIOs (compatível com Raspberry Pi / suporta UART, I2C, SPI, PWM e I2S) ADC input
|-
! scope="row"| Debug
| UART
|-
! scope="row"| Dimensões
| 92,7 x 88.0 mm
|-
! scope="row"| Peso
| 59,4g
|}

= Limitações das imagens de software disponíveis =
==Labrador 32 bits==
Atualmente a imagem do Debian 10, disponibilizada para a Labrador Core v2, de 32 bits, possui algumas limitações de suporte às funcionalidades da Baseboard. Estamos continuamente trabalhando para ampliar a disponibilidade e qualidade dos Drivers das plataformas e contamos com a comunidade para colaborar com estes aprimoramentos.

As seguintes funcionalidades ainda não estão disponíveis no último release:
* Áudio
* Câmera
* USB 3.0
* LoRa / LoRaWAN
* Temperatura da CPU
* Receptor Infravermelho
* Aceleração gráfica por hardware

Além disso, existem os seguintes bugs conhecidos:
* Resolução de vídeo só alcança 1080p caso o cabo HDMI seja conectado após a Labrador ligar. Caso a placa seja ligada com o cabo HDMI já conectado, a resolução será 720p.
* A Labrador não funciona com todos os monitores. Foi observado até agora que monitores e TVs HDMI funcionam normalmente e a maioria dos adaptadores VGA também apresenta bom funcionamento. No entanto, ao usá-las com adaptadores DVI alguns monitores não funcionam corretamente.

A imagem da Labrador 32 bits pode ser encontrada em: [http://downloads.caninosloucos.org.br/labrador_32_bits/ Labrador 32 bits]

Caso você queira compilar sua própria versão, pode encontrar os arquivos em nosso [https://github.com/caninos-loucos/labrador-linux GitHub].

==Labrador 64 bits==

Atualmente a imagem do Debian 10, kernel Linux 4.19, disponibilizada para a Labrador Core v3, de 64 bits, possui algumas limitações de suporte às funcionalidades da Baseboard. Estamos continuamente trabalhando para ampliar a disponibilidade e qualidade dos Drivers das plataformas e contamos com a comunidade para colaborar com estes aprimoramentos.

As seguintes funcionalidades ainda não estão disponíveis no último release:

* CVBS
* HDCP
* Câmera
* USB 3.0
* WiringK9
* LoRa / LoRaWAN
* Botão programável
* Áudio (saída HDMI)
* Receptor Infravermelho
* Set Mode do HDMI (seleção de resolução de vídeo)
* Sensores (carga de bateria, consumo de energia e temperatura do PMIC e do processador)

A imagem da Labrador 64 bits pode ser encontrada em [http://downloads.caninosloucos.org.br/labrador_64_bits/ Labrador 64 bits].

Caso você queira compilar sua própria versão, pode encontrar os arquivos em nosso [https://github.com/caninos-loucos/labrador-linux-64 GitHub].

Apresentação Geral e Especificações Técnicas

2020-05-20T14:53:38Z

Thalyson: /* Labrador 64 bits */

[[Arquivo:Core_v2_base_v1.jpg|thumb|400px|Coreboard v2 e Baseboard v1]]

[[Arquivo:Core_v3_base_v2.jpg|thumb|400px|Coreboard v3 e Baseboard v2]]
A placa Labrador é a primeira Single Board Computer da Caninos Loucos, aberta e com as funcionalidades de um computador. É capaz de rodar em um sistema operacional Linux, acessar a internet, reproduzir vídeos e executar programas de edição de texto. Esse conjunto possui proteção ESD, é compacta, resistente e serve para as mais diversas aplicações, desde projetos pessoais até aplicações profissionais.

A Labrador é uma combinação de 2 placas: a coreboard, uma placa de tamanho reduzido e alta capacidade de processamento, e a baseboard, onde encontramos as diversas interfaces de comunicação.

Estão disponíveis duas versões de coreboards para a Labrador: a Labrador Core v2 que possui um poderoso processador ARM de 32 bits e, para as aplicações que necessitam de ainda mais desempenho, a Labrador Core v3, possui um processador ARM de 64 bits com capacidade de processamento de IA com deep learning.

Modelos da Labrador Baseboard podem desenvolvidos para diferentes aplicações. Estão disponíveis duas versões para o público maker. A Labrador Base M v1 foi uma primeira versão que disponibiliza uma ampla gama de interfaces, incluindo diferentes tipos de interfaces USB, de áudio e vídeo, cartão de expansão de memória, GPIOs, etc. A Labrador Base M v2 que traz uma série de melhorias mecânicas e amplia as possibilidades de comunicação sem fio incluindo o sistema LoRa/LoRaWAN e Bluetooth 5.0.

A Labrador padroniza a interface entre coreboard e baseboard, permitindo a compatibilidade entre seus vários modelos.

= Especificações =

== Labrador Core v2==

[http://caninosloucos.org/downloads/caninos_loucos_datasheet_labradorV2_001.pdf Fazer o download do folder de especificações]

{| class="wikitable"
|-
! scope="row"| CPU
| 32-bit quad-core ARM® Cortex™ 1,3GHz A9R4 CPU (ARM v7 instruction set)
|-
! scope="row"| GPU
| Imagination PowerVR SGX544. Suporta: OpenGL-ES 1.1 e 2.0, OpenGL 1.2.1, OpenCL 1.1
|-
! scope="row"| Memória
| 2 GB DDR3 SDRAM 16GB eMMC
|-
! scope="row"| Sistema operacional
| Debian 10 Linux Kernel 4.14.13 32-bits
|-
! scope="row"| PMU
| ATC2306C - Gerenciamento de energia e subsistema de áudio
|-
! scope="row"| Vídeo
| 1080p@60fps com suporte a codificação de vídeo (incluindo H264, H263, MPEG-4)
|-
! scope="row"| Interface de expansão
| Conector DDR3 SODIMM 204 pinos (macho)
|-
! scope="row"| Botão
| ADFU
|-
! scope="row"| Dimensões
| 67.6 x 42.2 mm
|-
! scope="row"| Peso
| 13.6g
|}

==Labrador Core v3==

{| class="wikitable"
|-
! scope="row"| CPU
| 64-bit quad-Core ARM Cortex A53 1,3GHz CPU (ARM v8 instruction set)
|-
! scope="row"| GPU
| ARM Mali450 MP6 (4PP + 2GP). Suporta: OpenGL-ES 1.1 e 2.0, OpenVG 1.1, EGL 1.5
|-
! scope="row"| Memória
| 2 GB LPDDR3 SDRAM 16GB eMMC
|-
! scope="row"| Sistema operacional
| Debian 10 Linux Kernel 4.19
|-
! scope="row"| PMU
| ATC2306C - Gerenciamento de energia e subsistema de áudio
|-
! scope="row"| Vídeo
| 2160p@30fps ou 1080p@60fps com suporte a codificação de vídeo (incluindo H264, H263, MPEG-4)
|-
! scope="row"| Interface de expansão
| Conector DDR3 SODIMM 204 pinos (macho)
|-
! scope="row"| Botão
| ADFU
|-
! scope="row"| Dimensões
| 67.6 x 31.0 mm
|-
! scope="row"| Peso
| 10.1g
|}

==Labrador Base M v1==

{| class="wikitable"
|-
! scope="row"| Armazenamento
| MicroSD Card Slot SD/SDHC/SDXC - até: 32GB
|-
! scope="row"| Ethernet
| 10/100Mbps (RJ45)
|-
! scope="row"| Wireless
| Wi-Fi 802.11 b/g/n 2.4GHz Bluetooth 4.0 1 x receptor infravermelho (38kHz)
|-
! scope="row"| USB
| 2 x USB2.0 HOST (tipo A) 1 x USB3.0 OTG (micro-B)
|-
! scope="row"| Display
| 1 x HDMI 1.4 (tipo A), até 1920x1080@60Hz 1 x LVDS-DSI para LCDs, até 1920x1080@60Hz 1 x CVBS PAL/NTSC (PJ342 3,5mm)
|-
! scope="row"| Áudio
| Saída no HDMI Saída analógica estéreo (PJ342 3,5mm) I2S entrada/saída Microfone embutido
|-
! scope="row"| Câmera
| 1 x interface paralela de 8-bits
|-
! scope="row"| LED
| 1 x ligar/desligar (vermelho) 1 x programável (verde) 1 x programável (azul)
|-
! scope="row"| Botões
| 1x ligar/desligar 1x reiniciar 1x programável
|-
! scope="row"| Alimentação
| 5~12V @ 3W (diâmetro interno 2,1mm, externo de 5,5mm, centro positivo).
|-
! scope="row"| Expansão
| Conector SODIMM de 204 pinos (fêmea) 40-pin header: 28 GPIOs (compatível com Raspberry Pi / suporta UART, I2C, SPI, PWM e I2S) ADC input
|-
! scope="row"| Debug
| UART
|-
! scope="row"| Dimensões
| 88 x 81,3 mm
|-
! scope="row"| Peso
| 52,6g
|}

==Labrador Base M v2==

{| class="wikitable"
|-
! scope="row"| Armazenamento
| MicroSD Card Slot SD/SDHC/SDXC - até: 32GB
|-
! scope="row"| Ethernet
| 10/100Mbps (RJ45)
|-
! scope="row"| Wireless
| Wi-Fi 802.11 b/g/n 2.4GHz Bluetooth LE 5.0* LoRaWAN™* 1 x receptor infravermelho (38kHz)
|-
! scope="row"| USB
| 2 x USB2.0 HOST (tipo A) 1 x USB3.0 OTG (micro-B)
|-
! scope="row"| Display
| 1 x HDMI 1.4 (tipo A), até 1920x1080@60Hz 1 x LVDS-DSI para LCDs, até 1920x1080@60Hz 1 x CVBS PAL/NTSC (PJ342 3,5mm)
|-
! scope="row"| Áudio
| saída no HDMI Saída analógica estéreo (PJ342 3,5mm) I2S entrada/saída Microfone embutido
|-
! scope="row"| Câmera
| 1 x interface paralela de 8-bits
|-
! scope="row"| LED
| 1 x ligar/desligar (vermelho) 1 x programável (verde) 1 x programável (azul)
|-
! scope="row"| Botões
| 1x ligar/desligar 1x reiniciar 1x programável
|-
! scope="row"| Alimentação
| 5~12V @ 3W (diâmetro interno 2,1mm, externo de 5,5mm, centro positivo).
|-
! scope="row"| Expansão
| Conector SODIMM de 204 pinos (fêmea) 40-pin header: 28 GPIOs (compatível com Raspberry Pi / suporta UART, I2C, SPI, PWM e I2S) ADC input
|-
! scope="row"| Debug
| UART
|-
! scope="row"| Dimensões
| 92,7 x 88.0 mm
|-
! scope="row"| Peso
| 59,4g
|}

= Limitações das imagens de software disponíveis =
==Labrador 32 bits==
Atualmente a imagem do Debian 10, disponibilizada para a Labrador Core v2, de 32 bits, possui algumas limitações de suporte às funcionalidades da Baseboard. Estamos continuamente trabalhando para ampliar a disponibilidade e qualidade dos Drivers das plataformas e contamos com a comunidade para colaborar com estes aprimoramentos.

As seguintes funcionalidades ainda não estão disponíveis no último release:
* Áudio
* Câmera
* USB 3.0
* LoRa / LoRaWAN
* Temperatura da CPU
* Receptor Infravermelho
* Aceleração gráfica por hardware

Além disso, existem os seguintes bugs conhecidos:
* Resolução de vídeo só alcança 1080p caso o cabo HDMI seja conectado após a Labrador ligar. Caso a placa seja ligada com o cabo HDMI já conectado, a resolução será 720p.
* A Labrador não funciona com todos os monitores. Foi observado até agora que monitores e TVs HDMI funcionam normalmente e a maioria dos adaptadores VGA também apresenta bom funcionamento. No entanto, ao usá-las com adaptadores DVI alguns monitores não funcionam corretamente.

A imagem da Labrador 32 bits pode ser encontrada em: [http://downloads.caninosloucos.org.br/labrador_32_bits/ Labrador 32 bits]

Caso você queira compilar sua própria versão, pode encontrar os arquivos em nosso [https://github.com/caninos-loucos/labrador-linux GitHub].

==Labrador 64 bits==

Atualmente a imagem do Debian 10, kernel Linux 4.19, disponibilizada para a Labrador Core v3, de 64 bits, possui algumas limitações de suporte às funcionalidades da Baseboard. Estamos continuamente trabalhando para ampliar a disponibilidade e qualidade dos Drivers das plataformas e contamos com a comunidade para colaborar com estes aprimoramentos.

As seguintes funcionalidades ainda não estão disponíveis no último release:

* CVBS
* HDCP
* Câmera
* USB 3.0
* WiringK9
* LoRa / LoRaWAN
* Botão programável
* Áudio (saída HDMI)
* Receptor Infravermelho
* Set Mode do HDMI (seleção de resolução de vídeo)
* Sensores (carga de bateria, consumo de energia e temperatura do PMIC e do processador)

A imagem da Labrador 64 bits pode ser encontrada em [http://downloads.caninosloucos.org.br/labrador_64_bits/ Labrador_64_v.x.x.img.7z].

Caso você queira compilar sua própria versão, pode encontrar os arquivos em nosso [https://github.com/caninos-loucos/labrador-linux-64 GitHub].

Apresentação Geral e Especificações Técnicas

2020-05-20T14:53:03Z

Thalyson: /* Labrador 32 bits */

[[Arquivo:Core_v2_base_v1.jpg|thumb|400px|Coreboard v2 e Baseboard v1]]

[[Arquivo:Core_v3_base_v2.jpg|thumb|400px|Coreboard v3 e Baseboard v2]]
A placa Labrador é a primeira Single Board Computer da Caninos Loucos, aberta e com as funcionalidades de um computador. É capaz de rodar em um sistema operacional Linux, acessar a internet, reproduzir vídeos e executar programas de edição de texto. Esse conjunto possui proteção ESD, é compacta, resistente e serve para as mais diversas aplicações, desde projetos pessoais até aplicações profissionais.

A Labrador é uma combinação de 2 placas: a coreboard, uma placa de tamanho reduzido e alta capacidade de processamento, e a baseboard, onde encontramos as diversas interfaces de comunicação.

Estão disponíveis duas versões de coreboards para a Labrador: a Labrador Core v2 que possui um poderoso processador ARM de 32 bits e, para as aplicações que necessitam de ainda mais desempenho, a Labrador Core v3, possui um processador ARM de 64 bits com capacidade de processamento de IA com deep learning.

Modelos da Labrador Baseboard podem desenvolvidos para diferentes aplicações. Estão disponíveis duas versões para o público maker. A Labrador Base M v1 foi uma primeira versão que disponibiliza uma ampla gama de interfaces, incluindo diferentes tipos de interfaces USB, de áudio e vídeo, cartão de expansão de memória, GPIOs, etc. A Labrador Base M v2 que traz uma série de melhorias mecânicas e amplia as possibilidades de comunicação sem fio incluindo o sistema LoRa/LoRaWAN e Bluetooth 5.0.

A Labrador padroniza a interface entre coreboard e baseboard, permitindo a compatibilidade entre seus vários modelos.

= Especificações =

== Labrador Core v2==

[http://caninosloucos.org/downloads/caninos_loucos_datasheet_labradorV2_001.pdf Fazer o download do folder de especificações]

{| class="wikitable"
|-
! scope="row"| CPU
| 32-bit quad-core ARM® Cortex™ 1,3GHz A9R4 CPU (ARM v7 instruction set)
|-
! scope="row"| GPU
| Imagination PowerVR SGX544. Suporta: OpenGL-ES 1.1 e 2.0, OpenGL 1.2.1, OpenCL 1.1
|-
! scope="row"| Memória
| 2 GB DDR3 SDRAM 16GB eMMC
|-
! scope="row"| Sistema operacional
| Debian 10 Linux Kernel 4.14.13 32-bits
|-
! scope="row"| PMU
| ATC2306C - Gerenciamento de energia e subsistema de áudio
|-
! scope="row"| Vídeo
| 1080p@60fps com suporte a codificação de vídeo (incluindo H264, H263, MPEG-4)
|-
! scope="row"| Interface de expansão
| Conector DDR3 SODIMM 204 pinos (macho)
|-
! scope="row"| Botão
| ADFU
|-
! scope="row"| Dimensões
| 67.6 x 42.2 mm
|-
! scope="row"| Peso
| 13.6g
|}

==Labrador Core v3==

{| class="wikitable"
|-
! scope="row"| CPU
| 64-bit quad-Core ARM Cortex A53 1,3GHz CPU (ARM v8 instruction set)
|-
! scope="row"| GPU
| ARM Mali450 MP6 (4PP + 2GP). Suporta: OpenGL-ES 1.1 e 2.0, OpenVG 1.1, EGL 1.5
|-
! scope="row"| Memória
| 2 GB LPDDR3 SDRAM 16GB eMMC
|-
! scope="row"| Sistema operacional
| Debian 10 Linux Kernel 4.19
|-
! scope="row"| PMU
| ATC2306C - Gerenciamento de energia e subsistema de áudio
|-
! scope="row"| Vídeo
| 2160p@30fps ou 1080p@60fps com suporte a codificação de vídeo (incluindo H264, H263, MPEG-4)
|-
! scope="row"| Interface de expansão
| Conector DDR3 SODIMM 204 pinos (macho)
|-
! scope="row"| Botão
| ADFU
|-
! scope="row"| Dimensões
| 67.6 x 31.0 mm
|-
! scope="row"| Peso
| 10.1g
|}

==Labrador Base M v1==

{| class="wikitable"
|-
! scope="row"| Armazenamento
| MicroSD Card Slot SD/SDHC/SDXC - até: 32GB
|-
! scope="row"| Ethernet
| 10/100Mbps (RJ45)
|-
! scope="row"| Wireless
| Wi-Fi 802.11 b/g/n 2.4GHz Bluetooth 4.0 1 x receptor infravermelho (38kHz)
|-
! scope="row"| USB
| 2 x USB2.0 HOST (tipo A) 1 x USB3.0 OTG (micro-B)
|-
! scope="row"| Display
| 1 x HDMI 1.4 (tipo A), até 1920x1080@60Hz 1 x LVDS-DSI para LCDs, até 1920x1080@60Hz 1 x CVBS PAL/NTSC (PJ342 3,5mm)
|-
! scope="row"| Áudio
| Saída no HDMI Saída analógica estéreo (PJ342 3,5mm) I2S entrada/saída Microfone embutido
|-
! scope="row"| Câmera
| 1 x interface paralela de 8-bits
|-
! scope="row"| LED
| 1 x ligar/desligar (vermelho) 1 x programável (verde) 1 x programável (azul)
|-
! scope="row"| Botões
| 1x ligar/desligar 1x reiniciar 1x programável
|-
! scope="row"| Alimentação
| 5~12V @ 3W (diâmetro interno 2,1mm, externo de 5,5mm, centro positivo).
|-
! scope="row"| Expansão
| Conector SODIMM de 204 pinos (fêmea) 40-pin header: 28 GPIOs (compatível com Raspberry Pi / suporta UART, I2C, SPI, PWM e I2S) ADC input
|-
! scope="row"| Debug
| UART
|-
! scope="row"| Dimensões
| 88 x 81,3 mm
|-
! scope="row"| Peso
| 52,6g
|}

==Labrador Base M v2==

{| class="wikitable"
|-
! scope="row"| Armazenamento
| MicroSD Card Slot SD/SDHC/SDXC - até: 32GB
|-
! scope="row"| Ethernet
| 10/100Mbps (RJ45)
|-
! scope="row"| Wireless
| Wi-Fi 802.11 b/g/n 2.4GHz Bluetooth LE 5.0* LoRaWAN™* 1 x receptor infravermelho (38kHz)
|-
! scope="row"| USB
| 2 x USB2.0 HOST (tipo A) 1 x USB3.0 OTG (micro-B)
|-
! scope="row"| Display
| 1 x HDMI 1.4 (tipo A), até 1920x1080@60Hz 1 x LVDS-DSI para LCDs, até 1920x1080@60Hz 1 x CVBS PAL/NTSC (PJ342 3,5mm)
|-
! scope="row"| Áudio
| saída no HDMI Saída analógica estéreo (PJ342 3,5mm) I2S entrada/saída Microfone embutido
|-
! scope="row"| Câmera
| 1 x interface paralela de 8-bits
|-
! scope="row"| LED
| 1 x ligar/desligar (vermelho) 1 x programável (verde) 1 x programável (azul)
|-
! scope="row"| Botões
| 1x ligar/desligar 1x reiniciar 1x programável
|-
! scope="row"| Alimentação
| 5~12V @ 3W (diâmetro interno 2,1mm, externo de 5,5mm, centro positivo).
|-
! scope="row"| Expansão
| Conector SODIMM de 204 pinos (fêmea) 40-pin header: 28 GPIOs (compatível com Raspberry Pi / suporta UART, I2C, SPI, PWM e I2S) ADC input
|-
! scope="row"| Debug
| UART
|-
! scope="row"| Dimensões
| 92,7 x 88.0 mm
|-
! scope="row"| Peso
| 59,4g
|}

= Limitações das imagens de software disponíveis =
==Labrador 32 bits==
Atualmente a imagem do Debian 10, disponibilizada para a Labrador Core v2, de 32 bits, possui algumas limitações de suporte às funcionalidades da Baseboard. Estamos continuamente trabalhando para ampliar a disponibilidade e qualidade dos Drivers das plataformas e contamos com a comunidade para colaborar com estes aprimoramentos.

As seguintes funcionalidades ainda não estão disponíveis no último release:
* Áudio
* Câmera
* USB 3.0
* LoRa / LoRaWAN
* Temperatura da CPU
* Receptor Infravermelho
* Aceleração gráfica por hardware

Além disso, existem os seguintes bugs conhecidos:
* Resolução de vídeo só alcança 1080p caso o cabo HDMI seja conectado após a Labrador ligar. Caso a placa seja ligada com o cabo HDMI já conectado, a resolução será 720p.
* A Labrador não funciona com todos os monitores. Foi observado até agora que monitores e TVs HDMI funcionam normalmente e a maioria dos adaptadores VGA também apresenta bom funcionamento. No entanto, ao usá-las com adaptadores DVI alguns monitores não funcionam corretamente.

A imagem da Labrador 32 bits pode ser encontrada em: [http://downloads.caninosloucos.org.br/labrador_32_bits/ Labrador 32 bits]

Caso você queira compilar sua própria versão, pode encontrar os arquivos em nosso [https://github.com/caninos-loucos/labrador-linux GitHub].

==Labrador 64 bits==

Atualmente a imagem do Debian 10, kernel Linux 4.19, disponibilizada para a Labrador Core v3, de 64 bits, possui algumas limitações de suporte às funcionalidades da Baseboard. Estamos continuamente trabalhando para ampliar a disponibilidade e qualidade dos Drivers das plataformas e contamos com a comunidade para colaborar com estes aprimoramentos.

As seguintes funcionalidades ainda não estão disponíveis no último release:

* CVBS
* HDCP
* Câmera
* USB 3.0
* WiringK9
* LoRa / LoRaWAN
* Botão programável
* Áudio (saída HDMI)
* Receptor Infravermelho
* Set Mode do HDMI (seleção de resolução de vídeo)
* Sensores (carga de bateria, consumo de energia e temperatura do PMIC e do processador)

A imagem da Labrador 64 bits pode ser encontrada em [http://downloads.caninosloucos.org.br/labrador64_test_image/ Labrador_64_v.x.x.img.7z].

Caso você queira compilar sua própria versão, pode encontrar os arquivos em nosso [https://github.com/caninos-loucos/labrador-linux-64 GitHub].

Apresentação do Programa

2020-05-20T14:24:16Z

Thalyson:

[[Arquivo:Dogtag_branco.jpg|thumb|400px|Dog tag Caninos Loucos]]
O Programa Caninos Loucos desenvolve Single Board Computers (SBCs) com estrutura de software aberta para Internet das Coisas (IoT). O Programa quer formar uma comunidade de desenvolvedores para uso da tecnologia de IoT no meio industrial e disseminar a aprendizagem de eletrônica embarcada no Brasil. É uma iniciativa do Laboratório de Sistemas Integráveis Tecnológico (LSI-TEC) com o apoio da Escola Politécnica da Universidade de São Paulo (Poli-USP) e do Jon “Maddog” Hall, Diretor do Conselho do Linux Professional Institute.

Apresentação Geral e Especificações Técnicas

2020-05-15T20:37:40Z

Thalyson:

[[Arquivo:Core_v2_base_v1.jpg|thumb|400px|Coreboard v2 e Baseboard v1]]

[[Arquivo:Core_v3_base_v2.jpg|thumb|400px|Coreboard v3 e Baseboard v2]]
A placa Labrador é a primeira Single Board Computer da Caninos Loucos, aberta e com as funcionalidades de um computador. É capaz de rodar em um sistema operacional Linux, acessar a internet, reproduzir vídeos e executar programas de edição de texto. Esse conjunto possui proteção ESD, é compacta, resistente e serve para as mais diversas aplicações, desde projetos pessoais até aplicações profissionais.

A Labrador é uma combinação de 2 placas: a coreboard, uma placa de tamanho reduzido e alta capacidade de processamento, e a baseboard, onde encontramos as diversas interfaces de comunicação.

Estão disponíveis duas versões de coreboards para a Labrador: a Labrador Core v2 que possui um poderoso processador ARM de 32 bits e, para as aplicações que necessitam de ainda mais desempenho, a Labrador Core v3, possui um processador ARM de 64 bits com capacidade de processamento de IA com deep learning.

Modelos da Labrador Baseboard podem desenvolvidos para diferentes aplicações. Estão disponíveis duas versões para o público maker. A Labrador Base M v1 foi uma primeira versão que disponibiliza uma ampla gama de interfaces, incluindo diferentes tipos de interfaces USB, de áudio e vídeo, cartão de expansão de memória, GPIOs, etc. A Labrador Base M v2 que traz uma série de melhorias mecânicas e amplia as possibilidades de comunicação sem fio incluindo o sistema LoRa/LoRaWAN e Bluetooth 5.0.

A Labrador padroniza a interface entre coreboard e baseboard, permitindo a compatibilidade entre seus vários modelos.

= Especificações =

== Labrador Core v2==

[http://caninosloucos.org/downloads/caninos_loucos_datasheet_labradorV2_001.pdf Fazer o download do folder de especificações]

{| class="wikitable"
|-
! scope="row"| CPU
| 32-bit quad-core ARM® Cortex™ 1,3GHz A9R4 CPU (ARM v7 instruction set)
|-
! scope="row"| GPU
| Imagination PowerVR SGX544. Suporta: OpenGL-ES 1.1 e 2.0, OpenGL 1.2.1, OpenCL 1.1
|-
! scope="row"| Memória
| 2 GB DDR3 SDRAM 16GB eMMC
|-
! scope="row"| Sistema operacional
| Debian 10 Linux Kernel 4.14.13 32-bits
|-
! scope="row"| PMU
| ATC2306C - Gerenciamento de energia e subsistema de áudio
|-
! scope="row"| Vídeo
| 1080p@60fps com suporte a codificação de vídeo (incluindo H264, H263, MPEG-4)
|-
! scope="row"| Interface de expansão
| Conector DDR3 SODIMM 204 pinos (macho)
|-
! scope="row"| Botão
| ADFU
|-
! scope="row"| Dimensões
| 67.6 x 42.2 mm
|-
! scope="row"| Peso
| 13.6g
|}

==Labrador Core v3==

{| class="wikitable"
|-
! scope="row"| CPU
| 64-bit quad-Core ARM Cortex A53 1,3GHz CPU (ARM v8 instruction set)
|-
! scope="row"| GPU
| ARM Mali450 MP6 (4PP + 2GP). Suporta: OpenGL-ES 1.1 e 2.0, OpenVG 1.1, EGL 1.5
|-
! scope="row"| Memória
| 2 GB LPDDR3 SDRAM 16GB eMMC
|-
! scope="row"| Sistema operacional
| Debian 10 Linux Kernel 4.19
|-
! scope="row"| PMU
| ATC2306C - Gerenciamento de energia e subsistema de áudio
|-
! scope="row"| Vídeo
| 2160p@30fps ou 1080p@60fps com suporte a codificação de vídeo (incluindo H264, H263, MPEG-4)
|-
! scope="row"| Interface de expansão
| Conector DDR3 SODIMM 204 pinos (macho)
|-
! scope="row"| Botão
| ADFU
|-
! scope="row"| Dimensões
| 67.6 x 31.0 mm
|-
! scope="row"| Peso
| 10.1g
|}

==Labrador Base M v1==

{| class="wikitable"
|-
! scope="row"| Armazenamento
| MicroSD Card Slot SD/SDHC/SDXC - até: 32GB
|-
! scope="row"| Ethernet
| 10/100Mbps (RJ45)
|-
! scope="row"| Wireless
| Wi-Fi 802.11 b/g/n 2.4GHz Bluetooth 4.0 1 x receptor infravermelho (38kHz)
|-
! scope="row"| USB
| 2 x USB2.0 HOST (tipo A) 1 x USB3.0 OTG (micro-B)
|-
! scope="row"| Display
| 1 x HDMI 1.4 (tipo A), até 1920x1080@60Hz 1 x LVDS-DSI para LCDs, até 1920x1080@60Hz 1 x CVBS PAL/NTSC (PJ342 3,5mm)
|-
! scope="row"| Áudio
| Saída no HDMI Saída analógica estéreo (PJ342 3,5mm) I2S entrada/saída Microfone embutido
|-
! scope="row"| Câmera
| 1 x interface paralela de 8-bits
|-
! scope="row"| LED
| 1 x ligar/desligar (vermelho) 1 x programável (verde) 1 x programável (azul)
|-
! scope="row"| Botões
| 1x ligar/desligar 1x reiniciar 1x programável
|-
! scope="row"| Alimentação
| 5~12V @ 3W (diâmetro interno 2,1mm, externo de 5,5mm, centro positivo).
|-
! scope="row"| Expansão
| Conector SODIMM de 204 pinos (fêmea) 40-pin header: 28 GPIOs (compatível com Raspberry Pi / suporta UART, I2C, SPI, PWM e I2S) ADC input
|-
! scope="row"| Debug
| UART
|-
! scope="row"| Dimensões
| 88 x 81,3 mm
|-
! scope="row"| Peso
| 52,6g
|}

==Labrador Base M v2==

{| class="wikitable"
|-
! scope="row"| Armazenamento
| MicroSD Card Slot SD/SDHC/SDXC - até: 32GB
|-
! scope="row"| Ethernet
| 10/100Mbps (RJ45)
|-
! scope="row"| Wireless
| Wi-Fi 802.11 b/g/n 2.4GHz Bluetooth LE 5.0* LoRaWAN™* 1 x receptor infravermelho (38kHz)
|-
! scope="row"| USB
| 2 x USB2.0 HOST (tipo A) 1 x USB3.0 OTG (micro-B)
|-
! scope="row"| Display
| 1 x HDMI 1.4 (tipo A), até 1920x1080@60Hz 1 x LVDS-DSI para LCDs, até 1920x1080@60Hz 1 x CVBS PAL/NTSC (PJ342 3,5mm)
|-
! scope="row"| Áudio
| saída no HDMI Saída analógica estéreo (PJ342 3,5mm) I2S entrada/saída Microfone embutido
|-
! scope="row"| Câmera
| 1 x MIPI-CSI 1 x interface paralela de 8-bits
|-
! scope="row"| LED
| 1 x ligar/desligar (vermelho) 1 x programável (verde) 1 x programável (azul)
|-
! scope="row"| Botões
| 1x ligar/desligar 1x reiniciar 1x programável
|-
! scope="row"| Alimentação
| 5~12V @ 3W (diâmetro interno 2,1mm, externo de 5,5mm, centro positivo).
|-
! scope="row"| Expansão
| Conector SODIMM de 204 pinos (fêmea) 40-pin header: 28 GPIOs (compatível com Raspberry Pi / suporta UART, I2C, SPI, PWM e I2S) ADC input
|-
! scope="row"| Debug
| UART
|-
! scope="row"| Dimensões
| 92,7 x 88.0 mm
|-
! scope="row"| Peso
| 59,4g
|}

= Limitações das imagens de software disponíveis =
==Labrador 32 bits==
Atualmente a imagem do Debian 10, disponibilizada para a Labrador Core v2, de 32 bits, possui algumas limitações de suporte às funcionalidades da Baseboard. Estamos continuamente trabalhando para ampliar a disponibilidade e qualidade dos Drivers das plataformas e contamos com a comunidade para colaborar com estes aprimoramentos.

As seguintes funcionalidades ainda não estão disponíveis no último release:
* Áudio
* Câmera
* USB 3.0
* LoRa / LoRaWAN
* Temperatura da CPU
* Receptor Infravermelho
* Aceleração gráfica por hardware

Além disso, existem os seguintes bugs conhecidos:
* Resolução de vídeo só alcança 1080p caso o cabo HDMI seja conectado após a Labrador ligar. Caso a placa seja ligada com o cabo HDMI já conectado, a resolução será 720p.
* A Labrador não funciona com todos os monitores. Foi observado até agora que monitores e TVs HDMI funcionam normalmente e a maioria dos adaptadores VGA também apresenta bom funcionamento. No entanto, ao usá-las com adaptadores DVI alguns monitores não funcionam corretamente.

A imagem da Labrador 64 bits pode ser encontrada em: [http://downloads.caninosloucos.org.br/kernel_4_image/ Labrador 32 bits]

Caso você queira compilar sua própria versão, pode encontrar os arquivos em nosso [https://github.com/caninos-loucos/labrador-linux GitHub].

==Labrador 64 bits==

Atualmente a imagem do Debian 10, kernel Linux 4.19, disponibilizada para a Labrador Core v3, de 64 bits, possui algumas limitações de suporte às funcionalidades da Baseboard. Estamos continuamente trabalhando para ampliar a disponibilidade e qualidade dos Drivers das plataformas e contamos com a comunidade para colaborar com estes aprimoramentos.

As seguintes funcionalidades ainda não estão disponíveis no último release:

* CVBS
* HDCP
* Câmera
* USB 3.0
* WiringK9
* LoRa / LoRaWAN
* Botão programável
* Áudio (saída HDMI)
* Receptor Infravermelho
* Set Mode do HDMI (seleção de resolução de vídeo)
* Sensores (carga de bateria, consumo de energia e temperatura do PMIC e do processador)

A imagem da Labrador 64 bits pode ser encontrada em [http://downloads.caninosloucos.org.br/labrador64_test_image/ Labrador_64_v.x.x.img.7z].

Caso você queira compilar sua própria versão, pode encontrar os arquivos em nosso [https://github.com/caninos-loucos/labrador-linux-64 GitHub].

Começando com a Labrador

2020-05-15T18:37:42Z

Thalyson: /* Crie seus próprios programas */

= O que vem na caixa =

Neste capítulo vamos conhecer um pouco mais sobre o hardware e o software contido na caixa da Labrador.

== Hardware e acessórios inclusos ==

Ao abrir a caixa da Labrador, você irá encontrar uma Labrador dentro de um case de acrílico e uma fonte de alimentação. Note que a Labrador é composta de duas placas: a Core e a Base. A Tabela abaixo descreve e ilustra cada um dos componentes inclusos.

{| class="wikitable"
! style="background-color:#c0c0c0;" | Item
! style="background-color:#c0c0c0;" | Descrição
! style="background-color:#c0c0c0; text-align: center" | Foto
|-
| Labrador Coreboard
| Núcleo da Labrador, contém Processador e Memória.
| style="text-align: center" | [[Arquivo:CoreBoard-v2-front.png|300px]]
|-
| Labrador Baseboard
| Placa com periféricos, ex.: USB, HDMI, GPIO, conector de energia.
| style="text-align: center" | [[Arquivo:Base-frente.png|300px]]
|-
| Case de acrílico com espaçadores de nylon e parafusos
| Item para proteção da placa.
| style="text-align: center" | [[Arquivo:Case-labrador.jpeg|300px]]
|-
| Fonte de alimentação 12V @ 1A
| Fornece energia elétrica na tensão e corrente corretas.
| style="text-align: center" | [[Arquivo:Fonte-labrador.jpg|200px]]
|}

= Ligando a Labrador =

A principal maneira de usar a placa Labrador é conectando-a a um monitor HDMI e a um teclado e mouse USB, além da fonte de alimentação, para que possa ser usada como um dispositivo Linux comum. As próximas seções ensinam passo a passo como fazer isso.

== Conectando teclado e mouse - USB ==

Para poder interagir com a Labrador, basta conectar teclado e mouse às interfaces USB disponíveis. Em geral, você poderá usar qualquer teclado e mouse USB.

== Conectando o monitor - HDMI ==

A principal forma de visualizar a saída gráfica da Labrador é através de um monitor HDMI (High Definition Multimedia Interface). Você irá precisar de um cabo HDMI comum e de um monitor HDMI.

Caso seu monitor não possua entrada HDMI, mas possua DVI, a Labrador também funciona com adaptadores HDMI-para-DVI. Também já foram testadas entradas analógicas, como o VGA, que funciona com adaptadores HDMI-VGA que façam internamente a conversão digital-analógica.

== Conectando a fonte de alimentação ==

O último passo relacionado à conexão de componentes físicos, antes de usar a placa, é conectar a fonte de alimentação. A fonte enviada na caixa aceita ambas as tensões 110V e 220V, e tem como saída 12V 1A de corrente contínua. Caso necessário, fontes alternativas com especificação equivalente podem ser usadas.

Agora, com o mouse, teclado e monitor já conectados, coloque a fonte de alimentação na tomada e conecte-a à Labrador. Se tudo ocorreu bem, você deverá ver o logo do Caninos Loucos, seguido da tela de login.

= Usando o Debian =

O sistema operacional incluso na placa Labrador é o Debian, uma distribuição Linux utilizada no mundo todo. Para o leitor leigo no assunto, [http://www.devfuria.com.br/linux/como-iniciar-no-linux/ há vários tutoriais de Linux na internet], ensinando o básico de [https://sempreupdate.com.br/como-funciona-a-linha-de-comando-do-linux/ como mexer na linha de comando], e até mesmo [https://hacker-tools.github.io/lectures/ guias avançados para aproveitar o Linux ao máximo].

== Login ==

Para começar, assumindo que você já ligou a placa e está na tela de login, o próximo passo é digitar "caninos" (sem as aspas), tanto para o usuário quanto para a senha, e clicar em "Login".

== Acesso à Internet ==

Apesar de a Labrador possuir muitas aplicações para uso offline, conectá-la à Internet nos permite acessar websites, instalar bibliotecas e manter o sistema atualizado. Há duas formas principais, usando cabo de rede (Ethernet) ou a conexão sem-fio (Wi-Fi).

=== Ethernet ===

Para acessar a Internet usando cabo de rede, basta conectar o seu cabo de internet à entrada RJ45. Ao fazer isso com a placa ligada, observe também que o ícone de rede, no lado inferior direito da tela, irá carregar, até apontar que a conexão foi realizada com sucesso.

=== Wi-Fi ===

Como a Labrador já tem Wi-Fi embutido, basta acessar o menu de redes, escolher a sua rede, digitar a senha, e habilitar a conexão. Se for necessário especificar o tipo de segurança da rede, provavelmente será a opção "WPA2 Personal". Caso isso não funcione, peça ajuda à pessoa que realizou a configuração do seu roteador para descobrir os parâmetros corretos de configuração.

=== Verifique a conexão ===

Independente da forma como você se conectou à Internet, você agora pode testar a sua conexão. Uma forma simples de fazer isso é abrindo o Firefox e acessando o site http://caninosloucos.org. Já uma forma mais avançada é abrindo o terminal, digitando <code>ip address</code> e verificando se você tem um endereço IP válido. É útil saber o endereço IP, pois permite que nos comuniquemos com a Labrador, seja em uma aplicação IoT, seja durante o desenvolvimento. Por exemplo podemos acessar o terminal da Labrador via SSH (Secure Shell), evitando assim a necessidade de mantê-la sempre conectada a um teclado, mouse e monitor.

== Crie seus próprios programas ==

A Labrador tem suporte para uma variedade de linguagens de programação, desde as mais baixo nível, como o C, até as mais alto nível e expressivas, como Python e NodeJS. Portanto deixe a sua criatividade florescer e crie seus próprios programas usando a Labrador. Ah, e não esqueça de compartilhar os seus projetos com a comunidade, no [https://forum.caninosloucos.org.br/ fórum Caninos Loucos]!

=== Hello World - Piscando um LED (Kernel 3) ===

Se ao aprender programar imprimimos "Hello World" na tela, na programação de SBCs vamos além: vamos fazer piscar um LED (Light Emitting Diode). Este exemplo é interessante pois demonstra que nossos programas, além de controlarem caracteres na tela ou bytes na rede, também podem controlar componentes físicos.

Para fazer o LED azul da Labrador piscar em um ritmo de batimento cardíaco (de acordo com a demanda de processamento da Labrador), abra o terminal e execute o seguinte comando:

<pre>sudo echo heartbeat > /sys/class/leds/blue:GPIOB31/trigger</pre>

=== Programação GPIO ===

Uma interface interessante da Labrador são os pinos GPIO (General Purpose Input/Output), que são basicamente fios nos quais você pode enviar e receber dados. Para aprender como usar esta interface, confira o artigo principal [[Programação GPIO]].

=== UART ===

Através dos pinos de GPIO é possível utilizar a comunicação serial UART na Labrador. Segue um pequeno exemplo de como acessar esse recurso:

1. Conectar um adaptador tty-usb em um computador e a Labrador, através dos pinos 8 e 10 e um GND.

2. Abrir um emulador de terminal no computador e definir o baud rate como 115200bps.

3. No terminal da Labrador entrar com os seguintes comandos:

<pre>sudo stty -F /dev/ttyS0 115200</pre>
<pre>sudo echo "Teste" > /dev/ttyS0</pre>

4. No emulador de terminal do computador aparecerá a palavra “Teste”

=== ADC ===

A Labrador também possui ADC, que significa Analogic-Digital Converter (Conversor Analógico-Digital). A ideia é ler um valor analógico, entre 0v e 3v e converter para digital, representado por um valor de 10 bits (1024 valores possíveis).

Para ler o valor do ADC, entre com o seguinte comando no terminal:
<pre>cat /sys/kernel/auxadc/adc0</pre>
A primeira parte do resultado é o timestamp do sistema, enquanto a segunda parte é o resultado em si.

Página principal

2020-05-12T21:23:33Z

Thalyson:

Bem-vindo à wiki do Programa [https://caninosloucos.org/pt/ Caninos Loucos] <big>🐶</big>
Nesta wiki você encontrará informações técnicas e tutoriais sobre como utilizar as plataformas desenvolvidas no programa, entre elas a Labrador e a Pulga!

O Programa Caninos Loucos está em constante aprimoramento e esta Wiki recebe atualizações frequentes.

Para acesso às atualizações de software, acompanhe o projeto Caninos Loucos no GitHub: https://github.com/caninos-loucos.

Esperamos que esta Wiki possa resolver suas principais dúvidas e, caso reste alguma, entre em contato pelo [https://caninosloucos.org/pt/contact-pt/ formulário de contato] ou [https://forum.caninosloucos.org.br/ faça uma pergunta no fórum].

== Demais Páginas ==

Confira abaixo a lista das páginas disponíveis nesta Wiki:

*Caninos Loucos
**[[Apresentação do Programa]]
**[[Lista de projetos]]
***[[Tanque/carrinho de controle remoto]]
**[[Como criar uma página]]
*Labrador
**[[Apresentação Geral e Especificações Técnicas]]
**[[Começando com a Labrador]]
**Sobre o Linux
***[[Linux - Aplicativos e funções úteis do Linux]]
***[[Linux - Gerenciador de arquivos]]
***[[Linux - Comando ls]]
**Configurações
***[[Instalando um sistema 32 bits]]
***[[Instalando um sistema 64 bits]]
***[[Visão Computacional]]
***[[Programação GPIO]]
***[[MAC de rede]]
***[[Bluetooth]]
***[[Kernel]]
***[[Debug]]
*[[Pulga]]

== Quer colaborar com a Wiki? ==

* Rápido e direto: leia o tutorial explicando [[como criar uma página]].
* Avançado: consulte o [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents Manual de Usuário] para informações de como usar o software wiki.
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Traduza o MediaWiki para seu idioma]

[[en:Main page]]

Apresentação Geral e Especificações Técnicas

2020-05-12T21:22:39Z

Thalyson: Criou página com ' Coreboard v2 e Baseboard v1 Coreboard v3 e Baseboard v2 A placa Labrador é a primeir...'

[[Arquivo:Core_v2_base_v1.jpg|thumb|400px|Coreboard v2 e Baseboard v1]]

[[Arquivo:Core_v3_base_v2.jpg|thumb|400px|Coreboard v3 e Baseboard v2]]
A placa Labrador é a primeira Single Board Computer da Caninos Loucos, aberta e com as funcionalidades de um computador. É capaz de rodar em um sistema operacional Linux, acessar a internet, reproduzir vídeos e executar programas de edição de texto. Esse conjunto possui proteção ESD, é compacta, resistente e serve para as mais diversas aplicações, desde projetos pessoais até aplicações profissionais.

A Labrador é uma combinação de 2 placas, a coreboard, uma placa de tamanho reduzido e alta capacidade de processamento, e a baseboard, onde encontramos as diversas interfaces de comunicação.

Estão disponíveis duas versões de coreboards para a Labrador. A Labrador Core v2 possui um poderoso processador ARM de 32 bits. Para as aplicações que necessitam de ainda mais desempenho, a Labrador Core v3, possui um processador ARM de 64 bits com capacidade de processamento de IA com deep learning.

Modelos da Labrador Baseboard podem desenvolvidos para diferentes aplicações. Estão disponíveis duas versões para o público ‘ ‘maker ‘ ‘. A Labrador Base M v1 foi uma primeira versão que disponibiliza uma ampla gama de interfaces, incluindo diferentes tipos de interfaces USB, de áudio e vídeo, cartão de expansão de memória, GPIOs, etc. A Labrador Base M v2 que traz uma série de melhorias mecânicas e amplia as possibilidades de comunicação sem fio incluindo o sistema LoRa/LoRaWAN e Bluetooth 5.0.

A Labrador padroniza a interface entre coreboard e baseboard, permitindo a compatibilidade entre seus vários modelos.

= Especificações =

== Labrador Core v2==

[http://caninosloucos.org/downloads/caninos_loucos_datasheet_labradorV2_001.pdf Fazer o download do folder de especificações]

{| class="wikitable"
|-
! scope="row"| CPU
| 32-bit quad-core ARM® Cortex™ 1,3GHz A9R4 CPU (ARM v7 instruction set)
|-
! scope="row"| GPU
| Imagination PowerVR SGX544. Suporta: OpenGL-ES 1.1 e 2.0, OpenGL 1.2.1, OpenCL 1.1
|-
! scope="row"| Memória
| 2 GB DDR3 SDRAM 16GB eMMC
|-
! scope="row"| Sistema operacional
| Debian 10 Linux Kernel 4.14.13 32-bits
|-
! scope="row"| PMU
| ATC2306C - Gerenciamento de energia e subsistema de áudio
|-
! scope="row"| Vídeo
| 1080p@60fps com suporte a codificação de vídeo (incluindo H264, H263, MPEG-4)
|-
! scope="row"| Interface de expansão
| Conector DDR3 SODIMM 204 pinos (macho)
|-
! scope="row"| Botão
| ADFU
|-
! scope="row"| Dimensões
| 67.6 x 42.2 mm
|-
! scope="row"| Peso
| 13.6g
|}

==Labrador Core v3==

{| class="wikitable"
|-
! scope="row"| CPU
| 64-bit quad-Core ARM Cortex A53 1,3GHz CPU (ARM v8 instruction set)
|-
! scope="row"| GPU
| ARM Mali450 MP6 (4PP + 2GP). Suporta: OpenGL-ES 1.1 e 2.0, OpenVG 1.1, EGL 1.5
|-
! scope="row"| Memória
| 2 GB LPDDR3 SDRAM 16GB eMMC
|-
! scope="row"| Sistema operacional
| Debian 10 Linux Kernel 4.19
|-
! scope="row"| PMU
| ATC2306C - Gerenciamento de energia e subsistema de áudio
|-
! scope="row"| Vídeo
| 2160p@30fps ou 1080p@60fps com suporte a codificação de vídeo (incluindo H264, H263, MPEG-4)
|-
! scope="row"| Interface de expansão
| Conector DDR3 SODIMM 204 pinos (macho)
|-
! scope="row"| Botão
| ADFU
|-
! scope="row"| Dimensões
| 67.6 x 31.0 mm
|-
! scope="row"| Peso
| 10.1g
|}

==Labrador Base M v1==

{| class="wikitable"
|-
! scope="row"| Armazenamento
| MicroSD Card Slot SD/SDHC/SDXC - até: 32GB
|-
! scope="row"| Ethernet
| 10/100Mbps (RJ45)
|-
! scope="row"| Wireless
| Wi-Fi 802.11 b/g/n 2.4GHz Bluetooth 4.0 1 x receptor infravermelho (38kHz)
|-
! scope="row"| USB
| 2 x USB2.0 HOST (tipo A) 1 x USB3.0 OTG (micro-B)
|-
! scope="row"| Display
| 1 x HDMI 1.4 (tipo A), até 1920x1080@60Hz 1 x LVDS-DSI para LCDs, até 1920x1080@60Hz 1 x CVBS PAL/NTSC (PJ342 3,5mm)
|-
! scope="row"| Áudio
| Saída no HDMI Saída analógica estéreo (PJ342 3,5mm) I2S entrada/saída Microfone embutido
|-
! scope="row"| Câmera
| 1 x interface paralela de 8-bits
|-
! scope="row"| LED
| 1 x ligar/desligar (vermelho) 1 x programável (verde) 1 x programável (azul)
|-
! scope="row"| Botões
| 1x ligar/desligar 1x reiniciar 1x programável
|-
! scope="row"| Alimentação
| 5~12V @ 3W (diâmetro interno 2,1mm, externo de 5,5mm, centro positivo).
|-
! scope="row"| Expansão
| Conector SODIMM de 204 pinos (fêmea) 40-pin header: 28 GPIOs (compatível com Raspberry Pi / suporta UART, I2C, SPI, PWM e I2S) ADC input
|-
! scope="row"| Debug
| UART
|-
! scope="row"| Dimensões
| 88 x 81,3 mm
|-
! scope="row"| Peso
| 52,6g
|}

==Labrador Base M v2==

{| class="wikitable"
|-
! scope="row"| Armazenamento
| MicroSD Card Slot SD/SDHC/SDXC - até: 32GB
|-
! scope="row"| Ethernet
| 10/100Mbps (RJ45)
|-
! scope="row"| Wireless
| Wi-Fi 802.11 b/g/n 2.4GHz Bluetooth LE 5.0* LoRaWAN™* 1 x receptor infravermelho (38kHz)
|-
! scope="row"| USB
| 2 x USB2.0 HOST (tipo A) 1 x USB3.0 OTG (micro-B)
|-
! scope="row"| Display
| 1 x HDMI 1.4 (tipo A), até 1920x1080@60Hz 1 x LVDS-DSI para LCDs, até 1920x1080@60Hz 1 x CVBS PAL/NTSC (PJ342 3,5mm)
|-
! scope="row"| Áudio
| saída no HDMI Saída analógica estéreo (PJ342 3,5mm) I2S entrada/saída Microfone embutido
|-
! scope="row"| Câmera
| 1 x MIPI-CSI 1 x interface paralela de 8-bits
|-
! scope="row"| LED
| 1 x ligar/desligar (vermelho) 1 x programável (verde) 1 x programável (azul)
|-
! scope="row"| Botões
| 1x ligar/desligar 1x reiniciar 1x programável
|-
! scope="row"| Alimentação
| 5~12V @ 3W (diâmetro interno 2,1mm, externo de 5,5mm, centro positivo).
|-
! scope="row"| Expansão
| Conector SODIMM de 204 pinos (fêmea) 40-pin header: 28 GPIOs (compatível com Raspberry Pi / suporta UART, I2C, SPI, PWM e I2S) ADC input
|-
! scope="row"| Debug
| UART
|-
! scope="row"| Dimensões
| 92,7 x 88.0 mm
|-
! scope="row"| Peso
| 59,4g
|}

= Limitações das imagens de software disponíveis =
==Labrador 32 bits==
Atualmente a imagem do Debian 10, disponibilizada para a Labrador Core v2, de 32 bits, possui algumas limitações de suporte às funcionalidades da Baseboard. Estamos continuamente trabalhando para ampliar a disponibilidade e qualidade dos Drivers das plataformas e contamos com a comunidade para colaborar com estes aprimoramentos.

As seguintes funcionalidades ainda não estão disponíveis no último release:
* Áudio
* Câmera
* USB 3.0
* LoRa / LoRaWAN
* Temperatura da CPU
* Receptor Infravermelho
* Aceleração gráfica por hardware
* Aceleração de codificação e decodificação de vídeo por hardware

Além disso, há a seguinte falha conhecida:
* Resolução de vídeo só alcança 1080p caso o cabo HDMI seja conectado após a Labrador ligar. Caso a placa seja ligada com o cabo HDMI já conectado, a resolução será 720p.
* A Labrador não funciona com todos os monitores. Foi observado até agora que monitores e TVs HDMI funcionam normalmente e a maioria dos adaptadores VGA também apresenta bom funcionamento. No entanto, ao usá-las com adaptadores DVI alguns monitores não funcionam corretamente.

A imagem da Labrador 64 bits pode ser encontrada em: [http://downloads.caninosloucos.org.br/kernel_4_image/ Labrador 32 bits]

Caso você queira compilar sua própria versão, pode encontrar os arquivos em nosso [https://github.com/caninos-loucos/labrador-linux GitHub].

==Labrador 64 bits==

Atualmente a imagem do Debian 10, disponibilizada para a Labrador Core v3, de 64 bits, possui algumas limitações de suporte às funcionalidades da Baseboard. Estamos continuamente trabalhando para ampliar a disponibilidade e qualidade dos Drivers das plataformas e contamos com a comunidade para colaborar com estes aprimoramentos.

As seguintes funcionalidades ainda não estão disponíveis no último release:

* ADC
* HDCP
* CVBS
* Câmera
* USB 3.0
* WiringK9
* LoRa / LoRaWAN
* Áudio (saída HDMI)
* LEDs (verde e azul)
* Botão programável
* Receptor Infravermelho
* Set Mode (seleção de resolução de vídeo)
* Sensores (carga de bateria, temperatura do PMIC, temperatura do processador, consumo de energia)

A imagem da Labrador 64 bits pode ser encontrada em [http://downloads.caninosloucos.org.br/labrador64_test_image/ Labrador_64_v.x.x.img.7z].

Caso você queira compilar sua própria versão, pode encontrar os arquivos em nosso [https://github.com/caninos-loucos/labrador-linux-64 GitHub].

Página principal

2020-05-07T16:57:20Z

Thalyson: /* Demais Páginas */

Bem-vindo à wiki do Programa [https://caninosloucos.org/pt/ Caninos Loucos] <big>🐶</big>
Nesta wiki você encontrará informações técnicas e tutoriais sobre como utilizar as plataformas desenvolvidas no programa, entre elas a Labrador e a Pulga!

O Programa Caninos Loucos está em constante aprimoramento e esta Wiki recebe atualizações frequentes.

Para acesso às atualizações de software, acompanhe o projeto Caninos Loucos no GitHub: https://github.com/caninos-loucos.

Esperamos que esta Wiki possa resolver suas principais dúvidas e, caso reste alguma, entre em contato pelo [https://caninosloucos.org/pt/contact-pt/ formulário de contato] ou [https://forum.caninosloucos.org.br/ faça uma pergunta no fórum].

== Demais Páginas ==

Confira abaixo a lista das páginas disponíveis nesta Wiki:

*Caninos Loucos
**[[Apresentação do Programa]]
**[[Lista de projetos]]
***[[Tanque/carrinho de controle remoto]]
**[[Como criar uma página]]
*Labrador
**[[Apresentação geral]]
**[[Começando com a Labrador]]
**[[Conhecendo a Labrador 32 bits]]
**[[Conhecendo a Labrador 64 bits]]
**Sobre o Linux
***[[Linux - Aplicativos e funções úteis do Linux]]
***[[Linux - Gerenciador de arquivos]]
***[[Linux - Comando ls]]
**Configurações
***[[Instalando um sistema 32 bits]]
***[[Instalando um sistema 64 bits]]
***[[Visão Computacional]]
***[[Programação GPIO]]
***[[MAC de rede]]
***[[Bluetooth]]
***[[Kernel]]
***[[Debug]]
*[[Pulga]]

== Quer colaborar com a Wiki? ==

* Rápido e direto: leia o tutorial explicando [[como criar uma página]].
* Avançado: consulte o [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents Manual de Usuário] para informações de como usar o software wiki.
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Traduza o MediaWiki para seu idioma]

[[en:Main page]]

Página principal

2020-05-07T16:56:59Z

Thalyson: /* Demais Páginas */

Bem-vindo à wiki do Programa [https://caninosloucos.org/pt/ Caninos Loucos] <big>🐶</big>
Nesta wiki você encontrará informações técnicas e tutoriais sobre como utilizar as plataformas desenvolvidas no programa, entre elas a Labrador e a Pulga!

O Programa Caninos Loucos está em constante aprimoramento e esta Wiki recebe atualizações frequentes.

Para acesso às atualizações de software, acompanhe o projeto Caninos Loucos no GitHub: https://github.com/caninos-loucos.

Esperamos que esta Wiki possa resolver suas principais dúvidas e, caso reste alguma, entre em contato pelo [https://caninosloucos.org/pt/contact-pt/ formulário de contato] ou [https://forum.caninosloucos.org.br/ faça uma pergunta no fórum].

== Demais Páginas ==

Confira abaixo a lista das páginas disponíveis nesta Wiki:

*Caninos Loucos
**[[Apresentação do Programa]]
**[[Lista de projetos]]
***[[Tanque/carrinho de controle remoto]]
**[[Como criar uma página]]
*Labrador
**[[Apresentação geral]]
**[[Começando com a Labrador]]
**[[Conhecendo a Labrador 32 bits]]
**[[Conhecendo a Labrador 64 bits]]
**Sobre o Linux
***[[Linux - Aplicativos e funções úteis do Linux]]
***[[Linux - Comando ls]]
***[[Linux - Gerenciador de arquivos]]
**Configurações
***[[Instalando um sistema 32 bits]]
***[[Instalando um sistema 64 bits]]
***[[Visão Computacional]]
***[[Programação GPIO]]
***[[MAC de rede]]
***[[Bluetooth]]
***[[Kernel]]
***[[Debug]]
*[[Pulga]]

== Quer colaborar com a Wiki? ==

* Rápido e direto: leia o tutorial explicando [[como criar uma página]].
* Avançado: consulte o [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents Manual de Usuário] para informações de como usar o software wiki.
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Traduza o MediaWiki para seu idioma]

[[en:Main page]]

Página principal

2020-05-07T16:56:27Z

Thalyson: /* Demais Páginas */

Bem-vindo à wiki do Programa [https://caninosloucos.org/pt/ Caninos Loucos] <big>🐶</big>
Nesta wiki você encontrará informações técnicas e tutoriais sobre como utilizar as plataformas desenvolvidas no programa, entre elas a Labrador e a Pulga!

O Programa Caninos Loucos está em constante aprimoramento e esta Wiki recebe atualizações frequentes.

Para acesso às atualizações de software, acompanhe o projeto Caninos Loucos no GitHub: https://github.com/caninos-loucos.

Esperamos que esta Wiki possa resolver suas principais dúvidas e, caso reste alguma, entre em contato pelo [https://caninosloucos.org/pt/contact-pt/ formulário de contato] ou [https://forum.caninosloucos.org.br/ faça uma pergunta no fórum].

== Demais Páginas ==

Confira abaixo a lista das páginas disponíveis nesta Wiki:

*Caninos Loucos
**[[Apresentação do Programa]]
**[[Lista de projetos]]
***[[Tanque/carrinho de controle remoto]]
**[[Como criar uma página]]
*Labrador
**[[Apresentação geral]]
**[[Começando com a Labrador]]
**[[Conhecendo a Labrador 32 bits]]
**[[Conhecendo a Labrador 64 bits]]
**Sobre o Linux
***[[Linux - Aplicativos e funções úteis do Linux]]
***[[Linux - Comando ls]]
***[[Linux - Gerenciador de arquivos]]
**Configurações
***[[Instalando um sistema 32 bits]]
***[[Instalando um sistema 64 bits]]
***[[Programação GPIO]]
***[[Visão Computacional]]
***[[Bluetooth]]
***[[Kernel]]
***[[MAC de rede]]
***[[Debug]]
*[[Pulga]]

== Quer colaborar com a Wiki? ==

* Rápido e direto: leia o tutorial explicando [[como criar uma página]].
* Avançado: consulte o [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents Manual de Usuário] para informações de como usar o software wiki.
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Traduza o MediaWiki para seu idioma]

[[en:Main page]]

Debug

2020-05-07T16:56:06Z

Thalyson: Criou página com ' == Interface de Debug == A Labrador possui uma interface para debug, essa interface consiste em uma saída serial que utiliza o tradicional protocolo TTL. Essa interface pod...'

== Interface de Debug ==

A Labrador possui uma interface para debug, essa interface consiste em uma saída serial que utiliza o tradicional protocolo TTL. Essa interface pode ser utilizada para realizar comunicação com o sistema, sendo enviadas por ela os logs e alertas do sistema.

== Conexão com o Debug ==

Para conectar ao debug da serial é necessário observar o modelo da base-board, pois a disposição dos pinos de debug nas placas são alterados.

Para versões Labrador Base-M v1.0a, a disposição dos pinos GND, RX e TX são os da figura abaixo;

[[Arquivo:labrador-base-1.0a_debug.png]]

Para versões Labrador Base-M v2.x, a disposição dos pinos GND, RX e TX são os da figura abaixo;

[[Arquivo:labrador-base-2.0_debug.png]]

*Conecte então o pino RX da Labrador no pino TX do destino, e o pino TX da Labrador no pino RX do destino e também conecte o GND da labrador no GND do destino. Usualmente o destino é um conversor USB-SERIAL(TTL).

*Configure o destino para operar em uma taxa de 115200bps.

*Programas como PUTTY e SCREEN podem ser utilizados para auxiliar na comunicação.

Bluetooth

2020-05-07T16:55:16Z

Thalyson: Criou página com 'A Labrador Baseboard é equipada com módulos em combo de Wi-Fi e Bluetooth, podendo conter o módulo Realtek RTL8723BS ou o módulo Microchip ATWILC3000, dependendo da sua ve...'

A Labrador Baseboard é equipada com módulos em combo de Wi-Fi e Bluetooth, podendo conter o módulo Realtek RTL8723BS ou o módulo Microchip ATWILC3000, dependendo da sua versão. Estes dois módulos utilizam interface [https://pt.wikipedia.org/wiki/Universal_asynchronous_receiver/transmitter UART] para se comunicar com o sistema.

== Instalar o Bluetooth reinstalando o sistema ==

A maneira mais simples de realizar a ativação do Bluetooth é atualizar o sistema da labrador para o mais recente, basta seguir o descrito no link [[Instalando um sistema 32 bits]] ou [[Instalando um sistema 64 bits]], dependendo da versão da sua Labrador. Na versão atual os drivers de Bluetooth já estarão instalados e o Bluetooth já será iniciado automaticamente, independente do modulo de Wi-Fi/Bluetooth disponível na baseboard.

A inicialização do Bluetooth ocorre no durante o Boot do sistema, essa inicialização é realizada via script localizado em /etc/init.d/wifi_bt_start.sh, portanto é possível ajustar o comportamento inicial do Bluetooth alterando esse script.

== Desativando o Bluetooth da inicialização ==

Caso queira evitar que o Bluetooth seja automaticamente iniciado com o sistema basta impedir que o script /etc/init.d/wifi_bt_start.sh seja carregado como default ao sistema, isso pode ser realizado utilizando o comando abaixo;

$update-rc.d wifi_bt_start.sh remove

== Instalando o Bluetooth sem alterar o sistema ==

Para instalar o Bluetooth sem a necessidade de reinstalar o sistema, o processo é:

1 - Atualizar o Kernel, para atualizar o Kernel siga o descrito em [https://wiki.caninosloucos.org.br/index.php/Labrador/Configura%C3%A7%C3%B5es/Kernel/ Troca De Kernel Compilado].

2 - Instalar as aplicações necessárias para a execução do Bluetooth;

2.1 - Instale o Bluez

$sudo apt-get install bluez

2.2 - Instale o Blueman

$sudo apt-get install blueman

2.3 - Baixe os firmwares dos módulos para ATCWILC3000 e RTL8723BS,

Firmware do ATCWILC3000 estão disponíveis em [https://github.com/linux4wilc/firmware Linux4wilc/firmware].
Faça o download para o diretório /...qualquer diretório.../src/mchp/

Firmware do RTL8723BS estão disponíveis em [https://github.com/lwfinger/rtl8723bs_bt lwfinger/rtl8723bs_bt].
Faça o download para o diretório /...qualquer diretório.../src/rtk/

2.4 - Extraia e copie os firmwares para os diretórios corretos.

$cd /src/mchp/
$unzip firmware-master.zip
$sudo mkdir /lib/firmware/updates/4.14.13/mchp
$sudo cp firmware-master/* /lib/firmware/updates/4.14.13/mchp/
$cd ../rtk/
$unzip rtl8723bs_bt-master.zip
$sudo mkdir /lib/firmware/bluetooth/rtl8723bs
$sudo cp rtl8723bs_bt-master/* /lib/firmware/bluetooth/rtl8723bs/

2.5 - Instale o firmware do RTL8723BS

$cd /lib/firmware/bluetooth/rtl8723bs/
$sudo make
$sudo make install
$sudo rm /lib/firmware/rtl_bt/rtlbt_config

2.6 - Inicie o Bluetooth
2.6.1 - Iniciando o Realtek RTL8723BS

$cd /lib/firmware/Bluetooth/rtl8723bs/
$nohup ./rtk_hciattach -n -s 115200 /dev/ttyS2 rtk_h5 > r8723bs_bt.nolog 2> r8723bs_bt.log < /dev/null &

Neste ponto o dispositivo Bluetooth já deve estar disponível para uso. Para verificar basta usar o comando;

<nowiki>root@debian-armhf:/home/caninos# hciconfig -a
hci0: Type: Primary Bus: UART
BD Address: 14:6B:9C:7D:95:AD ACL MTU: 1021:8 SCO MTU: 255:16
UP RUNNING
RX bytes:1451 acl:0 sco:0 events:57 errors:0
TX bytes:6112 acl:0 sco:0 commands:58 errors:0
Features: 0xff 0xff 0xff 0xfe 0xdb 0xff 0x7b 0x87
Packet type: DM1 DM3 DM5 DH1 DH3 DH5 HV1 HV2 HV3
Link policy: RSWITCH HOLD SNIFF PARK
Link mode: SLAVE ACCEPT
Name: 'debian-armhf'
Class: 0x1c0000
Service Classes: Rendering, Capturing, Object Transfer
Device Class: Miscellaneous,
HCI Version: 4.0 (0x6) Revision: 0x1e3e
LMP Version: 4.0 (0x6) Subversion: 0xe40e
Manufacturer: Realtek Semiconductor Corporation (93)
</nowiki>
2.6.2 - Iniciando o Microchip ATCWILC3000

Carregue o modulo caso não esteja carregado;

$sudo modprobe wilc-sdio

$echo BT_POWER_UP > /dev/wilc_bt

$echo BT_FW_CHIP_WAKEUP > /dev/wilc_bt

$echo BT_DOWNLOAD_FW > /dev/wilc_bt

$echo BT_FW_CHIP_ALLOW_SLEEP > /dev/wilc_bt

$sudo hciattach ttyS2 any 115200 noflow

Neste ponto o dispositivo Bluetooth já deve estar disponível para uso. Para verificar basta usar o comando;

<nowiki>root@debian-armhf:/home/caninos# hciconfig -a
hci0: Type: Primary Bus: UART
BD Address: F8:F0:05:D9:2A:45 ACL MTU: 27:30 SCO MTU: 0:0
UP RUNNING
RX bytes:205 acl:0 sco:0 events:14 errors:0
TX bytes:109 acl:0 sco:0 commands:14 errors:0
Features: 0x00 0x00 0x00 0x00 0x60 0x00 0x00 0x00
Packet type: DM1 DH1 HV1
Link policy:
Link mode: SLAVE ACCEPT
Can't read local name on hci0: Input/output error (5)</nowiki>

2.7 - Altere a taxa de operação entre o sistema e o Bluetooth

Ambos módulos suportam operar em diversas frequências (Baud rate).

2.7.1 - Alterar baudrate RTL8723BS

O comando abaixo realiza troca do baudrate do RTL8723BS;

$sudo hcitool cmd 0x03F 0x0017 XX XX XX XX

Onde XX são os bytes do código da velocidade desejada, os códigos a serem enviados podem ser por hora os abaixo, e devem ser enviados os bytes menos significativos primeiros;
Baudrate 115200: 0x0252C014
Baudrate 230400: 0x0252C00A
Baudrate 921600: 0x05F75004
Baudrate 1000000: 0x00005004
Baudrate 1500000: 0x04928002
Baudrate 1500000: 0x01128002
Baudrate 2000000: 0x00005002(Não suportado atualmente)
Baudrate 2500000: 0x0000B001(Não suportado atualmente)
Baudrate 3000000: 0x04928001(Não suportado atualmente)
Baudrate 3500000: 0x052A6001(Não suportado atualmente)
Baudrate 4000000: 0x00005001(Não suportado atualmente)

Portanto, por exemplo para operar a um Baudrate de 1500000 basta utilizar o comando abaixo;

$sudo hcitool cmd 0x03F 0x0017 02 80 92 04

Depois é necessário atualizar o baudrate da UART do sistema, pode-se utilizar o comando abaixo para isso;

$sudo stty -F /dev/ttyS2 1500000

2.7.2 - alterar baudrate ATCWILC3000

para alterar este baudrate o comando abaixo pode ser utilizado

sudo hcitool cmd 0x03F 0x0053 XX XX XX XX YY

XX indica o baudrate, YY indica o controle de FLOW, se YY for 00 isso indica que não haverá FLOW control.

XX indica o valor em hexadecimal do baudrate desejado

por exemplo para uma taxa 921600 que é 0xE1000 em hexadecimal, sem controle de fluxo, basta utilizar o comando abaixo;

$sudo hcitool cmd 0x03F 0x0053 00 10 0E 00 00

Depois, basta alterar o baud rate da UART;

$sudo stty -F /dev/ttyS2 921600

MAC de rede

2020-05-07T16:54:57Z

Thalyson: /* Descrição */

A Labrador possui duas interfaces de rede, Wi-Fi (Wireless) e Ethernet (Cabeada), cada uma possui um endereço MAC, para mais informações sobre endereço MAC acesse: [https://pt.wikipedia.org/wiki/Endere%C3%A7o_MAC].

== Troca de endereço MAC ==

A Labrador suporta troca de endereço MAC para as duas interfaces, Wi-Fi e Ethernet. A troca de endereço pode ser utilizada por exemplo para manter um endereço IP estático em um rede.

A interface Ethernet tem comportamento aleatório, quando a placa é ligada, um novo endereço MAC é gerado toda vez. A interface Wi-Fi tem endereço MAC estático, quando a placa é reiniciada o endereço MAC é sempre o mesmo.

Há varias formas de trocar o endereço MAC em uma Labrador, o processo é mesmo para ambas interfaces.

'''Utilizando comando <code>ifconfig</code> para trocar o MAC da interface Ethernet temporariamente;'''

1 - Abra um terminal.

2 - Execute os seguintes passos;
2.1 Para identificar o seu MAC atual, use o seguinte comando;
$ sudo ifconfig
Veja o campo "ether" na interface eth0 que contém o MAC atual do ethernet
2.2 Abra o programa gerenciador de conexões, menu iniciar/Internet/Wicd Network Manager
2.2.1 Desconecte de qualquer rede, desmarque as opções de Automatically connect to this network.
2.2.2 Vá em Preferences, na aba "General Settings" Marque as opções "Always show wired interface", "Always switch to a wired connection when available".
2.3 No terminal execute;
$ sudo ifconfig eth0 down
$ sudo ifconfig eth0 hw ether 02:00:01:02:03:04
$ sudo ifconfig eth0 up
2.4 Faça o passo 2.1 novamente para ver seu novo MAC.
2.5 Volte ao Wicd Network Manager e conecte com a sua rede cabeada(Wired Network)

Após os passos anteriores o endereço MAC já foi alterado e sua conexão está estabelecida utilizando o novo MAC, contudo ao reiniciar a placa o endereço será perdido.

'''Utilizando um script para trocar o endereço MAC da interface ethernet de forma permanente'''

Para trocar e manter o endereço MAC, pode-se utilizar um script na conexão, o processo será feito pelo Wicd Network Manager.

Siga os passos abaixo;

1 - Abra um terminal

2 - Execute como sudo
$ su root
3 - Crie o arquivo de script na pasta do wicd
$ echo "" > /etc/wicd/scripts/preconnect/keep_mac.sh
4 - Abra o arquivo
$ sudo mousepad /etc/wicd/scripts/preconnect/keep_mac.sh
5 - Insira os comandos no arquivo keep_mac.sh (Dica: Evite copiar e colar, digite os textos dos comandos no arquivo manualmente)

#!/usr/bin/env bash

connection_type="$1"

if [[ "${connection_type}"=="wired" ]]; then

ip link set eth0 down

ifconfig eth0 down

ifconfig eth0 hw ether 02:55:66:77:88:99

ifconfig eth0 up

ip link set eth0 up

fi

6 - Salve e feche o arquivo keep_mac.sh

7 - No terminal dê as permissões de execução para o arquivo keep_mac.sh
$ chmod +x /etc/wicd/scripts/preconnect/keep_mac.sh
8 - Abra o Wicd Network Manager, desconecte-se da rede cabeada e conecte-se novamente.
9 - No terminal, veja o campo ether com o valor de MAC adicionado no script "02:55:66:77:88:99"
$ sudo ifconfig

Caso queira alterar o script para adicionar a interface Wireless, troque o conteúdo do script por este;

#!/usr/bin/env bash
connection_type="$1"

if [[ "${connection_type}" == "wireless" ]]; then
ip link set wlan0 down
ifconfig wlan0 down
ifconfig wlan0 hw ether 02:55:66:77:88:AA
ifconfig wlan0 up
ip link set wlan0 up
elif [[ "${connection_type}" == "wired" ]]; then
ip link set eth0 down
ifconfig eth0 down
ifconfig eth0 hw ether 02:55:66:77:88:99
ifconfig eth0 up
ip link set eth0 up
fi

Este script é executado sempre antes de estabelecer a conexão, desta forma mesmo quando a Labrador for reiniciada, o MAC será o mesmo sempre que a conexão for estabelecida.

Assim pode-se por exemplo ir até o servidor DHCP e indicar um endereço IP estático para o MAC escolhido do script.

Kernel

2020-05-07T16:54:08Z

Thalyson: /* Kernel */

Como a Labrador suporta Linux, ela precisa prover a interface entre entre o sistema operacional e o hardware, essa interface é chamada de Linux Kernel.

== Versão Do Kernel ==

Para verificar qual é a versão atual do Kernel, abra o LXTerminal e digite:

$ cat /proc/version

[[Arquivo:cat_proc_version.png|none|658px|Versão do Kernel]]

Pode-se verificar que neste caso a versão do Kernel é a 4.14.13.

== Atualização Do Kernel ==

Por diversas razões pode ser necessário trocar ou atualizar o Kernel, seja para suportar novos hardwares ou mesmo melhorar o desempenho com hardwares já suportados ou ainda prover novas funcionalidades a esses hardwares já suportados. É valido observar que este processo pode causar problemas ao seu sistema.

É possível realizar a troca do Kernel de algumas maneiras, a mais simples é utilizando a versão já compilada para a Labrador, que pode ser encontrada no repositório da [http://downloads.caninosloucos.org.br/ Caninos Loucos]. Procure Kernel_x_y.zip, onde x é a versão do kernel, y é o versionamento interno do Caninos Loucos, procure o mais recente.

'''Troca De Kernel Compilado'''

Para realizar a troca do Kernel siga os passos a seguir;

1 - Baixar o arquivo contendo o Kernel_x_y.zip do repositório.

2 - Extrair o conteúdo para um diretório, /*caminho qualquer de diretórios*/src/

3 - Copiar “kernel.dtb” e “uImage” para a raíz da partição BOOT

<code>$ sudo cp -r /src/kernel.dtb /media/caninos/BOOT
$ sudo cp -r /src/uImage /media/caninos/BOOT</code>

4 - Copiar “lib/modules” para “lib/modules” da partição SYSTEM:

<code>$ sudo cp -r /src/lib/modules /lib/</code>

5 - Reiniciar a Labrador

$ sudo reboot

Após esse processo a labrador já será inicializada com o Kernel desejado.

Kernel

2020-05-07T16:53:55Z

Thalyson: Criou página com ' == Kernel == Como a Labrador suporta Linux, ela precisa prover a interface entre entre o sistema operacional e o hardware, essa interface é chamada de Linux Kernel. == Ver...'

== Kernel ==

Como a Labrador suporta Linux, ela precisa prover a interface entre entre o sistema operacional e o hardware, essa interface é chamada de Linux Kernel.

== Versão Do Kernel ==

Para verificar qual é a versão atual do Kernel, abra o LXTerminal e digite:

$ cat /proc/version

[[Arquivo:cat_proc_version.png|none|658px|Versão do Kernel]]

Pode-se verificar que neste caso a versão do Kernel é a 4.14.13.

== Atualização Do Kernel ==

Por diversas razões pode ser necessário trocar ou atualizar o Kernel, seja para suportar novos hardwares ou mesmo melhorar o desempenho com hardwares já suportados ou ainda prover novas funcionalidades a esses hardwares já suportados. É valido observar que este processo pode causar problemas ao seu sistema.

É possível realizar a troca do Kernel de algumas maneiras, a mais simples é utilizando a versão já compilada para a Labrador, que pode ser encontrada no repositório da [http://downloads.caninosloucos.org.br/ Caninos Loucos]. Procure Kernel_x_y.zip, onde x é a versão do kernel, y é o versionamento interno do Caninos Loucos, procure o mais recente.

'''Troca De Kernel Compilado'''

Para realizar a troca do Kernel siga os passos a seguir;

1 - Baixar o arquivo contendo o Kernel_x_y.zip do repositório.

2 - Extrair o conteúdo para um diretório, /*caminho qualquer de diretórios*/src/

3 - Copiar “kernel.dtb” e “uImage” para a raíz da partição BOOT

<code>$ sudo cp -r /src/kernel.dtb /media/caninos/BOOT
$ sudo cp -r /src/uImage /media/caninos/BOOT</code>

4 - Copiar “lib/modules” para “lib/modules” da partição SYSTEM:

<code>$ sudo cp -r /src/lib/modules /lib/</code>

5 - Reiniciar a Labrador

$ sudo reboot

Após esse processo a labrador já será inicializada com o Kernel desejado.

MAC de rede

2020-05-07T16:53:13Z

Thalyson: Criou página com ' == '''Descrição''' == A Labrador possui duas interfaces de rede, Wi-Fi (Wireless) e Ethernet (Cabeada), cada uma possui um endereço MAC, para mais informações sobre en...'

== '''Descrição''' ==

A Labrador possui duas interfaces de rede, Wi-Fi (Wireless) e Ethernet (Cabeada), cada uma possui um endereço MAC, para mais informações sobre endereço MAC acesse: [https://pt.wikipedia.org/wiki/Endere%C3%A7o_MAC].

== Troca de endereço MAC ==

A Labrador suporta troca de endereço MAC para as duas interfaces, Wi-Fi e Ethernet. A troca de endereço pode ser utilizada por exemplo para manter um endereço IP estático em um rede.

A interface Ethernet tem comportamento aleatório, quando a placa é ligada, um novo endereço MAC é gerado toda vez. A interface Wi-Fi tem endereço MAC estático, quando a placa é reiniciada o endereço MAC é sempre o mesmo.

Há varias formas de trocar o endereço MAC em uma Labrador, o processo é mesmo para ambas interfaces.

'''Utilizando comando <code>ifconfig</code> para trocar o MAC da interface Ethernet temporariamente;'''

1 - Abra um terminal.

2 - Execute os seguintes passos;
2.1 Para identificar o seu MAC atual, use o seguinte comando;
$ sudo ifconfig
Veja o campo "ether" na interface eth0 que contém o MAC atual do ethernet
2.2 Abra o programa gerenciador de conexões, menu iniciar/Internet/Wicd Network Manager
2.2.1 Desconecte de qualquer rede, desmarque as opções de Automatically connect to this network.
2.2.2 Vá em Preferences, na aba "General Settings" Marque as opções "Always show wired interface", "Always switch to a wired connection when available".
2.3 No terminal execute;
$ sudo ifconfig eth0 down
$ sudo ifconfig eth0 hw ether 02:00:01:02:03:04
$ sudo ifconfig eth0 up
2.4 Faça o passo 2.1 novamente para ver seu novo MAC.
2.5 Volte ao Wicd Network Manager e conecte com a sua rede cabeada(Wired Network)

Após os passos anteriores o endereço MAC já foi alterado e sua conexão está estabelecida utilizando o novo MAC, contudo ao reiniciar a placa o endereço será perdido.

'''Utilizando um script para trocar o endereço MAC da interface ethernet de forma permanente'''

Para trocar e manter o endereço MAC, pode-se utilizar um script na conexão, o processo será feito pelo Wicd Network Manager.

Siga os passos abaixo;

1 - Abra um terminal

2 - Execute como sudo
$ su root
3 - Crie o arquivo de script na pasta do wicd
$ echo "" > /etc/wicd/scripts/preconnect/keep_mac.sh
4 - Abra o arquivo
$ sudo mousepad /etc/wicd/scripts/preconnect/keep_mac.sh
5 - Insira os comandos no arquivo keep_mac.sh (Dica: Evite copiar e colar, digite os textos dos comandos no arquivo manualmente)

#!/usr/bin/env bash

connection_type="$1"

if [[ "${connection_type}"=="wired" ]]; then

ip link set eth0 down

ifconfig eth0 down

ifconfig eth0 hw ether 02:55:66:77:88:99

ifconfig eth0 up

ip link set eth0 up

fi

6 - Salve e feche o arquivo keep_mac.sh

7 - No terminal dê as permissões de execução para o arquivo keep_mac.sh
$ chmod +x /etc/wicd/scripts/preconnect/keep_mac.sh
8 - Abra o Wicd Network Manager, desconecte-se da rede cabeada e conecte-se novamente.
9 - No terminal, veja o campo ether com o valor de MAC adicionado no script "02:55:66:77:88:99"
$ sudo ifconfig

Caso queira alterar o script para adicionar a interface Wireless, troque o conteúdo do script por este;

#!/usr/bin/env bash
connection_type="$1"

if [[ "${connection_type}" == "wireless" ]]; then
ip link set wlan0 down
ifconfig wlan0 down
ifconfig wlan0 hw ether 02:55:66:77:88:AA
ifconfig wlan0 up
ip link set wlan0 up
elif [[ "${connection_type}" == "wired" ]]; then
ip link set eth0 down
ifconfig eth0 down
ifconfig eth0 hw ether 02:55:66:77:88:99
ifconfig eth0 up
ip link set eth0 up
fi

Este script é executado sempre antes de estabelecer a conexão, desta forma mesmo quando a Labrador for reiniciada, o MAC será o mesmo sempre que a conexão for estabelecida.

Assim pode-se por exemplo ir até o servidor DHCP e indicar um endereço IP estático para o MAC escolhido do script.

Página principal

2020-05-07T16:50:03Z

Thalyson: /* Demais Páginas */

Bem-vindo à wiki do Programa [https://caninosloucos.org/pt/ Caninos Loucos] <big>🐶</big>
Nesta wiki você encontrará informações técnicas e tutoriais sobre como utilizar as plataformas desenvolvidas no programa, entre elas a Labrador e a Pulga!

O Programa Caninos Loucos está em constante aprimoramento e esta Wiki recebe atualizações frequentes.

Para acesso às atualizações de software, acompanhe o projeto Caninos Loucos no GitHub: https://github.com/caninos-loucos.

Esperamos que esta Wiki possa resolver suas principais dúvidas e, caso reste alguma, entre em contato pelo [https://caninosloucos.org/pt/contact-pt/ formulário de contato] ou [https://forum.caninosloucos.org.br/ faça uma pergunta no fórum].

== Demais Páginas ==

Confira abaixo a lista das páginas disponíveis nesta Wiki:

*Caninos Loucos
**[[Apresentação do Programa]]
**[[Lista de projetos]]
***[[Tanque/carrinho de controle remoto]]
**[[Como criar uma página]]
*Labrador
**[[Apresentação geral]]
**[[Começando com a Labrador]]
**[[Conhecendo a Labrador 32 bits]]
**[[Conhecendo a Labrador 64 bits]]
**Sobre o Linux
***[[Linux - Aplicativos e funções úteis do Linux]]
***[[Linux - Comando ls]]
***[[Linux - Gerenciador de arquivos]]
**Configurações
***[[Instalando um sistema 32 bits]]
***[[Instalando um sistema 64 bits]]
***[[Programação GPIO]]
***[[Visão Computacional]]
***[[Labrador/Configurações/Bluetooth]]
***[[Labrador/Configurações/Kernel/]]
***[[Labrador/Configurações/Rede/MAC]]
***[[Labrador/Debug]]
*[[Pulga]]

== Quer colaborar com a Wiki? ==

* Rápido e direto: leia o tutorial explicando [[como criar uma página]].
* Avançado: consulte o [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents Manual de Usuário] para informações de como usar o software wiki.
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Traduza o MediaWiki para seu idioma]

[[en:Main page]]

Página principal

2020-05-07T16:14:26Z

Thalyson:

Bem-vindo à wiki do Programa [https://caninosloucos.org/pt/ Caninos Loucos] <big>🐶</big>
Nesta wiki você encontrará informações técnicas e tutoriais sobre como utilizar as plataformas desenvolvidas no programa, entre elas a Labrador e a Pulga!

O Programa Caninos Loucos está em constante aprimoramento e esta Wiki recebe atualizações frequentes.

Para acesso às atualizações de software, acompanhe o projeto Caninos Loucos no GitHub: https://github.com/caninos-loucos.

Esperamos que esta Wiki possa resolver suas principais dúvidas e, caso reste alguma, entre em contato pelo [https://caninosloucos.org/pt/contact-pt/ formulário de contato] ou [https://forum.caninosloucos.org.br/ faça uma pergunta no fórum].

== Demais Páginas ==

Confira abaixo a lista das páginas disponíveis nesta Wiki:

*Caninos Loucos
**[[Apresentação do Programa]]
**[[Lista de projetos]]
***[[Tanque/carrinho de controle remoto]]
**[[Como criar uma página]]

*Labrador
**[[Apresentação geral]]
**[[Começando com a Labrador]]
**Sobre o Linux
***[[Linux - Aplicativos e funções úteis do Linux]]
***[[Linux - Comando ls]]
***[[Linux - Gerenciador de arquivos]]
**Configurações
***[[Programação GPIO]]
***[[Visão Computacional]]
***[[Labrador/Configurações/Bluetooth]]
***[[Labrador/Configurações/Kernel/]]
***[[Labrador/Configurações/Rede/MAC]]
***[[Labrador/Debug]]

*Labrador 32 bits
**[[Conhecendo a Labrador 32 bits]]
**[[Instalando um sistema 32 bits]]

*Labrador 64 bits
**[[Conhecendo a Labrador 64 bits]]
**[[Instalando um sistema 64 bits]]

*[[Pulga]]

== Quer colaborar com a Wiki? ==

* Rápido e direto: leia o tutorial explicando [[como criar uma página]].
* Avançado: consulte o [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents Manual de Usuário] para informações de como usar o software wiki.
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Traduza o MediaWiki para seu idioma]

[[en:Main page]]

Página principal

2020-05-06T20:50:35Z

Thalyson:

Bem-vindo à wiki do projeto [https://caninosloucos.org/pt/ Caninos Loucos] <big>🐶</big>

Nesta wiki você encontrará informações técnicas e tutoriais sobre como utilizar a Labrador, a primeira placa desenvolvida pelo projeto Caninos Loucos. Se você já está com uma Labrador em mãos, sugerimos que leia a página: [[Começando com a Labrador]]. Caso ainda não tenha uma, pedimos mais um pouquinho de paciência: informações sobre como adquirir uma Labrador serão disponibilizadas em breve.

Para tirar dúvidas, acesse nosso fórum: http://forum.caninosloucos.org.br/.

Para conferir o código-fonte do projeto, acesse nosso GitHub: http://github.com/caninos-loucos/.

== Demais Páginas ==

Confira abaixo a lista das páginas disponíveis nesta Wiki:

*Caninos Loucos
**[[Apresentação do Programa]]
**[[Lista de projetos]]
***[[Tanque/carrinho de controle remoto]]
**[[Como criar uma página]]

*Labrador
**[[Apresentação geral]]
**[[Começando com a Labrador]]
**Sobre o Linux
***[[Linux - Aplicativos e funções úteis do Linux]]
***[[Linux - Comando ls]]
***[[Linux - Gerenciador de arquivos]]
**Configurações
***[[Programação GPIO]]
***[[Visão Computacional]]
***[[Labrador/Configurações/Bluetooth]]
***[[Labrador/Configurações/Kernel/]]
***[[Labrador/Configurações/Rede/MAC]]
***[[Labrador/Debug]]

*Labrador 32 bits
**[[Conhecendo a Labrador 32 bits]]
**[[Instalando um sistema 32 bits]]

*Labrador 64 bits
**[[Conhecendo a Labrador 64 bits]]
**[[Instalando um sistema 64 bits]]

*[[Pulga]]

== Quer colaborar com a Wiki? ==

* Rápido e direto: leia o tutorial explicando [[como criar uma página]].
* Avançado: consulte o [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents Manual de Usuário] para informações de como usar o software wiki.
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Traduza o MediaWiki para seu idioma]

[[en:Main page]]

Página principal

2020-05-06T20:34:27Z

Thalyson:

Bem-vindo à wiki do projeto [https://caninosloucos.org/pt/ Caninos Loucos] <big>🐶</big>

Nesta wiki você encontrará informações técnicas e tutoriais sobre como utilizar a [[Labrador]], a primeira placa desenvolvida pelo projeto Caninos Loucos. Se você já está com uma Labrador em mãos, sugerimos que leia a página: [[Começando com a Labrador]]. Caso ainda não tenha uma, pedimos mais um pouquinho de paciência: informações sobre como adquirir uma Labrador serão disponibilizadas em breve.

Para tirar dúvidas, acesse nosso fórum: http://forum.caninosloucos.org.br/.

Para conferir o código-fonte do projeto, acesse nosso GitHub: http://github.com/caninos-loucos/.

== Demais Páginas ==

Confira abaixo a lista das páginas disponíveis nesta Wiki:

*Caninos Loucos
**[[Apresentação do Programa]]
**[[Lista de projetos]]
***[[Tanque/carrinho de controle remoto]]
**[[Como criar uma página]]

*Labrador
**[[Apresentação geral]]
**[[Começando com a Labrador]]
**Sobre o Linux
***[[Linux - Aplicativos e funções úteis do Linux]]
***[[Linux - Comando ls]]
***[[Linux - Gerenciador de arquivos]]
**Configurações
***[[Programação GPIO]]
***[[Visão Computacional]]
***[[Labrador/Configurações/Bluetooth]]
***[[Labrador/Configurações/Kernel/]]
***[[Labrador/Configurações/Rede/MAC]]
***[[Labrador/Debug]]

*Labrador 32 bits
**[[Conhecendo a Labrador 32 bits]]
**[[Instalando um sistema 32 bits]]

*Labrador 64 bits
**[[Conhecendo a Labrador 64 bits]]
**[[Instalando um sistema 64 bits]]

*[[Pulga]]

== Quer colaborar com a Wiki? ==

* Rápido e direto: leia o tutorial explicando [[como criar uma página]].
* Avançado: consulte o [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents Manual de Usuário] para informações de como usar o software wiki.
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Traduza o MediaWiki para seu idioma]

[[en:Main page]]

Pulga

2020-05-06T20:34:01Z

Thalyson:

[[Arquivo:pulga_v1.jpg|thumb|400px|Pulga Core v1]]

A placa Pulga, da Caninos Loucos, é um poderoso microcontrolador com um grande número de sensores, segura e ideal para aplicações de IoT (Internet of Things - Internet das Coisas). Com seu design feito totalmente no Brasil, esse é um projeto completamente aberto.

Esta placa de baixo consumo energético é aproximadamente do tamanho de uma moeda de 25 centavos e suporta Bluetooth 5.0, permitindo conexões sem fio entre múltiplas pulgas.

Aspectos como modularidade, através de uma coreboard autônoma e uma baseboard opcional, além da capacidade de utilizar energia harvesting, permitem grande flexibilidade para prototipação de interface de hardware.

A baseboard permite adicionar funcionalidades para aplicações customizadas. Por exemplo, adicionando protocolos sem fio de longa distância e novos sensores, você pode atingir as demandas de diferentes projetos.

Por fim, o harvesting permite capturar energia de diferentes fontes naturais, garantindo autonomia energética para a placa.

A Pulga possui duas variações: A Pulga Core e a Pulga Módulo. A Pulga Core é autossuficiente com sensores, LEDs e botões, além de dois headers superiores para conexão externa. Já a Pulga Módulo é mais compacta, já que não possui sensores, botões e LEDs, e possui pinos exportados para que possa ser soldado em outro placa, como um módulo.

{| class="wikitable"
|-
! scope="row"| CPU
| ARM Cortex-M4F
|-
! scope="row"| Armazenamento
| 1024kB
|-
! scope="row"| RAM
| 256kB
|-
! scope="row"| Wireless
| Bluetooth 5.0 Bluetooth Mesh
|-
! scope="row"| Segurança
| Aceleração de criptografia (ECC, AES, SHA)
|-
! scope="row"| Periféricos
| I2C, I2S, SPI, URT, USART, GPIO Sensor de luminosidade/ultravioleta* Sensor de 9-eixos (giroscópio, acelerômetro, magnetrômetro)* Sensores de ambiente (temperatura, umidade, pressão)*
|-
! scope="row"| LEDs
| 2 x programáveis (Vermelho/Laranja)*
|-
! scope="row"| Botões
| 2 x programáveis*
|-
! scope="row"| Energia
| 1-6V com capacidade de harvesting
|-
! scope="row"| Expansão
| 24 pinos de E/S (Core) 58 pinos de E/S (Módulo)
|-
! scope="row"| Debug
| SWD
|-
! scope="row"| Sistema operacional
| Compatível com Mbed™
|-
! scope="row"| Dimensões
| 25mm de diâmetro (Core) 20 x 20mm (Módulo)
|-
! scope="row"| Peso
| Aproximadamente 4 gramas
|}

* Não presentes da versão Módulo*

Rover

2020-05-06T18:41:13Z

Thalyson:

[[Arquivo:tanque-labrador.jpeg|thumb|400px|Tanque de controle remoto]]
Aqui será resumido o processo de desenvolvimento do tanque controlado remotamente usando a Labrador. De forma a simplificar o entendimento o processo completo será dividido nas seguintes partes:

*Montagem física: Apresenta uma breve explicação dos elementos utilizados na montagem do tanque e como eles foram ligados.

*Controle GPIO: Controlando o tanque pelo teclado - Apresenta um exemplo simples de controle via input de teclado.

*Configurando access point: Mostra como configurar um ponto de acesso para que o tanque seja controlado via Wi-Fi sem depender de uma conexão externa

= Montagem Física =

A montagem do tanque é feita de maneira muito simples. O desenvolvedor possui liberdade para alterar o projeto de acordo com suas preferências.

Para montar o Tanque Foram usadas as seguintes partes componentes:

*Chassi OSEPP Tank Kit
*Labrador
*Ponte H L298
*Pilhas (6), cabos e conectores

== Chassi ==
O Chassi utilizado já vem pronto para uso com motores e suporte de pilha instalados facilitando a montagem do Tanque. Outra vantagem do chassi utilizado é que ele possui inúmeros furos nos quais é possível fixar as placas de controle adicionais por meio de espaçadores.

== Labrador ==
A Labrador é basicamente a central de comando do Tanque. Ela foi fixada utilizando espaçadores M3 presos ao chassi. Foram feitas as seguintes conexões à placa:

1. Alimentação: Ligada diretamente à saída do conjunto de pilhas

2. Sinais de controle: É possível escolher pinos arbitrários de GPIO que são ligados às entradas de controle da ponte H

3. Sinal 5V: O pino de 5 volts é ligado à ponte H na porta de referência.

== Ponte H ==
A ponte H possui conexão a todos os elementos do sistema:

*Motores: Os motores são conectados um de cada lado da ponte H
*Alimentação
*Referência de tensão: Obtida da placa de controle (Labrador)
*Sinais de controle: responsáveis por controlar o estado do motor e, eventualmente, sua velocidade de rotação

== Alimentação ==
O chassi utilizado acompanha um suporte para 6 pilhas AA que foi utilizado, entretanto pode ser interessante substituí-las por baterias recarregáveis.

= Controle GPIO =
Como citado na seção sobre a montagem foi utilizada uma ponte H L298 para controlar a rotação do motor. Alimentando as portas de controle da ponte H com a combinação correta fará com que o motor rotacione em determinada direção, freie ou fique em ponto morto. O L298 ainda possui portas que controlam se o motor está habilitado ou não, essas portas podem ser utilizadas para aumentar ou diminuir a velocidade de rotação das esteiras por meio de um PWM.

== Controle Digital Simples ==
Um controle digital para o carrinho, ou seja, contendo apenas comandos para ir para frente/trás e rodar no lugar para a direita/esquerda. Nessa primeira abordagem não haverá controle de velocidade e o tanque terá de fazer paradas para mudar de direção.

== Programação GPIO ==
Informações relevantes para a programação GPIO podem ser encontradas na página [[Programação GPIO]]. Essas informações serão utilizadas para criar um Software de controle simples.

== Programa em C ==

=== Configurando a GPIO ===
A primeira grande tarefa do algoritmo de controle é configurar o GPIO indicando as portas que serão usadas e se serão usadas como input ou como output.

=== Em construção ===

Instalando um sistema 64 bits

2020-05-05T18:57:52Z

Thalyson: /* Labrador 64bits */

Para instalar um novo sistema na sua placa Labrador você vai precisar de:
* Labrador Coreboard + Baseboard
* Imagem do sistema em formato .img
* Cartão microSD de pelo menos 8Gb

*Verifique o modelo da Labrador Coreboard, caso a versão seja LABRADOR CORE V3.x siga as instruções de Labrador 64 bits, caso seja LABRADOR CORE V2.x siga as instruções contidas em [[Instalando um sistema 32 bits]].

== Labrador 64 bits ==
[[Arquivo:recovery64.jpg|thumb|400px|Botão Recovery]]
A instalação deve seguir conforme abaixo:

1. Primeiramente você deve baixar a imagem em [http://downloads.caninosloucos.org.br/labrador64_test_image/ Labrador_64_v.x.x.img.7z].

2. Depois você deve descompactar os arquivos.

3. Após descompactar deve escrever a imagem em um cartão microSD utilizando o comando dd no Linux ou o software [https://sourceforge.net/projects/win32diskimager/ Win32 Disk Imager] no Windows.

4. Remova a labrador da fonte de alimentação, insira o cartão SD na Labrador, mantenha o botão de recuperação da Coreboard (no canto superior esquerdo da Coreboard, próximo à etiqueta de número de série) pressionado, conecte a fonte de alimentação, espere próximo de 3 segundos ou até o logo aparecer na tela e solte o botão de recuperação.

5. O sistema será iniciado a partir do cartão. Para conferir utilize o comando <code>$lsblk</code>, o dispositivo em mmcblk0p1 (Cartão SD) deverá estar montado na raiz do sistema, e o dispositivo mmcblk2 (memória interna da labrador) pode estar ou não montada.

6. Para instalar o sistema abra o terminal e execute o comando;

<code>$ cd install

$ sudo ./install.sh</code>

7. Caso a Labrador já possua um sistema instalado previamente em sua memória interna, será necessário confirmar para que o processo de atualização continue.

8. Aguarde o processo ser finalizado, remova o cartão SD e reinicie a Labrador.

Rover

2020-05-05T18:54:36Z

Thalyson:

[[Arquivo:tanque-labrador.jpeg|thumb|400px|Tanque de controle remoto]]
Aqui será resumido o processo de desenvolvimento do tanque controlado remotamente usando a Labrador. De forma a simplificar o entendimento o processo completo será dividido nas seguintes partes:

- Montagem física - Apresenta uma breve explicação dos elementos utilizados na montagem do tanque e como eles foram ligados.

- Controle GPIO - Controlando o tanque pelo teclado - Apresenta um exemplo simples de controle via input de teclado.

- Configurando access point - Mostra como configurar um ponto de acesso para que o tanque seja controlado via Wi-Fi sem depender de uma conexão externa

= Montagem Física =

A montagem do tanque é feita de maneira muito simples. O desenvolvedor possui liberdade para alterar o projeto de acordo com suas preferências.

Para montar o Tanque Foram usadas as seguintes partes componentes:

- Chassi OSEPP Tank Kit
- Labrador
- Ponte H L298
- Pilhas (6), cabos e conectores

== Chassi ==
O Chassi utilizado já vem pronto para uso com motores e suporte de pilha instalados facilitando a montagem do Tanque. Outra vantagem do chassi utilizado é que ele possui inúmeros furos nos quais é possível fixar as placas de controle adicionais por meio de espaçadores.

== Labrador ==
A Labrador é basicamente a central de comando do Tanque. Ela foi fixada utilizando espaçadores M3 presos ao chassi. Foram feitas as seguintes conexões à placa:

1. Alimentação: Ligada diretamente à saída do conjunto de pilhas
2. Sinais de controle: É possível escolher pinos arbitrários de GPIO que são ligados às entradas de controle da ponte H
3. Sinal 5V: O pino de 5 volts é ligado à ponte H na porta de referência.

== Ponte H ==
A ponte H possui conexão a todos os elementos do sistema:

- Motores: Os motores são conectados um de cada lado da ponte H
- Alimentação
- Referência de tensão: Obtida da placa de controle (Labrador)
- Sinais de controle: responsáveis por controlar o estado do motor e, eventualmente, sua velocidade de rotação

== Alimentação ==
O chassi utilizado acompanha um suporte para 6 pilhas AA que foi utilizado, entretanto pode ser interessante substituí-las por baterias recarregáveis.

= Controle GPIO =
Como citado na seção sobre a montagem foi utilizada uma ponte H L298 para controlar a rotação do motor. Alimentando as portas de controle da ponte H com a combinação correta fará com que o motor rotacione em determinada direção, freie ou fique em ponto morto. O L298 aind possui portas que controlam se o motor está habilitado ou não, essas portas podem ser utilizadas para aumentar ou diminuir a velocidade de rotação das esteiras por meio de um PWM.

== Controle Digital Simples ==
Um controle digital para o carrinho, ou seja, contendo apenas comandos para ir para frente/trás e rodar no lugar para a direita/esquerda. Nessa primeira abordagem não haverá controle de velocidade e o tanque terá de fazer paradas para mudar de direção.

== Programação GPIO ==
Informações relevantes para a programação GPIO podem ser encontradas na página [[Programação GPIO]]. Essas informações serão utilizadas para criar um Software de controle simples.

== Programa em C ==

=== Configurando a GPIO ===
A primeira grande tarefa do algoritmo de controle é configurar o GPIO indicando as portas que serão usadas e se serão usadas como input ou como output.

=== Em construção ===

Instalando um sistema 64 bits

2020-05-05T18:53:03Z

Thalyson:

Para instalar um novo sistema na sua placa Labrador você vai precisar de:
* Labrador Coreboard + Baseboard
* Imagem do sistema em formato .img
* Cartão microSD de pelo menos 8Gb

*Verifique o modelo da Labrador Coreboard, caso a versão seja LABRADOR CORE V3.x siga as instruções de Labrador 64 bits, caso seja LABRADOR CORE V2.x siga as instruções contidas em [[Instalando um sistema 32 bits]].

== Labrador 64bits ==
[[Arquivo:recovery64.jpg|thumb|400px|Botão Recovery]]
A instalação deve seguir conforme abaixo:

1. Primeiramente você deve baixar a imagem em [http://downloads.caninosloucos.org.br/labrador64_test_image/ Labrador_64_v.x.x.img.7z].

2. Depois você deve descompactar os arquivos.

3. Após descompactar deve escrever a imagem em um cartão microSD utilizando o comando dd no Linux ou o software [https://sourceforge.net/projects/win32diskimager/ Win32 Disk Imager] no Windows.

4. Remova a labrador da fonte de alimentação, insira o cartão SD na Labrador, mantenha o botão de recuperação da Coreboard (no canto superior esquerdo da Coreboard, próximo à etiqueta de número de série) pressionado, conecte a fonte de alimentação, espere próximo de 3 segundos ou até o logo aparecer na tela e solte o botão de recuperação.

5. O sistema será iniciado a partir do cartão. Para conferir utilize o comando <code>$lsblk</code>, o dispositivo em mmcblk0p1 (Cartão SD) deverá estar montado na raiz do sistema, e o dispositivo mmcblk2 (memória interna da labrador) pode estar ou não montada.

6. Para instalar o sistema abra o terminal e execute o comando;

<code>$ cd install

$ sudo ./install.sh</code>

7. Caso a Labrador já possua um sistema instalado previamente em sua memória interna, será necessário confirmar para que o processo de atualização continue.

8. Aguarde o processo ser finalizado, remova o cartão SD e reinicie a Labrador.

Instalando um sistema 32 bits

2020-05-05T18:52:52Z

Thalyson:

Para instalar um novo sistema na sua placa Labrador você vai precisar de:
* Labrador Coreboard + Baseboard
* Imagem do sistema em formato .img
* Cartão microSD de pelo menos 8Gb
* Conversor Serial-TTL (não obrigatório)

[[Arquivo:recovery.png|thumb|400px|Botão Recovery]]

*Verifique o modelo da Labrador Coreboard, caso a versão seja LABRADOR CORE V2.x siga as instruções de Labrador 32 bits, caso seja LABRADOR CORE V3.x siga as instruções contidas em [[Instalando um sistema 64 bits]].

= Gravando uma nova imagem =

Apesar de a Labrador já vir com o Debian instalado na memória interna, você pode gravar uma nova imagem, feita por você mesmo, ou baixada do site Caninos Loucos. A Labrador suporta boot a partir da memória interna e a partir de um SD Card, e as seções a seguir ensinam como gravar uma imagem em cada uma dessas mídias. As imagens atuais disponibilizadas pela Caninos Loucos são: [http://downloads.caninosloucos.org.br/kernel_4_image/ Debian Buster com Kernel 4] e [http://downloads.caninosloucos.org.br/kernel_3_image/ Debian Buster com Kernel 3].

== Gravando no SD Card ==

Tendo uma imagem compatível com a Labrador (ver http://downloads.caninosloucos.org.br/), siga os passos abaixo para gravá-la em um SD Card, de acordo com o sistema operacional do seu computador.

=== Usando Linux ===

<dl>
<dt>Passo 1</dt>
<dd>Insira um cartão MicroSD no seu computador. O cartão deve ser maior que a imagem que você deseja gravar (geralmente 8 GB ou maior).</dd>
<dt>Passo 2</dt>
<dd>Execute no terminal o seguinte comando: <pre> $ sudo dd if=<caminho/pra/imagem>.img of=/dev/<nome do device> status=progress bs=4M conv=fsync </pre>
<dl>

Onde <code><image></code> deve ser substituído pelo nome da imagem, e <code><device></code> pelo nome do seu SD Card (algo como sda, ou sdb).

'''Importante: Se você não sabe qual o <code><nome do device></code> correto, peça ajuda! Um erro neste comando pode formatar o seu computador.'''

=== Usando Windows ===

<dl>
<dt>Passo 1</dt>
<dd>Insira um cartão MicroSD no seu computador. O cartão deve ser maior que a imagem que você deseja gravar (geralmente 8 GB ou maior).</dd>
<dt>Passo 2</dt>
<dd>Formate o cartão MicroSD. Recomenda-se que seja utilizado um software de formatação adequado, neste tutorial estamos usando o SDFormatter v4.0, disponível [https://www.sdcard.org/downloads/formatter_4/ neste website]. Execute o software como administrador e clique no botão “Opção”. Na nova janela aberta, selecione a opção “RÁPIDA” em “FORMAT TYPE” e “ON” em “FORMAT SIZE ADJUSTMENT” e pressione “OK” para voltar à tela anterior. Selecione o Drive equivalente ao seu cartão SD e clique em “Formatar” para iniciar o processo.
'''Importante: Se você não sabe qual o Drive correto, peça ajuda! Um erro neste comando pode formatar o seu computador.'''
[[File:win1.png|frame|none|alt=| Tela inicial do SDFormatter.]]

[[File:win2.png|frame|none|alt=| Tela com as opções do SDFormatter.]]
</dd>
<dt>Passo 3</dt>
<dd>Para gravar a imagem no cartão SD, recomenda-se o uso de uma ferramenta de gravação. Neste tutorial, estamos usando o Win32DiskImager, encontrado [https://sourceforge.net/projects/win32diskimager/files/latest/download neste link]. Execute o programa como administrador, selecione o arquivo de imagem (descompactado) e clique no botão Write para iniciar o processo de gravação. Quando a barra de carregamento termina, o processo é concluído.
[[File:win3.png|frame|none|alt=| Tela do Win32DiskImager (botão para selecionar o caminho em vermelho).]]
</dd></dl>

== Gravando na memória interna ==

1. Caso tenha o conversor serial-ttl, conecte ele na labrador de acordo com as instruções em [https://wiki.caninosloucos.org.br/index.php/Labrador/Debug Debug].

2. Remova a labrador da fonte de alimentação, insira o cartão SD na Labrador, mantenha o botão de recuperação da Coreboard (no canto superior esquerdo da Coreboard, próximo à etiqueta de número de série) pressionado, conecte a fonte de alimentação, espere próximo de dois segundos e solte o botão de recuperação.

===Com o conversor serial-tty===
3.1 Caso veja a seguinte mensagem 'Booting Proccess Aborted' na saída de debug, retire novamente a labrador da fonte, faça o passo anterior novamente, mas mantendo por menos tempo o botão de recuperação pressionado.

[[Arquivo:labrador32_flash_aborted.png|600px|Falha ao realizar boot]]

3.2 O processo de flash começará automaticamente e deve levar cerca de 90 minutos. Para verificar o progresso use o Debug pela serial.

[[Arquivo:labrador32_flash_finished.png|400px|Instalação completa]]

3.3 Após o fim do boot basta retirar o cartão SD e ligar a placa normalmente.

===Sem o conversor serial-tty(Em edição, não utilizar)===

1. Ao ligar a placa, entre no ''lxterminal''.

1.1 Em ''/media/caninos'', se existir, copie todo conteúdo do diretório '''BOOT2''' para o diretório '''BOOT1'''.
$ cp -r /media/caninos/BOOT2/* /media/caninos/BOOT1/
Caso não exista, copie o conteúdo de '''BOOT1''' para '''BOOT'''.

2. Aguarde o processo ser finalizado, remova o cartão SD e reinicie a Labrador.

Pulga

2020-05-05T18:48:01Z

Thalyson:

[[Arquivo:pulga_v1.jpg|thumb|400px|Pulga Core v1]]

A placa Pulga, da Caninos Loucos, é um poderoso microcontrolador com um grande número de sensores, segura e ideal para aplicações de IoT (Internet of Things - Internet das Coisas). Com seu design feito totalmente no Brasil, esse é um projeto completamente aberto.

Esta placa de baixo consumo energético é aproximadamente do tamanho de uma moeda de 25 centavos e suporta Bluetooth 5.0, permitindo conexões sem fio entre múltiplas pulgas.

Aspectos como modularidade, através de uma coreboard autônoma e uma baseboard opcional, além da capacidade de utilizar energia harvesting, permitem grande flexibilidade para prototipação de interface de hardware.

A baseboard permite adicionar funcionalidades para aplicações customizadas. Por exemplo, adicionando protocolos sem fio de longa distância e novos sensores, você pode atingir as demandas de diferentes projetos.

Por fim, o harvesting permite capturar energia de diferentes fontes naturais, garantindo autonomia energética para a placa.

{| class="wikitable"
|-
! scope="row"| CPU
| ARM Cortex-M4F
|-
! scope="row"| Armazenamento
| 1024kB
|-
! scope="row"| RAM
| 256kB
|-
! scope="row"| Wireless
| Bluetooth 5.0 Bluetooth Mesh
|-
! scope="row"| Segurança
| Aceleração de criptografia (ECC, AES, SHA)
|-
! scope="row"| Periféricos
| I2C, I2S, SPI, URT, USART, GPIO Sensor de luminosidade/ultravioleta* Sensor de 9-eixos (giroscópio, acelerômetro, magnetrômetro)* Sensores de ambiente (temperatura, umidade, pressão)*
|-
! scope="row"| LEDs
| 2 x programáveis (Vermelho/Laranja)*
|-
! scope="row"| Botões
| 2 x programáveis*
|-
! scope="row"| Energia
| 1-6V com capacidade de harvesting
|-
! scope="row"| Expansão
| 24 pinos de E/S (Core) 58 pinos de E/S (Módulo)
|-
! scope="row"| Debug
| SWD
|-
! scope="row"| Sistema operacional
| Compatível com Mbed™
|-
! scope="row"| Dimensões
| 25mm de diâmetro (Core) 20 x 20mm (Módulo)
|-
! scope="row"| Peso
| Aproximadamente 4 gramas
|}

* Não presentes da versão Módulo*

Arquivo:Labrador-base-2.0 debug.png

2020-05-05T18:44:24Z

Thalyson: Thalyson carregada uma nova versão de Arquivo:Labrador-base-2.0 debug.png

Arquivo:Labrador-base-1.0a debug.png

2020-05-05T18:44:07Z

Thalyson: Thalyson carregada uma nova versão de Arquivo:Labrador-base-1.0a debug.png

Instalando um sistema 64 bits

2020-05-05T18:15:14Z

Thalyson: /* Labrador 64bits */

Para instalar um novo sistema na sua placa Labrador você vai precisar de:
* Labrador Coreboard + Baseboard
* Imagem do sistema em formato .img
* Cartão microSD de pelo menos 8Gb

*Verifique o modelo da Labrador Core Board, caso a versão seja LABRADOR CORE V3.x siga as instruções de Labrador 64 bits, caso seja LABRADOR CORE V2.x siga as instruções contidas em [[Instalando um sistema 32 bits]].

== Labrador 64bits ==
[[Arquivo:recovery64.jpg|thumb|400px|Botão Recovery]]
A instalação deve seguir conforme abaixo:

1. Primeiramente você deve baixar a imagem em [http://downloads.caninosloucos.org.br/labrador64_test_image/ Labrador_64_v.x.x.img.7z].

2. Depois você deve descompactar os arquivos.

3. Após descompactar deve escrever a imagem em um cartão microSD utilizando o comando dd no Linux ou o software [https://sourceforge.net/projects/win32diskimager/ Win32 Disk Imager] no Windows.

4. Remova a labrador da fonte de alimentação, insira o cartão SD na Labrador, mantenha o botão de recuperação da Coreboard (no canto superior esquerdo da Coreboard, próximo à etiqueta de número de série) pressionado, conecte a fonte de alimentação, espere próximo de 3 segundos ou até o logo aparecer na tela e solte o botão de recuperação.

5. O sistema será iniciado a partir do cartão. Para conferir utilize o comando <code>$lsblk</code>, o dispositivo em mmcblk0p1 (Cartão SD) deverá estar montado na raiz do sistema, e o dispositivo mmcblk2 (memória interna da labrador) pode estar ou não montada.

6. Para instalar o sistema abra o terminal e execute o comando;

<code>$ cd install

$ sudo ./install.sh</code>

7. Caso a Labrador já possua um sistema instalado previamente em sua memória interna, será necessário confirmar para que o processo de atualização continue.

8. Aguarde o processo ser finalizado, remova o cartão SD e reinicie a Labrador.

Arquivo:Recovery64.jpg

2020-05-05T18:11:27Z

Thalyson:

Começando com a Labrador

2020-05-05T15:54:39Z

Thalyson: /* Crie seus próprios programas */

= Ligando a Labrador =

A principal maneira de usar a placa Labrador é conectando-a a um monitor HDMI e a um teclado e mouse USB, além da fonte de alimentação, para que possa ser usada como um dispositivo Linux comum. As próximas seções ensinam passo a passo como realizar cada um desses passos.

== Conectando teclado e mouse - USB ==

Para poder interagir com a Labrador, basta conectar teclado e mouse às interfaces USB da Labrador. Em geral, você poderá usar qualquer teclado e mouse USB, a compatibilidade é bastante estável.

== Conectando a fonte de alimentação ==

O último passo relacionado à conexão de componentes físicos, antes de usar a placa, é conectar a fonte de alimentação. A fonte enviada na caixa aceita ambas as tensões 110V e 220V, e tem como saída 12V 1A de corrente contínua. Caso necessário, fontes alternativas com especificação equivalente podem ser usadas.

== Conectando o monitor - HDMI ==

A principal forma de visualizar a saída gráfica da Labrador é através de um monitor HDMI (High Definition Multimedia Interface). Você irá precisar de um cabo HDMI comum e de um monitor HDMI.

Caso seu monitor não possua entrada HDMI, mas possua DVI, a Labrador também funciona com adaptadores HDMI-para-DVI. Também já foram testadas entradas analógicas, como o VGA, que funciona com adaptadores HDMI-VGA que façam internamente a conversão digital-analógica. Por fim, para casos muito específicos, existe a opção de conectar um display LCD diretamente a um conector chamado LVDS – mais detalhes sobre este tipo de conector podem ser encontrados na especificação, a página será atualizada de acordo mediante evolução dos testes.

Agora, com o mouse, teclado e monitor já conectados, coloque a fonte de alimentação na tomada e conecte-a à Labrador. Se tudo ocorreu bem, você deverá ver o logo do Caninos Loucos, seguido da tela de login.

= Usando o Debian =

O sistema operacional incluso na placa Labrador é o Debian, uma distribuição Linux utilizada no mundo todo. Para o leitor leigo no assunto, [http://www.devfuria.com.br/linux/como-iniciar-no-linux/ há vários tutoriais de Linux na internet], ensinando o básico de [https://sempreupdate.com.br/como-funciona-a-linha-de-comando-do-linux/ como mexer na linha de comando], e até mesmo [https://hacker-tools.github.io/lectures/ guias avançados para aproveitar o Linux ao máximo].

== Login ==

Para começar, assumindo que você já ligou a placa e está na tela de login, o próximo passo é digitar "caninos" (sem as aspas), tanto para o usuário quanto para a senha, e clicar em "Login".

== Acesso à Internet ==

Apesar de a Labrador possuir muitas aplicações para uso offline, conectá-la à Internet nos permite acessar websites, instalar bibliotecas e manter o sistema atualizado. Há duas formas principais, usando cabo de rede (Ethernet) ou a conexão sem-fio (Wi-Fi).

=== Ethernet ===

Para acessar a Internet usando cabo de rede, basta conectar o seu cabo de internet à entrada RJ45. Ao fazer isso com a placa ligada, observe também que o ícone de rede, no lado inferior direito da tela, irá carregar, até apontar que a conexão foi realizada com sucesso.

=== Wi-Fi ===

Como a Labrador já tem Wi-Fi embutido, basta acessar o menu de redes, escolher a sua rede, digitar a senha, e habilitar a conexão. Se for necessário especificar o tipo de segurança da rede, provavelmente será a opção "WPA2 Personal". Caso isso não funcione, peça ajuda à pessoa que realizou a configuração do seu roteador para descobrir os parâmetros corretos de configuração.

=== Verifique a conexão ===

Independente da forma como você se conectou à Internet, você agora pode testar a sua conexão. Uma forma simples de fazer isso é abrindo o Firefox e acessando o site http://caninosloucos.org. Já uma forma mais avançada é abrindo o terminal, digitando <code>ip address</code> e verificando se você tem um endereço IP válido. É útil saber o endereço IP, pois permite que nos comuniquemos com a Labrador, seja em uma aplicação IoT, seja durante o desenvolvimento. Por exemplo podemos acessar o terminal da Labrador via SSH (Secure Shell), evitando assim a necessidade de mantê-la sempre conectada a um teclado, mouse e monitor.

== Crie seus próprios programas ==

A Labrador tem suporte para uma variedade de linguagens de programação, desde as mais baixo nível, como o C, até as mais alto nível e expressivas, como Python e NodeJS. Portanto deixe a sua criatividade florescer e crie seus próprios programas usando a Labrador. Ah, e não esqueça de compartilhar os seus projetos com a comunidade, no [https://forum.caninosloucos.org.br/ fórum Caninos Loucos]!

=== Hello World - Piscando um LED (Kernel 3) ===

Se ao aprender programar imprimimos "Hello World" na tela, na programação de SBCs vamos além: vamos fazer piscar um LED (Light Emitting Diode). Este exemplo é interessante pois demonstra que nossos programas, além de controlarem caracteres na tela ou bytes na rede, também podem controlar componentes físicos.

Para fazer o LED azul da Labrador piscar em um ritmo de batimento cardíaco (de acordo com a demanda de processamento da Labrador), abra o terminal e execute o seguinte comando:

<pre>sudo echo heartbeat > /sys/class/leds/blue:GPIOB31/trigger</pre>

=== Programação GPIO ===

Uma interface interessante da Labrador são os pinos GPIO (General Purpose Input/Output), que são basicamente fios nos quais você pode enviar e receber dados. Para aprender como usar esta interface, confira o artigo principal [[Programação GPIO]].

Começando com a Labrador

2020-05-05T15:53:56Z

Thalyson: /* Crie seus próprios programas */

= Ligando a Labrador =

A principal maneira de usar a placa Labrador é conectando-a a um monitor HDMI e a um teclado e mouse USB, além da fonte de alimentação, para que possa ser usada como um dispositivo Linux comum. As próximas seções ensinam passo a passo como realizar cada um desses passos.

== Conectando teclado e mouse - USB ==

Para poder interagir com a Labrador, basta conectar teclado e mouse às interfaces USB da Labrador. Em geral, você poderá usar qualquer teclado e mouse USB, a compatibilidade é bastante estável.

== Conectando a fonte de alimentação ==

O último passo relacionado à conexão de componentes físicos, antes de usar a placa, é conectar a fonte de alimentação. A fonte enviada na caixa aceita ambas as tensões 110V e 220V, e tem como saída 12V 1A de corrente contínua. Caso necessário, fontes alternativas com especificação equivalente podem ser usadas.

== Conectando o monitor - HDMI ==

A principal forma de visualizar a saída gráfica da Labrador é através de um monitor HDMI (High Definition Multimedia Interface). Você irá precisar de um cabo HDMI comum e de um monitor HDMI.

Caso seu monitor não possua entrada HDMI, mas possua DVI, a Labrador também funciona com adaptadores HDMI-para-DVI. Também já foram testadas entradas analógicas, como o VGA, que funciona com adaptadores HDMI-VGA que façam internamente a conversão digital-analógica. Por fim, para casos muito específicos, existe a opção de conectar um display LCD diretamente a um conector chamado LVDS – mais detalhes sobre este tipo de conector podem ser encontrados na especificação, a página será atualizada de acordo mediante evolução dos testes.

Agora, com o mouse, teclado e monitor já conectados, coloque a fonte de alimentação na tomada e conecte-a à Labrador. Se tudo ocorreu bem, você deverá ver o logo do Caninos Loucos, seguido da tela de login.

= Usando o Debian =

O sistema operacional incluso na placa Labrador é o Debian, uma distribuição Linux utilizada no mundo todo. Para o leitor leigo no assunto, [http://www.devfuria.com.br/linux/como-iniciar-no-linux/ há vários tutoriais de Linux na internet], ensinando o básico de [https://sempreupdate.com.br/como-funciona-a-linha-de-comando-do-linux/ como mexer na linha de comando], e até mesmo [https://hacker-tools.github.io/lectures/ guias avançados para aproveitar o Linux ao máximo].

== Login ==

Para começar, assumindo que você já ligou a placa e está na tela de login, o próximo passo é digitar "caninos" (sem as aspas), tanto para o usuário quanto para a senha, e clicar em "Login".

== Acesso à Internet ==

Apesar de a Labrador possuir muitas aplicações para uso offline, conectá-la à Internet nos permite acessar websites, instalar bibliotecas e manter o sistema atualizado. Há duas formas principais, usando cabo de rede (Ethernet) ou a conexão sem-fio (Wi-Fi).

=== Ethernet ===

Para acessar a Internet usando cabo de rede, basta conectar o seu cabo de internet à entrada RJ45. Ao fazer isso com a placa ligada, observe também que o ícone de rede, no lado inferior direito da tela, irá carregar, até apontar que a conexão foi realizada com sucesso.

=== Wi-Fi ===

Como a Labrador já tem Wi-Fi embutido, basta acessar o menu de redes, escolher a sua rede, digitar a senha, e habilitar a conexão. Se for necessário especificar o tipo de segurança da rede, provavelmente será a opção "WPA2 Personal". Caso isso não funcione, peça ajuda à pessoa que realizou a configuração do seu roteador para descobrir os parâmetros corretos de configuração.

=== Verifique a conexão ===

Independente da forma como você se conectou à Internet, você agora pode testar a sua conexão. Uma forma simples de fazer isso é abrindo o Firefox e acessando o site http://caninosloucos.org. Já uma forma mais avançada é abrindo o terminal, digitando <code>ip address</code> e verificando se você tem um endereço IP válido. É útil saber o endereço IP, pois permite que nos comuniquemos com a Labrador, seja em uma aplicação IoT, seja durante o desenvolvimento. Por exemplo podemos acessar o terminal da Labrador via SSH (Secure Shell), evitando assim a necessidade de mantê-la sempre conectada a um teclado, mouse e monitor.

== Crie seus próprios programas ==

A Labrador tem suporte para uma variedade de linguagens de programação, desde as mais baixo nível, como o C, até as mais alto nível e expressivas, como Python e NodeJS. Portanto deixe a sua criatividade florescer e crie seus próprios programas usando a Labrador. Ah, e não esqueça de compartilhar os seus projetos com a comunidade, no [https://forum.caninosloucos.org.br/ fórum Caninos Loucos] e aqui na Wiki na nossa [[Lista de projetos]]!

=== Hello World - Piscando um LED (Kernel 3) ===

Se ao aprender programar imprimimos "Hello World" na tela, na programação de SBCs vamos além: vamos fazer piscar um LED (Light Emitting Diode). Este exemplo é interessante pois demonstra que nossos programas, além de controlarem caracteres na tela ou bytes na rede, também podem controlar componentes físicos.

Para fazer o LED azul da Labrador piscar em um ritmo de batimento cardíaco (de acordo com a demanda de processamento da Labrador), abra o terminal e execute o seguinte comando:

<pre>sudo echo heartbeat > /sys/class/leds/blue:GPIOB31/trigger</pre>

=== Programação GPIO ===

Uma interface interessante da Labrador são os pinos GPIO (General Purpose Input/Output), que são basicamente fios nos quais você pode enviar e receber dados. Para aprender como usar esta interface, confira o artigo principal [[Programação GPIO]].

Começando com a Labrador

2020-05-05T15:51:54Z

Thalyson: /* Verifique a conexão */

Começando com a Labrador

2020-05-05T15:50:31Z

Thalyson: /* Ethernet */

= Ligando a Labrador =

A principal maneira de usar a placa Labrador é conectando-a a um monitor HDMI e a um teclado e mouse USB, além da fonte de alimentação, para que possa ser usada como um dispositivo Linux comum. As próximas seções ensinam passo a passo como realizar cada um desses passos.

== Conectando teclado e mouse - USB ==

Para poder interagir com a Labrador, basta conectar teclado e mouse às interfaces USB da Labrador. Em geral, você poderá usar qualquer teclado e mouse USB, a compatibilidade é bastante estável.

== Conectando a fonte de alimentação ==

O último passo relacionado à conexão de componentes físicos, antes de usar a placa, é conectar a fonte de alimentação. A fonte enviada na caixa aceita ambas as tensões 110V e 220V, e tem como saída 12V 1A de corrente contínua. Caso necessário, fontes alternativas com especificação equivalente podem ser usadas.

== Conectando o monitor - HDMI ==

A principal forma de visualizar a saída gráfica da Labrador é através de um monitor HDMI (High Definition Multimedia Interface). Você irá precisar de um cabo HDMI comum e de um monitor HDMI.

Caso seu monitor não possua entrada HDMI, mas possua DVI, a Labrador também funciona com adaptadores HDMI-para-DVI. Também já foram testadas entradas analógicas, como o VGA, que funciona com adaptadores HDMI-VGA que façam internamente a conversão digital-analógica. Por fim, para casos muito específicos, existe a opção de conectar um display LCD diretamente a um conector chamado LVDS – mais detalhes sobre este tipo de conector podem ser encontrados na especificação, a página será atualizada de acordo mediante evolução dos testes.

Agora, com o mouse, teclado e monitor já conectados, coloque a fonte de alimentação na tomada e conecte-a à Labrador. Se tudo ocorreu bem, você deverá ver o logo do Caninos Loucos, seguido da tela de login.

= Usando o Debian =

O sistema operacional incluso na placa Labrador é o Debian, uma distribuição Linux utilizada no mundo todo. Para o leitor leigo no assunto, [http://www.devfuria.com.br/linux/como-iniciar-no-linux/ há vários tutoriais de Linux na internet], ensinando o básico de [https://sempreupdate.com.br/como-funciona-a-linha-de-comando-do-linux/ como mexer na linha de comando], e até mesmo [https://hacker-tools.github.io/lectures/ guias avançados para aproveitar o Linux ao máximo].

== Login ==

Para começar, assumindo que você já ligou a placa e está na tela de login, o próximo passo é digitar "caninos" (sem as aspas), tanto para o usuário quanto para a senha, e clicar em "Login".

== Acesso à Internet ==

Apesar de a Labrador possuir muitas aplicações para uso offline, conectá-la à Internet nos permite acessar websites, instalar bibliotecas e manter o sistema atualizado. Há duas formas principais, usando cabo de rede (Ethernet) ou a conexão sem-fio (Wi-Fi).

=== Ethernet ===

Para acessar a Internet usando cabo de rede, basta conectar o seu cabo de internet à entrada RJ45. Ao fazer isso com a placa ligada, observe também que o ícone de rede, no lado inferior direito da tela, irá carregar, até apontar que a conexão foi realizada com sucesso.

=== Wi-Fi ===

Como a Labrador já tem Wi-Fi embutido, basta acessar o menu de redes, escolher a sua rede, digitar a senha, e habilitar a conexão. Se for necessário especificar o tipo de segurança da rede, provavelmente será a opção "WPA2 Personal". Caso isso não funcione, peça ajuda à pessoa que realizou a configuração do seu roteador para descobrir os parâmetros corretos de configuração.

=== Verifique a conexão ===

Independente da forma como você se conectou à Internet, você agora pode testar a sua conexão. Uma forma simples de fazer isso é abrindo o Firefox e acessando o site http://caninnosloucos.org.br. Já uma forma mais avançada é abrindo o terminal, digitando <code>ip address</code> e verificando se você tem um endereço IP válido. É útil saber o endereço IP, pois permite que nos comuniquemos com a Labrador, seja em uma aplicação IoT, seja durante o desenvolvimento. Por exemplo podemos acessar o terminal da Labrador via SSH (Secure Shell), evitando assim a necessidade de mantê-la sempre conectada a um teclado, mouse e monitor.

== Crie seus próprios programas ==

A Labrador tem suporte para uma variedade de linguagens de programação, desde as mais baixo nível, como o C, até as mais alto nível e expressivas, como Python e NodeJS. Portanto deixe a sua criatividade florescer e crie seus próprios programas usando a Labrador. Ah, e não esqueça de compartilhar os seus projetos com a comunidade, no [https://forum.caninosloucos.org.br/ fórum Caninos Loucos]!

=== Hello World - Piscando um LED (Kernel 3) ===

Se ao aprender programar imprimimos "Hello World" na tela, na programação de SBCs vamos além: vamos fazer piscar um LED (Light Emitting Diode). Este exemplo é interessante pois demonstra que nossos programas, além de controlarem caracteres na tela ou bytes na rede, também podem controlar componentes físicos.

Para fazer o LED azul da Labrador piscar em um ritmo de batimento cardíaco (de acordo com a demanda de processamento da Labrador), abra o terminal e execute o seguinte comando:

<pre>sudo echo heartbeat > /sys/class/leds/blue:GPIOB31/trigger</pre>

=== Programação GPIO ===

Uma interface interessante da Labrador são os pinos GPIO (General Purpose Input/Output), que são basicamente fios nos quais você pode enviar e receber dados. Para aprender como usar esta interface, confira o artigo principal [[Programação GPIO]].