👼🏻 👩🏻‍⚖️ 💀 Conectando display OLED ssd1306 ao STM32 (SPI + DMA) 💅 🕴🏽 👩🏿‍🤝‍👩🏻

Este artigo descreverá o processo de conexão de um display OLED com um controlador ssd1306 com resolução 128x64 a um microcontrolador stm32f103C8T6 por meio da interface SPI. Eu também queria atingir a taxa máxima de atualização da tela, então é aconselhável usar DMA e programar o microcontrolador usando a biblioteca CMSIS.

Conexão

Vamos conectar o monitor ao microcontrolador por meio da interface SPI1 da seguinte maneira:

VDD-> + 3,3V
GND-> Ground
SCK -> PA5
SDA -> PA7 (MOSI)
RES-> PA1
CS-> PA2
DS-> PA3

A transmissão de dados ocorre na borda ascendente do sinal de sincronização em 1 byte por quadro. As linhas SCK e SDA são usadas para transferir dados através da interface SPI, RES - reinicializa o controlador de exibição em um nível lógico baixo, CS é responsável por selecionar um dispositivo no barramento SPI em um nível lógico baixo, DS determina o tipo de dados (comando - 1 / dados - 0) que são transmitidos exibição. Uma vez que nada pode ser lido no visor, não usaremos a saída MISO.

Organização da memória do controlador de exibição

Antes de exibir qualquer coisa na tela, você precisa entender como a memória está organizada no controlador ssd1306.

imagem

Toda a memória gráfica (GDDRAM) é uma área de 128 * 64 = 8192 bits = 1 KB. A área é dividida em 8 páginas, que são apresentadas como uma coleção de 128 segmentos de 8 bits. A memória é endereçada por número de página e número de segmento, respectivamente.

Com esse método de endereçamento, surge uma característica muito desagradável - a impossibilidade de escrever 1 bit de informação na memória, já que a gravação ocorre em um segmento (8 bits cada). E uma vez que para a exibição correta de um único pixel na tela, você precisa saber o estado dos pixels restantes no segmento, é aconselhável criar um buffer de 1 KB na memória do microcontrolador e carregá-lo ciclicamente na memória do display (é aqui que o DMA é útil), respectivamente, fazendo sua atualização completa. Ao usar este método, é possível recalcular a posição de cada bit na memória para as coordenadas clássicas x, y. Então, para exibir um ponto com coordenadas xey, usaremos o seguinte método:

displayBuff[x+(y/8)*SSD1306_WIDTH]|=(1<<(y%8));

E para apagar o ponto

displayBuff[x+(y/8)*SSD1306_WIDTH]&=~(1<<(y%8));

Configuração SPI

Conforme mencionado acima, conectaremos o display ao SPI1 do microcontrolador STM32F103C8.

imagem

Para a conveniência de escrever código, declararemos algumas constantes e criaremos uma função para inicializar o SPI.

#define SSD1306_WIDTH 128
#define SSD1306_HEIGHT 64
#define BUFFER_SIZE 1024
//     ,     /
#define CS_SET GPIOA->BSRR|=GPIO_BSRR_BS2
#define CS_RES GPIOA->BSRR|=GPIO_BSRR_BR2
#define RESET_SET GPIOA->BSRR|=GPIO_BSRR_BS1
#define RESET_RES GPIOA->BSRR|=GPIO_BSRR_BR1
#define DATA GPIOA->BSRR|=GPIO_BSRR_BS3
#define COMMAND GPIOA->BSRR|=GPIO_BSRR_BR3

void spi1Init()
{
    return;
}

Ligue o clocking e configure as saídas GPIO, conforme mostrado na tabela acima.


RCC->APB2ENR|=RCC_APB2ENR_SPI1EN | RCC_APB2ENR_IOPAEN;//  SPI1  GPIOA
RCC->AHBENR|=RCC_AHBENR_DMA1EN;//  DMA
GPIOA->CRL|= GPIO_CRL_MODE5 | GPIO_CRL_MODE7;//PA4,PA5,PA7    50MHz
GPIOA->CRL&= ~(GPIO_CRL_CNF5 | GPIO_CRL_CNF7);
GPIOA->CRL|=  GPIO_CRL_CNF5_1 | GPIO_CRL_CNF7_1;//PA5,PA7 -     push-pull, PA4 -  push-pull

A seguir, vamos configurar o SPI para o modo mestre e uma frequência de 18 MHz.

SPI1->CR1|=SPI_CR1_MSTR;// 
SPI1->CR1|= (0x00 & SPI_CR1_BR);//   2
SPI1->CR1|=SPI_CR1_SSM;// NSS
SPI1->CR1|=SPI_CR1_SSI;//NSS - high
SPI1->CR2|=SPI_CR2_TXDMAEN;//  DMA
SPI1->CR1|=SPI_CR1_SPE;// SPI1

Vamos configurar o DMA.

DMA1_Channel3->CCR|=DMA_CCR1_PSIZE_0;//  1
DMA1_Channel3->CCR|=DMA_CCR1_DIR;// DMA    
DMA1_Channel3->CCR|=DMA_CCR1_MINC;//  
DMA1_Channel3->CCR|=DMA_CCR1_PL;//  DMA

A seguir, vamos escrever uma função para enviar dados via SPI (até agora sem DMA) O processo de troca de dados é o seguinte:

Aguardando o lançamento do SPI
CS = 0
Enviando dados
CS = 1


void spiTransmit(uint8_t data)
{
	CS_RES;	
	SPI1->DR = data;
	while((SPI1->SR & SPI_SR_BSY))
	{};
	CS_SET;
}

Também escreveremos uma função de envio direto de um comando para a tela (trocamos a linha DC apenas ao transmitir um comando, e depois o retornamos ao estado "dados", já que não transmitiremos comandos com tanta frequência e não perderemos performance).

void ssd1306SendCommand(uint8_t command)
{
	COMMAND;
	spiTransmit(command);
	DATA;
}

A seguir trataremos de funções para trabalhar diretamente com DMA, para isso declararemos um buffer na memória do microcontrolador e criaremos funções para iniciar e interromper o envio cíclico desse buffer para a memória da tela.

static uint8_t displayBuff[BUFFER_SIZE];// 

void ssd1306RunDisplayUPD()
{
	DATA;
	DMA1_Channel3->CCR&=~(DMA_CCR1_EN);// DMA
	DMA1_Channel3->CPAR=(uint32_t)(&SPI1->DR);//  DMA    SPI1
	DMA1_Channel3->CMAR=(uint32_t)&displayBuff;// 
	DMA1_Channel3->CNDTR=sizeof(displayBuff);// 
	DMA1->IFCR&=~(DMA_IFCR_CGIF3);
	CS_RES;//   
	DMA1_Channel3->CCR|=DMA_CCR1_CIRC;//  DMA
	DMA1_Channel3->CCR|=DMA_CCR1_EN;// DMA
}

void ssd1306StopDispayUPD()
{
	CS_SET;//   
	DMA1_Channel3->CCR&=~(DMA_CCR1_EN);// DMA
	DMA1_Channel3->CCR&=~DMA_CCR1_CIRC;//  
}

Inicialização da tela e saída de dados

Agora vamos criar uma função para inicializar a própria tela.

void ssd1306Init()
{

}

Primeiro, vamos configurar CS, RESET e linha DC, e também reiniciar o controlador de display.

uint16_t i;
GPIOA->CRL|= GPIO_CRL_MODE2 |GPIO_CRL_MODE1 | GPIO_CRL_MODE3;
GPIOA->CRL&= ~(GPIO_CRL_CNF1 | GPIO_CRL_CNF2 | GPIO_CRL_CNF3);//PA1,PA2,PA3   
//    
RESET_RES;
for(i=0;i<BUFFER_SIZE;i++)
{
	displayBuff[i]=0;
}
RESET_SET;
CS_SET;//

A seguir, enviaremos uma sequência de comandos para inicialização (você pode aprender mais sobre eles na documentação do controlador ssd1306).

ssd1306SendCommand(0xAE); //display off
ssd1306SendCommand(0xD5); //Set Memory Addressing Mode
ssd1306SendCommand(0x80); //00,Horizontal Addressing Mode;01,Vertical
ssd1306SendCommand(0xA8); //Set Page Start Address for Page Addressing
ssd1306SendCommand(0x3F); //Set COM Output Scan Direction
ssd1306SendCommand(0xD3); //set low column address
ssd1306SendCommand(0x00); //set high column address
ssd1306SendCommand(0x40); //set start line address
ssd1306SendCommand(0x8D); //set contrast control register
ssd1306SendCommand(0x14);
ssd1306SendCommand(0x20); //set segment re-map 0 to 127
ssd1306SendCommand(0x00); //set normal display
ssd1306SendCommand(0xA1); //set multiplex ratio(1 to 64)
ssd1306SendCommand(0xC8); //
ssd1306SendCommand(0xDA); //0xa4,Output follows RAM
ssd1306SendCommand(0x12); //set display offset
ssd1306SendCommand(0x81); //not offset
ssd1306SendCommand(0x8F); //set display clock divide ratio/oscillator frequency
ssd1306SendCommand(0xD9); //set divide ratio
ssd1306SendCommand(0xF1); //set pre-charge period
ssd1306SendCommand(0xDB); 
ssd1306SendCommand(0x40); //set com pins hardware configuration
ssd1306SendCommand(0xA4);
ssd1306SendCommand(0xA6); //set vcomh
ssd1306SendCommand(0xAF); //0x20,0.77xVcc

Vamos criar funções para preencher a tela inteira com a cor selecionada e exibir um pixel.

typedef enum COLOR
{
	BLACK,
	WHITE
}COLOR;

void ssd1306DrawPixel(uint16_t x, uint16_t y,COLOR color){
	if(x<SSD1306_WIDTH && y <SSD1306_HEIGHT && x>=0 && y>=0)
	{
		if(color==WHITE)
		{
			displayBuff[x+(y/8)*SSD1306_WIDTH]|=(1<<(y%8));
		}
		else if(color==BLACK)
		{
			displayBuff[x+(y/8)*SSD1306_WIDTH]&=~(1<<(y%8));
		}
	}
}

void ssd1306FillDisplay(COLOR color)
{
	uint16_t i;
	for(i=0;i<SSD1306_HEIGHT*SSD1306_WIDTH;i++)
	{
		if(color==WHITE)
			displayBuff[i]=0xFF;
		else if(color==BLACK)
			displayBuff[i]=0;
	}
}

A seguir, no corpo do programa principal, inicializamos o SPI e o display.

RccClockInit();
spi1Init();
ssd1306Init();

A função RccClockInit () destina-se a definir o relógio do microcontrolador.

Código RccClockInit

int RccClockInit()
{
	//Enable HSE
	//Setting PLL
	//Enable PLL
	//Setting count wait cycles of FLASH
	//Setting AHB1,AHB2 prescaler
	//Switch to PLL	
	uint16_t timeDelay;
	RCC->CR|=RCC_CR_HSEON;//Enable HSE
	for(timeDelay=0;;timeDelay++)
	{
		if(RCC->CR&RCC_CR_HSERDY) break;
		if(timeDelay>0x1000)
		{
			RCC->CR&=~RCC_CR_HSEON;
			return 1;
		}
	}	
	RCC->CFGR|=RCC_CFGR_PLLMULL9;//PLL x9
	RCC->CFGR|=RCC_CFGR_PLLSRC_HSE;//PLL sourse:HSE
	RCC->CR|=RCC_CR_PLLON;//Enable PLL
	for(timeDelay=0;;timeDelay++)
	{
		if(RCC->CR&RCC_CR_PLLRDY) break;
		if(timeDelay>0x1000)
		{
			RCC->CR&=~RCC_CR_HSEON;
			RCC->CR&=~RCC_CR_PLLON;
			return 2;
		}
	}
	FLASH->ACR|=FLASH_ACR_LATENCY_2;
	RCC->CFGR|=RCC_CFGR_PPRE1_DIV2;//APB1 prescaler=2
	RCC->CFGR|=RCC_CFGR_SW_PLL;//Switch to PLL
	while((RCC->CFGR&RCC_CFGR_SWS)!=(0x02<<2)){}
	RCC->CR&=~RCC_CR_HSION;//Disable HSI
	return 0;
}

Preencha todo o display com branco e veja o resultado.

ssd1306RunDisplayUPD();
ssd1306FillDisplay(WHITE);

Vamos desenhar na tela em uma grade em incrementos de 10 pixels.

for(i=0;i<SSD1306_WIDTH;i++)
{
	for(j=0;j<SSD1306_HEIGHT;j++)
	{
		if(j%10==0 || i%10==0)
			ssd1306DrawPixel(i,j,WHITE);
	}
}

As funções funcionam corretamente, o buffer é continuamente gravado na memória do controlador do display, o que permite utilizar o sistema de coordenadas cartesianas na exibição de primitivas gráficas.

Taxa de atualização da tela

Como o buffer é enviado ciclicamente para a memória do display, será suficiente saber quanto tempo leva para o DMA completar a transferência de dados para aproximar a taxa de atualização do display. Para depuração em tempo real, usaremos a biblioteca EventRecorder de Keil.

Para saber o momento do fim da transferência de dados, configuramos a interrupção DMA para terminar a transferência.

DMA1_Channel3->CCR|=DMA_CCR1_TCIE;//   
DMA1->IFCR&=~DMA_IFCR_CTCIF3;//  
NVIC_EnableIRQ(DMA1_Channel3_IRQn);//

Rastrearemos o intervalo de tempo usando as funções EventStart e EventStop.

imagem

Obtemos 0,00400881-0,00377114 = 0,00012767 seg, que corresponde a uma taxa de atualização de 4,2 KHz. Na verdade, a frequência não é tão alta, o que se deve à imprecisão do método de medição, mas claramente mais do que o padrão de 60 Hz.

Conectando display OLED ssd1306 ao STM32 (SPI + DMA)

Conexão

Organização da memória do controlador de exibição

Configuração SPI

Inicialização da tela e saída de dados

Taxa de atualização da tela

Links

More articles: