td3:bbx - Wiki TDIII

Estás aquí: start » td3 » bbx
Esta página es de solo lectura. Puedes ver la fuente pero no puedes cambiarla. Pregunta a tu administrador si crees que esto es incorrecto.
====== Introducción ======

La presente guía tiene por objeto brindar el procedimiento necesario para la instalación de un SO Linux distribución Ubuntu en una SD para un sistema del tipo Beagle.
El procedimiento detallado en los subsiguientes apartados se encuentra basado en [[https://www.digikey.com/eewiki/display/linuxonarm/BeagleBone+Black|Linux on ARM]], pero con las modificiones necesarias para satisfacer el propósito de la cátedra, por tal motivo no se utilizará la ROM.

La idea es que el alumno pueda empaparse con el procedimiento básico para la generación de imágenes //custom// de Linux para sistemas embebidos. Cada caso, será particular al embebido en cuestión, pero típicamente consta de lo mismos **macro-pasos** enumerados. 

====== Mapa de memoria ======
==== Componentes del sistema ====
* **MLO :**
Minimal LOader es un bootloader básico utilizado por TI (Texas Instruments) para las familias OMAP y derivados. Su principal misión es inicializar el hardware, unidades del SOC y 
periféricos de la placa, mínimo para la operación. Por lo general en este software se configura el controlador de RAM externa, terminal de depuración, relojes del sistema y unidades de control de alimentación

* **[[http://www.denx.de/wiki/U-Boot|U-Boot]] :**
Es un bootloader de propósito general destinado principalmente a embebidos. Entre las funciones implementadas se destacan la inicialización de los pines no críticos para la primera etapa de arranque, hardware secundario (USB, display), la copia de la imagen del kernel, rootfs y DTB de la memoria persistente a RAM y su posterior expansión (deflat)
 
* **[[http://wiki.electron.frba.utn.edu.ar/doku.php?id=td3:device_tree_presentation|DTB]] :**
Es el binario (Device Tree Blob) asociado al DTS (Device Tree Source) que describe el hardware del sistema

* **zImage :**
Imagen comprimida del kernel de Linux

* **rootfs :**
Imagen del sistema de archivos del sistema. En el mismo se localizan todos los binarios necesarios para operación a nivel usuario (root/user) del sistema, así
como tambien aquellos utilizados por el propio OS para su correcta ejecución.


==== SD ====

<code asm>
+--------------------------------------+
|                                      |
|                  MLO                 |
|                                      |
+--------------------------------------+
|                                      |
|                 U-Boot               |
|                                      |
+--------------------------------------+
|                                      |
|                  DTB                 |
|                                      |
+--------------------------------------+
|                                      |
|                zImage                |
|                                      |
+--------------------------------------+
|                                      |
|              Linux rootfs            |
|                                      |
+--------------------------------------+ 
</code>

==== RAM ====
{{:td3:under_construction.jpg|105x200}}

====== Procedimiento ======

A fin de ejecutar exitosamente el procedimiento propuesto es altamente recomendable satisfacer los siguientes requerimientos
  * Crear una carpeta base en un directorio que no requiera privilegios, por ejemplo 
<code bash>
cd /home/<su usuario>
mkdir Imagen_BBB
</code>
  * Trabajar dentro la carpeta creada
<code bash>
cd Imagen_BBB
</code>
  * Verificar que la microSD a utilizar sea compatible con la versión de Beagle.
  * Disponer de unas horas libres para la compilación del Kernel. 
  * Requerimiento del ordenador
    * Lector de memoria SD
    * Al menos 7 GB de espacio en disco
    * SO Linux de 64b (**x86_64**)
<code bash>
christian@desarrollo:/home/usuario/Imagen_BBB$ uname -a
christian@desarrollo:/home/usuario/Imagen_BBB$ Linux nsw02 4.15.0-34-generic #37~16.04.1-Ubuntu SMP Tue Aug 28 10:44:06 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux
</code>
    * GIT instalado
<code bash>
christian@desarrollo:/home/usuario/Imagen_BBB$ sudo apt-get install git-core
</code> 

===== Instalacion del cross compiler =====

Como //cross-compiler// se utiliza [[https://www.linaro.org/|GCC Linaro]]. De esa página, acceder al link: [[https://releases.linaro.org/components/toolchain/binaries/latest-7/arm-linux-gnueabihf/|Binaries]] en **Support/Downloads** (utilizamos arquitectura ARM-v7), descargar la última versión disponible y descomprimir:

<code bash>
user@machine:/home/<su usuario>/Imagen_BBB$ tar xf gcc-linaro-X.X.X-YYYY.MM-x86_64_arm-linux-gnueabihf.tar.xz 
</code>

Dónde, por ejemplo:
  * X.X.X = 7.5.0,
  * YYYY.MM = 2019.12

Para utilizar el nuevo //toolchain//, se disponen de dos opciones a elección del desarrollador
  * **1-Persistente**
Permite disponer de forma permanente la herramienta, para lo cual es necesario incorporar al fichero **.bashrc** ubicado en el directorio de trabajo del usuario la siguiente directiva
<code bash>
export PATH=$PATH:/home/<su usuario>/Imagen_BBB/gcc-linaro-X.X.X-YYYY.MM-x86_64_arm-linux-gnueabihf/bin/ 
</code>
Relanzar la terminal para que los cambios surtan efecto
<code bash>
user@machine://home/<su usuario>/Imagen_BBB/$ arm-linux-gnueabihf-gcc --version
arm-linux-gnueabihf-gcc (Linaro GCC X.X-YYYY.MM) X.X.X YYYYMMDD [linaro-X.X.X-YYYY.MM revision 7b15d0869c096fe39603ad63dc19ab7cf035eb70]
Copyright (C) 2017 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. </code>
  * **2-Temporal**
Para evitar conflictos con otras herramientas utilizadas, es posible establecer una herramienta específica antes de cada contrucción 
<code bash>
user@machine:/home/<su usuario>/Imagen_BBB/$ export CC=`pwd`/gcc-linaro-X.X.X-YYYY.MM-x86_64_arm-linux-gnueabihf/bin/arm-linux-gnueabihf-
user@machine:/home/<su usuario>/Imagen_BBB/$ ${CC}gcc --version
arm-linux-gnueabihf-gcc (Linaro GCC X.X-YYYY.MM) X.X.X YYYYMMDD [linaro-X.X.X-YYYY.MM revision 7b15d0869c096fe39603ad63dc19ab7cf035eb70]
Copyright (C) 2017 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
</code>

===== Instalación y construcción de U-Boot =====
Descargar el //bootloader//, U-Boot((http://www.denx.de/wiki/U-Boot))((http://git.denx.de/?p=u-boot.git;a=summary))((https://github.com/eewiki/u-boot-patches)), para la imagen a construir. Para ello, clonamos el siguiente repositorio y buscamos uno de los branch más reciente (pero **nunca** el último, ya que usualmente requiere de correcciones por parte de los desarrolladores. Idealmente: 1 o 2 branch detrás):

<code bash>
user@machine:~/ubicacion_carpeta/Imagen_BBB$ git clone https://github.com/u-boot/u-boot
user@machine:~/ubicacion_carpeta/Imagen_BBB$ cd u-boot/
user@machine:~/ubicacion_carpeta/Imagen_BBB/u-boot$ git checkout vYYYY.MM -b tmp
</code>

Por ejemplo, YYYY.MM = 2019.04.

Descargar y aplicar los parches correspondientes:

<code bash>
user@machine:~/ubicacion_carpeta/Imagen_BBB/u-boot$ wget -c https://rcn-ee.com/repos/git/u-boot-patches/vYYYY.MM/0001-am335x_evm-uEnv.txt-bootz-n-fixes.patch
user@machine:~/ubicacion_carpeta/Imagen_BBB/u-boot$ wget -c https://rcn-ee.com/repos/git/u-boot-patches/vYYYY.MM/0002-U-Boot-BeagleBone-Cape-Manager.patch
user@machine:~/ubicacion_carpeta/Imagen_BBB/u-boot$ patch -p1 < 0001-am335x_evm-uEnv.txt-bootz-n-fixes.patch
user@machine:~/ubicacion_carpeta/Imagen_BBB/u-boot$ patch -p1 < 0002-U-Boot-BeagleBone-Cape-Manager.patch
</code>

**Nota:** YYYY.MM es el mismo que en el paso anterior.

Configurar y construir ("//buildear//") segun la configuración de las herramientas en la sección anterior (**export** o **.bashrc**):

**Opción 1:** si hiciste //export// antes:
<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB/u-boot$ make ARCH=arm CROSS_COMPILE=${CC} distclean
user@machine:~/ubicacion_carpeta/Imagen_BBB/u-boot$ make ARCH=arm CROSS_COMPILE=${CC} am335x_evm_defconfig
user@machine:~/ubicacion_carpeta/Imagen_BBB/u-boot$ make ARCH=arm CROSS_COMPILE=${CC}
</code>

**Opción 2:** si **NO** hiciste //export// antes:
<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB/u-boot$ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- distclean
user@machine:~/ubicacion_carpeta/Imagen_BBB/u-boot$ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- am335x_evm_defconfig
user@machine:~/ubicacion_carpeta/Imagen_BBB/u-boot$ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-
</code>

Pueden aparecer algunos warnings al finalizar.

**Antes de pasar a la siguiente sección:**

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB/u-boot$ cd ..
user@machine:~/ubicacion_carpeta/Imagen_BBB$
</code>



===== Instalación y contrucción del Linux Kernel =====
Verificar que se encuentra en la carpeta raiz del proyecto
<code bash>
user@machine:~/ubicacion_carpeta/Imagen_BBB/u-boot$ cd user@machine:/home/<su usuario>/Imagen_BBB/
user@machine:~/ubicacion_carpeta/Imagen_BBB$ pwd
user@machine:~/ubicacion_carpeta/Imagen_BBB$ /home/<su usuario>/Imagen_BBB/
</code>

Descargar el //mainline//:
<code bash>
user@machine:~/ubicacion_carpeta/Imagen_BBB$ git clone https://github.com/RobertCNelson/bb-kernel
user@machine:~/ubicacion_carpeta/Imagen_BBB$ cd bb-kernel/
user@machine:~/ubicacion_carpeta/Imagen_BBB/bb-kernel$
</code>

Descargar y contruir  la última versión estable (por ej.: **am33x-v4.19** al momento de actualización de la Wiki): 
<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB/bb-kernel$ git checkout origin/am33x-v4.19 -b tmp
user@machine:~/ubicacion_carpeta/Imagen_BBB/bb-kernel$ ./build_kernel.sh
</code>

Puede que al ejecutar el script **build_kernel.sh** arroje un error pidiendo satisfacer ciertas dependencias, en cuyo caso procedemos a cumplirlas. Por ejemplo, un mensaje que al menos a mi me apareció fue:

<code bash>
 Detected build host [KDE neon User Edition 5.19]
+ host: [x86_64]
+ git HEAD commit: [703093899bef60a157a0586b256e598d85b8227a]
Debian/Ubuntu/Mint: missing dependencies, please install:
-----------------------------
sudo apt-get update
sudo apt-get install lzma lzop libmpc-dev u-boot-tools libssl-dev:amd64 
-----------------------------
* Failed dependency check
</code>

En cuyo caso, ejecuté la línea: 
<code bash>
user@machine:~/ubicacion_carpeta/Imagen_BBB/bb-kernel$ sudo apt-get install lzma lzop libmpc-dev u-boot-tools libssl-dev:amd64 
</code>

Volvemos ejecutar el script, y luego de que realiza un par de descargas y prepara todo, nos aparece la siguiente pantalla de configuración:

{{td3:kernelcfgscreen.png?1000x500}}

la cual, a menos que sea por interés propio del alumno, no modificamos nada. Seleccionamos **exit** y continuamos...y a sentarse a esperar un buen rato (depende de la PC):!::!:. Esta sección (y el script ejecutado) se encarga de construir el Kernel, sus módulos, el //device tree// y los copia al directorio //deploy// (dentro de ésta misma carpeta bb-kernel/deploy/).

Vale aclarar, que a partir de las versiones: **U-Boot: v2018.07 y Kernel: v4.18.x**, se dispone de los parches para Spectre y Meltdown. 

**Una vez finalizado:** observar las últimas líneas devueltas por el script:

<code bash>-----------------------------
Script Complete
eewiki.net: [user@localhost:~$ export kernel_version=4.X.Y-Z]
-----------------------------</code>

Ejecutamos esa línea:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB/bb-kernel$ export kernel_version=4.X.Y-Z </code>


**Y antes de pasar a la siguiente sección:**
<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB/bb-kernel$ cd ..
user@machine:~/ubicacion_carpeta/Imagen_BBB$
</code>



====== RFS: Root File System ======

Aqui nos encargamos de descargar la imagen de Ubuntu:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ wget -c https://rcn-ee.com/rootfs/eewiki/minfs/ubuntu-XX.YY.Z-minimal-armhf-YYYY-MM-DD.tar.xz</code>

Ejemplo:
  * XX.YY.Z: puede ser **18.04.1** o **20.04**. Se puede acceder a dicha [[https://rcn-ee.com/rootfs/eewiki/minfs/|web]] y elegir la imagen a gusto,
  * YYYY-MM-DD: puede ser **2020-05-10**, como siempre, se recomienda no elegir la última.

Verificamos que se haya descargado correctamente:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sha256sum ubuntu-XX.YY.Z-minimal-armhf-YYYY-MM-DD.tar.xz
6b212ee7dd0d5c9c0af49c22cf78b63e6ad20cec641c303232fca9f21a18804c  ubuntu-XX.YY.Z-minimal-armhf-YYYY-MM-DD.tar.xz
</code>

Extraemos:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ tar xf ubuntu-XX.YY.Z-minimal-armhf-YYYY-MM-DD.tar.xz</code>

Al momento de la creación de este tutorial, el usuario y contraseña para esta distribución son:

^ Usuario  ^ Contraseña ^
| ubuntu   | temppwd    |

====== Instalación ======

LLegados a este punto, debemos contar con el siguiente árbol de directorios en la carpeta Imagen_BBB/:

{{td3:carpetas2.png?1000x500}}

Dónde además, ya compilamos el bootloader y el kernel. Los pasos restantes son para grabar la imagen en la micro SD y en la sección siguiente, configurar la conectividad a internet.

==== Preparación de la microSD ====

**NOTA:** tener cuidado con los comandos a continuación, sobre todo con el comando **dd**, ya que si ponemos mal el //device// (el "disco" en este caso"), podemos llegar a perder la PC Host. Para más información, ingresar a la pagina [[http://man7.org/linux/man-pages/man1/dd.1.html|man linux dd]].

Antes de continuar, tenemos que saber que nombre le asignó el sistema operativo al //device//. Para ello, ejecutamos el comando **dmesg** ([[http://man7.org/linux/man-pages/man1/dmesg.1.html|man linux dmesg]]):

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo dmesg </code>

Luego, **COLOCAR LA SD EN EL LECTOR DE LA NOTEBOOK/PC**, no montarla, ni abrir el gestor de archivos si el SO nos ofrece hacerlo (eso monta la SD), y volver a ejecutar el mismo comando. De todo el listado de mensajes que nos devuelve, ubicar los mensajes nuevos debido a la inserción de la SD:

<code bash>[  345.857375] mmc0: new SDHC card at address 0001
[  345.931132] mmcblk0: mmc0:0001 SD8GB 7.28 GiB
[  345.933006]  mmcblk0: p1</code>



En el caso ejemplo, resulta ser: **mmcblk0**. Por lo tanto, hacemos:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ export DISK=/dev/mmcblk0</code>

Con el comando **lsblk** podrán obtener un listado de las unidades de almacenamiento y sus particiones.

Comenzamos con el procedimiento:

  * Borramos la tabla de particiones de la microSD:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo dd if=/dev/zero of=${DISK} bs=1M count=10</code>

  * Instalamos el bootloader:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ dd if=./u-boot/MLO of=${DISK} count=1 seek=1 bs=128k
user@machine:~/ubicacion_carpeta/Imagen_BBB$ dd if=./u-boot/u-boot.img of=${DISK} count=2 seek=1 bs=384k</code>

  * Creamos el esquema de particiones. Para ello, requerimos del comando **sfdisk** ([[http://man7.org/linux/man-pages/man8/sfdisk.8.html | man linux sfdisk]]). Y en función de la versión que dispongamos:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo sfdisk --version
sfdisk from util-linux X.XX.X</code>
   
**Para version >= 2.26.x:**

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo sfdisk ${DISK} <<-__EOF__
4M,,L,*
__EOF__</code>
   
**Para version =< 2.25.x:**

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo sfdisk --unit M ${DISK} <<-__EOF__
4,,L,*
__EOF__</code>

  * Formateamos las particiones. Para ello, utilizamos el comando **mkfs.ext4** ([[https://linux.die.net/man/8/mkfs.ext4 | man linux mkfs.ext4]]). Y en función de la versión que dispongamos:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo mkfs.ext4 -V</code>
   
**Para versión >= 1.43:**

Para el caso en que: //**DISK=/dev/mmcblk0**//:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo mkfs.ext4 -L rootfs -O ^metadata_csum,^64bit ${DISK}p1</code>

Para el caso en que: //**DISK=/dev/sdX**//:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo mkfs.ext4 -L rootfs -O ^metadata_csum,^64bit ${DISK}1</code>

   
**Para versión =< 1.42:**

Para el caso en que: //**DISK=/dev/mmcblk0**//:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo mkfs.ext4 -L rootfs ${DISK}p1</code>

Para el caso en que: //**DISK=/dev/sdX**//:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo mkfs.ext4 -L rootfs ${DISK}1</code>

  * **Finalmente, montamos la microSD:**

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo mkdir -p /media/rootfs/</code>

Para el caso en que: //**DISK=/dev/mmcblk0**//:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo mount ${DISK}p1 /media/rootfs/ </code>

Para el caso en que: //**DISK=/dev/sdX**//:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo mount ${DISK}1 /media/rootfs/</code>



==== Instalación del Kernel y el Root File System ====

=== Root File System ===

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo tar xfvp ./*-*-*-armhf-*/armhf-rootfs-*.tar -C /media/rootfs/ 
user@machine:~/ubicacion_carpeta/Imagen_BBB$ sync
user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo chown root:root /media/rootfs/
user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo chmod 755 /media/rootfs/</code>

Crear el archivo uEnv.txt en el directorio local de trabajo, con las siguientes lineas:

<code bash>#for single partitions:
mmcroot=/dev/mmcblk0p1</code>

Luego, copiarlo al microSD:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo cp -v ./uEnv.txt /media/rootfs/boot/</code>

Y finalmente: 

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo sh -c "echo 'uname_r=${kernel_version}' >> /media/rootfs/boot/uEnv.txt"</code>

=== Linux Kernel ===

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo cp -v ./bb-kernel/deploy/${kernel_version}.zImage /media/rootfs/boot/vmlinuz-${kernel_version}
user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo mkdir -p /media/rootfs/boot/dtbs/${kernel_version}/
user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo tar xfv ./bb-kernel/deploy/${kernel_version}-dtbs.tar.gz -C /media/rootfs/boot/dtbs/${kernel_version}/
user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo tar xfv ./bb-kernel/deploy/${kernel_version}-modules.tar.gz -C /media/rootfs/
</code>

Editamos el archivo que contiene la tabla de particiones, y lo configuramos para que ante el booteo, monte la partición //p1// de la SD en el directorio //raiz//:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo sh -c "echo '/dev/mmcblk0p1  /  auto  errors=remount-ro  0  1' >> /media/rootfs/etc/fstab"</code>












====== Networking ======

En este paso caben 2 escenarios distintos. Uno es que se desee utilizar la BBB conectada a un router, y el otro conectada a la PC. Estos casos, a fines prácticos de la materia, son mutuamente excluyentes. Es decir, se opta por uno de los métodos. 

=== Configuración en la BBB ===

Editamos/creamos el archivo de configuración: **interfaces**:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo vim /media/rootfs/etc/network/interfaces</code>

  * Si pretendemos conectar la BBB a un router, creamos el archivo con las siguientes lineas:

<code>auto lo
iface lo inet loopback
  
auto eth0
iface eth0 inet dhcp </code>

  * Si pretendemos conectarla a la PC, creamos el archivo con las siguientes lineas:

<code>auto lo
iface lo inet loopback</code>

Luego, para cualquiera de los 2 casos, agregamos la siguiente regla persistente:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo vim /media/rootfs/etc/udev/rules.d/70-persistent-net.rules</code>

Y le escribimos:

<code># BeagleBone: net device ()
SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{dev_id}=="0x0", ATTR{type}=="1", KERNEL=="eth*", NAME="eth0"</code>

Por otro lado, nuevamente, dependiendo del caso elegido varía la configuración de [[https://netplan.io/|Netplan]]((https://netplan.io/examples)). Para ello creamos un archivo que llamaremos **default.yaml**:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo vim /media/rootfs/etc/netplan/default.yaml</code>

  * Si pretendemos conectar la BBB a un router, creamos el archivo con las siguientes lineas:

<code>
network:
  version: 2
  renderer: networkd
  ethernets:
    eth0:
      dhcp4: true
</code>


  * Si pretendemos conectar la BBB a la PC, creamos el archivo con las siguientes lineas:

<code>
network:
  version: 2
  renderer: networkd
  ethernets:
    eth0:
      addresses:
        - 172.31.255.2/24
      nameservers:
          addresses: [8.8.8.8, 8.8.4.4]
</code>

Finalizados estos pasos, podemos extraer la microSD:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sync
user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo umount /media/rootfs</code>


=== Configuración en la PC ===

Este paso debe seguirse si se optó por conectar la BBB a la PC. En este paso, lo que haremos será crear una nueva conexión cableada con el gestor de conexiones de la distribución que estemos utilizando. La cual debe quedar configurada de la siguiente manera:


^ Nombre Conexión ^ Hardware ^ Tipo ^ Método ^ Dirección IP ^ Máscara de Red ^ Puerta de enlace ^
| BBB_Cable       | Cableada | IPv4 | Manual | 172.31.255.1 | 255.255.255.0  | 0.0.0.0 |


=== Configuración para acceso SSH ===

Finalmente, para poder acceder mediante **ssh** debemos editar un archivo de configuración ubicado en **/etc/ssh/** llamado //**ssh_config**//. Por default, aparece totalmente comentado (comentarios son: #) y debemos **descomentar** las líneas (editar con **sudo**): 

<code>
    Port 22
    Protocol 2
</code>

Y agregar al final de todo:

<code>
    PermitRootLogin yes
</code>

Guardar el archivo y listo. Con esto, ya deberíamos poder conectarnos a la BBB con un cable de red conectado a la PC, mediante **ssh**: 

<code bash>user@machine:~$ ssh ubuntu@172.31.255.2</code> 

=== Internet en la BBB y la PC (método NO seguro para producto)===

Este paso NO es obligatorio, pero si conectamos la BBB a la PC y queremos tener acceso a internet en la BBB, debemos realizar las siguientes operaciones:

== BBB ===

En el primer booteo de la BBB:

<code bash>ubuntu@arm:~$ cd /etc
ubuntu@arm:~$ sudo ln -sf ../run/systemd/resolve/stub-resolv.conf resolv.conf
ubuntu@arm:~$ sudo systemctl disable connman.service
ubuntu@arm:~$ sudo systemctl enable systemd-networkd.service systemd-resolved.service
ubuntu@arm:~$ sudo systemctl reboot</code>

Esto no se repite más. Lo siguiente, debe hacerse cada vez que se bootee la BBB:

<code bash>ubuntu@arm:~$ sudo ip route add 0.0.0.0/0 via IP_ASIGNADA_AL_HOST</code>

Que en el caso ejemplo, IP_ASIGNADA_AL_HOST = 172.31.255.1

== PC ==

En la consola de la PC deben ejecutarse los siguientes comandos:

<code bash>user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo iptables -A POSTROUTING -t nat -j MASQUERADE
user@machine:~/ubicacion_carpeta/Imagen_BBB$ sudo sysctl -w net.ipv4.ip_forward=1</code>

**Aclaración**: el método mostrado para brindarle acceso a internet a la BBB a través de la PC, no es el método más seguro, con lo cual **NO** debe ser tomado como el procedimiento estándar para implementaciones
profesionales. La forma correcta es algo más compleja, y escapa a los objetivos de la materia (y los tiempos disponibles para que todos los alumnos puedan implementarlo).\\

====== FAQ ======
  * **¿Al crear uEnv.txt siempre debo utilizar el dispositivo indicado en el "paso a paso"?**
No. El dispositivo corresponde al visualizado en el punto de montaje, ya sea por dmesg o mount. Por ejmplo si se observa que la tarjeta se monta en /dev/sdX, se debe utilizar dicho dispositivo.


 --- //[[luciano.ferreyro@iteda.cnea.gov.ar|LFerreyro]]//\\ 
 --- //[[cnigri@frba.utn.edu.ar|ChristiaN]]//\\
//2020/08/04 16:33//
Traza: • td2_slides • td3_slides • lnks • gtp_1 • uso_del_git_para_la_entrega_de_tp
Búsqueda
