jetson nano | Registro de lanzamiento

1. Refrigeración por ventilador nano Jetson

2020-5-10 0:23 El viento y la lluvia golpearon el enrejado de la ventana
. Empecé con un jet de segunda mano nano en * pescado, y empezó esta historia.

• jetson nano 600RMB * pescado
• Ventilador regulador de velocidad 15RMB * bao
• Tarjeta de red inalámbrica 79RMB * bao

1. Configure manualmente el comando del terminal de velocidad del ventilador

• a toda velocidad

sudo sh -c 'echo 255 > /sys/devices/pwm-fan/target_pwm'

• Detener (tenga en cuenta que se reduce lentamente de la velocidad actual a 0, el proceso de desaceleración es de 1 minuto)

sudo sh -c 'echo 20 > /sys/devices/pwm-fan/target_pwm'

2. Ajusta automáticamente la velocidad del ventilador de acuerdo con la temperatura de la CPU

Nota: Las condiciones de los siguientes procedimientos se pueden cambiar según sea necesario.

# 源地址：https://blog.csdn.net/bornfree5511/article/details/103076414
#!/usr/bin/python
#~/fan_control.py
import time
 
while True:
    fo = open("/sys/class/thermal/thermal_zone0/temp","r")
#thermal_zone1是cpu的温度，thermal_zone2是gpu的温度，thermal_zone0的温度一直是最高的，可能
#是封装的温度，可用jtop查看具体的信息
    thermal = int(fo.read(10))
    fo.close()
 
    thermal = thermal / 1000
    
    if thermal < 30: 
        thermal = 0
    elif thermal >= 30 and thermal < 70:
        thermal = thermal - 30
    else:
        thermal = thermal
 
 
    thermal = str(thermal)
    print thermal
 
    fw=open("/sys/devices/pwm-fan/target_pwm","w")
    fw.write(thermal)
    fw.close()
 
    time.sleep(60)

3. Inicio automático en el arranque

Para configurar Jupyter para que se inicie automáticamente al arrancar, consulte: Deje que Jupyter Lab se inicie automáticamente en Jetson Nano.
Consulte ubuntu para implementar el script de Python que se ejecuta en segundo plano + arrancar automáticamente.

1. Cree el archivo rc-local.service

sudo gedit /etc/systemd/system/rc-local.service

2. Reemplace el archivo rc-local.service con lo siguiente

[Unit]
Description=/etc/rc.local Compatibility
ConditionPathExists=/etc/rc.local
 
[Service]
Type=forking
ExecStart=/etc/rc.local start
TimeoutSec=0
StandardOutput=tty
RemainAfterExit=yes
SysVStartPriority=99
 
[Install]
WantedBy=multi-user.target

3. Cree el archivo rc.local

sudo gedit /etc/rc.local

4. Copie el siguiente contenido en el archivo rc.local

#!/bin/sh -e
# rc.local
nohup sudo python ~/fan_control.py > /usr/local/out.log 2>&1 &
exit 0

5. Comando sudo del sistema Ubuntu sin contraseña

sudo gedit /etc/sudoers

El %sudo ALL=(ALL:ALL) ALLrevisado a%sudo ALL=(ALL) NOPASSWD:ALL

请仔细操作！
6. Agregue permisos a rc.local

sudo chmod +x /etc/rc.local

7. Habilite el servicio

sudo systemctl enable rc-local

8. Inicie el servicio y verifique el estado.

sudo systemctl start rc-local.service
sudo systemctl status rc-local.service

9. Reinicie y compruebe si se ha realizado correctamente.

reboot

Si el ventilador gira automáticamente, significa éxito.

2. Visualización de pantalla OLED del bus I2C

1. Tarjeta de expansión Jetracer + paquete de batería (255RMB)

Encontré un auto pequeño basado en jetson nano en un tesoro, hay dos modelos: 1) jetbot; 2) jetracer. Jetbot usa dirección de transmisión diferencial, jetracer es una versión mini de un vehículo no tripulado (el modelo de cinemática geométrica es el modelo de dirección de rueda Ackerman). Esto último es lo que quiero. Jetracer es muy bueno, el único inconveniente es que el motor no tiene codificador, lo que falta en las funciones posteriores (no se puede obtener información más precisa del odómetro). Entonces: solo compré la placa de expansión jetracer y el paquete de baterías de litio.

2. Bus I2C

Jetson nano tiene 2 juegos de buses I2C en total, a saber (I2C BUS 1: 3, 5) (I2C BUS 2:27, 28). Los pines del bus I2C están en J41, es decir, las dos filas de áreas densas de pines.

Ver dispositivos en el bus 1

sudo i2cdetect -y -r 1

Entre ellos, 3c es la dirección del dispositivo I2C del OLED.

3. Pantalla OLED

Dado que la placa de expansión jetracer utiliza la pantalla OLED de 0,91 pulgadas de SSD1306, primero debe instalar Adafruit_SSD1306

sudo pip3 install Adafruit_SSD1306

Dado que el programa de muestra que muestra OLED está en jetbot, instale jetbot primero.

git clone https://github.com/NVIDIA-AI-IOT/jetbot.git
cd jetbot
python3 setup.py build
sudo python3 setup.py install --record jetbot.uninstall.txt

Si necesita desinstalar jetbot, puede ejecutarlo en el directorio raíz de jetbot:

sudo cat jetbot.uninstall.txt | sudo xargs rm -rf

Por lo tanto, es mejor conservar los jetbot.uninstall.txtarchivos.

Ejecuta el programa:

cd jetbot/jetbot/apps/
sudo python3 stats.py

Verá que el OLED muestra información como Ethernet, wlan, memoria y almacenamiento.

3. Chasis y control del automóvil

1. Chasis del coche de dirección Ackerman (209RMB)

Debido a la escasa escalabilidad de jetracer y jetbot, (sin mpu, sin codificación de motor). Jetbot usa control de velocidad diferencial, un motor TT simple sin codificador. Jetracer usa servos de dirección para controlar la dirección, pero los dos motores traseros no tienen codificadores. Por lo tanto, no se consideran los chasis de jetbot y jetracer.

Escogí un mini auto (motor con código, mecanismo de dirección) sin controlador en otra tienda. En esa tienda, también hay controladores (del tipo que se puede controlar directamente con un gamepad). Porque el coche ya es pequeño, 211 x 191 x 65 mm. Si el sistema usa dos placas de computación, la carrocería del automóvil debe estar hinchada. Quiero enfocar todo en jetson nano, al igual que jetracer.

Protocolo de comunicación serie ROS y capa inferior

Número de dígitos	Hexadecimal	código ASCII
1	0x7B	{
2	0x2D o 0x2B	-O +
3	0x30 ~ 0x39	0 ~ 9
4	0x30 ~ 0x39	0 ~ 9
5	0x30 ~ 0x39	0 ~ 9
6	0x30 ~ 0x39	0 ~ 9
7	0x2D o 0x2B	-O +
8	0x30 ~ 0x39	0 ~ 9
9	0x30 ~ 0x39	0 ~ 9
10	0x30 ~ 0x39	0 ~ 9
11	0x30 ~ 0x39	0 ~ 9
12	0x7D	}

Por ejemplo, si envío {+ 3000-0100}, significa que la velocidad esperada es 3000/100 y el ángulo esperado es -100/100.

2. Motor DC + FeatherWing paso a paso （45RMB）

El PCA9686 en la placa de expansión jetracer solo conduce a dos canales, uno de los cuales se usa para controlar el servo de dirección, y los dos motores detrás de él comparten un canal. 在实际测试中，即使用同一个信号控制，两个电机的转速是不一样的，这次上电是左边的快些，下次上电可能就是右边的快些。Si las velocidades de los motores izquierdo y derecho no se pueden controlar para que sean consistentes, entonces, en la operación real, no podemos controlar bien el automóvil para que conduzca en una trayectoria predeterminada. Para más discusión, consulte los dos motores de CC a diferentes velocidades. El automóvil siempre va en línea recta. ¿Cómo resolverlo? .

La única solución es controlar los motores izquierdo y derecho por separado y usar PID para ajustar la velocidad a la misma velocidad. Sin embargo, pero, pero, sin embargo. . . Los motores izquierdo y derecho de la placa de expansión jetracer comparten un canal de control. Preguntó al servicio de atención al cliente, a menos que se cambie el circuito de hardware. . .

Entonces, varias soluciones de búsqueda, encuentre DC Motor + Stepper FeatherWing que se muestra en la figura a continuación.

Descripción del pin

Casualmente, es la placa de control del motor utilizada en la versión oficial del jetbot (no la versión Micro Snow) (también puede accionar otros tipos de motores). El siguiente diagrama es más sencillo.

Método de conexión:
MPU6050 jetson nano
VCC - 5v
GND - GND
SCL - 28
SDL - 27
(28, 27) significa bus I2C0

La dirección del dispositivo de MPU6050 es 0x68

código:

import atexit
from Adafruit_MotorHAT import Adafruit_MotorHAT
import traitlets
from traitlets.config.configurable import Configurable


class Motor(Configurable):

    value = traitlets.Float()
    
    # config
    alpha = traitlets.Float(default_value=1.0).tag(config=True)
    beta = traitlets.Float(default_value=0.0).tag(config=True)

    def __init__(self, driver, channel, *args, **kwargs):
        super(Motor, self).__init__(*args, **kwargs)  # initializes traitlets

        self._driver = driver
        self._motor = self._driver.getMotor(channel)
        if(channel == 1):
            self._ina = 1
            self._inb = 0
        else:
            self._ina = 2
            self._inb = 3
        atexit.register(self._release)
        
    @traitlets.observe('value')
    def _observe_value(self, change):
        self._write_value(change['new'])

    def _write_value(self, value):
        """Sets motor value between [-1, 1]"""
        mapped_value = int(255.0 * (self.alpha * value + self.beta))
        speed = min(max(abs(mapped_value), 0), 255)
        self._motor.setSpeed(speed)
        if mapped_value < 0:
            self._motor.run(Adafruit_MotorHAT.FORWARD)
            self._driver._pwm.setPWM(self._ina,0,0)
            self._driver._pwm.setPWM(self._inb,0,speed*16)
        else:
            self._motor.run(Adafruit_MotorHAT.BACKWARD)
            self._driver._pwm.setPWM(self._ina,0,speed*16)
            self._driver._pwm.setPWM(self._inb,0,0)

    def _release(self):
        """Stops motor by releasing control"""
        self._motor.run(Adafruit_MotorHAT.RELEASE)
        self._driver._pwm.setPWM(self._ina,0,0)
        self._driver._pwm.setPWM(self._inb,0,0)
import time
import traitlets
from traitlets.config.configurable import SingletonConfigurable
from Adafruit_MotorHAT import Adafruit_MotorHAT



class Robot(SingletonConfigurable):
    
    left_motor = traitlets.Instance(Motor)
    right_motor = traitlets.Instance(Motor)

    # config
    i2c_bus = traitlets.Integer(default_value=0).tag(config=True)
    left_motor_channel = traitlets.Integer(default_value=1).tag(config=True)
    left_motor_alpha = traitlets.Float(default_value=1.0).tag(config=True)
    right_motor_channel = traitlets.Integer(default_value=2).tag(config=True)
    right_motor_alpha = traitlets.Float(default_value=1.0).tag(config=True)
    
    def __init__(self, *args, **kwargs):
        super(Robot, self).__init__(*args, **kwargs)
        self.motor_driver = Adafruit_MotorHAT(i2c_bus=self.i2c_bus, addr=0x68)
        self.left_motor = Motor(self.motor_driver, channel=self.left_motor_channel, alpha=self.left_motor_alpha)
        self.right_motor = Motor(self.motor_driver, channel=self.right_motor_channel, alpha=self.right_motor_alpha)
        
    def set_motors(self, left_speed, right_speed):
        self.left_motor.value = left_speed
        self.right_motor.value = right_speed
        
    def forward(self, speed=1.0, duration=None):
        self.left_motor.value = speed
        self.right_motor.value = speed

    def backward(self, speed=1.0):
        self.left_motor.value = -speed
        self.right_motor.value = -speed

    def left(self, speed=1.0):
        self.left_motor.value = -speed
        self.right_motor.value = speed

    def right(self, speed=1.0):
        self.left_motor.value = speed
        self.right_motor.value = -speed

    def stop(self):
        self.left_motor.value = 0
        self.right_motor.value = 0
robot = Robot()
robot.set_motors(2.0, 1.0)

Si la velocidad de los dos motores de la izquierda y la derecha no es la misma, significa éxito.

Cuarto, el sensor

1. MPU6050 (3.28RMB)

Lo compré de cierto tesoro, esta cosa es tan barata. Sin embargo, se colocó con Motor DC + Stepper FeatherWing. No sé qué significa GY-521. De todos modos, sé que jetson nano lee los datos de IMU de esta cosa a través de I2C.

Primero, instale
py_imu_mpu6050 dirección github: https://github.com/romybompart/py_imu_mpu6050

sudo pip3 install py-imu-mpu6050

Método de conexión:
MPU6050 jetson nano
VCC - 5v
GND - GND
SCL - 28
SDL - 27
(28, 27) significa bus I2C0

La dirección del dispositivo de MPU6050 es 0x68

Después de conectarse, ejecute el siguiente comando, aparecerá la dirección del dispositivo mpu6050.

Descripción de Jetson Nano I2C y carcasa de Python: MPU6050