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

Instalando um sistema 32 bits

2022-01-18T13:59:01Z

Ruschigo: editando Link do repositório de imagens

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

Display TFT SPI na Labrador

2021-09-02T12:49:12Z

Ruschigo: adicionando a configuração do framebuffer

Em alguns casos utilizar uma tela TFT SPI pode ser uma boa escolha ao invés de uma tela HDMI, seja por custo ou qualquer outro fator, a intenção deste tópico é descrever como conectar e ligar essas telas a Labrador.

* Nos exemplos é usado uma tela 3.5" touch screen;
**Driver da tela: ILI9486
**Driver do touch: XPT2046

== Preparando o Kernel da Labrador para o display==

1 - Habilitar o SPI na Labrador, siga o procedimento descrito na nossa WIKI, [[https://wiki.caninosloucos.org/index.php/SPI SPI]].

2 - Verifique se os drivers de sua tela estão habilitados no Kernel da labrador.
* No repositório onde contem o seu [https://github.com/caninos-loucos/labrador-linux Kernel Labrador] com SPI já habilitado, execute o comando make com o parâmetro menuconfig;
<pre>$make menuconfig</pre>
*habilite o driver do seu touchscreen em;
<pre>Device Drivers -> Input devices support -> Touchscreens --> /*Seu dispositivo*/</pre>
<pre>Exemplo: Habilitando o driver touch do XPT2046=TSC2046/ADS7846
Device Drivers -> Input devices support -> Touchscreens -->
| | <M> ADS7846/TSC2046/AD7873 and AD(S)7843 based touchscreens │ │
│ │ <M> AD7877 based touchscreens │ │
│ │ <M> Analog Devices AD7879-1/AD7889-1 touchscreen interface │ │
│ │ <M> support I2C bus connection │ │
│ │ <M> support SPI bus connection | |</pre>
*habilite o driver do display
<pre>Device Drivers -> Staging drivers-> Support for small TFT LCD display modules --> /*Seu dispositivo*/</pre>
<pre>Exemplo: habilitando o driver da tela ILI9486
Device Drivers -> Staging drivers-> Support for small TFT LCD display modules -->
<M> FB driver for the ILI9486 LCD Controller</pre>
*salve o arquivo .config com o nome caninos.config
<pre>faça um backup do arquivo linux/arch/arm/configs/caninos_labrador_defconfig
$mv linux/arch/arm/configs/caninos_labrador_defconfig linux/arch/arm/configs/caninos_labrador_defconfig_backup
</pre>
<pre>copie o seu arquivo caninos.config no lugar do caninos_labrador_defconfig
$cp build/caninos.config linux/arch/arm/configs/caninos_labrador_defconfig
</pre>

3 - Configurar a device-tree do Kernel
*abra a device-tree da labrador com um editor de texto da sua preferência;
<pre>gedit linux/arch/arm/boot/caninos-labrador.dts</pre>
*configure a device-tree de acordo com as características da sua tela touch screen, dentro do nó spi0.
<pre>
Exemplo: adicionando as configurações do display ILI9486 e o touchscreen XPT2046
spi0: spi@b0200000 {
#address-cells = <1>;
#size-cells = <0>;
compatible = "caninos,caninos-spi";
reg = <0xb0200000 0x4000>;
interrupts = < 0 19 0x4 >;
pinctrl-names = "default";
pinctrl-0 = <&spi0_state_default>;
status = "okay";

displayPi35@0{//LCD DISPLAY DRIVER
compatible = "ilitek,ili9486";
reg = <0>;
fps = <30>;
bgr;
buswidth = <8>;
spi-max-frequency = <20000000>;
dc-gpios = <&gpio 70 0>; //GPIOC6
reset-gpios = <&gpio 69 0>; //GPIOC5
led-gpios = <&gpio 68 1>; //Pin 11 Header DIsplay => GPIOC0
//rotation = <270>;
init = <0x10000b0 0x00
0x1000011
0x20000FF
0x100003A 0x55
0x1000036 0x28
0x10000C2 0x44
0x10000C5 0x00 0x00 0x00 0x00
0x10000E0 0x0F 0x1F 0x1C 0x0C 0x0F 0x08 0x48 0x98 0x37 0x0A 0x13 0x04 0x11 0x0D 0x00
0x10000E1 0x0F 0x32 0x2E 0x0B 0x0D 0x05 0x47 0x75 0x37 0x06 0x10 0x03 0x24 0x20 0x00
0x10000E2 0x0F 0x32 0x2E 0x0B 0x0D 0x05 0x47 0x75 0x37 0x06 0x10 0x03 0x24 0x20 0x00
0x1000011
0X1000029>;
status = "okay";
};

tsc2046@1 {//TOUCH SCREEN DEVICE
compatible = "ti,tsc2046";
reg = <1>;
spi-max-frequency = <1000000>;
interrupt-parent = <&gpio 64>; //GPIOC0
interrupts = <3 17>; //Ainda nao entendi isso
pendown-gpio = <&gpio 64 0>;
ti,x-min = /bits/ 16 <0>;
ti,x-max = /bits/ 16 <480>;
ti,y-min = /bits/ 16 <0>;
ti,y-max = /bits/ 16 <320>;
ti,x-plate-ohms = /bits/ 16 <100>;
ti,pressure-max = /bits/ 16 <255>;
wakeup-source;
status = "okay";
};
};</pre>

4 - Compile o e atualize o Kernel de sua labrador
<pre>$make</pre>

5 - Reinicie a Labrador

6 - Confira se os módulos do Kernel foram todos carregados corretamente com lsmod, caso tenha problemas investigue o carregamento do driver com o comando dmesg
<pre>
$lsmod
$sudo dmesg
</pre>

== Configurando o Debian 10 ==

para conseguir configurar o X para enviar os quadros ao display SPI, é necessário reconfigurar o framebuffer de saída.

para isso instale;

<pre>sudo apt-get install xserver-xorg-video-fbdev</pre>

Crie o arquivo: /usr/share/X11/xorg.conf.d/99-fbdev.conf

Altere o arquivo com um editor de texto, e insira o seguinte conteúdo ao arquivo;
<pre>Section "Device"
Identifier "myfb"
Driver "fbdev"
Option "fbdev" "/dev/fb2"
EndSection</pre>
***O campo Option deve ser preenchido com o framebuffer padrão desejado, para consultar qual é framebuffer da tela procure no comando dmesg o log que mostra modulo do driver do seu display, o padrão da Labrador é HDMI(/dev/fb0), caso não tenha outros framebuffers adicionados, o framebuffer padrão do modulo SPI deve ser /dev/fb2.

outra alternativa é utilizar o seguinte comando;
<pre>
Tela SPI:
$FRAMEBUFFER=/dev/fb2 startx
Tela HDMI:
$FRAMEBUFFER=/dev/fb0 startx</pre>

para mais informações sobre framebuffer, consulte diretamente no [https://github.com/notro/fbtft/wiki/Framebuffer-use Notro];

== Conecte os sinais do display na Labrador ==

Observe o display 3.5inch Rpi Display por exemplo pode ser conectado diretamente ao barramento de GPIOs da Labrador, consulte a seção Mapeamento SPI, dentro de [https://wiki.caninosloucos.org/index.php/SPI SPI]

==Iniciar o display sem alterar a device-tree==

Para Kernel com versão menor que 5.4(utilize o comando "$uname -a) é possivél invocar o driver do display sem alterar o Device-Tree do Linux, o que precisa ser recompilada e atualizar na labrador, então pode-se usar outra ferramenta do Notro, o [https://github.com/notro/fbtft/wiki/fbtft_device fbtft_device].

<pre>Exemplo: Invocando o display 3.5inch RPI DISPLAY na Labrador 32bits
fbtft_device name=piscreen speed=32000000 cs=0 mode=SPI_MODE_0 rotate=90 fps=30 gpios=reset:69,dc:70,cs:87,led:68</pre>

Display TFT SPI na Labrador

2021-09-01T21:02:04Z

Ruschigo: update

Em alguns casos utilizar uma tela TFT SPI pode ser uma boa escolha ao invés de uma tela HDMI, seja por custo ou qualquer outro fator, a intenção deste tópico é descrever como conectar e ligar essas telas a Labrador.

* Nos exemplos é usado uma tela 3.5" touch screen;
**Driver da tela: ILI9486
**Driver do touch: XPT2046

== Preparando o Kernel da Labrador para o display==

1 - Habilitar o SPI na Labrador, siga o procedimento descrito na nossa WIKI, [[https://wiki.caninosloucos.org/index.php/SPI SPI]].

2 - Verifique se os drivers de sua tela estão habilitados no Kernel da labrador.
* No repositório onde contem o seu [https://github.com/caninos-loucos/labrador-linux Kernel Labrador] com SPI já habilitado, execute o comando make com o parâmetro menuconfig;
<pre>$make menuconfig</pre>
*habilite o driver do seu touchscreen em;
<pre>Device Drivers -> Input devices support -> Touchscreens --> /*Seu dispositivo*/</pre>
<pre>Exemplo: Habilitando o driver touch do XPT2046=TSC2046/ADS7846
Device Drivers -> Input devices support -> Touchscreens -->
| | <M> ADS7846/TSC2046/AD7873 and AD(S)7843 based touchscreens │ │
│ │ <M> AD7877 based touchscreens │ │
│ │ <M> Analog Devices AD7879-1/AD7889-1 touchscreen interface │ │
│ │ <M> support I2C bus connection │ │
│ │ <M> support SPI bus connection | |</pre>
*habilite o driver do display
<pre>Device Drivers -> Staging drivers-> Support for small TFT LCD display modules --> /*Seu dispositivo*/</pre>
<pre>Exemplo: habilitando o driver da tela ILI9486
Device Drivers -> Staging drivers-> Support for small TFT LCD display modules -->
<M> FB driver for the ILI9486 LCD Controller</pre>
*salve o arquivo .config com o nome caninos.config
<pre>faça um backup do arquivo linux/arch/arm/configs/caninos_labrador_defconfig
$mv linux/arch/arm/configs/caninos_labrador_defconfig linux/arch/arm/configs/caninos_labrador_defconfig_backup
</pre>
<pre>copie o seu arquivo caninos.config no lugar do caninos_labrador_defconfig
$cp build/caninos.config linux/arch/arm/configs/caninos_labrador_defconfig
</pre>

3 - Configurar a device-tree do Kernel
*abra a device-tree da labrador com um editor de texto da sua preferência;
<pre>gedit linux/arch/arm/boot/caninos-labrador.dts</pre>
*configure a device-tree de acordo com as características da sua tela touch screen, dentro do nó spi0.
<pre>
Exemplo: adicionando as configurações do display ILI9486 e o touchscreen XPT2046
spi0: spi@b0200000 {
#address-cells = <1>;
#size-cells = <0>;
compatible = "caninos,caninos-spi";
reg = <0xb0200000 0x4000>;
interrupts = < 0 19 0x4 >;
pinctrl-names = "default";
pinctrl-0 = <&spi0_state_default>;
status = "okay";

displayPi35@0{//LCD DISPLAY DRIVER
compatible = "ilitek,ili9486";
reg = <0>;
fps = <30>;
bgr;
buswidth = <8>;
spi-max-frequency = <20000000>;
dc-gpios = <&gpio 70 0>; //GPIOC6
reset-gpios = <&gpio 69 0>; //GPIOC5
led-gpios = <&gpio 68 1>; //Pin 11 Header DIsplay => GPIOC0
//rotation = <270>;
init = <0x10000b0 0x00
0x1000011
0x20000FF
0x100003A 0x55
0x1000036 0x28
0x10000C2 0x44
0x10000C5 0x00 0x00 0x00 0x00
0x10000E0 0x0F 0x1F 0x1C 0x0C 0x0F 0x08 0x48 0x98 0x37 0x0A 0x13 0x04 0x11 0x0D 0x00
0x10000E1 0x0F 0x32 0x2E 0x0B 0x0D 0x05 0x47 0x75 0x37 0x06 0x10 0x03 0x24 0x20 0x00
0x10000E2 0x0F 0x32 0x2E 0x0B 0x0D 0x05 0x47 0x75 0x37 0x06 0x10 0x03 0x24 0x20 0x00
0x1000011
0X1000029>;
status = "okay";
};

tsc2046@1 {//TOUCH SCREEN DEVICE
compatible = "ti,tsc2046";
reg = <1>;
spi-max-frequency = <1000000>;
interrupt-parent = <&gpio 64>; //GPIOC0
interrupts = <3 17>; //Ainda nao entendi isso
pendown-gpio = <&gpio 64 0>;
ti,x-min = /bits/ 16 <0>;
ti,x-max = /bits/ 16 <480>;
ti,y-min = /bits/ 16 <0>;
ti,y-max = /bits/ 16 <320>;
ti,x-plate-ohms = /bits/ 16 <100>;
ti,pressure-max = /bits/ 16 <255>;
wakeup-source;
status = "okay";
};
};</pre>

4 - Compile o e atualize o Kernel de sua labrador
<pre>$make</pre>

5 - Reinicie a Labrador

6 - Confira se os módulos do Kernel foram todos carregados corretamente com lsmod, caso tenha problemas investigue o carregamento do driver com o comando dmesg
<pre>
$lsmod
$sudo dmesg
</pre>

== Configurando o Debian 10 ==

para conseguir configurar o X para enviar a tela ao display SPI, é necessário reconfigurar o framebuffer de saída.

para isso instale;

<pre>sudo apt-get install xserver-xorg-video-fbdev</pre>

Crie o arquivo: /usr/share/X11/xorg.conf.d/99-fbdev.conf

<pre></>

https://github.com/notro/fbtft-spindle/wiki/FBTFT-image#fbcp---framebuffer-copy

== Conecte os sinais do display na Labrador ==

Observe o display 3.5inch Rpi Display por exemplo pode ser conectado diretamente ao barramento de GPIOs da Labrador, observe a figura a seguir como exemplo.

Display TFT SPI na Labrador

2021-09-01T20:24:23Z

Ruschigo: Primeira versão

SPI

2021-08-31T22:22:44Z

Ruschigo: Inserindo página sobre SPI na labrador

= Labrador SPI =
O processador da Labrador conta com diferentes hardwares dedicados para comunicação, um desses hardwares permite o uso de transferência por SPI em altas velocidades de até 60Mps.
No entanto esse hardware fica disponível através do barramento de GPIO por multiplexação, desta forma o padrão é desabilitado devido maior uso do GPIOS.

= Mapeamento SPI =

Observe a que o SPI fica disponível nos pinos 19(SPI0_MOSI), 21(SPI0_MISO), 23(SPI0_SCLK), 24(SPI0_SS).

[[File:40pinh.png|image|800px|caption Mapeamento do header de 40 pinos.]]

= Habilitar SPI =

Para ativar o SPI é necessário alterar a device-tree do Kernel.

<pre>Crie uma pasta para clonar o kernel da labrador;
$mkdir $HOME/kernel_labrador/</pre>

<pre>Entre na pasta
cd $HOME/kernel_labrador/</pre>

Labrador 32bits
<pre>$git clone https://github.com/caninos-loucos/labrador-linux</pre>

Labrador 64bits
<pre>$git clone https://github.com/caninos-loucos/linux-labrador64.git</pre>

<pre>abra a device-tree com um editor de texto de sua preferência
$gedit linux/arch/arm/boot/dts/caninos_labrador.dts</pre>

procure por;
<pre>
spi0: spi@b0200000 {
#address-cells = <1>;
#size-cells = <0>;
compatible = "caninos,caninos-spi";
reg = <0xb0200000 0x4000>;
interrupts = < 0 19 0x4 >;
pinctrl-names = "default";
pinctrl-0 = <&spi0_state_default>;
status = "disabled";
};
</pre>

<pre>ative o SPI0, altere o parâmetro status, troque "disabled" por "okay"
*status = "disabled";
por
*status = "okay";</pre>

<pre>compile o kernel novamente, isso pode ser demorado, pois depende do processamento do seu computador.
$make</pre>
***Observação: se tiver dificuldades em compilar o kernel, consulter o Readme.md na raiz do repositório do kernel.

Quando acabar o processo, o kernel com o SPI0 habilitado estará disponível na pasta output/
***Observação: veja como trocar o kernel da labrador neste [https://wiki.caninosloucos.org/index.php/Kernel link].

Uma vez substituido uImage, kernel.dtb e a pasta /lib/modules pelos compilados

reinicie a Labrador

<pre>utilize o comando lsmod para verificar se o driver foi adicionado
$lsmod</pre>

<pre>também pode verificar pelo comando dmesg
$sudo dmesg</pre>

deverá ver algo como;
<pre>
Feb 14 08:12:02 debian-armhf kernel: [ 8.538818] bus: 'platform': add driver caninos_spi0
Feb 14 08:12:02 debian-armhf kernel: [ 8.538947] bus: 'platform': driver_probe_device: matched device b0200000.spi with driver caninos_spi0
Feb 14 08:12:02 debian-armhf kernel: [ 8.538966] bus: 'platform': really_probe: probing driver caninos_spi0 with device b0200000.spi
Feb 14 08:12:02 debian-armhf kernel: [ 8.539042] pinctrl core: add 2 pinctrl maps
Feb 14 08:12:02 debian-armhf kernel: [ 8.539127] caninos-labrador-pinctrl soc:pinctrl@b01b0040: found group selector 34 for mfp1_2_0
Feb 14 08:12:02 debian-armhf kernel: [ 8.539141] caninos-labrador-pinctrl soc:pinctrl@b01b0040: found group selector 33 for mfp1_4_3
Feb 14 08:12:02 debian-armhf kernel: [ 8.539152] caninos_spi0 b0200000.spi: no init pinctrl state
Feb 14 08:12:02 debian-armhf kernel: [ 8.539167] caninos-labrador-pinctrl soc:pinctrl@b01b0040: request pin 87 (P_SPI0_SS) for b0200000.spi
Feb 14 08:12:02 debian-armhf kernel: [ 8.539177] caninos-labrador-pinctrl soc:pinctrl@b01b0040: request pin 88 (P_SPI0_MISO) for b0200000.spi
Feb 14 08:12:02 debian-armhf kernel: [ 8.539196] caninos-labrador-pinctrl soc:pinctrl@b01b0040: request pin 86 (P_SPI0_SCLK) for b0200000.spi
Feb 14 08:12:02 debian-armhf kernel: [ 8.539203] caninos-labrador-pinctrl soc:pinctrl@b01b0040: request pin 89 (P_SPI0_MOSI) for b0200000.spi
Feb 14 08:12:02 debian-armhf kernel: [ 8.539215] caninos_spi0 b0200000.spi: no sleep pinctrl state
Feb 14 08:12:02 debian-armhf kernel: [ 8.539222] caninos_spi0 b0200000.spi: no idle pinctrl state
Feb 14 08:12:02 debian-armhf kernel: [ 8.539271] devices_kset: Moving b0200000.spi to end of list
Feb 14 08:12:02 debian-armhf kernel: [ 8.552479] device: 'spi0': device_add
Feb 14 08:12:02 debian-armhf kernel: [ 8.552784] PM: Adding info for No Bus:spi0
Feb 14 08:12:02 debian-armhf kernel: [ 8.552906] caninos_spi0 b0200000.spi: controller is unqueued, this is deprecated
Feb 14 08:12:02 debian-armhf kernel: [ 8.552925] driver: 'caninos_spi0': driver_bound: bound to device 'b0200000.spi'
Feb 14 08:12:02 debian-armhf kernel: [ 8.553044] bus: 'platform': really_probe: bound device b0200000.spi to driver caninos_spi0
</pre>

Debug

2020-07-24T14:24:31Z

Ruschigo:

== Interface de Debug ==

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

== Conexão com o Debug ==

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

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

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

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

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

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

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

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

== Desativando o Debug [Silent Boot] (Em edição) ==

Algumas vezes pode ser útil desativar o console pela serial, isso torna a UART3 (UART de debug) livre para propósitos gerais como a UART0, mas isso torna o boot difícil para debug. Para realizar essa alteração é necessário a troca do bootloader e quando houver necessidade o u-boot, como mostrado nos passos a frente.

1 - Download do Bootloader: Faça o download do bootloader com console desativado;

*Para Labradores Coreboard 2.x: silent_bootloader-32bits.
*Para Labradores Coreboard 3.x: silent_bootloader-64bits.

2 - Troca do Bootloader: use o comando dd para a troca do bootloader;

- $sudo dd if=/*diretório-do-bootloader*/silent-bootloader.bin of=/dev/*device*/ conv=notrunc seek=1 bs=512
- onde /*diretório-do-bootloader*/ deve ser substituído pelo endereço do diretório onde se encontra o binário do bootloader adquirido no passo anterior.
- onde /*device*/ deve ser substituído pelo endereço do dispositivo onde se quer trocar o bootloader, se estiver na Labrador o endereço da memória interna será /dev/mmcblk2.

3 - Download do Uboot(Somente necessário em arquitetura 32 bits, Coreboards 2.x);

*Faça o download do uboot com console desativado.(silent_uboot-32bits)

4 - Troca do Uboot(Somente necessário em arquitetura 32 bits, Coreboards 2.x)

- $sudo dd if=/*diretório-do-uboot*/silent-u-boot-dtb.img of=/dev/*device*/ conv=notrunc seek=66 bs=512
- onde /*diretório-do-uboot*/ deve ser substituído pelo endereço do diretório onde se encontra o binário do uboot adquirido no passo anterior.
- onde /*device*/ deve ser substituído pelo endereço do dispositivo onde se quer trocar o uboot, se estiver na Labrador o endereço da memória interna será /dev/mmcblk2.

5 - Use o comando sync

- $sudo sync

6 - Use o comando reboot

- $sudo reboot

A Labrador deve agora estar com a serial de Debug desativada, para conferir pode-se utilizar um dispositivo ttl-usb e monitorar em um outro pc durante o boot da Labrador.

Arquivo:Labrador-base-2.0 debug.png

2019-12-20T16:10:03Z

Ruschigo:

Arquivo:Labrador-base-1.0a debug.png

2019-12-20T16:09:42Z

Ruschigo:

Arquivo:Labrador32 flash aborted1.png

2019-12-20T14:21:44Z

Ruschigo:

Arquivo:Labrador32 flash finished.png

2019-12-20T14:14:14Z

Ruschigo:

Arquivo:Labrador32 flash aborted.png

2019-12-20T14:13:35Z

Ruschigo: