Placa de expansão de simulação para Raspberry Pi

Durante muito tempo, o microcomputador Raspberry Pi entrou na vida de geeks, administradores de sistemas, programadores e engenheiros eletrônicos. Barato e relativamente poderoso para sua classe, com portas de E / S integradas, ele pode lidar com várias tarefas e atender às necessidades do usuário. Depois de comprar um Raspberry Pi, eu queria algo para ativar, medir e gerenciar dispositivos externos. Um grande número de cartões de expansão está sendo vendido atualmente, como aqui, Você pode usar a placa de ensaio com fios para prototipagem rápida, mas eu prefiro criar dispositivos por conta própria, para tarefas específicas. Pela primeira vez, eu não usei um pente de duas linhas para todas as saídas, mas me limitei a várias portas de E / S, SPI, I2C e barramento UART. Liguei o Raspberry Pi com os fios-alvo para prototipar "mãe-mãe".

imagem

Nesse sentido, uma série de três placas de prototipagem foi desenvolvida, sendo uma delas a mais simples que discutirei neste artigo.

Então o que eu precisava:

  • Trabalhe com o GPIO com entradas e saídas;
  • Gerenciamento de carga;
  • Conexão de sensores de temperatura no barramento de 1 fio;
  • Medição de tensão;
  • Relógio em tempo real;
  • Monitoramento e controle de um dispositivo externo via barramento RS485;
  • Fonte de alimentação separada para placa de expansão;

De acordo com a lista acima, um circuito elétrico foi desenvolvido:
imagem
Um circuito de um armazenamento de alta resolução

O circuito utiliza uma fonte de energia do transformador com dois enrolamentos de saída. O primeiro enrolamento opera em um regulador de tensão linear com uma saída de 5V, para alimentar o chip do driver RS485 e o relógio em tempo real. O segundo enrolamento é usado para alimentar relés e montagem eletromagnéticos com transistores Darlington.

O sensor de temperatura DS18B20 é alimentado por + 3.3V a partir da placa Raspberry Pi, a placa possui um conector para conectar sensores externos DS18B20, a mesma tensão é tomada para o ADC e os níveis correspondentes com um relógio em tempo real. O circuito usa quatro botões S1-S4 para controlar quaisquer ações que operam em um nível lógico baixo. Para controlar as cargas, é usado o conjunto do transistor DD1 ULN2003 com diodos de proteção embutidos. Os relés K1 e K2 são conectados aos pinos 16, 15 do conjunto do transistor, os LEDs para indicação são conectados aos pinos 14-12, os pinos 11, 10 são projetados para se conectar a dispositivos externos de acordo com o esquema com um coletor comum ou relés adicionais com uma tensão de enrolamento de + 12V.

Para medir a tensão, são utilizados dois canais de um ADC DD3 MCP3008 de 10 bits com uma interface SPI, com um filtro passa-baixo de entrada. O nó analógico é feito primitivamente, para fins acadêmicos ou para depuração rápida. Se surgir a pergunta sobre a medição qualitativa de um sinal analógico, você precisará desacoplar o terra digital e analógico, use uma fonte de referência de tensão externa. Como alternativa, a parte analógica pode ser feita da seguinte forma:



Somente será necessário usar o conversor de nível TTL → LVTTL no barramento SPI.

O relógio em tempo real DD4 é produzido no chip DS1307, e o ressonador de quartzo Q1 a 32.768 kHz é usado para o relógio. Uma bateria de lítio de 3 volts soldada na placa é usada para alimentar o chip de RAM do relógio. O microcircuito é conectado através de um conversor de nível 5V-3.3V fabricado nos transistores MOS VT2, VT3 ao Raspberry Pi através do barramento I2C (o CAD usou a conexão com linhas sem conexão explícita).

Como driver UART → RS485, o chip DD2 ST485 foi usado. As soluções de circuito que usam o transistor VT1 permitiram abandonar uma saída separada para controlar o transceptor. Ele muda para o modo de transmissão somente quando o UART está transmitindo dados, o resto do tempo o ST485 está no modo de recebimento. O comando de controle do transceptor é removido do coletor do transistor VT1.

Além de converter as interfaces, esse esquema também desempenha a função de combinar os níveis LVTTL da interface UART Raspberry Pi com os níveis TTL do driver ST485. O sinal recebido do coletor do transistor VT1 eleva o nível na entrada DI para 5V, e o resistor R16 e o ​​diodo Zener VD8 limitam o nível da saída R0 a 3,3V. Não preste atenção no resistor R11, ele permaneceu no circuito durante a depuração. O RS485 é testado com o protocolo ModBus RTU a 115200 baud.

Consequentemente, uma placa de circuito foi desenvolvida:



Modelos 3D da placa de circuito impresso



Foto do dispositivo acabado e trabalho com a placa de expansão:







Variante do esquema de conexão com dispositivos externos:


para verificar os nós da placa de expansão, usei alguns scripts em python (não conheço essa linguagem, escrevi por tentativa e erro, pesquisando os códigos dos especialistas)
Para medir a tensão de um potenciômetro conectado aos canais ADC, escrevi um simples script:

Fonte python MCP3008
#!/usr/bin/python

# Example program to read data from MCP3008 10 bit ADC

import spidev
import time
import os
 
# Open SPI bus
spi = spidev.SpiDev()
spi.open(0,0)
 
# Function to read SPI data from MCP3008 chip
# Channel must be an integer 0-7
def ReadChannel(channel):
  adc = spi.xfer2([1,(8+channel)<<4,0])
  data = ((adc[1]&3) << 8) + adc[2]
  return data
 
# Function to convert data to voltage level,
# rounded to specified number of decimal places.
def ConvertVolts(data,places):
  volts = (data * 3.3) / float(1023)
  volts = round(volts,places)
  return volts
 
# Define sensor channels
first_channel = 0
second_channel  = 1
 
# Define delay between readings
delay = 5

print "------------------------------------------------------"
 
while True:
 
  # Read the first channel data
  first_level = ReadChannel(first_channel)
  first_channel_volts = ConvertVolts(first_level,2)
 
  # Read the second channel data
  second_level = ReadChannel(second_channel)
  second_channel_volts = ConvertVolts(second_level,2)
  
 
  # Print out results
  print "------------------------------------------------------"
  print("First ADC channel: {} ({}V)".format(first_level,first_channel_volts))
  print("Second ADC channel : {} ({}V)".format(second_level,second_channel_volts))
 
  # Wait before repeating loop
  time.sleep(delay)



O script a seguir foi usado para trabalhar com termômetros DS18B20:

Fonte python DS18B20

# Example program to read data from DS18B20
# This code taken from
# https://kropochev.com/?go=all/raspberry-pi-and-onewire-sensor/

import os
import glob
import time

os.system('modprobe w1-gpio')
os.system('modprobe w1-therm')

base_dir = '/sys/bus/w1/devices/'
device_folder = glob.glob(base_dir + '10*')[0]
device_file = device_folder + '/w1_slave'

def read_temp_raw():
    f = open(device_file, 'r')
    lines = f.readlines()
    f.close()
    return lines

def read_temp():
    lines = read_temp_raw()
    while lines[0].strip()[-3:] != 'YES':
        time.sleep(0.2)
        lines = read_temp_raw()
    equals_pos = lines[1].find('t=')
    if equals_pos != -1:
        temp_string = lines[1][equals_pos+2:]
        temp_c = float(temp_string) / 1000.0
        temp_f = temp_c * 9.0 / 5.0 + 32.0
        return temp_c, temp_f

while True:
    print(read_temp())
    time.sleep(1)


Também documentei as configurações no Raspbian:

Configurar dispositivos
— 1 Wire settings:
— Raspbian wheezy

Enter command in console:
pi@raspberrypi~$ sudo modprobe w1-gpio
pi@raspberrypi~$ sudo modprobe w1_therm

Then check sensor in system:
pi@raspberrypi ~ $ sudo ls /sys/bus/w1/devices/w1_bus_master1/

You can see the tabel below entered comman and
there you should find HEX like 28-000002da8328;
This is DS18B20 address;

Next read the data from DS18B20 sensor using command:
pi@raspberrypi ~ $ cat /sys/bus/w1/devices/w1_bus_master1/28-000002da8328/w1_sla

And you are going see temperature in console like:
6f 01 4b 46 7f ff 01 10 67: crc=67 YES
6f 01 4b 46 7f ff 01 10 67 t=22937

t=22937 — you should divide this number on 1000 and you will have temperature in Celsius;

— Raspbian Jezzy

Enter command:
pi@raspberrypi~$ sudo nano /boot/config.txt

On next step you should write in config file
dtoverlay=w1-gpio,gpiopin=4
dtoverlay=w1-gpio-pullup

Then you should reboot your raspberry Pi;

— I2C Real Time Clock settings:
— Update your system if it needed and install i2c-tools:
pi@raspberrypi~$ sudo apt-get update
pi@raspberrypi~$ sudo apt-get -y upgrade
pi@raspberrypi~$ sudo apt-get i2c-tools:

Enter command:
pi@raspberrypi~$ sudo nano /etc/modules
Add these lines:
i2c-bcm2708
i2c-dev
rtc_ds1307

Comment one line in file:
pi@raspberrypi~$ sudo nano /etc/modprobe.d/raspi-blacklist.conf
Add # Symbol in beginning of line

blacklist i2c-bcm2708
________________________________________________________
Reboot system;
Enter command:
pi@raspberrypi~$ sudo lsmod

You will see lines like:
rtc_ds1307 7715 0
i2c_dev 5277 0
i2c_bcm2708 4719 0
________________________________________________________

Get DS1307 address:
pi@raspberrypi~$ sudo i2cdetect -y 1

You will see table in console:

0 1 2 3 4 5 6 7 8 9 a b c d e f
00: — -- — -- — -- — -- — -- — -- — 10: — -- — -- — -- — -- — -- — -- — -- — --
20: — -- — -- — -- — -- — -- — -- — -- — --
30: — -- — -- — -- — -- — -- — UU — -- — --
40: — -- — -- — -- — -- — -- — -- — -- — --
50: — -- — -- — -- — -- — -- — -- — -- — --
60: — -- — -- — -- — -- 68 — -- — -- — -- — 70: — -- — -- — -- — --

In address 0x3b some device without driver and 0x68 perhaps DS1307 clock address.

Enter command:
echo ds1307 0x68 > /sys/class/i2c-adapter/i2c-1/new_device

Read clock:
pi@raspberrypi~$ sudo hwclock -r

Set time:
pi@raspberrypi~$ sudo hwclock -w
Set system time from RTC:
pi@raspberrypi~$ sudo hwclock -s

Automatic RTC start;
Add lines in /etc/rc.local file

echo ds1307 0x68 > /sys/class/i2c-adapter/i2c-1/new_device
sudo hwclock -s
Before last line in file looks like:

exit 0
— Uart settings:
— Back up files:
cp /boot/cmdline.txt /boot/cmdline.bak
cp /etc/inittab /etc/inittab.bak

Delete «console=ttyAMA0,115200» «kgdboc=ttyAMA0,115200» lines from configuration file:
pi@raspberrypi~$ nano /boot/cmdline.txt

Comment last line looks like «T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100: in /etc/inittab file: using # symbol:
pi@raspberrypi~$ nano /etc/inittab


A placa de circuito era urgentemente necessária, então eu mesmo a fiz usando a tecnologia LUT e algumas horas de tempo livre. Para facilitar o trabalho e economizar tempo, a placa de circuito foi fabricada unilateralmente com jumpers do MGShV 0.5. Projeto do circuito DipTrace e PCB, códigos-fonte de teste, lista de componentes e tutorial com comandos para configuração no
repositório .

PS: no vídeo abaixo, é utilizada a primeira placa de simulação, que foi montada em uma placa de ensaio com botões e LEDs em 20 minutos, as seguintes versões apareceram em sua base:

Source: https://habr.com/ru/post/pt401089/


All Articles