As placas ESP32 têm suporte para vários protocolos de comunicação. Esses protocolos incluem USART serial, I2C (IIC) e SPI. Juntamente com essas placas ESP32, também estão disponíveis protocolos de comunicação sem fio, como WiFi, Bluetooth duplo, ESP-Now, LoRa e muitos mais. Hoje estaremos focando no protocolo ESP32 SPI (Serial Peripheral interface).
SPI (Serial Peripheral Interface) no ESP32
SPI ou interface serial periférica é um protocolo de comunicação de curta distância usado em vários dispositivos microcontroladores, como o ESP32. É um protocolo de comunicação síncrona usado principalmente por microcontroladores para se comunicar com seus periféricos, de modo que podemos usar esse protocolo para ler e controlar dispositivos que suportam o protocolo SPI.
A comunicação SPI suporta a configuração mestre-escravo, há sempre um 1 mestre que controla vários escravos. É um duplex completo comunicação para que os dados possam ser trocados simultaneamente de mestre para escravo e escravo para mestre.
A comunicação SPI nas necessidades do ESP32 quatro pinos diferentes para transmitir e receber dados para dispositivos. A seguir estão esses quatro pinos:
- SCK: A linha do relógio determina a velocidade de transmissão
- MISSÔ: Master in slave out é o pino de transmissão do slave para o master
- FUMAÇA: Master out slave in é a linha de transmissão de dados mestre para escravo
- SS: A linha de seleção de escravos ajuda o ESP32 a selecionar um escravo específico e transmitir ou receber dados desse escravo
Observação: Alguns dispositivos que são apenas escravos e não podem atuar como mestres, sua nomenclatura de pin é diferente, como:
-
- MISSÔ é substituído por SDO (Saída de dados seriais)
- FUMAÇA é substituído por SDI (Entrada de dados seriais)
Pinos SPI no ESP32
A placa ESP32 vem com 4 diferentes periféricos SPI integrados com seu microcontrolador.
-
- SPI0: Apenas para comunicação de memória interna - não pode ser usado com dispositivos SPI externos
- SPI1: Apenas para comunicação de memória interna - não pode ser usado com dispositivos SPI externos
- SPI2: (HSPI) possuem sinais de barramento independentes. Cada ônibus pode derivar 3 dispositivos escravos
- SPI3: (VSPI) o sinal do barramento é independente. Cada ônibus pode derivar 3 dispositivos escravos
A maioria das placas ESP32 vem com pinos SPI pré-atribuídos para SPI2 e SPI3. No entanto, se não for atribuído, sempre podemos atribuir pinos SPI no código. A seguir estão os pinos SPI encontrados na maior parte da placa ESP32 que são pré-atribuídos:
Interface SPI | FUMAÇA | MISSÔ | SCLK | CS |
VSPI | GPIO 23 | GPIO 19 | GPIO 18 | GPIO5 |
HSPI | GPIO 13 | GPIO 12 | GPIO 14 | GPIO 15 |
Os pinos SPI mencionados acima podem variar dependendo do tipo de placa. Agora vamos escrever um código para verificar os pinos ESP32 SPI usando o Arduino IDE.
Como encontrar os pinos SPI padrão do ESP32
O código escrito abaixo ajudará a encontrar os pinos SPI padrão na placa ESP32. Abra o Arduino IDE, conecte o ESP32 ao PC, selecione a porta correta e faça o upload do código. Em seguida, aguarde a saída. É isso! é assim que é simples
Código para encontrar pinos SPI padrão do ESP32
O código fornecido abaixo imprimirá os pinos SPI padrão do ESP32 no monitor serial.
anular configuração ( ) {Serial.begin ( 115200 ) ;
Serial.print ( 'Pino MOSI GPIO: ' ) ;
Serial.println ( FUMAÇA ) ;
Serial.print ( 'Pino MISO GPIO: ' ) ;
Serial.println ( MISSÔ ) ;
Serial.print ( 'SCK GPIO Pino: ' ) ;
Serial.println ( SCK ) ;
Serial.print ( 'Pino SS GPIO: ' ) ;
Serial.println ( SS ) ;
}
loop vazio ( ) {
}
O código começa definindo a taxa de transmissão e continua chamando o pino GPIO padrão para o protocolo de comunicação ESP32 SPI.
Resultado
Aqui, em nosso caso, o monitor serial exibiu os pinos 23, 19, 18 e 5 para MOSI, MISO, SCK e SS, respectivamente.
Como usar pinos SPI personalizados no ESP32
Graças aos recursos de multiplexação do ESP32, é possível configurar qualquer pino da placa ESP32 como UART, I2C, SPI e PWM. Basta atribuí-los em código. Agora vamos definir novos pinos SPI e imprimi-los no monitor serial para confirmar.
Digite o código abaixo no editor Arduino IDE.
#includeanular configuração ( ) {
Serial.begin ( 115200 ) ;
Serial.print ( 'Pino MOSI GPIO padrão: ' ) ;
Serial.println ( FUMAÇA ) ;
Serial.print ( 'Pino MISO GPIO padrão: ' ) ;
Serial.println ( MISSÔ ) ;
Serial.print ( 'Pino SCK GPIO padrão: ' ) ;
Serial.println ( SCK ) ;
Serial.print ( 'Pino SS GPIO padrão: ' ) ;
Serial.println ( SS ) ;
#define SCK 25
#define MISO 32
#define MOSI 26
#define CS 33
/* Library_Name Sensor_name ( CS, MOSI, MISO, SCK ) ; // chamar novos pinos SPI */
Serial.print ( 'MOSI NOVO pino GPIO: ' ) ;
Serial.println ( FUMAÇA ) ;
Serial.print ( 'NOVO PIN GPIO MISO: ' ) ;
Serial.println ( MISSÔ ) ;
Serial.print ( 'SCK NOVO pino GPIO: ' ) ;
Serial.println ( SCK ) ;
Serial.print ( 'SS NOVO pino GPIO: ' ) ;
Serial.println ( SS ) ;
}
loop vazio ( ) {
}
Aqui no código acima, incluímos a biblioteca serial SPI e imprimimos os pinos SPI padrão no monitor serial. Pode-se pular esta parte do código se não for necessário. Em seguida, usando define, atribuímos novos pinos ao SPI e os imprimimos um por um no monitor serial.
Resultado
A saída exibida no monitor serial imprime todos os novos pinos SPI para a placa ESP32.
ESP32 com vários dispositivos SPI
O ESP32 possui dois barramentos SPI, e cada barramento pode controlar 3 dispositivos, o que significa que um total de 6 dispositivos podem ser controlados usando SPI do ESP32. Para controlar mais dispositivos, podemos usar diferentes técnicas de multiplexação.
Ao controlar vários dispositivos escravos, o ESP32 atuará como um mestre para todas as três linhas MISO, MOSI SCLK será o mesmo para eles, a única diferença é a linha de sinal de relógio CS. Para enviar dados para um dispositivo escravo, o pino CS desse dispositivo escravo deve ser definido como baixo.
A seguinte sintaxe será seguida se quisermos definir CS como LOW.
Suponha que queremos ler dados de qualquer outro dispositivo, então devemos definir o pino CS do primeiro dispositivo escravo como HIGH para desativá-lo.
digitalWrite ( CS_2, BAIXO ) ; // Habilita o pino CS do SLAVE dois
Conclusão
A interface periférica serial é um protocolo de comunicação com fio usado pelo microcontrolador ESP32 para trocar dados entre vários dispositivos escravos. O ESP32 SPI suporta dois barramentos diferentes para comunicação com cada barramento capaz de controlar 3 dispositivos escravos. Por padrão, o ESP32 vem com pinos SPI; no entanto, também podemos definir e usar pinos personalizados usando código.