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

Instalando um sistema 32 bits

2025-05-12T17:32:56Z

Augrm: /* Labrador 32 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 4Gb

*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 V2.x siga as instruções contidas em [[Instalando um sistema 64 bits]].

== Labrador 32 bits ==
[[Arquivo:recovery.png|thumb|400px|Botão Recovery]]
A instalação deve seguir conforme abaixo:

1. Primeiramente você deve baixar a imagem em [https://downloads.caninosloucos.org/images/labrador_32_bits/ Labrador 32 bits]. Para este procedimento a imagem deverá ser a versão 0.12 ou superior.

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 ./install32_labrador.sh</code>

8. Aguarde o processo ser finalizado, desligue a Labrador, remova o cartão SD e religue a placa.

Programação GPIO

2023-04-19T18:17:40Z

Augrm:

Esta página explica como programar as saídas GPIO (General Purpose Input/Output) da Labrador, que são basicamente pinos nos quais você pode enviar e receber dados. Para facilitar a programação, a placa Labrador segue a interface padrão para userspace para Linux embarcado. O tutorial desta página funciona tanto com a Labrador 32 quanto 64-bits.

Além disso, possuímos uma biblioteca simplificada específica para as placas da linha Caninos Loucos e compatível com Python, chamada caninos-sdk, que pode ser encontrada [https://pypi.org/project/caninos-sdk/ neste link]

== Configuração dos pinos ==

A configuração de pinos para o cabeçalho de GPIO é a seguinte:

=== GPIO Labrador 32-bits ===
[[File:40pinh.png|image|800px|caption Mapeamento do header de 40 pinos.]]

=== GPIO Labrador 64 bits===
{| class="wikitable" style="background-color:#ffffff;"
|- style="background-color:#c0c0c0;"
! Default Function
! colspan="2" | Header Pin
! Default Function
|-
| style="background-color:#efefef;" | VCC
| 1
| 2
| style="background-color:#efefef;" | 5V
|-
| GPIOE3
| 3
| 4
| style="background-color:#efefef;" | 5V
|-
| GPIOE2
| 5
| 6
| style="background-color:#efefef;" | GND
|-
| GPIOB18
| 7
| 8
| UART0_TX
|-
| style="background-color:#efefef;" | GND
| 9
| 10
| UART0_RX
|-
| GPIOC0
| 11
| 12
| GPIOB8
|-
| GPIOC1
| 13
| 14
| style="background-color:#efefef;" | GND
|-
| GPIOC4
| 15
| 16
| GPIOD30
|-
| style="background-color:#efefef;" | VCC
| 17
| 18
| GPIOC6
|-
| TWI3_SDA
| 19
| 20
| style="background-color:#efefef;" | GND
|-
| GPIOC24
| 21
| 22
| GPIOC5
|-
| TWI3_SCK
| 23
| 24
| GPIOC23
|-
| style="background-color:#efefef;" | GND
| 25
| 26
| GPIOB19
|-
| GPIOB16
| 27
| 28
| GPIOB14
|-
| GPIOB15
| 29
| 30
| style="background-color:#efefef;" | GND
|-
| GPIOB10
| 31
| 32
| GPIOB13
|-
| GPIOB0
| 33
| 34
| style="background-color:#efefef;" | GND
|-
| GPIOB1
| 35
| 36
| GPIOA28
|-
| GPIOB2
| 37
| 38
| RESERVED
|-
| style="background-color:#efefef;" | GND
| 39
| 40
| RESERVED
|}

== Interface GPIO do Linux ==
O kernel Linux implementa em si uma solução de acesso à GPIO atraves de um modelo de criação e consumo de GPIO. Os drivers de criação são drivers como o controlador de GPIO que será detalhado nesta página, os consumidores são os drivers como sensores que utilizam estas linhas GPIO.
Dentro do kernel Linux existe uma estrutura de alocação e registradores dos pinos GPIO chamado gpiolib, esta estrutura cobre os drivers em nível de kernel e userspace.
As bibliotecas de espaço de usuário são, até a versão 4.7 do Kernel Linux a <code>sysfs</code> e a partir da versao 4.8 a <code>chardev</code>. Embora a placa Labrador esteja atualmente no Kernel 4.19, ambas ainda são compatíveis e cobriremos o uso das duas interfaces de espaço de usuário.

==Interface sysfs==

Na interface sysfs o usuário tem acesso às GPIO através de arquivos exportados em <code>/sys/class/gpio</code>. Para isso é necessário exportar um arquivo para cada GPIO, configurar a porta e escrever na mesma.

===Identificando o número da GPIO===
No método sysfs utiliza-se o número absoluto das GPIO para exportá-las individualmente. A Labrador possui 5 grupos de GPIO (A, B, C, D e E). Cada um desses possui 32 pinos agrupados, portanto para indicar o valor absoluto do pino temos um offset dado pelo grupo mais o valor do pino, este offset seguem a lógica a seguir:

*A: 0
*B: 32
*C: 64
*D: 96
*E: 128

Portanto se quisermos acessar o pino 3 do header GPIO, no caso seria GPIOE3, portanto devemos exportar o pino GPIO 128+3=131. Isto seria feito com a seguinte linha de terminal:
<pre>$ echo 131 > /sys/class/gpio/export</pre>

=== Configurando a direção do pino ===

Após exportado o pino devemos configurar a direção do mesmo entre input (<code>in</code>) ou output (<code>out</code>). Para isto basta escrever no GPIO exportado o valor requerido. No nosso exemplo colocaremos como output:

<pre>$ echo out > /sys/class/gpio/gpio131/direction</pre>

=== Escrevendo ou lendo no pino ===

Para escrever no pino configurado como output basta enviar o valor para o parâmetro <code>value</code> do pino. No nosso exemplo colocaremos o valor 1 no pino:

<pre>$ echo 1 > /sys/class/gpio/gpio131/value</pre>

Caso o pino seja definido como input basta ler este mesmo arquivo.

<pre>$ cat /sys/class/gpio/gpio131/value</pre>

=== Lendo um parâmetro ===
O comando <code>cat</code> pode ser usado nestes arquivos de parâmetros para ler o que já foi configurado dos pinos ficamos então com os seguinte exemplo completos para configuração do pino GPIOE3 como output em alta e GPIOE2 como input:
<pre>$ echo 131 > /sys/class/gpio/export #Exportando GPIOE3
$ echo out > /sys/class/gpio/gpio131/direction #Definindo como output
$ echo 1 > /sys/class/gpio/gpio131/value #Escrevendo o valor 1
$ cat /sys/class/gpio/gpio131/direction #Lendo a direção do pino
out
$ cat /sys/class/gpio/gpio131/value #Lendo o valor do pino
1
$ echo 130 > /sys/class/gpio/export #Exportando GPIOE2
$ echo in > /sys/class/gpio/gpio130/direction #Definindo como input
$ cat /sys/class/gpio/gpio130/value #Lendo o valor do pino
0
$ cat /sys/class/gpio/gpio130/direction #Lendo a direção do pino
in
</pre>

==Interface chardev==
A interface chardev é a interface padrão do kernel Linux a partir do kernel 4.8 e compatível com a Labrador 64-bits, apesar de esta solução não permitir o uso de comandos padrão do terminal linux para controle da gpio como <code>echo</code> e <code>cat</code> usados anteriormente, esta API utiliza a biblioteca [https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/ libgpiod] que provê uma série de ferramentas para uso em terminal e também para uso em C, com bibliotecas de [https://github.com/brgl/libgpiod/tree/master/bindings vinculações] disponíveis em [https://github.com/brgl/libgpiod/tree/master/bindings/cxx C++] e [https://pypi.org/project/gpio-next/ Python]. A solução chardev é mais simples, elegante e robusta que a sysfs.

Para instalar a biblioteca libgpiod no Debian Buster (10), execute: <pre>sudo apt install gpiod libgpiod-dev libgpiod-doc</pre>

=== Identificando o número da GPIO ===
Para o chardev os diferentes controladores de GPIO possuem pastas diferentes, chamados gpiochip. No caso temos A=0, B=1, C=2, D=3, E=4.
Portanto, os pinos agora serão definidos pelo controlador e pela linha dentro do mesmo.

=== libgpiod no terminal ===
==== gpiodetect ====
Os controladores podem ser identificados com o comando <code>gpiodetect</code> disponível pelo <code>libgpiod</code>
<pre>$ gpiodetect
gpiochip0 [209c000.gpio] (32 lines)
gpiochip1 [20a0000.gpio] (32 lines)
gpiochip2 [20a4000.gpio] (32 lines)
gpiochip3 [20a8000.gpio] (32 lines)
gpiochip4 [20ac000.gpio] (32 lines)</pre>

==== gpioinfo ====
O comando <code>gpioinfo</code> fornece as informações dos pinos de cada controlador, por exemplo para exemplos dos pinos do controlador E:
<pre>$ gpioinfo 0
line 0: unnamed unused input active-high
line 1: unnamed unused input active-high
line 2: unnamed unused input active-high</pre>
No caso, nenhum destes pinos está em utilização.

==== gpioget ====
Os pinos estão configurados como entrada por padrão, para acessar os valores de entrada dos pinos basta utilizar o comando <code>gpioget</code>, no exemplo o pino GPIOE3 (controlador 4, pino 3)
<pre>$ gpioget 4 3
0</pre>

==== gpioset ====
O comando <code>gpioset</code> muda a direção para output e define o valor do mesmo, no exemplo definiremos o GPIOE3 para alto:
<pre>$ gpioset 4 3=1
1</pre>

==== gpiomon ====
Este comando é utilizado para interrupções e eventos, ele monitorará o pino para mudanças e retornará as mudanças encontradas.

<pre>$gpiomon 4 3
event: RISING EDGE offset: 3 timestamp: [ 322.073816438]
event: FALLING EDGE offset: 3 timestamp: [ 323.467289198]
event: RISING EDGE offset: 3 timestamp: [ 324.245127683]</pre>

=== Utilizando chardev em C ===

A API chardev facilita o uso em programas em C, alguns exemplos podem ser encontrados com facilidade, como [https://github.com/starnight/libgpiod-example estes].

Instalando um sistema 64 bits

2023-04-19T18:04:09Z

Augrm: /* 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 [https://downloads.caninosloucos.org/images/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.

Exemplo de uso do dd no Linux: <code>sudo dd if=lab64_v0.7.img of=/dev/mmcblk0p1 bs=8M status=progress</code>

⚠️ Atenção: tome cuidado com o parâmetro <code>of</code>, dependendo do valor poderá apagar ou corromper o seu sistema.

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

2022-10-06T18:37:06Z

Augrm:

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 4Gb

*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 V2.x siga as instruções contidas em [[Instalando um sistema 64 bits]].

== Labrador 32 bits ==
[[Arquivo:recovery.png|thumb|400px|Botão Recovery]]
A instalação deve seguir conforme abaixo:

1. Primeiramente você deve baixar a imagem em [https://downloads.caninosloucos.org/images/labrador_32_bits/ Labrador 32 bits]. Para este procedimento a imagem deverá ser a versão 0.12 ou superior.

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-32bits.sh</code>

8. Aguarde o processo ser finalizado, desligue a Labrador, remova o cartão SD e religue a placa.

Começando com a Labrador

2022-08-24T14:58:26Z

Augrm:

Este artigo busca esclarecer o básico para o uso básico das placas Labrador. Caso você já possua familiaridade com o sistema Debian e com a SBC, o login e senha padrão da placa ao sair da fábrica são:

<pre>login: caninos
senha: caninos </pre>

= 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>

Página principal

2022-08-24T14:50:23Z

Augrm:

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/ faça uma pergunta no fórum].

Caso você esteja com uma placa Labrador e queira começar a utilizá-la, sugiro dar uma olhada no artigo [[Começando com a Labrador]].

== Páginas ==

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

*Caninos Loucos
**[[Abertura do Programa]]
**[[Apresentação do Programa]]
**[[Como contribuir]]
**[[Lista de projetos]]
***[[Tanque/carrinho de controle remoto]]
***[[Thin Client]]
**[[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]]
***[[Labrador 32 bits - Criando uma imagem]]
***[[Labrador 64 bits - Criando uma imagem]]
***Inteligência Artificial
****[[Visão Computacional]]
****[[Tensorflow]]
***[[Programação GPIO]]
***[[Sensores internos]]
***[[MAC de rede]]
***[[Bluetooth]]
***[[Kernel]]
***[[Debug]]
***[[Configurando o Wi-Fi na linha de comando]]
*[[Pulga]]
**[[Programando a Pulga usando RIOT]]
**[[Programando a Pulga usando Mbed Compiler]]

== 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]]

Thin Client

2022-07-07T20:39:43Z

Augrm: /* Atualizando os repositórios */

= Protocolo de comunicação =
Neste tutorial conectaremos a placa Labrador como Thin Client através do protocolo RDP, utilizando a última versão do Debian instalado na placa. Assumimos portanto que você já tenha uma máquina remota para ser acessada pela Labrador e acesso à rede que ela está conectada.

=Preparando a Labrador=
Este tutorial foi feito com a Labradr 32-bits, mas é compatível com os dois sistemas.

==Atualizando os repositórios==

Antes de tudo temos de ter certeza que os repositórios estão atualizados, para isto basta abrir o terminal e rodar o comando abaixo. Isto pode levar alguns minutos.

<code> $ sudo apt update</code>

Se é a primeira vez que a Labrador é ligada é possível que o relógio da mesma não esteja atualizado, neste caso existem duas possibilidades, conectar-se à internet e aguardar para que o relógio sincronize ou forçar a atualização através do comando abaixo (neste exemplo, atualizando para o dia 16 de Agosto de 2021, 13h).

<code> $ sudo ntpdate -u a.ntp.br</code>

== Instalando o Remmina ==
Para acessar nossa máquina remota utilizaremos o [https://remmina.org Remmina] compatível com RDP, SSH, VNC, entre outros. Como comentado anteriormente, utilizaremos o protocolo RDP. Podemos instalar o Remmina e a camada de compatibilidade na Labrador através do comando:

<code> $ sudo apt install remmina remmina-plugin-rdp</code>

Uma vez instalado, rode o comando <code>$ remmina</code> para abrir a interface de usuário do programa.

== Configurando sua conexão ==
Na tela do Remmina, clique em nova conexão ou utilize o atalho CTRL+N para criar a nova conexão.

[[Arquivo:Tela-remmina1.png]]

Coloque as configurações da sua máquina remota na nova janela, dê um nome à sua conexão e clique em "Save". Recomendamos para fins de compatibilidade selecionar a opção "Use client resolution" no campo de resolução. Há diversas possibilidades e configurações a serem exploradas ao criar uma nova conexão, como pedir a senha ao entrar, logar em diferentes usuários na mesma máquina, entre outros. Explore as possibilidades que melhor encaixem com o perfil de seu sistema.

[[Arquivo:Tela-remmina-config.png]]

Sua conexão aparecerá na tela do Remmina, recomendamos que teste antes de seguir os próximos passos.

[[Arquivo:Tela-remmina2.png]]

= Integrando a experiência de usuário =
Para uma experiência mais integrada, recomendamos automatizar o login no sistema principal da caninos e iniciar a conexão RDP automaticamente, seguindo os passos abaixo.

== Automatizando o login da Labrador ==
Para que o login ocorra automaticamente, basta editar o arquivo <code>/etc/lightdm/lightdm.conf</code> na Labrador, neste caso editaremos utilizando o comando abaixo.

<code> $ sudo nano /etc/lightdm/lightdm.conf</code>

Neste arquivo devemos editar as linhas autologin-user e autologin-user-timeout nas configurações [Seat:*] conforme imagem abaixo. Neste caso, utilizando o login padrão da placa <code>caninos</code>.

[[Arquivo:autologin.png]]

Feito isto, ao ligar a placa o login ocorrerá automaticamente.

== Automatizar a inicialização da máquina virtual ==
Para automatizar a inicialização do Thin Client inicialmente deveremos achar o arquivo da conexão criada no Remmina, para isso basta rodar os comandos abaixo para ver todas as conexões criadas. Neste caso temos apenas a conexão criada anteriormente, identificada pelo arquivo <code>1629132345709.remmina</code>.

<code>$ cd .local/share/remmina 
$ ls</code>

[[Arquivo:arquivo-remmina.png]]

Após termos o nome do arquivo, devemos editar o script de inicialização para conectar à essa máquina, para isso devemos editar o arquivo <code>~/.config/lxsession/LXDE/autostart</code> e adicionar a linha <code>@remmina -c [caminho do arquivo .remmina]</code> com o nome de arquivo encontrado anteriormente. Neste caso utilizamos novamente o nano com o comando:

<code> $sudo nano ~/.config/lxsession/LXDE/autostart</code>

[[Arquivo:autostart.png]]

=== Conexão via WiFi ===
Esta configuração acima é recomendada para placas que ficarão conectadas à internet através da conexão ethernet, para placas com conexão WiFi sugerimos aguardar a conexão à internet antes de fazer a conexão. Isso pode ser feito criando um script para inicialização. Uma sugestão para este script seria:

<code>while ! ping 8.8.8.8 -q -c 1; do sleep 0.5; done && remmina -c [caminho do arquivo .remmina]</code>

Neste exemplo criamos este script no arquivo <code>tcstart.sh</code> na home do usuário.

<code>$ touch ~/tcstart.sh 
$ sudo nano ~/tcstart.sh</code>

Após criar o arquivo devemos rodar o comando:

<code>sudo chmod +x ~/tcstart.sh</code>

E finalmente substituir o comando do autostart para <code>@/home/caninos/tcstart.sh</code>

Abertura do Programa

2022-05-10T19:41:43Z

Augrm:

O programa Caninos Loucos desenvolve uma família de Single Board Computers com projeto aberto e livre com o intuito de fomentar o desenvolvimento e aprendizagem de sistemas embarcados no Brasil.
É importante ressaltar que o termo livre não implica em gratuidade, visto que existem custos associados ao desenvolvimento e esforço de engenharia destas tecnologias, principalmente na parte de Hardware. Os benefícios deste modelo são inúmeros, mas em sua essência está a liberdade fundamental a todos os usuários que quiserem desenvolver algo a partir de nossa documentação, dado que contribuam com suas mudanças retornando à comunidade.

O desafio do programa Caninos Loucos é alcançar a abertura do projeto com sustentabilidade. Temos um time de profissionais focados em discutir os próximos passos de abertura e desenvolver soluções em modelos de licenciamento e de sustentabilidade. Alguns destes profissionais tem trabalhado desde os primeiros conceitos do programa, acreditam nesses ideais de hardware e software livre e conseguiram trazer o projeto para onde estamos hoje.

Atualmente já temos boa parte de nosso software aberto e livre, que pode ser encontrado no nosso [https://github.com/caninos-loucos Github], as exceções ao que está disponível lá são binários de propriedade intelectual de terceiros, como desenvolvedores de certos subsistemas de nossas placas. Estas exceções também estão sendo tratadas através de contatos e negociação com as empresas detentoras dessas propriedades intelectuais.
Quanto ao hardware, o processo de abertura segue de maneira mais compassada, este desenvolvimento envolveu grandes investimentos de diferentes fontes e é necessária maior atenção para a sustentabilidade do modelo de desenvolvimento e licenciamento para que possamos manter a equipe de desenvolvimento da Caninos e seguir contribuindo com novos projetos e aperfeiçoar os existentes. Criar um modelo novo como este de abertura sustentável é um processo árduo e custoso, mas que acreditamos ter que ser feito com bastante cuidado mirando não só o momento atual, mas também o futuro sustentável do programa.

Para isso, seguiremos as [[Abertura do Programa#Diretrizes da Política de Abertura da Caninos Louco|diretrizes de abertura]] que determinamos garantirem esta sustentabilidade.

Novas atualizações sobre o desenvolvimento e abertura do projeto serão listadas também nesta página. Caso acredite nestas aspirações e queira ajudar com o projeto, entre em contato conosco ou acesse a página [[Como contribuir]] nesta wiki.

= Diretrizes da Política de Abertura da Caninos Loucos =

Estas diretrizes de licenciamento do projeto Caninos Loucos foram formuladas a fim de disseminar o máximo de informações possível mantendo ainda um fluxo de receitas para manutenção do projeto.

Em linhas gerais a Caninos Loucos segue um modelo de desenvolvimento direto, trabalhando com um núcleo de desenvolvedores. No entanto, reconhecemos que para atingir as metas do programa de disseminação de informação, é necessário uma política de abertura.

Estas políticas reconhecem também que diferentes usuários da tecnologia desenvolvida pela Caninos Loucos terão diferentes necessidades com relação à abertura, assim como partes diferentes do sistema possuem níveis desejáveis de abertura distintos.

Como um exemplo, reconhecemos que categorias como “Educação” e “Comercial” podem ser quebradas em diferentes níveis, no primeiro caso “Ensino Médio”, “Ensino Superior”, “Ensino Superior para Engenharia de Computação” e “Makers” são alguns exemplos. Similarmente, na categoria “Comercial” algumas empresas podem estar confortáveis em compartilhar suas modificações publicamente, enquanto outras não.

Para abarcar estes diferentes níveis de mercado a Caninos Loucos seguirá um modelo de múltiplas licenças, composto por uma licença padrão que fornecida para os desenvolvimentos do projeto e a possibilidade de negociação de outras licenças a serem negociadas de acordo com as necessidades do licenciado.

Outras partes do projeto, como software a nível de sistema operacional, seguirão as práticas de licenciamento originais do próprio software. Por exemplo, mudanças no kernel ou device drivers do serão submetidas aos repositórios do Linux (ou outros kernels, como BSD) de acordo com as estratégias de código aberto destes.

No momento, o programa Caninos Loucos projetou uma família de placas. Cada uma destas placas poderá ter um nível diferente de abertura, mas a intenção é que pelo menos toda a informação necessária para suporte de software nas placas seja disponibilizada.

O Programa Caninos Loucos encoraja o desenvolvimento de placas de expansão ou customizadas, fornecendo toda a documentação de exemplos para este tipo de projeto. Permissão para comercialização, manufatura ou sub-licenciamento destas placas exemplos podem ser negociados.

A Caninos Loucos fornecerá também recursos de engenharia para terceiros que desejem desenvolver suas próprias placas, sob pagamento e licenças. Para estes contratos a licença a ser utilizada será negociada entre as partes envolvidas.

Além disso, apenas placas produzidas pela Caninos Loucos, ou com licença específica, poderão utilizar os nomes e marcas da Caninos Loucos. Qualquer uso dos nomes e marcas registradas pela Caninos Loucos ou qualquer divulgação de compatibilidade com as placas Caninos Loucos sem permissão e homologação prévia não é autorizada. Esta medida busca garantir a compatibilidade e qualidade do programa.

Instalando um sistema 32 bits

2022-04-19T20:54:23Z

Augrm:

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 4Gb

*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 V2.x siga as instruções contidas em [[Instalando um sistema 64 bits]].

== Labrador 32 bits ==
[[Arquivo:recovery.png|thumb|400px|Botão Recovery]]
A instalação deve seguir conforme abaixo:

1. Primeiramente você deve baixar a imagem em [http://downloads.caninosloucos.org/labrador_32_bits/ Labrador 32 bits]. Para este procedimento a imagem deverá ser a versão 0.12 ou superior.

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-32bits.sh</code>

8. Aguarde o processo ser finalizado, desligue a Labrador, remova o cartão SD e religue a placa.

Thin Client

2021-08-16T19:04:41Z

Augrm: /* Conexão via WiFi */

= Protocolo de comunicação =
Neste tutorial conectaremos a placa Labrador como Thin Client através do protocolo RDP, utilizando a última versão do Debian instalado na placa. Assumimos portanto que você já tenha uma máquina remota para ser acessada pela Labrador e acesso à rede que ela está conectada.

=Preparando a Labrador=
Este tutorial foi feito com a Labradr 32-bits, mas é compatível com os dois sistemas.

==Atualizando os repositórios==

Antes de tudo temos de ter certeza que os repositórios estão atualizados, para isto basta abrir o terminal e rodar o comando abaixo. Isto pode levar alguns minutos.

<code> $ sudo apt update</code>

Se é a primeira vez que a Labrador é ligada é possível que o relógio da mesma não esteja atualizado, neste caso existem duas possibilidades, conectar-se à internet e aguardar para que o relógio sincronize ou forçar a atualização através do comando abaixo (neste exemplo, atualizando para o dia 16 de Agosto de 2021, 13h).

<code> $ sudo date -s "16 AUG 2021 13:00:00"</code>

== Instalando o Remmina ==
Para acessar nossa máquina remota utilizaremos o [https://remmina.org Remmina] compatível com RDP, SSH, VNC, entre outros. Como comentado anteriormente, utilizaremos o protocolo RDP. Podemos instalar o Remmina e a camada de compatibilidade na Labrador através do comando:

<code> $ sudo apt install remmina remmina-plugin-rdp</code>

Uma vez instalado, rode o comando <code>$ remmina</code> para abrir a interface de usuário do programa.

== Configurando sua conexão ==
Na tela do Remmina, clique em nova conexão ou utilize o atalho CTRL+N para criar a nova conexão.

[[Arquivo:Tela-remmina1.png]]

Coloque as configurações da sua máquina remota na nova janela, dê um nome à sua conexão e clique em "Save". Recomendamos para fins de compatibilidade selecionar a opção "Use client resolution" no campo de resolução. Há diversas possibilidades e configurações a serem exploradas ao criar uma nova conexão, como pedir a senha ao entrar, logar em diferentes usuários na mesma máquina, entre outros. Explore as possibilidades que melhor encaixem com o perfil de seu sistema.

[[Arquivo:Tela-remmina-config.png]]

Sua conexão aparecerá na tela do Remmina, recomendamos que teste antes de seguir os próximos passos.

[[Arquivo:Tela-remmina2.png]]

= Integrando a experiência de usuário =
Para uma experiência mais integrada, recomendamos automatizar o login no sistema principal da caninos e iniciar a conexão RDP automaticamente, seguindo os passos abaixo.

== Automatizando o login da Labrador ==
Para que o login ocorra automaticamente, basta editar o arquivo <code>/etc/lightdm/lightdm.conf</code> na Labrador, neste caso editaremos utilizando o comando abaixo.

<code> $ sudo nano /etc/lightdm/lightdm.conf</code>

Neste arquivo devemos editar as linhas autologin-user e autologin-user-timeout nas configurações [Seat:*] conforme imagem abaixo. Neste caso, utilizando o login padrão da placa <code>caninos</code>.

[[Arquivo:autologin.png]]

Feito isto, ao ligar a placa o login ocorrerá automaticamente.

== Automatizar a inicialização da máquina virtual ==
Para automatizar a inicialização do Thin Client inicialmente deveremos achar o arquivo da conexão criada no Remmina, para isso basta rodar os comandos abaixo para ver todas as conexões criadas. Neste caso temos apenas a conexão criada anteriormente, identificada pelo arquivo <code>1629132345709.remmina</code>.

<code>$ cd .local/share/remmina 
$ ls</code>

[[Arquivo:arquivo-remmina.png]]

Após termos o nome do arquivo, devemos editar o script de inicialização para conectar à essa máquina, para isso devemos editar o arquivo <code>~/.config/lxsession/LXDE/autostart</code> e adicionar a linha <code>@remmina -c [caminho do arquivo .remmina]</code> com o nome de arquivo encontrado anteriormente. Neste caso utilizamos novamente o nano com o comando:

<code> $sudo nano ~/.config/lxsession/LXDE/autostart</code>

[[Arquivo:autostart.png]]

=== Conexão via WiFi ===
Esta configuração acima é recomendada para placas que ficarão conectadas à internet através da conexão ethernet, para placas com conexão WiFi sugerimos aguardar a conexão à internet antes de fazer a conexão. Isso pode ser feito criando um script para inicialização. Uma sugestão para este script seria:

<code>while ! ping 8.8.8.8 -q -c 1; do sleep 0.5; done && remmina -c [caminho do arquivo .remmina]</code>

Neste exemplo criamos este script no arquivo <code>tcstart.sh</code> na home do usuário.

<code>$ touch ~/tcstart.sh 
$ sudo nano ~/tcstart.sh</code>

Após criar o arquivo devemos rodar o comando:

<code>sudo chmod +x ~/tcstart.sh</code>

E finalmente substituir o comando do autostart para <code>@/home/caninos/tcstart.sh</code>

Thin Client

2021-08-16T19:03:42Z

Augrm: /* Automatizar a inicialização da máquina virtual */

= Protocolo de comunicação =
Neste tutorial conectaremos a placa Labrador como Thin Client através do protocolo RDP, utilizando a última versão do Debian instalado na placa. Assumimos portanto que você já tenha uma máquina remota para ser acessada pela Labrador e acesso à rede que ela está conectada.

=Preparando a Labrador=
Este tutorial foi feito com a Labradr 32-bits, mas é compatível com os dois sistemas.

==Atualizando os repositórios==

Antes de tudo temos de ter certeza que os repositórios estão atualizados, para isto basta abrir o terminal e rodar o comando abaixo. Isto pode levar alguns minutos.

<code> $ sudo apt update</code>

Se é a primeira vez que a Labrador é ligada é possível que o relógio da mesma não esteja atualizado, neste caso existem duas possibilidades, conectar-se à internet e aguardar para que o relógio sincronize ou forçar a atualização através do comando abaixo (neste exemplo, atualizando para o dia 16 de Agosto de 2021, 13h).

<code> $ sudo date -s "16 AUG 2021 13:00:00"</code>

== Instalando o Remmina ==
Para acessar nossa máquina remota utilizaremos o [https://remmina.org Remmina] compatível com RDP, SSH, VNC, entre outros. Como comentado anteriormente, utilizaremos o protocolo RDP. Podemos instalar o Remmina e a camada de compatibilidade na Labrador através do comando:

<code> $ sudo apt install remmina remmina-plugin-rdp</code>

Uma vez instalado, rode o comando <code>$ remmina</code> para abrir a interface de usuário do programa.

== Configurando sua conexão ==
Na tela do Remmina, clique em nova conexão ou utilize o atalho CTRL+N para criar a nova conexão.

[[Arquivo:Tela-remmina1.png]]

Coloque as configurações da sua máquina remota na nova janela, dê um nome à sua conexão e clique em "Save". Recomendamos para fins de compatibilidade selecionar a opção "Use client resolution" no campo de resolução. Há diversas possibilidades e configurações a serem exploradas ao criar uma nova conexão, como pedir a senha ao entrar, logar em diferentes usuários na mesma máquina, entre outros. Explore as possibilidades que melhor encaixem com o perfil de seu sistema.

[[Arquivo:Tela-remmina-config.png]]

Sua conexão aparecerá na tela do Remmina, recomendamos que teste antes de seguir os próximos passos.

[[Arquivo:Tela-remmina2.png]]

= Integrando a experiência de usuário =
Para uma experiência mais integrada, recomendamos automatizar o login no sistema principal da caninos e iniciar a conexão RDP automaticamente, seguindo os passos abaixo.

== Automatizando o login da Labrador ==
Para que o login ocorra automaticamente, basta editar o arquivo <code>/etc/lightdm/lightdm.conf</code> na Labrador, neste caso editaremos utilizando o comando abaixo.

<code> $ sudo nano /etc/lightdm/lightdm.conf</code>

Neste arquivo devemos editar as linhas autologin-user e autologin-user-timeout nas configurações [Seat:*] conforme imagem abaixo. Neste caso, utilizando o login padrão da placa <code>caninos</code>.

[[Arquivo:autologin.png]]

Feito isto, ao ligar a placa o login ocorrerá automaticamente.

== Automatizar a inicialização da máquina virtual ==
Para automatizar a inicialização do Thin Client inicialmente deveremos achar o arquivo da conexão criada no Remmina, para isso basta rodar os comandos abaixo para ver todas as conexões criadas. Neste caso temos apenas a conexão criada anteriormente, identificada pelo arquivo <code>1629132345709.remmina</code>.

<code>$ cd .local/share/remmina 
$ ls</code>

[[Arquivo:arquivo-remmina.png]]

Após termos o nome do arquivo, devemos editar o script de inicialização para conectar à essa máquina, para isso devemos editar o arquivo <code>~/.config/lxsession/LXDE/autostart</code> e adicionar a linha <code>@remmina -c [caminho do arquivo .remmina]</code> com o nome de arquivo encontrado anteriormente. Neste caso utilizamos novamente o nano com o comando:

<code> $sudo nano ~/.config/lxsession/LXDE/autostart</code>

[[Arquivo:autostart.png]]

=== Conexão via WiFi ===
Esta configuração acima é recomendada para placas que ficarão conectadas à internet através da conexão ethernet, para placas com conexão WiFi sugerimos aguardar a conexão à internet antes de fazer a conexão. Isso pode ser feito criando um script para inicialização. Uma sugestão para este script seria:

<code>while ! ping 8.8.8.8 -q -c 1; do sleep 0.5; done && remmina -c [caminho do arquivo .remmina]</code>

Neste exemplo criamos este script no arquivo <code>tcstart.sh</code> na come do usuário.

<code>$ touch ~/tcstart.sh 
$ sudo nano ~/tcstart.sh</code>

Após criar o arquivo devemos rodar o comando:

<code>sudo chmod +x ~/tcstart.sh</code>

E finalmente substituir o comando do autostart para <code>@/home/caninos/tcstart.sh</code>

Thin Client

2021-08-16T18:56:12Z

Augrm: /* Automatizar a inicialização da máquina virtual */

= Protocolo de comunicação =
Neste tutorial conectaremos a placa Labrador como Thin Client através do protocolo RDP, utilizando a última versão do Debian instalado na placa. Assumimos portanto que você já tenha uma máquina remota para ser acessada pela Labrador e acesso à rede que ela está conectada.

=Preparando a Labrador=
Este tutorial foi feito com a Labradr 32-bits, mas é compatível com os dois sistemas.

==Atualizando os repositórios==

Antes de tudo temos de ter certeza que os repositórios estão atualizados, para isto basta abrir o terminal e rodar o comando abaixo. Isto pode levar alguns minutos.

<code> $ sudo apt update</code>

Se é a primeira vez que a Labrador é ligada é possível que o relógio da mesma não esteja atualizado, neste caso existem duas possibilidades, conectar-se à internet e aguardar para que o relógio sincronize ou forçar a atualização através do comando abaixo (neste exemplo, atualizando para o dia 16 de Agosto de 2021, 13h).

<code> $ sudo date -s "16 AUG 2021 13:00:00"</code>

== Instalando o Remmina ==
Para acessar nossa máquina remota utilizaremos o [https://remmina.org Remmina] compatível com RDP, SSH, VNC, entre outros. Como comentado anteriormente, utilizaremos o protocolo RDP. Podemos instalar o Remmina e a camada de compatibilidade na Labrador através do comando:

<code> $ sudo apt install remmina remmina-plugin-rdp</code>

Uma vez instalado, rode o comando <code>$ remmina</code> para abrir a interface de usuário do programa.

== Configurando sua conexão ==
Na tela do Remmina, clique em nova conexão ou utilize o atalho CTRL+N para criar a nova conexão.

[[Arquivo:Tela-remmina1.png]]

Coloque as configurações da sua máquina remota na nova janela, dê um nome à sua conexão e clique em "Save". Recomendamos para fins de compatibilidade selecionar a opção "Use client resolution" no campo de resolução. Há diversas possibilidades e configurações a serem exploradas ao criar uma nova conexão, como pedir a senha ao entrar, logar em diferentes usuários na mesma máquina, entre outros. Explore as possibilidades que melhor encaixem com o perfil de seu sistema.

[[Arquivo:Tela-remmina-config.png]]

Sua conexão aparecerá na tela do Remmina, recomendamos que teste antes de seguir os próximos passos.

[[Arquivo:Tela-remmina2.png]]

= Integrando a experiência de usuário =
Para uma experiência mais integrada, recomendamos automatizar o login no sistema principal da caninos e iniciar a conexão RDP automaticamente, seguindo os passos abaixo.

== Automatizando o login da Labrador ==
Para que o login ocorra automaticamente, basta editar o arquivo <code>/etc/lightdm/lightdm.conf</code> na Labrador, neste caso editaremos utilizando o comando abaixo.

<code> $ sudo nano /etc/lightdm/lightdm.conf</code>

Neste arquivo devemos editar as linhas autologin-user e autologin-user-timeout nas configurações [Seat:*] conforme imagem abaixo. Neste caso, utilizando o login padrão da placa <code>caninos</code>.

[[Arquivo:autologin.png]]

Feito isto, ao ligar a placa o login ocorrerá automaticamente.

== Automatizar a inicialização da máquina virtual ==
Para automatizar a inicialização do Thin Client inicialmente deveremos achar o arquivo da conexão criada no Remmina, para isso basta rodar os comandos abaixo para ver todas as conexões criadas. Neste caso temos apenas a conexão criada anteriormente, identificada pelo arquivo <code>1629132345709.remmina</code>.

<code>$ cd .local/share/remmina 
$ ls</code>

[[Arquivo:arquivo-remmina.png]]

Após termos o nome do arquivo, devemos editar o script de inicialização para conectar à essa máquina, para isso devemos editar o arquivo <code>~/.config/lxsession/LXDE/autostart</code> e adicionar a linha <code>@remmina -c [caminho do arquivo .remmina]</code> com o nome de arquivo encontrado anteriormente. Neste caso utilizamos novamente o nano com o comando:

<code> $sudo nano ~/.config/lxsession/LXDE/autostart</code>

[[Arquivo:autostart.png]]

Esta configuração é recomendada para placas que ficarão conectadas à internet através da conexão ethernet, para placas com conexão WiFi é recomendado um tempo de espera antes da conexão, para que a interface WiFi se conecte antes de abrir a máquina virtual, isso pode ser feito modificando a linha do autostart para:

<code>@while ! ping 8.8.8.8 -q -c 1; do sleep 0.5; done && remmina -c [caminho do arquivo .remmina]</code>

Thin Client

2021-08-16T18:53:53Z

Augrm: /* Automatizar a inicialização da máquina virtual */

= Protocolo de comunicação =
Neste tutorial conectaremos a placa Labrador como Thin Client através do protocolo RDP, utilizando a última versão do Debian instalado na placa. Assumimos portanto que você já tenha uma máquina remota para ser acessada pela Labrador e acesso à rede que ela está conectada.

=Preparando a Labrador=
Este tutorial foi feito com a Labradr 32-bits, mas é compatível com os dois sistemas.

==Atualizando os repositórios==

Antes de tudo temos de ter certeza que os repositórios estão atualizados, para isto basta abrir o terminal e rodar o comando abaixo. Isto pode levar alguns minutos.

<code> $ sudo apt update</code>

Se é a primeira vez que a Labrador é ligada é possível que o relógio da mesma não esteja atualizado, neste caso existem duas possibilidades, conectar-se à internet e aguardar para que o relógio sincronize ou forçar a atualização através do comando abaixo (neste exemplo, atualizando para o dia 16 de Agosto de 2021, 13h).

<code> $ sudo date -s "16 AUG 2021 13:00:00"</code>

== Instalando o Remmina ==
Para acessar nossa máquina remota utilizaremos o [https://remmina.org Remmina] compatível com RDP, SSH, VNC, entre outros. Como comentado anteriormente, utilizaremos o protocolo RDP. Podemos instalar o Remmina e a camada de compatibilidade na Labrador através do comando:

<code> $ sudo apt install remmina remmina-plugin-rdp</code>

Uma vez instalado, rode o comando <code>$ remmina</code> para abrir a interface de usuário do programa.

== Configurando sua conexão ==
Na tela do Remmina, clique em nova conexão ou utilize o atalho CTRL+N para criar a nova conexão.

[[Arquivo:Tela-remmina1.png]]

Coloque as configurações da sua máquina remota na nova janela, dê um nome à sua conexão e clique em "Save". Recomendamos para fins de compatibilidade selecionar a opção "Use client resolution" no campo de resolução. Há diversas possibilidades e configurações a serem exploradas ao criar uma nova conexão, como pedir a senha ao entrar, logar em diferentes usuários na mesma máquina, entre outros. Explore as possibilidades que melhor encaixem com o perfil de seu sistema.

[[Arquivo:Tela-remmina-config.png]]

Sua conexão aparecerá na tela do Remmina, recomendamos que teste antes de seguir os próximos passos.

[[Arquivo:Tela-remmina2.png]]

= Integrando a experiência de usuário =
Para uma experiência mais integrada, recomendamos automatizar o login no sistema principal da caninos e iniciar a conexão RDP automaticamente, seguindo os passos abaixo.

== Automatizando o login da Labrador ==
Para que o login ocorra automaticamente, basta editar o arquivo <code>/etc/lightdm/lightdm.conf</code> na Labrador, neste caso editaremos utilizando o comando abaixo.

<code> $ sudo nano /etc/lightdm/lightdm.conf</code>

Neste arquivo devemos editar as linhas autologin-user e autologin-user-timeout nas configurações [Seat:*] conforme imagem abaixo. Neste caso, utilizando o login padrão da placa <code>caninos</code>.

[[Arquivo:autologin.png]]

Feito isto, ao ligar a placa o login ocorrerá automaticamente.

== Automatizar a inicialização da máquina virtual ==
Para automatizar a inicialização do Thin Client inicialmente deveremos achar o arquivo da conexão criada no Remmina, para isso basta rodar os comandos abaixo para ver todas as conexões criadas. Neste caso temos apenas a conexão criada anteriormente, identificada pelo arquivo <code>1629132345709.remmina</code>.

<code> $ cd .local/share/remmina 
$ ls</code>

[[Arquivo:arquivo-remmina.png]]

Após termos o nome do arquivo, devemos editar o script de inicialização para conectar à essa máquina, para isso devemos editar o arquivo <code>~/.config/lxsession/LXDE/autostart</code> e adicionar a linha <code>@remmina -c [caminho do arquivo .remmina]</code> com o nome de arquivo encontrado anteriormente. Neste caso utilizamos novamente o nano com o comando:

<code> $sudo nano ~/.config/lxsession/LXDE/autostart</code>

[[Arquivo:autostart.png]]

Esta configuração é recomendada para placas que ficarão conectadas à internet através da conexão ethernet, para placas com conexão WiFi é recomendado um tempo de espera antes da conexão, para que a interface WiFi se conecte antes de abrir a máquina virtual, isso pode ser feito modificando a linha do autostart para:

<code>@while ! ping 8.8.8.8 -q -c 1; do sleep 0.5; done && remmina -c [caminho do arquivo .remmina]</code>

Arquivo:Tela-remmina2.png

2021-08-16T18:43:06Z

Augrm: Augrm carregada uma nova versão de Arquivo:Tela-remmina2.png

Página principal

2021-08-16T18:38:56Z

Augrm: /* 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/ faça uma pergunta no fórum].

== Demais Páginas ==

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

*Caninos Loucos
**[[Abertura do Programa]]
**[[Apresentação do Programa]]
**[[Como contribuir]]
**[[Lista de projetos]]
***[[Tanque/carrinho de controle remoto]]
***[[Thin Client]]
**[[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]]
***[[Labrador 32 bits - Criando uma imagem]]
***[[Labrador 64 bits - Criando uma imagem]]
***[[Visão Computacional]]
***[[Programação GPIO]]
****[[Wiring K9]]
***[[Sensores internos]]
***[[MAC de rede]]
***[[Bluetooth]]
***[[Kernel]]
***[[Debug]]
***[[Configurando o Wi-Fi na linha de comando]]
*[[Pulga]]
**[[Programando a Pulga usando Mbed Compiler]]

== 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]]

Arquivo:Autostart.png

2021-08-16T18:37:12Z

Augrm:

Arquivo:Arquivo-remmina.png

2021-08-16T18:37:05Z

Augrm:

Thin Client

2021-08-16T18:36:53Z

Augrm: /* Automatizar a inicialização da máquina virtual */

= Protocolo de comunicação =
Neste tutorial conectaremos a placa Labrador como Thin Client através do protocolo RDP, utilizando a última versão do Debian instalado na placa. Assumimos portanto que você já tenha uma máquina remota para ser acessada pela Labrador e acesso à rede que ela está conectada.

=Preparando a Labrador=
Este tutorial foi feito com a Labradr 32-bits, mas é compatível com os dois sistemas.

==Atualizando os repositórios==

Antes de tudo temos de ter certeza que os repositórios estão atualizados, para isto basta abrir o terminal e rodar o comando abaixo. Isto pode levar alguns minutos.

<code> $ sudo apt update</code>

Se é a primeira vez que a Labrador é ligada é possível que o relógio da mesma não esteja atualizado, neste caso existem duas possibilidades, conectar-se à internet e aguardar para que o relógio sincronize ou forçar a atualização através do comando abaixo (neste exemplo, atualizando para o dia 16 de Agosto de 2021, 13h).

<code> $ sudo date -s "16 AUG 2021 13:00:00"</code>

== Instalando o Remmina ==
Para acessar nossa máquina remota utilizaremos o [https://remmina.org Remmina] compatível com RDP, SSH, VNC, entre outros. Como comentado anteriormente, utilizaremos o protocolo RDP. Podemos instalar o Remmina e a camada de compatibilidade na Labrador através do comando:

<code> $ sudo apt install remmina remmina-plugin-rdp</code>

Uma vez instalado, rode o comando <code>$ remmina</code> para abrir a interface de usuário do programa.

== Configurando sua conexão ==
Na tela do Remmina, clique em nova conexão ou utilize o atalho CTRL+N para criar a nova conexão.

[[Arquivo:Tela-remmina1.png]]

Coloque as configurações da sua máquina remota na nova janela, dê um nome à sua conexão e clique em "Save". Recomendamos para fins de compatibilidade selecionar a opção "Use client resolution" no campo de resolução. Há diversas possibilidades e configurações a serem exploradas ao criar uma nova conexão, como pedir a senha ao entrar, logar em diferentes usuários na mesma máquina, entre outros. Explore as possibilidades que melhor encaixem com o perfil de seu sistema.

[[Arquivo:Tela-remmina-config.png]]

Sua conexão aparecerá na tela do Remmina, recomendamos que teste antes de seguir os próximos passos.

[[Arquivo:Tela-remmina2.png]]

= Integrando a experiência de usuário =
Para uma experiência mais integrada, recomendamos automatizar o login no sistema principal da caninos e iniciar a conexão RDP automaticamente, seguindo os passos abaixo.

== Automatizando o login da Labrador ==
Para que o login ocorra automaticamente, basta editar o arquivo <code>/etc/lightdm/lightdm.conf</code> na Labrador, neste caso editaremos utilizando o comando abaixo.

<code> $ sudo nano /etc/lightdm/lightdm.conf</code>

Neste arquivo devemos editar as linhas autologin-user e autologin-user-timeout nas configurações [Seat:*] conforme imagem abaixo. Neste caso, utilizando o login padrão da placa <code>caninos</code>.

[[Arquivo:autologin.png]]

Feito isto, ao ligar a placa o login ocorrerá automaticamente.

== Automatizar a inicialização da máquina virtual ==
Para automatizar a inicialização do Thin Client inicialmente deveremos achar o arquivo da conexão criada no Remmina, para isso basta rodar os comandos abaixo para ver todas as conexões criadas. Neste caso temos apenas a conexão criada anteriormente, identificada pelo arquivo <code>1629132345709.remmina</code>.

<code> $ cd .local/share/remmina
$ ls</code>

[[Arquivo:arquivo-remmina.png]]

Após termos o nome do arquivo, devemos editar o script de inicialização para conectar à essa máquina, para isso devemos editar o arquivo <code>~/.config/lxsession/LXDE/autostart</code> e adicionar a linha <code>@remmina -c [caminho do arquivo .remmina]</code> com o nome de arquivo encontrado anteriormente. Neste caso utilizamos novamente o nano com o comando:

<code> $sudo nano ~/.config/lxsession/LXDE/autostart</code>

[[Arquivo:autostart.png]]

Esta configuração é recomendada para placas que ficarão conectadas à internet através da conexão ethernet, para placas com conexão WiFi é recomendado um tempo de espera antes da conexão, para que a interface WiFi se conecte antes de abrir a máquina virtual, isso pode ser feito modificando a linha do autostart para:

<code>@while ! ping 8.8.8.8 -q -c 1; do sleep 0.5; done && remmina -c [caminho do arquivo .remmina]</code>

Arquivo:Autologin.png

2021-08-16T18:36:14Z

Augrm:

Thin Client

2021-08-16T18:36:05Z

Augrm: /* Automatizando o login da Labrador */

= Protocolo de comunicação =
Neste tutorial conectaremos a placa Labrador como Thin Client através do protocolo RDP, utilizando a última versão do Debian instalado na placa. Assumimos portanto que você já tenha uma máquina remota para ser acessada pela Labrador e acesso à rede que ela está conectada.

=Preparando a Labrador=
Este tutorial foi feito com a Labradr 32-bits, mas é compatível com os dois sistemas.

==Atualizando os repositórios==

Antes de tudo temos de ter certeza que os repositórios estão atualizados, para isto basta abrir o terminal e rodar o comando abaixo. Isto pode levar alguns minutos.

<code> $ sudo apt update</code>

Se é a primeira vez que a Labrador é ligada é possível que o relógio da mesma não esteja atualizado, neste caso existem duas possibilidades, conectar-se à internet e aguardar para que o relógio sincronize ou forçar a atualização através do comando abaixo (neste exemplo, atualizando para o dia 16 de Agosto de 2021, 13h).

<code> $ sudo date -s "16 AUG 2021 13:00:00"</code>

== Instalando o Remmina ==
Para acessar nossa máquina remota utilizaremos o [https://remmina.org Remmina] compatível com RDP, SSH, VNC, entre outros. Como comentado anteriormente, utilizaremos o protocolo RDP. Podemos instalar o Remmina e a camada de compatibilidade na Labrador através do comando:

<code> $ sudo apt install remmina remmina-plugin-rdp</code>

Uma vez instalado, rode o comando <code>$ remmina</code> para abrir a interface de usuário do programa.

== Configurando sua conexão ==
Na tela do Remmina, clique em nova conexão ou utilize o atalho CTRL+N para criar a nova conexão.

[[Arquivo:Tela-remmina1.png]]

Coloque as configurações da sua máquina remota na nova janela, dê um nome à sua conexão e clique em "Save". Recomendamos para fins de compatibilidade selecionar a opção "Use client resolution" no campo de resolução. Há diversas possibilidades e configurações a serem exploradas ao criar uma nova conexão, como pedir a senha ao entrar, logar em diferentes usuários na mesma máquina, entre outros. Explore as possibilidades que melhor encaixem com o perfil de seu sistema.

[[Arquivo:Tela-remmina-config.png]]

Sua conexão aparecerá na tela do Remmina, recomendamos que teste antes de seguir os próximos passos.

[[Arquivo:Tela-remmina2.png]]

= Integrando a experiência de usuário =
Para uma experiência mais integrada, recomendamos automatizar o login no sistema principal da caninos e iniciar a conexão RDP automaticamente, seguindo os passos abaixo.

== Automatizando o login da Labrador ==
Para que o login ocorra automaticamente, basta editar o arquivo <code>/etc/lightdm/lightdm.conf</code> na Labrador, neste caso editaremos utilizando o comando abaixo.

<code> $ sudo nano /etc/lightdm/lightdm.conf</code>

Neste arquivo devemos editar as linhas autologin-user e autologin-user-timeout nas configurações [Seat:*] conforme imagem abaixo. Neste caso, utilizando o login padrão da placa <code>caninos</code>.

[[Arquivo:autologin.png]]

Feito isto, ao ligar a placa o login ocorrerá automaticamente.

== Automatizar a inicialização da máquina virtual ==
Para automatizar a inicialização do Thin Client inicialmente deveremos achar o arquivo da conexão criada no Remmina, para isso basta rodar os comandos abaixo para ver todas as conexões criadas. Neste caso temos apenas a conexão criada anteriormente, identificada pelo arquivo <code>1629132345709.remmina</code>.

<code> $ cd .local/share/remmina
$ ls</code>

Após termos o nome do arquivo, devemos editar o script de inicialização para conectar à essa máquina, para isso devemos editar o arquivo <code>~/.config/lxsession/LXDE/autostart</code> e adicionar a linha <code>@remmina -c [caminho do arquivo .remmina]</code> com o nome de arquivo encontrado anteriormente. Neste caso utilizamos novamente o nano com o comando:

<code> $sudo nano ~/.config/lxsession/LXDE/autostart</code>

Esta configuração é recomendada para placas que ficarão conectadas à internet através da conexão ethernet, para placas com conexão WiFi é recomendado um tempo de espera antes da conexão, para que a interface WiFi se conecte antes de abrir a máquina virtual, isso pode ser feito modificando a linha do autostart para:

<code>@while ! ping 8.8.8.8 -q -c 1; do sleep 0.5; done && remmina -c [caminho do arquivo .remmina]</code>

Thin Client

2021-08-16T18:35:21Z

Augrm: /* Configurando sua conexão */

= Protocolo de comunicação =
Neste tutorial conectaremos a placa Labrador como Thin Client através do protocolo RDP, utilizando a última versão do Debian instalado na placa. Assumimos portanto que você já tenha uma máquina remota para ser acessada pela Labrador e acesso à rede que ela está conectada.

=Preparando a Labrador=
Este tutorial foi feito com a Labradr 32-bits, mas é compatível com os dois sistemas.

==Atualizando os repositórios==

Antes de tudo temos de ter certeza que os repositórios estão atualizados, para isto basta abrir o terminal e rodar o comando abaixo. Isto pode levar alguns minutos.

<code> $ sudo apt update</code>

Se é a primeira vez que a Labrador é ligada é possível que o relógio da mesma não esteja atualizado, neste caso existem duas possibilidades, conectar-se à internet e aguardar para que o relógio sincronize ou forçar a atualização através do comando abaixo (neste exemplo, atualizando para o dia 16 de Agosto de 2021, 13h).

<code> $ sudo date -s "16 AUG 2021 13:00:00"</code>

== Instalando o Remmina ==
Para acessar nossa máquina remota utilizaremos o [https://remmina.org Remmina] compatível com RDP, SSH, VNC, entre outros. Como comentado anteriormente, utilizaremos o protocolo RDP. Podemos instalar o Remmina e a camada de compatibilidade na Labrador através do comando:

<code> $ sudo apt install remmina remmina-plugin-rdp</code>

Uma vez instalado, rode o comando <code>$ remmina</code> para abrir a interface de usuário do programa.

== Configurando sua conexão ==
Na tela do Remmina, clique em nova conexão ou utilize o atalho CTRL+N para criar a nova conexão.

[[Arquivo:Tela-remmina1.png]]

Coloque as configurações da sua máquina remota na nova janela, dê um nome à sua conexão e clique em "Save". Recomendamos para fins de compatibilidade selecionar a opção "Use client resolution" no campo de resolução. Há diversas possibilidades e configurações a serem exploradas ao criar uma nova conexão, como pedir a senha ao entrar, logar em diferentes usuários na mesma máquina, entre outros. Explore as possibilidades que melhor encaixem com o perfil de seu sistema.

[[Arquivo:Tela-remmina-config.png]]

Sua conexão aparecerá na tela do Remmina, recomendamos que teste antes de seguir os próximos passos.

[[Arquivo:Tela-remmina2.png]]

= Integrando a experiência de usuário =
Para uma experiência mais integrada, recomendamos automatizar o login no sistema principal da caninos e iniciar a conexão RDP automaticamente, seguindo os passos abaixo.

== Automatizando o login da Labrador ==
Para que o login ocorra automaticamente, basta editar o arquivo <code>/etc/lightdm/lightdm.conf</code> na Labrador, neste caso editaremos utilizando o comando abaixo.

<code> $ sudo nano /etc/lightdm/lightdm.conf</code>

Neste arquivo devemos editar as linhas autologin-user e autologin-user-timeout nas configurações [Seat:*] conforme imagem abaixo. Neste caso, utilizando o login padrão da placa <code>caninos</code>.

Feito isto, ao ligar a placa o login ocorrerá automaticamente.

== Automatizar a inicialização da máquina virtual ==
Para automatizar a inicialização do Thin Client inicialmente deveremos achar o arquivo da conexão criada no Remmina, para isso basta rodar os comandos abaixo para ver todas as conexões criadas. Neste caso temos apenas a conexão criada anteriormente, identificada pelo arquivo <code>1629132345709.remmina</code>.

<code> $ cd .local/share/remmina
$ ls</code>

Após termos o nome do arquivo, devemos editar o script de inicialização para conectar à essa máquina, para isso devemos editar o arquivo <code>~/.config/lxsession/LXDE/autostart</code> e adicionar a linha <code>@remmina -c [caminho do arquivo .remmina]</code> com o nome de arquivo encontrado anteriormente. Neste caso utilizamos novamente o nano com o comando:

<code> $sudo nano ~/.config/lxsession/LXDE/autostart</code>

Esta configuração é recomendada para placas que ficarão conectadas à internet através da conexão ethernet, para placas com conexão WiFi é recomendado um tempo de espera antes da conexão, para que a interface WiFi se conecte antes de abrir a máquina virtual, isso pode ser feito modificando a linha do autostart para:

<code>@while ! ping 8.8.8.8 -q -c 1; do sleep 0.5; done && remmina -c [caminho do arquivo .remmina]</code>

Arquivo:Tela-remmina2.png

2021-08-16T18:35:05Z

Augrm:

Arquivo:Tela-remmina-config.png

2021-08-16T18:34:56Z

Augrm:

Arquivo:Tela-remmina1.png

2021-08-16T18:34:41Z

Augrm:

Thin Client

2021-08-16T18:31:27Z

Augrm: /* Configurando sua conexão */

= Protocolo de comunicação =
Neste tutorial conectaremos a placa Labrador como Thin Client através do protocolo RDP, utilizando a última versão do Debian instalado na placa. Assumimos portanto que você já tenha uma máquina remota para ser acessada pela Labrador e acesso à rede que ela está conectada.

=Preparando a Labrador=
Este tutorial foi feito com a Labradr 32-bits, mas é compatível com os dois sistemas.

==Atualizando os repositórios==

Antes de tudo temos de ter certeza que os repositórios estão atualizados, para isto basta abrir o terminal e rodar o comando abaixo. Isto pode levar alguns minutos.

<code> $ sudo apt update</code>

Se é a primeira vez que a Labrador é ligada é possível que o relógio da mesma não esteja atualizado, neste caso existem duas possibilidades, conectar-se à internet e aguardar para que o relógio sincronize ou forçar a atualização através do comando abaixo (neste exemplo, atualizando para o dia 16 de Agosto de 2021, 13h).

<code> $ sudo date -s "16 AUG 2021 13:00:00"</code>

== Instalando o Remmina ==
Para acessar nossa máquina remota utilizaremos o [https://remmina.org Remmina] compatível com RDP, SSH, VNC, entre outros. Como comentado anteriormente, utilizaremos o protocolo RDP. Podemos instalar o Remmina e a camada de compatibilidade na Labrador através do comando:

<code> $ sudo apt install remmina remmina-plugin-rdp</code>

Uma vez instalado, rode o comando <code>$ remmina</code> para abrir a interface de usuário do programa.

== Configurando sua conexão ==
Na tela do Remmina, clique em nova conexão ou utilize o atalho CTRL+N para criar a nova conexão.

[[Arquivo:Tela-remmina1.jpg]]

Coloque as configurações da sua máquina remota na nova janela, dê um nome à sua conexão e clique em "Save". Recomendamos para fins de compatibilidade selecionar a opção "Use client resolution" no campo de resolução. Há diversas possibilidades e configurações a serem exploradas ao criar uma nova conexão, como pedir a senha ao entrar, logar em diferentes usuários na mesma máquina, entre outros. Explore as possibilidades que melhor encaixem com o perfil de seu sistema.

[[Arquivo:Tela-remmina-config.jpg]]

Sua conexão aparecerá na tela do Remmina, recomendamos que teste antes de seguir os próximos passos.

[[Arquivo:Tela-remmina2.jpg]]

= Integrando a experiência de usuário =
Para uma experiência mais integrada, recomendamos automatizar o login no sistema principal da caninos e iniciar a conexão RDP automaticamente, seguindo os passos abaixo.

== Automatizando o login da Labrador ==
Para que o login ocorra automaticamente, basta editar o arquivo <code>/etc/lightdm/lightdm.conf</code> na Labrador, neste caso editaremos utilizando o comando abaixo.

<code> $ sudo nano /etc/lightdm/lightdm.conf</code>

Neste arquivo devemos editar as linhas autologin-user e autologin-user-timeout nas configurações [Seat:*] conforme imagem abaixo. Neste caso, utilizando o login padrão da placa <code>caninos</code>.

Feito isto, ao ligar a placa o login ocorrerá automaticamente.

== Automatizar a inicialização da máquina virtual ==
Para automatizar a inicialização do Thin Client inicialmente deveremos achar o arquivo da conexão criada no Remmina, para isso basta rodar os comandos abaixo para ver todas as conexões criadas. Neste caso temos apenas a conexão criada anteriormente, identificada pelo arquivo <code>1629132345709.remmina</code>.

<code> $ cd .local/share/remmina
$ ls</code>

Após termos o nome do arquivo, devemos editar o script de inicialização para conectar à essa máquina, para isso devemos editar o arquivo <code>~/.config/lxsession/LXDE/autostart</code> e adicionar a linha <code>@remmina -c [caminho do arquivo .remmina]</code> com o nome de arquivo encontrado anteriormente. Neste caso utilizamos novamente o nano com o comando:

<code> $sudo nano ~/.config/lxsession/LXDE/autostart</code>

Esta configuração é recomendada para placas que ficarão conectadas à internet através da conexão ethernet, para placas com conexão WiFi é recomendado um tempo de espera antes da conexão, para que a interface WiFi se conecte antes de abrir a máquina virtual, isso pode ser feito modificando a linha do autostart para:

<code>@while ! ping 8.8.8.8 -q -c 1; do sleep 0.5; done && remmina -c [caminho do arquivo .remmina]</code>

Thin Client

2021-08-16T18:02:04Z

Augrm: /* Automatizar a inicialização da máquina virtual */

= Protocolo de comunicação =
Neste tutorial conectaremos a placa Labrador como Thin Client através do protocolo RDP, utilizando a última versão do Debian instalado na placa. Assumimos portanto que você já tenha uma máquina remota para ser acessada pela Labrador e acesso à rede que ela está conectada.

=Preparando a Labrador=
Este tutorial foi feito com a Labradr 32-bits, mas é compatível com os dois sistemas.

==Atualizando os repositórios==

Antes de tudo temos de ter certeza que os repositórios estão atualizados, para isto basta abrir o terminal e rodar o comando abaixo. Isto pode levar alguns minutos.

<code> $ sudo apt update</code>

Se é a primeira vez que a Labrador é ligada é possível que o relógio da mesma não esteja atualizado, neste caso existem duas possibilidades, conectar-se à internet e aguardar para que o relógio sincronize ou forçar a atualização através do comando abaixo (neste exemplo, atualizando para o dia 16 de Agosto de 2021, 13h).

<code> $ sudo date -s "16 AUG 2021 13:00:00"</code>

== Instalando o Remmina ==
Para acessar nossa máquina remota utilizaremos o [https://remmina.org Remmina] compatível com RDP, SSH, VNC, entre outros. Como comentado anteriormente, utilizaremos o protocolo RDP. Podemos instalar o Remmina e a camada de compatibilidade na Labrador através do comando:

<code> $ sudo apt install remmina remmina-plugin-rdp</code>

Uma vez instalado, rode o comando <code>$ remmina</code> para abrir a interface de usuário do programa.

== Configurando sua conexão ==
Na tela do Remmina, clique em nova conexão ou utilize o atalho CTRL+N para criar a nova conexão.

Coloque as configurações da sua máquina remota na nova janela, dê um nome à sua conexão e clique em "Save". Recomendamos para fins de compatibilidade selecionar a opção "Use client resolution" no campo de resolução. Há diversas possibilidades e configurações a serem exploradas ao criar uma nova conexão, como pedir a senha ao entrar, logar em diferentes usuários na mesma máquina, entre outros. Explore as possibilidades que melhor encaixem com o perfil de seu sistema.

Sua conexão aparecerá na tela do Remmina, recomendamos que teste antes de seguir os próximos passos.

= Integrando a experiência de usuário =
Para uma experiência mais integrada, recomendamos automatizar o login no sistema principal da caninos e iniciar a conexão RDP automaticamente, seguindo os passos abaixo.

== Automatizando o login da Labrador ==
Para que o login ocorra automaticamente, basta editar o arquivo <code>/etc/lightdm/lightdm.conf</code> na Labrador, neste caso editaremos utilizando o comando abaixo.

<code> $ sudo nano /etc/lightdm/lightdm.conf</code>

Neste arquivo devemos editar as linhas autologin-user e autologin-user-timeout nas configurações [Seat:*] conforme imagem abaixo. Neste caso, utilizando o login padrão da placa <code>caninos</code>.

Feito isto, ao ligar a placa o login ocorrerá automaticamente.

== Automatizar a inicialização da máquina virtual ==
Para automatizar a inicialização do Thin Client inicialmente deveremos achar o arquivo da conexão criada no Remmina, para isso basta rodar os comandos abaixo para ver todas as conexões criadas. Neste caso temos apenas a conexão criada anteriormente, identificada pelo arquivo <code>1629132345709.remmina</code>.

<code> $ cd .local/share/remmina
$ ls</code>

Após termos o nome do arquivo, devemos editar o script de inicialização para conectar à essa máquina, para isso devemos editar o arquivo <code>~/.config/lxsession/LXDE/autostart</code> e adicionar a linha <code>@remmina -c [caminho do arquivo .remmina]</code> com o nome de arquivo encontrado anteriormente. Neste caso utilizamos novamente o nano com o comando:

<code> $sudo nano ~/.config/lxsession/LXDE/autostart</code>

Esta configuração é recomendada para placas que ficarão conectadas à internet através da conexão ethernet, para placas com conexão WiFi é recomendado um tempo de espera antes da conexão, para que a interface WiFi se conecte antes de abrir a máquina virtual, isso pode ser feito modificando a linha do autostart para:

<code>@while ! ping 8.8.8.8 -q -c 1; do sleep 0.5; done && remmina -c [caminho do arquivo .remmina]</code>

Thin Client

2021-08-16T17:55:25Z

Augrm: /* Automatizar a inicialização da máquina virtual */

= Protocolo de comunicação =
Neste tutorial conectaremos a placa Labrador como Thin Client através do protocolo RDP, utilizando a última versão do Debian instalado na placa. Assumimos portanto que você já tenha uma máquina remota para ser acessada pela Labrador e acesso à rede que ela está conectada.

=Preparando a Labrador=
Este tutorial foi feito com a Labradr 32-bits, mas é compatível com os dois sistemas.

==Atualizando os repositórios==

Antes de tudo temos de ter certeza que os repositórios estão atualizados, para isto basta abrir o terminal e rodar o comando abaixo. Isto pode levar alguns minutos.

<code> $ sudo apt update</code>

Se é a primeira vez que a Labrador é ligada é possível que o relógio da mesma não esteja atualizado, neste caso existem duas possibilidades, conectar-se à internet e aguardar para que o relógio sincronize ou forçar a atualização através do comando abaixo (neste exemplo, atualizando para o dia 16 de Agosto de 2021, 13h).

<code> $ sudo date -s "16 AUG 2021 13:00:00"</code>

== Instalando o Remmina ==
Para acessar nossa máquina remota utilizaremos o [https://remmina.org Remmina] compatível com RDP, SSH, VNC, entre outros. Como comentado anteriormente, utilizaremos o protocolo RDP. Podemos instalar o Remmina e a camada de compatibilidade na Labrador através do comando:

<code> $ sudo apt install remmina remmina-plugin-rdp</code>

Uma vez instalado, rode o comando <code>$ remmina</code> para abrir a interface de usuário do programa.

== Configurando sua conexão ==
Na tela do Remmina, clique em nova conexão ou utilize o atalho CTRL+N para criar a nova conexão.

Coloque as configurações da sua máquina remota na nova janela, dê um nome à sua conexão e clique em "Save". Recomendamos para fins de compatibilidade selecionar a opção "Use client resolution" no campo de resolução. Há diversas possibilidades e configurações a serem exploradas ao criar uma nova conexão, como pedir a senha ao entrar, logar em diferentes usuários na mesma máquina, entre outros. Explore as possibilidades que melhor encaixem com o perfil de seu sistema.

Sua conexão aparecerá na tela do Remmina, recomendamos que teste antes de seguir os próximos passos.

= Integrando a experiência de usuário =
Para uma experiência mais integrada, recomendamos automatizar o login no sistema principal da caninos e iniciar a conexão RDP automaticamente, seguindo os passos abaixo.

== Automatizando o login da Labrador ==
Para que o login ocorra automaticamente, basta editar o arquivo <code>/etc/lightdm/lightdm.conf</code> na Labrador, neste caso editaremos utilizando o comando abaixo.

<code> $ sudo nano /etc/lightdm/lightdm.conf</code>

Neste arquivo devemos editar as linhas autologin-user e autologin-user-timeout nas configurações [Seat:*] conforme imagem abaixo. Neste caso, utilizando o login padrão da placa <code>caninos</code>.

Feito isto, ao ligar a placa o login ocorrerá automaticamente.

== Automatizar a inicialização da máquina virtual ==
Para automatizar a inicialização do Thin Client inicialmente deveremos achar o arquivo da conexão criada no Remmina, para isso basta rodar os comandos abaixo para ver todas as conexões criadas. Neste caso temos apenas a conexão criada anteriormente, identificada pelo arquivo <code>1629132345709.remmina</code>.

<code> $ cd .local/share/remmina
$ ls</code>

Após termos o nome do arquivo, devemos editar o script de inicialização para conectar à essa máquina, para isso devemos editar o arquivo <code>~/.config/lxsession/LXDE/autostart</code> e adicionar a linha <code>@remmina -c [caminho do arquivo .remmina]</code> com o nome de arquivo encontrado anteriormente. Neste caso utilizamos novamente o nano com o comando:

<code> $sudo nano ~/.config/lxsession/LXDE/autostart</code>

Esta configuração é recomendada para placas que ficarão conectadas à internet através da conexão ethernet, para placas com conexão WiFi é recomendado um tempo de espera antes da conexão, para que a interface WiFi se conecte antes de abrir a máquina virtual, isso pode ser feito modificando a linha do autostart para:

<code>@while ! ping 8.8.8.8 -c 1; do sleep 0.5; done && remmina -c [caminho do arquivo .remmina]</code>

Thin Client

2021-08-16T17:51:26Z

Augrm: /* Automatizar a inicialização da máquina virtual */

= Protocolo de comunicação =
Neste tutorial conectaremos a placa Labrador como Thin Client através do protocolo RDP, utilizando a última versão do Debian instalado na placa. Assumimos portanto que você já tenha uma máquina remota para ser acessada pela Labrador e acesso à rede que ela está conectada.

=Preparando a Labrador=
Este tutorial foi feito com a Labradr 32-bits, mas é compatível com os dois sistemas.

==Atualizando os repositórios==

Antes de tudo temos de ter certeza que os repositórios estão atualizados, para isto basta abrir o terminal e rodar o comando abaixo. Isto pode levar alguns minutos.

<code> $ sudo apt update</code>

Se é a primeira vez que a Labrador é ligada é possível que o relógio da mesma não esteja atualizado, neste caso existem duas possibilidades, conectar-se à internet e aguardar para que o relógio sincronize ou forçar a atualização através do comando abaixo (neste exemplo, atualizando para o dia 16 de Agosto de 2021, 13h).

<code> $ sudo date -s "16 AUG 2021 13:00:00"</code>

== Instalando o Remmina ==
Para acessar nossa máquina remota utilizaremos o [https://remmina.org Remmina] compatível com RDP, SSH, VNC, entre outros. Como comentado anteriormente, utilizaremos o protocolo RDP. Podemos instalar o Remmina e a camada de compatibilidade na Labrador através do comando:

<code> $ sudo apt install remmina remmina-plugin-rdp</code>

Uma vez instalado, rode o comando <code>$ remmina</code> para abrir a interface de usuário do programa.

== Configurando sua conexão ==
Na tela do Remmina, clique em nova conexão ou utilize o atalho CTRL+N para criar a nova conexão.

Coloque as configurações da sua máquina remota na nova janela, dê um nome à sua conexão e clique em "Save". Recomendamos para fins de compatibilidade selecionar a opção "Use client resolution" no campo de resolução. Há diversas possibilidades e configurações a serem exploradas ao criar uma nova conexão, como pedir a senha ao entrar, logar em diferentes usuários na mesma máquina, entre outros. Explore as possibilidades que melhor encaixem com o perfil de seu sistema.

Sua conexão aparecerá na tela do Remmina, recomendamos que teste antes de seguir os próximos passos.

= Integrando a experiência de usuário =
Para uma experiência mais integrada, recomendamos automatizar o login no sistema principal da caninos e iniciar a conexão RDP automaticamente, seguindo os passos abaixo.

== Automatizando o login da Labrador ==
Para que o login ocorra automaticamente, basta editar o arquivo <code>/etc/lightdm/lightdm.conf</code> na Labrador, neste caso editaremos utilizando o comando abaixo.

<code> $ sudo nano /etc/lightdm/lightdm.conf</code>

Neste arquivo devemos editar as linhas autologin-user e autologin-user-timeout nas configurações [Seat:*] conforme imagem abaixo. Neste caso, utilizando o login padrão da placa <code>caninos</code>.

Feito isto, ao ligar a placa o login ocorrerá automaticamente.

== Automatizar a inicialização da máquina virtual ==
Para automatizar a inicialização do Thin Client inicialmente deveremos achar o arquivo da conexão criada no Remmina, para isso basta rodar os comandos abaixo para ver todas as conexões criadas. Neste caso temos apenas a conexão criada anteriormente, identificada pelo arquivo <code>1629132345709.remmina</code>.

<code> $ cd .local/share/remmina
$ ls</code>

Após termos o nome do arquivo, devemos editar o script de inicialização para conectar à essa máquina, para isso devemos editar o arquivo <code>~/.config/lxsession/LXDE/autostart</code> e adicionar a linha <code>@remmina -c [caminho do arquivo .remmina]</code> com o nome de arquivo encontrado anteriormente. Neste caso utilizamos novamente o nano com o comando:

<code> $sudo nano ~/.config/lxsession/LXDE/autostart</code>

Esta configuração é recomendada para placas que ficarão conectadas à internet através da conexão ethernet, para placas com conexão WiFi é recomendado um tempo de espera antes da conexão, para que a interface WiFi se conecte antes de abrir a máquina virtual, isso pode ser feito modificando a linha do autostart para:

<code>@while ! ping 8.8.8.8 -c 1; do sleep 0.5; done && remmina -c [caminho do arquivo .remmina]</code>

Thin Client

2021-08-16T17:42:27Z

Augrm:

= Protocolo de comunicação =
Neste tutorial conectaremos a placa Labrador como Thin Client através do protocolo RDP, utilizando a última versão do Debian instalado na placa. Assumimos portanto que você já tenha uma máquina remota para ser acessada pela Labrador e acesso à rede que ela está conectada.

=Preparando a Labrador=
Este tutorial foi feito com a Labradr 32-bits, mas é compatível com os dois sistemas.

==Atualizando os repositórios==

Antes de tudo temos de ter certeza que os repositórios estão atualizados, para isto basta abrir o terminal e rodar o comando abaixo. Isto pode levar alguns minutos.

<code> $ sudo apt update</code>

Se é a primeira vez que a Labrador é ligada é possível que o relógio da mesma não esteja atualizado, neste caso existem duas possibilidades, conectar-se à internet e aguardar para que o relógio sincronize ou forçar a atualização através do comando abaixo (neste exemplo, atualizando para o dia 16 de Agosto de 2021, 13h).

<code> $ sudo date -s "16 AUG 2021 13:00:00"</code>

== Instalando o Remmina ==
Para acessar nossa máquina remota utilizaremos o [https://remmina.org Remmina] compatível com RDP, SSH, VNC, entre outros. Como comentado anteriormente, utilizaremos o protocolo RDP. Podemos instalar o Remmina e a camada de compatibilidade na Labrador através do comando:

<code> $ sudo apt install remmina remmina-plugin-rdp</code>

Uma vez instalado, rode o comando <code>$ remmina</code> para abrir a interface de usuário do programa.

== Configurando sua conexão ==
Na tela do Remmina, clique em nova conexão ou utilize o atalho CTRL+N para criar a nova conexão.

Coloque as configurações da sua máquina remota na nova janela, dê um nome à sua conexão e clique em "Save". Recomendamos para fins de compatibilidade selecionar a opção "Use client resolution" no campo de resolução. Há diversas possibilidades e configurações a serem exploradas ao criar uma nova conexão, como pedir a senha ao entrar, logar em diferentes usuários na mesma máquina, entre outros. Explore as possibilidades que melhor encaixem com o perfil de seu sistema.

Sua conexão aparecerá na tela do Remmina, recomendamos que teste antes de seguir os próximos passos.

= Integrando a experiência de usuário =
Para uma experiência mais integrada, recomendamos automatizar o login no sistema principal da caninos e iniciar a conexão RDP automaticamente, seguindo os passos abaixo.

== Automatizando o login da Labrador ==
Para que o login ocorra automaticamente, basta editar o arquivo <code>/etc/lightdm/lightdm.conf</code> na Labrador, neste caso editaremos utilizando o comando abaixo.

<code> $ sudo nano /etc/lightdm/lightdm.conf</code>

Neste arquivo devemos editar as linhas autologin-user e autologin-user-timeout nas configurações [Seat:*] conforme imagem abaixo. Neste caso, utilizando o login padrão da placa <code>caninos</code>.

Feito isto, ao ligar a placa o login ocorrerá automaticamente.

== Automatizar a inicialização da máquina virtual ==
Para automatizar a inicialização do Thin Client inicialmente deveremos achar o arquivo da conexão criada no Remmina, para isso basta rodar os comandos abaixo para ver todas as conexões criadas. Neste caso temos apenas a conexão criada anteriormente, identificada pelo arquivo <code>1629132345709.remmina</code>.
<code> $ cd .local/share/remmina
$ ls</code>

Após termos o nome do arquivo, devemos editar o script de inicialização para conectar à essa máquina, para isso devemos editar o arquivo <code>~/.config/lxsession/LXDE/autostart</code> e adicionar a linha <code>@remmina -c [caminho do arquivo .remmina]</code> com o nome de arquivo encontrado anteriormente. Neste caso utilizamos novamente o nano com o comando:

<code> $sudo nano ~/.config/lxsession/LXDE/autostart</code>

Esta configuração é recomendada para placas que ficarão conectadas à internet através da conexão ethernet, para placas com conexão WiFi é recomendado um tempo de espera antes da conexão, para que a interface WiFi se conecte antes de abrir a máquina virtual, isso pode ser feito adicionando a linha <code>@sleep 10</code> antes do commando remmina no autostart, neste caso, 10s foi o suficiente nas nossas configurações WiFi.

Thin Client

2021-08-16T17:07:35Z

Augrm:

Thin Client

2021-08-16T17:03:29Z

Augrm: Criou página com '= Protocolo de comunicação = Neste tutorial conectaremos a placa Labrador como Thin Client através do protocolo RDP, utilizando a última versão do Debian instalado na pla...'

Lista de projetos

2021-08-16T16:25:53Z

Augrm:

Esta página busca listar projetos implementados com a Caninos Loucos Labrador e seus tutoriais.

{| class="wikitable"
! style="font-weight:bold;" | Nome do Projeto
! style="font-weight:bold;" | Imagem de referência
|-
| [[Tanque/carrinho de controle remoto]]
| [[Arquivo:tanque-labrador.jpeg|300px]]
|-
| [[Thin Client]]
|}

Instalando um sistema 32 bits

2021-06-29T18:11:57Z

Augrm:

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/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.

Instalando um sistema 64 bits

2021-06-29T18:11:32Z

Augrm:

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/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.

Abertura do Programa

2021-04-19T19:15:36Z

Augrm:

Página principal

2020-12-10T20:42:30Z

Augrm: /* 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
**[[Abertura do Programa]]
**[[Apresentação do Programa]]
**[[Como contribuir]]
**[[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]]
***[[Labrador 32 bits - Criando uma imagem]]
***[[Labrador 64 bits - Criando uma imagem]]
***[[Visão Computacional]]
***[[Programação GPIO]]
****[[Wiring K9]]
***[[Sensores internos]]
***[[MAC de rede]]
***[[Bluetooth]]
***[[Kernel]]
***[[Debug]]
***[[Configurando o Wi-Fi na linha de comando]]
*[[Pulga]]
**[[Programando a Pulga usando Mbed Compiler]]

== 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-09-03T19:13:11Z

Augrm:

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
**[[Abertura do Programa]]
**[[Apresentação do Programa]]
**[[Como contribuir]]
**[[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]]
***[[Labrador 32 bits - Criando uma imagem]]
***[[Labrador 64 bits - Criando uma imagem]]
***[[Visão Computacional]]
***[[Programação GPIO]]
****[[Wiring K9]]
***[[Sensores internos]]
***[[MAC de rede]]
***[[Bluetooth]]
***[[Kernel]]
***[[Debug]]
*[[Pulga]]
**[[Programando a Pulga usando Mbed Compiler]]

== 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]]

Abertura do Programa

2020-09-02T18:46:41Z

Augrm:

Abertura do Programa

2020-09-02T18:46:14Z

Augrm: Criou página com 'O programa Caninos Loucos desenvolve uma família de Single Board Computers com projeto aberto e livre com o intuito de fomentar o desenvolvimento e aprendizagem de sistemas e...'

Como contribuir

2020-09-02T18:45:24Z

Augrm:

O programa Caninos Loucos é um programa aberto desenvolvido com o intuito de fomentar o desenvolvimento de tecnologia no Brasil, leia mais sobre a [[Abertura do Programa]]. Por esta natureza, o rápido desenvolvimento e melhora dos projetos conta com a colaboração dos usuários de todos os níveis. Caso você queira ajudar também a promover a tecnologia nacional e a melhorar a Caninos Loucos, este guia te ajudará no processo.
= Colaborando com a documentação =
A maneira mais simples de ajudar na Caninos Loucos é colaborar com a documentação da plataforma, tornando-a acessível para um número cada vez maior de usuários. A melhor maneira de ajudar com isto é a manutenção e edição das páginas desta Wiki, nossa equipe se esforça para manter a Wiki atualizada e com o máximo de informações possíveis, no entanto, revisões de artigos e novas páginas sempre são adições importantes.
== Editando a Wiki ==
A plataforma da Wiki é aberta para edição e, portanto, qualquer usuário pode propor mudanças e novos artigos, para tanto, basta criar uma conta clicando na opção “Crie uma conta” no canto superior direito da página.
Para começar a editar basta ir na página à sua escolha e clicar em “Editar” no campo superior direito. A Wiki conta com um editor visual de fácil utilização, mais detalhes podem ser encontrados neste link [https://www.mediawiki.org/wiki/Help:VisualEditor/User_guide/pt-br].
Caso você deseje criar uma nova página pode seguir este exemplo: [[Como criar uma página]]
== Páginas interessantes==
Todas as páginas da Wiki podem ser editadas, mas algumas páginas são bastante interessantes e podem ter uma grande ajuda da comunidade, são elas:
· [[Lista de projetos]] – Esta página lista guias e comentários de projetos realizados com as placas Caninos Loucos, caso você tenha desenvolvido algum projeto, e um lugar legal de compartilhar suas descobertas e ajudar novos usuários.
· [[Sobre o Linux]] – Página com guias para usuários neófitos ao sistema operacional Linux onde podem ser adicionadas funções, aplicativos e comandos úteis para o primeiro contato com o sistema.
· [[Pacotes testados]] – Página com guia dos pacotes Linux testados e funcionando na placa Labrador, bem como pequenos ajustes que podem ser necessários para fazer o pacote rodar no sistema. Adicione nesta página pacotes que você utilizou sem problemas ou mesmo soluções implementadas para certos pacotes.
= Colaborando com o software =
Todo o software da plataforma caninos está disponível no nosso Github [https://github.com/caninos-loucos] para usuários familiarizados com o Github e com o kernel e sistema Linux, esta é uma boa maneira de ajudar no desenvolvimento do projeto.
Os repositórios da Caninos no Github contam com sua própria página de informações, onde você pode se informar sobre como contribuir com o repositório.
== Reportar um bug ou solicitar aprimoramento ==
O Github também conta com a possibilidade de listar problemas encontrados ou características que deveriam ser implementadas no repositório, e esta é nossa principal ferramenta de rastreamento de bugs, para criar este tipo de solicitação, basta criar uma Issue no Github, seguindo este guia [https://help.github.com/pt/github/managing-your-work-on-github/creating-an-issue].
= Ajudar novos usuários: o Fórum Caninos Loucos=
O crescimento da comunidade depende em grande parte da ajuda entre usuários, para facilitar este canal possuímos um fórum [https://forum.caninosloucos.org.br] de discussão onde todos podem solicitar ajudas, tirar dúvidas, conhecer outros usuários da plataforma. Temos um grupo de desenvolvedores no projeto que acompanha o fórum de perto, no entanto, usuários com maior experiência de uso da plataforma podem ajudar tirando dúvidas e esclarecendo questões que podem já ter enfrentado no passado, ajudando a fortalecer a comunidade. O fórum é também uma boa plataforma para conversar diretamente com os desenvolvedores do projeto e acompanhar novidades nas atualizações da plataforma.

==Doações==
Se você tem interesse em investir ou fazer doações para o projeto Caninos Loucos ou se quiser fazer outros tipos de parceria, pode entrar em contato conosco através [https://caninosloucos.org/pt/contact-pt deste formulário].

Labrador 32 bits - Criando uma imagem

2020-07-23T17:27:14Z

Augrm:

Nesta página você encontrará instruções de como criar uma imagem mínima para Labrador 32 bits. Esse processo compreende compilar o bootloader, o Kernel Linux e gerar um sistema de arquivos de uma distribuição GNU/Linux ''Debian-like''. Compreende também os passos para escrever essa imagem em um cartão SD.

Para encontrar a versão mais atualizada dos softwares aqui citados, acesse nosso [http://github.com/caninos-loucos/ Github].

Para a versão 64 bits acesse a seguinte página: [[Labrador 64 bits - Criando uma imagem]]

= Pré-requesitos =

== Bootloader ==
O primeiro passo é obter o bootloader. É possível usar um binário pré-compilado ou compilá-lo a partir do código-fonte, seguindo as instruções da página do [https://github.com/caninos-loucos/labrador-uboot-32 github/labrador-uboot-32].

Ao final desse processo você terá um arquivo ''u-boot-dtb.img'' ou ''u-boot-dtb-no-UART3-console.img''.

Obs.: Se você quer ter a UART3 (/dev/ttyS3) ativada para console de debug, que é o recomendado para a maior parte dos casos, use o ''u-boot-dtb.img''. Caso você tenha intenção de usar o UART3 para alguma outra finalidade, use o ''u-boot-dtb-no-UART3-console.img''.

== Kernel Linux ==
Para obter o kernel, acesse [https://github.com/caninos-loucos/labrador-linux github/labrador-linux]. Novamente aqui você tem a opção de usar binários pré-compilados ou compilá-los a partir do código-fonte, conforme as instruções do arquivo README.md.

Obs.: Se você está fazendo compilação cruzada do kernel, é possível usar o arm-linux-gnueabihf-gcc disponível no repositório do bootloader. Nesse caso adicione o caminho para o compilador ao PATH. Por exemplo, se você fez o clone do u-boot em $HOME:

<pre>$ export PATH=$PATH:$HOME/labrador-uboot-32/toolchain/arm-linux-gnueabihf/bin</pre>

Ao final desse processo você terá:
* kernel.dtb
* uImage
* lib/modules

== Sistema de Arquivos ==

Você pode usar qualquer rootfs compatível com a arquitetura arm. Nesse procedimento descreveremos o processo para criação de um rootfs usando o [https://wiki.debian.org/pt_BR/Debootstrap debootstrap].

'''i) debootstrap primeiro estágio'''

Para gerar um sistema base Debian Buster:
<pre># debootstrap --arch=armhf --foreign buster rootfs</pre>

'''ii) debootstrap segundo estágio'''
<pre>
# cp /usr/bin/qemu-arm-static rootfs/usr/bin
# cp /etc/resolv.conf rootfs/etc
# chroot rootfs
# export LANG=C
# /debootstrap/debootstrap --second-stage
</pre>

'''iii) configurando o repositório de pacotes'''
<pre>
# cat << EOT > /etc/apt/sources.list
deb http://ftp.br.debian.org/debian/ buster main contrib non-free
deb-src http://ftp.br.debian.org/debian/ buster main contrib non-free

deb http://security.debian.org/debian-security buster/updates main contrib non-free
deb-src http://security.debian.org/debian-security buster/updates main contrib non-free

# buster-updates, previously known as 'volatile'
deb http://ftp.br.debian.org/debian/ buster-updates main contrib non-free
deb-src http://ftp.br.debian.org/debian/ buster-updates main contrib non-free
EOT
</pre>

'''iv) instalando pacotes adicionais'''
<pre>
# apt-get update
# apt-get upgrade
# apt-get install sudo
</pre>

'''v) definindo o hostname'''
<pre># echo labrador > /etc/hostname</pre>

'''vi) adiocionar o hostname ao hosts'''

Você deve adicionar o nome definido no passo anterior (''hostname'') ao arquivo /etc/hosts, da seguinte forma:

127.0.1.1 labrador

Ao final seu arquivo /etc/hosts deve se parecer com esse:
<pre>
# cat /etc/hosts
127.0.0.1 localhost
127.0.1.1 labrador
::1 localhost ip6-localhost ip6-loopback
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
</pre>

'''vii) criar um usuário e adicioná-lo ao grupo sudo'''

Criaremos um usuário chamado caninos:
<pre>
# useradd -m caninos
# usermod -aG sudo caninos
</pre>

Definiremos uma senha para esse usuário:
<pre># passwd caninos</pre>

'''viii) demais ajustes'''

Você pode fazer outros ajustes aqui que julgar necessário. Os passos descritos até aqui são os mais essenciais para se ter uma versão mínima em modo texto.

'''ix) finalizando'''
<pre>
# apt-get autoclean
# apt-get clean
</pre>

Para sair do chroot:
<pre># exit</pre>

Limpando:
<pre>
# rm -f rootfs/root/.bash_history rootfs/usr/bin/qemu-arm-static
# cat /dev/null > rootfs/etc/resolv.conf
</pre>

= Gravando o sistema num cartão SD =
'''i) Criar a tabela de partições'''

Obs.: Você deve substituir mmcblkX pelo descritor correto para o seu caso.

<pre>
# parted /dev/mmcblkX
Welcome to GNU Parted! Type 'help' to view a list of commands.
(parted) mklabel gpt
(parted) unit s
(parted) mkpart primary 16384 114687
(parted) mkpart primary 114688 -1
Warning: You requested a partition from 114688s to AAAs (sectors 114688..AAA).
The closest location we can manage is 114688s to BBBs (sectors 114688..BBB).
Is this still acceptable to you?
Yes/No? yes
(parted) print
Model: (file)
Disk /dev/mmcblkX: DDDs
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags:

Number Start End Size File system Name Flags
1 16384s 114687s 98304s primary
2 114688s BBBs CCCs primary

(parted) q
</pre>

'''ii) Gravar o bootloader'''
<pre># dd if=/path/to/u-boot-dtb.img of=/dev/mmcblkX bs=512 seek=66 status=progress</pre>

'''iii) Formatar as partições'''
<pre>
# mkfs.vfat /dev/mmcblkXp1
# mkfs.ext4 /dev/mmcblkXp2
</pre>

'''iv) Gravar o kernel na partição 1'''
<pre>
# mount /dev/mmcblkXp1 /mnt
# cp /path/to/kernel.dtb /mnt
# cp /path/to/uImage /mnt
# cat << EOT > /mnt/uEnv.txt
uenvcmd=setenv ramdisk_addr_r -; setenv os_type linux;
bootargs=clk_ignore_unused selinux=0 scandelay root=/dev/mmcblk0p2 rw console=ttyS3 rootfstype=ext4 console=tty0 loglevel=6 rootwait
EOT
# sync
# umount /mnt
</pre>

'''v) Gravar o rootfs na partição 2'''
<pre>
# mount /dev/mmcblk0p2 /mnt
# cp -rp /path/to/rootfs/* /mnt
# cp -r /path/to/lib/modules /mnt/lib
# sync
# umount /mnt
</pre>

Página principal

2020-07-23T17:27:00Z

Augrm: /* 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]]
**[[Como contribuir]]
**[[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]]
***[[Labrador 32 bits - Criando uma imagem]]
***[[Labrador 64 bits - Criando uma imagem]]
***[[Visão Computacional]]
***[[Programação GPIO]]
****[[Wiring K9]]
***[[Sensores internos]]
***[[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-07-23T17:26:48Z

Augrm: /* 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]]
**[[Como contribuir]]
**[[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]]
***[[Labrador 64 bits - Criando uma imagem]]
***[[Labrador 64 bits - Criando uma imagem]]
***[[Visão Computacional]]
***[[Programação GPIO]]
****[[Wiring K9]]
***[[Sensores internos]]
***[[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]]

Visão Computacional

2020-07-22T19:25:33Z

Augrm: /* Labrador 64-bits */

Uma das ferramentas mais utilizadas para processamento de imagem é o OpenCV, fornecendo diversas funções para manipular imagens e vídeos a fim de realizar os mais variados projetos de visão computacional.

Como o processador da Labrador apresenta uma arquitetura ARM, algumas bibliotecas ainda não foram compiladas para ela, impossibilitando uma instalação simples pelo pip ou pelo apt-get. Para solucionar esse problema, alguns colaboradores disponibilizaram os arquivos necessários e os scripts de instalação.

Este tutorial é funcional para a Labrador 32-bits

== Python 3.7 ==
A Labrador vem inicialmente com a versão 3.7 do Python. Dessa forma, basta baixar o arquivo presente nesse link [https://drive.google.com/open?id=1SPY1kXQx-POSjppYAj1Iea8fBuNez6_W], descompactá-lo em um local que não será deletado e rodar o script por meio do comando:

<code>sudo bash opencv_py37.sh</code>

Ao completar o processo de instalação, reinicie o terminal e em seguida poderá utilizar o OpenCV.

== Outras versões de Python ==
Para poder utilizar outras versões de Python, utilizaremos o pyenv, capaz de gerenciar várias versões de Python ao mesmo tempo. Antes, verifique no nosso Drive as versões de Python para as quais o OpenCV já foi compilado, bastando seguir esse link [https://drive.google.com/drive/folders/19qsq3tuXpTgypKiT0nZ1wC9-ZIlkjxqy]. Se a versão que deseja não se encontra disponível, você deverá seguir pelo caminho mais difícil e demorado, explicado na seção Compilação.

Para instalar o pyenv, siga o tutorial nesse link [https://github.com/pyenv/pyenv#basic-github-checkout].

Obs. 1: Nos passos 2 e 3, substituir <code>bash_profile</code> por <code>bashrc</code>

Obs. 2: No passo de número 6, insira a versão que deseja instalar.

----

Em seguida, faça o download do arquivo <code>minimal.zip</code> à partir do Drive, descomprima e rode o script por meio do comando:

<code>sudo bash opencv.sh</code>

Obs. 1: na linha 1, altere a variável <code>VIRTUALENV_NAME</code> para o nome do seu virtual environment.

== Compilação ==
Se precisar utilizar alguma outra versão do OpenCV ou do Python, poderá utilizar um script de instalação, que fará o download de todos os pacotes necessários. O script está disponível no mesmo Drive de download dos arquivos [https://drive.google.com/drive/folders/19qsq3tuXpTgypKiT0nZ1wC9-ZIlkjxqy].

=Labrador 64-bits=
A Labrador 64-bits conta com todos os pacotes disponíveis no debian arm64, portanto o processo de instalação de ferramentas como OpenCV e Keras é facilitado.

<code>sudo apt install libopencv-dev #instalando Open-CV no sistema

pip3 install opencv-python #instalando biblioteca no Python 3

pip3 install -U --user keras #instalando Keras no Python 3

pip3 install -U --user theano #instalando Theano no Python 3</code>

Para instalar o Tensorflow, disponibilizamos um pacote pré-compilado para a Labrador 64 [https://drive.google.com/file/d/1L1-B588FD7o9UhyT6-gYGnGzDNICMloL/view?usp=sharing neste link]. Para instalar este pacote basta ir na pasta de Download no terminal e rodar
<code>pip3 install tensorflow-1.14.0-cp37-cp37m-linux_aarch64.whl<code>

Visão Computacional

2020-07-22T19:25:02Z

Augrm:

Uma das ferramentas mais utilizadas para processamento de imagem é o OpenCV, fornecendo diversas funções para manipular imagens e vídeos a fim de realizar os mais variados projetos de visão computacional.

Como o processador da Labrador apresenta uma arquitetura ARM, algumas bibliotecas ainda não foram compiladas para ela, impossibilitando uma instalação simples pelo pip ou pelo apt-get. Para solucionar esse problema, alguns colaboradores disponibilizaram os arquivos necessários e os scripts de instalação.

Este tutorial é funcional para a Labrador 32-bits

== Python 3.7 ==
A Labrador vem inicialmente com a versão 3.7 do Python. Dessa forma, basta baixar o arquivo presente nesse link [https://drive.google.com/open?id=1SPY1kXQx-POSjppYAj1Iea8fBuNez6_W], descompactá-lo em um local que não será deletado e rodar o script por meio do comando:

<code>sudo bash opencv_py37.sh</code>

Ao completar o processo de instalação, reinicie o terminal e em seguida poderá utilizar o OpenCV.

== Outras versões de Python ==
Para poder utilizar outras versões de Python, utilizaremos o pyenv, capaz de gerenciar várias versões de Python ao mesmo tempo. Antes, verifique no nosso Drive as versões de Python para as quais o OpenCV já foi compilado, bastando seguir esse link [https://drive.google.com/drive/folders/19qsq3tuXpTgypKiT0nZ1wC9-ZIlkjxqy]. Se a versão que deseja não se encontra disponível, você deverá seguir pelo caminho mais difícil e demorado, explicado na seção Compilação.

Para instalar o pyenv, siga o tutorial nesse link [https://github.com/pyenv/pyenv#basic-github-checkout].

Obs. 1: Nos passos 2 e 3, substituir <code>bash_profile</code> por <code>bashrc</code>

Obs. 2: No passo de número 6, insira a versão que deseja instalar.

----

Em seguida, faça o download do arquivo <code>minimal.zip</code> à partir do Drive, descomprima e rode o script por meio do comando:

<code>sudo bash opencv.sh</code>

Obs. 1: na linha 1, altere a variável <code>VIRTUALENV_NAME</code> para o nome do seu virtual environment.

== Compilação ==
Se precisar utilizar alguma outra versão do OpenCV ou do Python, poderá utilizar um script de instalação, que fará o download de todos os pacotes necessários. O script está disponível no mesmo Drive de download dos arquivos [https://drive.google.com/drive/folders/19qsq3tuXpTgypKiT0nZ1wC9-ZIlkjxqy].

=Labrador 64-bits=
A Labrador 64-bits conta com todos os pacotes disponíveis no debian arm64, portanto o processo de instalação de ferramentas como OpenCV e Keras é facilitado.
<code>sudo apt install libopencv-dev #instalando Open-CV no sistema
pip3 install opencv-python #instalando biblioteca no Python 3
pip3 install -U --user keras #instalando Keras no Python 3
pip3 install -U --user theano #instalando Theano no Python 3</code>

Para instalar o Tensorflow, disponibilizamos um pacote pré-compilado para a Labrador 64 [https://drive.google.com/file/d/1L1-B588FD7o9UhyT6-gYGnGzDNICMloL/view?usp=sharing neste link]. Para instalar este pacote basta ir na pasta de Download no terminal e rodar
<code>pip3 install tensorflow-1.14.0-cp37-cp37m-linux_aarch64.whl<code>

Programação GPIO

2020-07-09T17:36:07Z

Augrm: /* GPIO Labrador 32-bits */

Esta página explica como programar as saídas GPIO (General Purpose Input/Output) da Labrador, que são basicamente pinos nos quais você pode enviar e receber dados. Para facilitar a programação, a placa Labrador segue a interface padrão para userspace para Linux embarcado. O tutorial desta página funciona tanto com a Labrador 32 quanto 64-bits.

Além disso, a placa Labrador 32-bits é compatível com o formato da Raspberry Pi, e possui a biblioteca <code>wiringK9</code>, baseada na wiringPi, também da Raspberry Pi. Mais detalhes desta biblioteca pode ser encontrado nessa página [[Wiring K9]].

== Configuração dos pinos ==

A configuração de pinos para o cabeçalho de GPIO é a seguinte:

=== GPIO Labrador 32-bits ===
[[File:40pinh.png|image|800px|caption Mapeamento do header de 40 pinos.]]

=== GPIO Labrador 64 bits===
{| class="wikitable" style="background-color:#ffffff;"
|- style="background-color:#c0c0c0;"
! Default Function
! colspan="2" | Header Pin
! Default Function
|-
| style="background-color:#efefef;" | VCC
| 1
| 2
| style="background-color:#efefef;" | 5V
|-
| GPIOE3
| 3
| 4
| style="background-color:#efefef;" | 5V
|-
| GPIOE2
| 5
| 6
| style="background-color:#efefef;" | GND
|-
| GPIOB18
| 7
| 8
| UART0_TX
|-
| style="background-color:#efefef;" | GND
| 9
| 10
| UART0_RX
|-
| GPIOC0
| 11
| 12
| GPIOB8
|-
| GPIOC1
| 13
| 14
| style="background-color:#efefef;" | GND
|-
| GPIOC4
| 15
| 16
| GPIOD30
|-
| style="background-color:#efefef;" | VCC
| 17
| 18
| GPIOC6
|-
| TWI3_SDA
| 19
| 20
| style="background-color:#efefef;" | GND
|-
| GPIOC24
| 21
| 22
| GPIOC5
|-
| TWI3_SCK
| 23
| 24
| GPIOC23
|-
| style="background-color:#efefef;" | GND
| 25
| 26
| GPIOB19
|-
| GPIOB16
| 27
| 28
| GPIOB14
|-
| GPIOB15
| 29
| 30
| style="background-color:#efefef;" | GND
|-
| GPIOB10
| 31
| 32
| GPIOB13
|-
| GPIOB0
| 33
| 34
| style="background-color:#efefef;" | GND
|-
| GPIOB1
| 35
| 36
| GPIOA28
|-
| GPIOB2
| 37
| 38
| RESERVED
|-
| style="background-color:#efefef;" | GND
| 39
| 40
| RESERVED
|}

== Interface GPIO do Linux ==
O kernel Linux implementa em si uma solução de acesso à GPIO atraves de um modelo de criação e consumo de GPIO. Os drivers de criação são drivers como o controlador de GPIO que será detalhado nesta página, os consumidores são os drivers como sensores que utilizam estas linhas GPIO.
Dentro do kernel Linux existe uma estrutura de alocação e registradores dos pinos GPIO chamado gpiolib, esta estrutura cobre os drivers em nível de kernel e userspace.
As bibliotecas de espaço de usuário são, até a versão 4.7 do Kernel Linux a <code>sysfs</code> e a partir da versao 4.8 a <code>chardev</code>. Embora a placa Labrador esteja atualmente no Kernel 4.19, ambas ainda são compatíveis e cobriremos o uso das duas interfaces de espaço de usuário.

==Interface sysfs==

Na interface sysfs o usuário tem acesso às GPIO através de arquivos exportados em <code>/sys/class/gpio</code>. Para isso é necessário exportar um arquivo para cada GPIO, configurar a porta e escrever na mesma.

===Identificando o número da GPIO===
No método sysfs utiliza-se o número absoluto das GPIO para exportá-las individualmente. A Labrador possui 5 grupos de GPIO (A, B, C, D e E). Cada um desses possui 32 pinos agrupados, portanto para indicar o valor absoluto do pino temos um offset dado pelo grupo mais o valor do pino, este offset seguem a lógica a seguir:

*A: 0
*B: 32
*C: 64
*D: 96
*E: 128

Portanto se quisermos acessar o pino 3 do header GPIO, no caso seria GPIOE3, portanto devemos exportar o pino GPIO 128+3=131. Isto seria feito com a seguinte linha de terminal:
<pre>$ echo 131 > /sys/class/gpio/export</pre>

=== Configurando a direção do pino ===

Após exportado o pino devemos configurar a direção do mesmo entre input (<code>in</code>) ou output (<code>out</code>). Para isto basta escrever no GPIO exportado o valor requerido. No nosso exemplo colocaremos como output:

<pre>$ echo out > /sys/class/gpio/gpio131/direction</pre>

=== Escrevendo ou lendo no pino ===

Para escrever no pino configurado como output basta enviar o valor para o parâmetro <code>value</code> do pino. No nosso exemplo colocaremos o valor 1 no pino:

<pre>$ echo 1 > /sys/class/gpio/gpio131/value</pre>

Caso o pino seja definido como input basta ler este mesmo arquivo.

<pre>$ cat /sys/class/gpio/gpio131/value</pre>

=== Lendo um parâmetro ===
O comando <code>cat</code> pode ser usado nestes arquivos de parâmetros para ler o que já foi configurado dos pinos ficamos então com os seguinte exemplo completos para configuração do pino GPIOE3 como output em alta e GPIOE2 como input:
<pre>$ echo 131 > /sys/class/gpio/export #Exportando GPIOE3
$ echo out > /sys/class/gpio/gpio131/direction #Definindo como output
$ echo 1 > /sys/class/gpio/gpio131/value #Escrevendo o valor 1
$ cat /sys/class/gpio/gpio131/direction #Lendo a direção do pino
out
$ cat /sys/class/gpio/gpio131/value #Lendo o valor do pino
1
$ echo 130 > /sys/class/gpio/export #Exportando GPIOE2
$ echo in > /sys/class/gpio/gpio130/direction #Definindo como input
$ cat /sys/class/gpio/gpio130/value #Lendo o valor do pino
0
$ cat /sys/class/gpio/gpio130/direction #Lendo a direção do pino
in
</pre>

==Interface chardev==
A interface chardev é a interface padrão do kernel Linux a partir do kernel 4.8 e compatível com a Labrador 64-bits, apesar de esta solução não permitir o uso de comandos padrão do terminal linux para controle da gpio como <code>echo</code> e <code>cat</code> usados anteriormente, esta API utiliza a biblioteca [https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/ libgpiod] que provê uma série de ferramentas para uso em terminal e também para uso em C, com bibliotecas de [https://github.com/brgl/libgpiod/tree/master/bindings vinculações] disponíveis em [https://github.com/brgl/libgpiod/tree/master/bindings/cxx C++] e [https://pypi.org/project/gpio-next/ Python]. A solução chardev é mais simples, elegante e robusta que a sysfs.

=== Identificando o número da GPIO ===
Para o chardev os diferentes controladores de GPIO possuem pastas diferentes, chamados gpiochip. No caso temos A=0, B=1, C=2, D=3, E=4.
Portanto, os pinos agora serão definidos pelo controlador e pela linha dentro do mesmo.

=== libgpiod no terminal ===
==== gpiodetect ====
Os controladores podem ser identificados com o comando <code>gpiodetect</code> disponível pelo <code>libgpiod</code>
<pre>$ gpiodetect
gpiochip0 [209c000.gpio] (32 lines)
gpiochip1 [20a0000.gpio] (32 lines)
gpiochip2 [20a4000.gpio] (32 lines)
gpiochip3 [20a8000.gpio] (32 lines)
gpiochip4 [20ac000.gpio] (32 lines)</pre>

==== gpioinfo ====
O comando <code>gpioinfo</code> fornece as informações dos pinos de cada controlador, por exemplo para exemplos dos pinos do controlador E:
<pre>$ gpioinfo 0
line 0: unnamed unused input active-high
line 1: unnamed unused input active-high
line 2: unnamed unused input active-high</pre>
No caso, nenhum destes pinos está em utilização.

==== gpioget ====
Os pinos estão configurados como entrada por padrão, para acessar os valores de entrada dos pinos basta utilizar o comando <code>gpioget</code>, no exemplo o pino GPIOE3 (controlador 4, pino 3)
<pre>$ gpioget 4 3
0</pre>

==== gpioset ====
O comando <code>gpioset</code> muda a direção para output e define o valor do mesmo, no exemplo definiremos o GPIOE3 para alto:
<pre>$ gpioset 4 3=1
1</pre>

==== gpiomon ====
Este comando é utilizado para interrupções e eventos, ele monitorará o pino para mudanças e retornará as mudanças encontradas.

<pre>$gpiomon 4 3
event: RISING EDGE offset: 3 timestamp: [ 322.073816438]
event: FALLING EDGE offset: 3 timestamp: [ 323.467289198]
event: RISING EDGE offset: 3 timestamp: [ 324.245127683]</pre>

=== Utilizando chardev em C ===

A API chardev facilita o uso em programas em C, alguns exemplos podem ser encontrados com facilidade, como [https://github.com/starnight/libgpiod-example estes].

Programação GPIO

2020-07-09T17:35:32Z

Augrm: /* Interface chardev */

Esta página explica como programar as saídas GPIO (General Purpose Input/Output) da Labrador, que são basicamente pinos nos quais você pode enviar e receber dados. Para facilitar a programação, a placa Labrador segue a interface padrão para userspace para Linux embarcado. O tutorial desta página funciona tanto com a Labrador 32 quanto 64-bits.

Além disso, a placa Labrador 32-bits é compatível com o formato da Raspberry Pi, e possui a biblioteca <code>wiringK9</code>, baseada na wiringPi, também da Raspberry Pi. Mais detalhes desta biblioteca pode ser encontrado nessa página [[Wiring K9]].

== Configuração dos pinos ==

A configuração de pinos para o cabeçalho de GPIO é a seguinte:

=== GPIO Labrador 32-bits ===
[[File:40pinh.png|image|1000px|caption Mapeamento do header de 40 pinos.]]

=== GPIO Labrador 64 bits===
{| class="wikitable" style="background-color:#ffffff;"
|- style="background-color:#c0c0c0;"
! Default Function
! colspan="2" | Header Pin
! Default Function
|-
| style="background-color:#efefef;" | VCC
| 1
| 2
| style="background-color:#efefef;" | 5V
|-
| GPIOE3
| 3
| 4
| style="background-color:#efefef;" | 5V
|-
| GPIOE2
| 5
| 6
| style="background-color:#efefef;" | GND
|-
| GPIOB18
| 7
| 8
| UART0_TX
|-
| style="background-color:#efefef;" | GND
| 9
| 10
| UART0_RX
|-
| GPIOC0
| 11
| 12
| GPIOB8
|-
| GPIOC1
| 13
| 14
| style="background-color:#efefef;" | GND
|-
| GPIOC4
| 15
| 16
| GPIOD30
|-
| style="background-color:#efefef;" | VCC
| 17
| 18
| GPIOC6
|-
| TWI3_SDA
| 19
| 20
| style="background-color:#efefef;" | GND
|-
| GPIOC24
| 21
| 22
| GPIOC5
|-
| TWI3_SCK
| 23
| 24
| GPIOC23
|-
| style="background-color:#efefef;" | GND
| 25
| 26
| GPIOB19
|-
| GPIOB16
| 27
| 28
| GPIOB14
|-
| GPIOB15
| 29
| 30
| style="background-color:#efefef;" | GND
|-
| GPIOB10
| 31
| 32
| GPIOB13
|-
| GPIOB0
| 33
| 34
| style="background-color:#efefef;" | GND
|-
| GPIOB1
| 35
| 36
| GPIOA28
|-
| GPIOB2
| 37
| 38
| RESERVED
|-
| style="background-color:#efefef;" | GND
| 39
| 40
| RESERVED
|}

== Interface GPIO do Linux ==
O kernel Linux implementa em si uma solução de acesso à GPIO atraves de um modelo de criação e consumo de GPIO. Os drivers de criação são drivers como o controlador de GPIO que será detalhado nesta página, os consumidores são os drivers como sensores que utilizam estas linhas GPIO.
Dentro do kernel Linux existe uma estrutura de alocação e registradores dos pinos GPIO chamado gpiolib, esta estrutura cobre os drivers em nível de kernel e userspace.
As bibliotecas de espaço de usuário são, até a versão 4.7 do Kernel Linux a <code>sysfs</code> e a partir da versao 4.8 a <code>chardev</code>. Embora a placa Labrador esteja atualmente no Kernel 4.19, ambas ainda são compatíveis e cobriremos o uso das duas interfaces de espaço de usuário.

==Interface sysfs==

Na interface sysfs o usuário tem acesso às GPIO através de arquivos exportados em <code>/sys/class/gpio</code>. Para isso é necessário exportar um arquivo para cada GPIO, configurar a porta e escrever na mesma.

===Identificando o número da GPIO===
No método sysfs utiliza-se o número absoluto das GPIO para exportá-las individualmente. A Labrador possui 5 grupos de GPIO (A, B, C, D e E). Cada um desses possui 32 pinos agrupados, portanto para indicar o valor absoluto do pino temos um offset dado pelo grupo mais o valor do pino, este offset seguem a lógica a seguir:

*A: 0
*B: 32
*C: 64
*D: 96
*E: 128

Portanto se quisermos acessar o pino 3 do header GPIO, no caso seria GPIOE3, portanto devemos exportar o pino GPIO 128+3=131. Isto seria feito com a seguinte linha de terminal:
<pre>$ echo 131 > /sys/class/gpio/export</pre>

=== Configurando a direção do pino ===

Após exportado o pino devemos configurar a direção do mesmo entre input (<code>in</code>) ou output (<code>out</code>). Para isto basta escrever no GPIO exportado o valor requerido. No nosso exemplo colocaremos como output:

<pre>$ echo out > /sys/class/gpio/gpio131/direction</pre>

=== Escrevendo ou lendo no pino ===

Para escrever no pino configurado como output basta enviar o valor para o parâmetro <code>value</code> do pino. No nosso exemplo colocaremos o valor 1 no pino:

<pre>$ echo 1 > /sys/class/gpio/gpio131/value</pre>

Caso o pino seja definido como input basta ler este mesmo arquivo.

<pre>$ cat /sys/class/gpio/gpio131/value</pre>

=== Lendo um parâmetro ===
O comando <code>cat</code> pode ser usado nestes arquivos de parâmetros para ler o que já foi configurado dos pinos ficamos então com os seguinte exemplo completos para configuração do pino GPIOE3 como output em alta e GPIOE2 como input:
<pre>$ echo 131 > /sys/class/gpio/export #Exportando GPIOE3
$ echo out > /sys/class/gpio/gpio131/direction #Definindo como output
$ echo 1 > /sys/class/gpio/gpio131/value #Escrevendo o valor 1
$ cat /sys/class/gpio/gpio131/direction #Lendo a direção do pino
out
$ cat /sys/class/gpio/gpio131/value #Lendo o valor do pino
1
$ echo 130 > /sys/class/gpio/export #Exportando GPIOE2
$ echo in > /sys/class/gpio/gpio130/direction #Definindo como input
$ cat /sys/class/gpio/gpio130/value #Lendo o valor do pino
0
$ cat /sys/class/gpio/gpio130/direction #Lendo a direção do pino
in
</pre>

==Interface chardev==
A interface chardev é a interface padrão do kernel Linux a partir do kernel 4.8 e compatível com a Labrador 64-bits, apesar de esta solução não permitir o uso de comandos padrão do terminal linux para controle da gpio como <code>echo</code> e <code>cat</code> usados anteriormente, esta API utiliza a biblioteca [https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/ libgpiod] que provê uma série de ferramentas para uso em terminal e também para uso em C, com bibliotecas de [https://github.com/brgl/libgpiod/tree/master/bindings vinculações] disponíveis em [https://github.com/brgl/libgpiod/tree/master/bindings/cxx C++] e [https://pypi.org/project/gpio-next/ Python]. A solução chardev é mais simples, elegante e robusta que a sysfs.

=== Identificando o número da GPIO ===
Para o chardev os diferentes controladores de GPIO possuem pastas diferentes, chamados gpiochip. No caso temos A=0, B=1, C=2, D=3, E=4.
Portanto, os pinos agora serão definidos pelo controlador e pela linha dentro do mesmo.

=== libgpiod no terminal ===
==== gpiodetect ====
Os controladores podem ser identificados com o comando <code>gpiodetect</code> disponível pelo <code>libgpiod</code>
<pre>$ gpiodetect
gpiochip0 [209c000.gpio] (32 lines)
gpiochip1 [20a0000.gpio] (32 lines)
gpiochip2 [20a4000.gpio] (32 lines)
gpiochip3 [20a8000.gpio] (32 lines)
gpiochip4 [20ac000.gpio] (32 lines)</pre>

==== gpioinfo ====
O comando <code>gpioinfo</code> fornece as informações dos pinos de cada controlador, por exemplo para exemplos dos pinos do controlador E:
<pre>$ gpioinfo 0
line 0: unnamed unused input active-high
line 1: unnamed unused input active-high
line 2: unnamed unused input active-high</pre>
No caso, nenhum destes pinos está em utilização.

==== gpioget ====
Os pinos estão configurados como entrada por padrão, para acessar os valores de entrada dos pinos basta utilizar o comando <code>gpioget</code>, no exemplo o pino GPIOE3 (controlador 4, pino 3)
<pre>$ gpioget 4 3
0</pre>

==== gpioset ====
O comando <code>gpioset</code> muda a direção para output e define o valor do mesmo, no exemplo definiremos o GPIOE3 para alto:
<pre>$ gpioset 4 3=1
1</pre>

==== gpiomon ====
Este comando é utilizado para interrupções e eventos, ele monitorará o pino para mudanças e retornará as mudanças encontradas.

<pre>$gpiomon 4 3
event: RISING EDGE offset: 3 timestamp: [ 322.073816438]
event: FALLING EDGE offset: 3 timestamp: [ 323.467289198]
event: RISING EDGE offset: 3 timestamp: [ 324.245127683]</pre>

=== Utilizando chardev em C ===

A API chardev facilita o uso em programas em C, alguns exemplos podem ser encontrados com facilidade, como [https://github.com/starnight/libgpiod-example estes].

Programação GPIO

2020-07-09T17:34:32Z

Augrm: /* GPIO Labrador 64 bits */

Esta página explica como programar as saídas GPIO (General Purpose Input/Output) da Labrador, que são basicamente pinos nos quais você pode enviar e receber dados. Para facilitar a programação, a placa Labrador segue a interface padrão para userspace para Linux embarcado. O tutorial desta página funciona tanto com a Labrador 32 quanto 64-bits.

Além disso, a placa Labrador 32-bits é compatível com o formato da Raspberry Pi, e possui a biblioteca <code>wiringK9</code>, baseada na wiringPi, também da Raspberry Pi. Mais detalhes desta biblioteca pode ser encontrado nessa página [[Wiring K9]].

== Configuração dos pinos ==

A configuração de pinos para o cabeçalho de GPIO é a seguinte:

=== GPIO Labrador 32-bits ===
[[File:40pinh.png|image|1000px|caption Mapeamento do header de 40 pinos.]]

=== GPIO Labrador 64 bits===
{| class="wikitable" style="background-color:#ffffff;"
|- style="background-color:#c0c0c0;"
! Default Function
! colspan="2" | Header Pin
! Default Function
|-
| style="background-color:#efefef;" | VCC
| 1
| 2
| style="background-color:#efefef;" | 5V
|-
| GPIOE3
| 3
| 4
| style="background-color:#efefef;" | 5V
|-
| GPIOE2
| 5
| 6
| style="background-color:#efefef;" | GND
|-
| GPIOB18
| 7
| 8
| UART0_TX
|-
| style="background-color:#efefef;" | GND
| 9
| 10
| UART0_RX
|-
| GPIOC0
| 11
| 12
| GPIOB8
|-
| GPIOC1
| 13
| 14
| style="background-color:#efefef;" | GND
|-
| GPIOC4
| 15
| 16
| GPIOD30
|-
| style="background-color:#efefef;" | VCC
| 17
| 18
| GPIOC6
|-
| TWI3_SDA
| 19
| 20
| style="background-color:#efefef;" | GND
|-
| GPIOC24
| 21
| 22
| GPIOC5
|-
| TWI3_SCK
| 23
| 24
| GPIOC23
|-
| style="background-color:#efefef;" | GND
| 25
| 26
| GPIOB19
|-
| GPIOB16
| 27
| 28
| GPIOB14
|-
| GPIOB15
| 29
| 30
| style="background-color:#efefef;" | GND
|-
| GPIOB10
| 31
| 32
| GPIOB13
|-
| GPIOB0
| 33
| 34
| style="background-color:#efefef;" | GND
|-
| GPIOB1
| 35
| 36
| GPIOA28
|-
| GPIOB2
| 37
| 38
| RESERVED
|-
| style="background-color:#efefef;" | GND
| 39
| 40
| RESERVED
|}

== Interface GPIO do Linux ==
O kernel Linux implementa em si uma solução de acesso à GPIO atraves de um modelo de criação e consumo de GPIO. Os drivers de criação são drivers como o controlador de GPIO que será detalhado nesta página, os consumidores são os drivers como sensores que utilizam estas linhas GPIO.
Dentro do kernel Linux existe uma estrutura de alocação e registradores dos pinos GPIO chamado gpiolib, esta estrutura cobre os drivers em nível de kernel e userspace.
As bibliotecas de espaço de usuário são, até a versão 4.7 do Kernel Linux a <code>sysfs</code> e a partir da versao 4.8 a <code>chardev</code>. Embora a placa Labrador esteja atualmente no Kernel 4.19, ambas ainda são compatíveis e cobriremos o uso das duas interfaces de espaço de usuário.

==Interface sysfs==

Na interface sysfs o usuário tem acesso às GPIO através de arquivos exportados em <code>/sys/class/gpio</code>. Para isso é necessário exportar um arquivo para cada GPIO, configurar a porta e escrever na mesma.

===Identificando o número da GPIO===
No método sysfs utiliza-se o número absoluto das GPIO para exportá-las individualmente. A Labrador possui 5 grupos de GPIO (A, B, C, D e E). Cada um desses possui 32 pinos agrupados, portanto para indicar o valor absoluto do pino temos um offset dado pelo grupo mais o valor do pino, este offset seguem a lógica a seguir:

*A: 0
*B: 32
*C: 64
*D: 96
*E: 128

Portanto se quisermos acessar o pino 3 do header GPIO, no caso seria GPIOE3, portanto devemos exportar o pino GPIO 128+3=131. Isto seria feito com a seguinte linha de terminal:
<pre>$ echo 131 > /sys/class/gpio/export</pre>

=== Configurando a direção do pino ===

Após exportado o pino devemos configurar a direção do mesmo entre input (<code>in</code>) ou output (<code>out</code>). Para isto basta escrever no GPIO exportado o valor requerido. No nosso exemplo colocaremos como output:

<pre>$ echo out > /sys/class/gpio/gpio131/direction</pre>

=== Escrevendo ou lendo no pino ===

Para escrever no pino configurado como output basta enviar o valor para o parâmetro <code>value</code> do pino. No nosso exemplo colocaremos o valor 1 no pino:

<pre>$ echo 1 > /sys/class/gpio/gpio131/value</pre>

Caso o pino seja definido como input basta ler este mesmo arquivo.

<pre>$ cat /sys/class/gpio/gpio131/value</pre>

=== Lendo um parâmetro ===
O comando <code>cat</code> pode ser usado nestes arquivos de parâmetros para ler o que já foi configurado dos pinos ficamos então com os seguinte exemplo completos para configuração do pino GPIOE3 como output em alta e GPIOE2 como input:
<pre>$ echo 131 > /sys/class/gpio/export #Exportando GPIOE3
$ echo out > /sys/class/gpio/gpio131/direction #Definindo como output
$ echo 1 > /sys/class/gpio/gpio131/value #Escrevendo o valor 1
$ cat /sys/class/gpio/gpio131/direction #Lendo a direção do pino
out
$ cat /sys/class/gpio/gpio131/value #Lendo o valor do pino
1
$ echo 130 > /sys/class/gpio/export #Exportando GPIOE2
$ echo in > /sys/class/gpio/gpio130/direction #Definindo como input
$ cat /sys/class/gpio/gpio130/value #Lendo o valor do pino
0
$ cat /sys/class/gpio/gpio130/direction #Lendo a direção do pino
in
</pre>

==Interface chardev==
A interface chardev é a interface padrão do kernel Linux a partir do kernel 4.8, apesar de esta solução não permitir o uso de comandos padrão do terminal linux para controle da gpio como <code>echo</code> e <code>cat</code> usados anteriormente, esta API utiliza a biblioteca [https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/ libgpiod] que provê uma série de ferramentas para uso em terminal e também para uso em C, com bibliotecas de [https://github.com/brgl/libgpiod/tree/master/bindings vinculações] disponíveis em [https://github.com/brgl/libgpiod/tree/master/bindings/cxx C++] e [https://pypi.org/project/gpio-next/ Python]. A solução chardev é mais simples, elegante e robusta que a sysfs.

=== Identificando o número da GPIO ===
Para o chardev os diferentes controladores de GPIO possuem pastas diferentes, chamados gpiochip. No caso temos A=0, B=1, C=2, D=3, E=4.
Portanto, os pinos agora serão definidos pelo controlador e pela linha dentro do mesmo.

=== libgpiod no terminal ===
==== gpiodetect ====
Os controladores podem ser identificados com o comando <code>gpiodetect</code> disponível pelo <code>libgpiod</code>
<pre>$ gpiodetect
gpiochip0 [209c000.gpio] (32 lines)
gpiochip1 [20a0000.gpio] (32 lines)
gpiochip2 [20a4000.gpio] (32 lines)
gpiochip3 [20a8000.gpio] (32 lines)
gpiochip4 [20ac000.gpio] (32 lines)</pre>

==== gpioinfo ====
O comando <code>gpioinfo</code> fornece as informações dos pinos de cada controlador, por exemplo para exemplos dos pinos do controlador E:
<pre>$ gpioinfo 0
line 0: unnamed unused input active-high
line 1: unnamed unused input active-high
line 2: unnamed unused input active-high</pre>
No caso, nenhum destes pinos está em utilização.

==== gpioget ====
Os pinos estão configurados como entrada por padrão, para acessar os valores de entrada dos pinos basta utilizar o comando <code>gpioget</code>, no exemplo o pino GPIOE3 (controlador 4, pino 3)
<pre>$ gpioget 4 3
0</pre>

==== gpioset ====
O comando <code>gpioset</code> muda a direção para output e define o valor do mesmo, no exemplo definiremos o GPIOE3 para alto:
<pre>$ gpioset 4 3=1
1</pre>

==== gpiomon ====
Este comando é utilizado para interrupções e eventos, ele monitorará o pino para mudanças e retornará as mudanças encontradas.

<pre>$gpiomon 4 3
event: RISING EDGE offset: 3 timestamp: [ 322.073816438]
event: FALLING EDGE offset: 3 timestamp: [ 323.467289198]
event: RISING EDGE offset: 3 timestamp: [ 324.245127683]</pre>

=== Utilizando chardev em C ===

A API chardev facilita o uso em programas em C, alguns exemplos podem ser encontrados com facilidade, como [https://github.com/starnight/libgpiod-example estes].

Programação GPIO

2020-07-09T17:33:21Z

Augrm: /* Configuração dos pinos */

Esta página explica como programar as saídas GPIO (General Purpose Input/Output) da Labrador, que são basicamente pinos nos quais você pode enviar e receber dados. Para facilitar a programação, a placa Labrador segue a interface padrão para userspace para Linux embarcado. O tutorial desta página funciona tanto com a Labrador 32 quanto 64-bits.

Além disso, a placa Labrador 32-bits é compatível com o formato da Raspberry Pi, e possui a biblioteca <code>wiringK9</code>, baseada na wiringPi, também da Raspberry Pi. Mais detalhes desta biblioteca pode ser encontrado nessa página [[Wiring K9]].

== Configuração dos pinos ==

A configuração de pinos para o cabeçalho de GPIO é a seguinte:

=== GPIO Labrador 32-bits ===
[[File:40pinh.png|image|1000px|caption Mapeamento do header de 40 pinos.]]

=== GPIO Labrador 64 bits===
{| class="wikitable"
|- style="background-color:#c0c0c0;"
! Default Function
! colspan="2" | Header Pin
! Default Function
|-
| style="background-color:#efefef;" | VCC
| 1
| 2
| style="background-color:#efefef;" | 5V
|-
| GPIOE3
| 3
| 4
| style="background-color:#efefef;" | 5V
|-
| GPIOE2
| 5
| 6
| style="background-color:#efefef;" | GND
|-
| GPIOB18
| 7
| 8
| UART0_TX
|-
| style="background-color:#efefef;" | GND
| 9
| 10
| UART0_RX
|-
| GPIOC0
| 11
| 12
| GPIOB8
|-
| GPIOC1
| 13
| 14
| style="background-color:#efefef;" | GND
|-
| GPIOC4
| 15
| 16
| GPIOD30
|-
| style="background-color:#efefef;" | VCC
| 17
| 18
| GPIOC6
|-
| TWI3_SDA
| 19
| 20
| style="background-color:#efefef;" | GND
|-
| GPIOC24
| 21
| 22
| GPIOC5
|-
| TWI3_SCK
| 23
| 24
| GPIOC23
|-
| style="background-color:#efefef;" | GND
| 25
| 26
| GPIOB19
|-
| GPIOB16
| 27
| 28
| GPIOB14
|-
| GPIOB15
| 29
| 30
| style="background-color:#efefef;" | GND
|-
| GPIOB10
| 31
| 32
| GPIOB13
|-
| GPIOB0
| 33
| 34
| style="background-color:#efefef;" | GND
|-
| GPIOB1
| 35
| 36
| GPIOA28
|-
| GPIOB2
| 37
| 38
| RESERVED
|-
| style="background-color:#efefef;" | GND
| 39
| 40
| RESERVED
|}

== Interface GPIO do Linux ==
O kernel Linux implementa em si uma solução de acesso à GPIO atraves de um modelo de criação e consumo de GPIO. Os drivers de criação são drivers como o controlador de GPIO que será detalhado nesta página, os consumidores são os drivers como sensores que utilizam estas linhas GPIO.
Dentro do kernel Linux existe uma estrutura de alocação e registradores dos pinos GPIO chamado gpiolib, esta estrutura cobre os drivers em nível de kernel e userspace.
As bibliotecas de espaço de usuário são, até a versão 4.7 do Kernel Linux a <code>sysfs</code> e a partir da versao 4.8 a <code>chardev</code>. Embora a placa Labrador esteja atualmente no Kernel 4.19, ambas ainda são compatíveis e cobriremos o uso das duas interfaces de espaço de usuário.

==Interface sysfs==

Na interface sysfs o usuário tem acesso às GPIO através de arquivos exportados em <code>/sys/class/gpio</code>. Para isso é necessário exportar um arquivo para cada GPIO, configurar a porta e escrever na mesma.

===Identificando o número da GPIO===
No método sysfs utiliza-se o número absoluto das GPIO para exportá-las individualmente. A Labrador possui 5 grupos de GPIO (A, B, C, D e E). Cada um desses possui 32 pinos agrupados, portanto para indicar o valor absoluto do pino temos um offset dado pelo grupo mais o valor do pino, este offset seguem a lógica a seguir:

*A: 0
*B: 32
*C: 64
*D: 96
*E: 128

Portanto se quisermos acessar o pino 3 do header GPIO, no caso seria GPIOE3, portanto devemos exportar o pino GPIO 128+3=131. Isto seria feito com a seguinte linha de terminal:
<pre>$ echo 131 > /sys/class/gpio/export</pre>

=== Configurando a direção do pino ===

Após exportado o pino devemos configurar a direção do mesmo entre input (<code>in</code>) ou output (<code>out</code>). Para isto basta escrever no GPIO exportado o valor requerido. No nosso exemplo colocaremos como output:

<pre>$ echo out > /sys/class/gpio/gpio131/direction</pre>

=== Escrevendo ou lendo no pino ===

Para escrever no pino configurado como output basta enviar o valor para o parâmetro <code>value</code> do pino. No nosso exemplo colocaremos o valor 1 no pino:

<pre>$ echo 1 > /sys/class/gpio/gpio131/value</pre>

Caso o pino seja definido como input basta ler este mesmo arquivo.

<pre>$ cat /sys/class/gpio/gpio131/value</pre>

=== Lendo um parâmetro ===
O comando <code>cat</code> pode ser usado nestes arquivos de parâmetros para ler o que já foi configurado dos pinos ficamos então com os seguinte exemplo completos para configuração do pino GPIOE3 como output em alta e GPIOE2 como input:
<pre>$ echo 131 > /sys/class/gpio/export #Exportando GPIOE3
$ echo out > /sys/class/gpio/gpio131/direction #Definindo como output
$ echo 1 > /sys/class/gpio/gpio131/value #Escrevendo o valor 1
$ cat /sys/class/gpio/gpio131/direction #Lendo a direção do pino
out
$ cat /sys/class/gpio/gpio131/value #Lendo o valor do pino
1
$ echo 130 > /sys/class/gpio/export #Exportando GPIOE2
$ echo in > /sys/class/gpio/gpio130/direction #Definindo como input
$ cat /sys/class/gpio/gpio130/value #Lendo o valor do pino
0
$ cat /sys/class/gpio/gpio130/direction #Lendo a direção do pino
in
</pre>

==Interface chardev==
A interface chardev é a interface padrão do kernel Linux a partir do kernel 4.8, apesar de esta solução não permitir o uso de comandos padrão do terminal linux para controle da gpio como <code>echo</code> e <code>cat</code> usados anteriormente, esta API utiliza a biblioteca [https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/ libgpiod] que provê uma série de ferramentas para uso em terminal e também para uso em C, com bibliotecas de [https://github.com/brgl/libgpiod/tree/master/bindings vinculações] disponíveis em [https://github.com/brgl/libgpiod/tree/master/bindings/cxx C++] e [https://pypi.org/project/gpio-next/ Python]. A solução chardev é mais simples, elegante e robusta que a sysfs.

=== Identificando o número da GPIO ===
Para o chardev os diferentes controladores de GPIO possuem pastas diferentes, chamados gpiochip. No caso temos A=0, B=1, C=2, D=3, E=4.
Portanto, os pinos agora serão definidos pelo controlador e pela linha dentro do mesmo.

=== libgpiod no terminal ===
==== gpiodetect ====
Os controladores podem ser identificados com o comando <code>gpiodetect</code> disponível pelo <code>libgpiod</code>
<pre>$ gpiodetect
gpiochip0 [209c000.gpio] (32 lines)
gpiochip1 [20a0000.gpio] (32 lines)
gpiochip2 [20a4000.gpio] (32 lines)
gpiochip3 [20a8000.gpio] (32 lines)
gpiochip4 [20ac000.gpio] (32 lines)</pre>

==== gpioinfo ====
O comando <code>gpioinfo</code> fornece as informações dos pinos de cada controlador, por exemplo para exemplos dos pinos do controlador E:
<pre>$ gpioinfo 0
line 0: unnamed unused input active-high
line 1: unnamed unused input active-high
line 2: unnamed unused input active-high</pre>
No caso, nenhum destes pinos está em utilização.

==== gpioget ====
Os pinos estão configurados como entrada por padrão, para acessar os valores de entrada dos pinos basta utilizar o comando <code>gpioget</code>, no exemplo o pino GPIOE3 (controlador 4, pino 3)
<pre>$ gpioget 4 3
0</pre>

==== gpioset ====
O comando <code>gpioset</code> muda a direção para output e define o valor do mesmo, no exemplo definiremos o GPIOE3 para alto:
<pre>$ gpioset 4 3=1
1</pre>

==== gpiomon ====
Este comando é utilizado para interrupções e eventos, ele monitorará o pino para mudanças e retornará as mudanças encontradas.

<pre>$gpiomon 4 3
event: RISING EDGE offset: 3 timestamp: [ 322.073816438]
event: FALLING EDGE offset: 3 timestamp: [ 323.467289198]
event: RISING EDGE offset: 3 timestamp: [ 324.245127683]</pre>

=== Utilizando chardev em C ===

A API chardev facilita o uso em programas em C, alguns exemplos podem ser encontrados com facilidade, como [https://github.com/starnight/libgpiod-example estes].

Sensores internos

2020-07-02T15:53:05Z

Augrm: Criou página com 'A Labrador conta com diferentes sensores internos nos chips de processador e de gerenciamento de energia. Todos estes sensores podem ser acessados no diretório <code>/sys/ker...'

A Labrador conta com diferentes sensores internos nos chips de processador e de gerenciamento de energia. Todos estes sensores podem ser acessados no diretório <code>/sys/kernel/auxadc</code>.

= Sensores disponíveis =
Os sensores disponíveis bem como suas unidades de medida são conforme abaixo:

*ictemp - Temperatura do controlador de energia - 10-3 oC
*batv - Tensão no conector de bateria - mV
*bati - Corrente no conector de bateria - mA
*vbusv - Tensão no bus USB 3 - mV
*vbusi - Corrente no bus USB 3 - mA
*syspwrv - Tensão interna do processador - mV
*wallv - Tensão da fonte de entrada - mV
*walli - Corrente da fonte de entrada - mA
*chgi - Corrente de carregamento da bateria pela fonte - mA *

<nowiki>*</nowiki> O carregamento da bateria ainda não está implementado na última versão do sistema, não recomendamos conectar bateria e fonte simultaneamente.

= Leitura =
O valor dos arquivos de cada sensor serão atualizados quando for realizada uma leitura. A leitura terá o timestamp do momento da mediçãop e o valor obtido, inclusive com sinal para casos negativos. Por exemplo através do comando abaixo:

<pre>$ cat /sys/kernel/auxadc/ictemp
102345 53000 mCelsius</pre>

No caso, mostrando 53oC no gerenciador de energia.

<pre>$ cat /sys/kernel/auxadc/ictemp
102348 -15000 mCelsius</pre>

No caso, mostrando -15oC no gerenciador de energia.

== Leitura em programas ==
Os arquivos podem ser acessados também dentro de outros programas, e atualizarão a cada leitura, é necessário que o arquivo seja aberto, lido e fechado para que os dados continuem atualizados. Um exemplo seria:
<pre>fd= fopen("/sys/kernel/auxadc/ictemp")
read(fd, buffer)
close(fd)</pre>

Outra opção é utilizar a função <code>open</code> do C para Linux, que utiliza um buffer intermediário e também atualiza os valores de leitura, sendo mais rápido do que abrir e fechar o arquivo em cada atualização.