//============================================================================= //Adaptado da biblioteca do SDK Pico-example //FATEC SANTO ANDRE - julho de 2024 - Prof. Edson Kitani & Prof. Weslley Torres //============================================================================= #include "ssd1306.h" #include #include #include #include #include "pico/stdlib.h" #include "pico/binary_info.h" #include "hardware/i2c.h" #include "ssd1306_font.h" // Configuração da interface I2C #define I2C_PORT i2c0 #define SDA_PIN 4 #define SCL_PIN 5 // Definição do endereço I2C do SSD1306 #define SSD1306_I2C_ADDRESS 0x3C #define SSD1306_DATA 0x40 #define CHAR_WIDTH 8 #define CHAR_HEIGHT 8 /*================================================================================================*/ void SSD1306_init() { // Some of these commands are not strictly necessary as the reset // process defaults to some of these but they are shown here // to demonstrate what the initialization sequence looks like // Some configuration values are recommended by the board manufacturer i2c_init(i2c_default, 400 * 1000); gpio_set_function(21, GPIO_FUNC_I2C); gpio_set_function(20, GPIO_FUNC_I2C); gpio_pull_up(21); gpio_pull_up(20); uint8_t cmds[] = { SSD1306_SET_DISP, // set display off /* memory mapping */ SSD1306_SET_MEM_MODE, // set memory address mode 0 = horizontal, 1 = vertical, 2 = page 0x00, // horizontal addressing mode /* resolution and layout */ SSD1306_SET_DISP_START_LINE, // set display start line to 0 SSD1306_SET_SEG_REMAP | 0x01, // set segment re-map, column address 127 is mapped to SEG0 SSD1306_SET_MUX_RATIO, // set multiplex ratio 0x3F, SSD1306_HEIGHT - 1, // Display height - 1 SSD1306_SET_COM_OUT_DIR | 0x08, // set COM (common) output scan direction. Scan from bottom up, COM[N-1] to COM0 SSD1306_SET_DISP_OFFSET, // set display offset 0x00, // no offset SSD1306_SET_COM_PIN_CFG, // set COM (common) pins hardware configuration. Board specific magic number. // 0x02 Works for 128x32, 0x12 Possibly works for 128x64. Other options 0x22, 0x32 #if ((SSD1306_WIDTH == 128) && (SSD1306_HEIGHT == 32)) 0x02, #elif ((SSD1306_WIDTH == 128) && (SSD1306_HEIGHT == 64)) 0x12, #else 0x02, #endif /* timing and driving scheme */ SSD1306_SET_DISP_CLK_DIV, // set display clock divide ratio 0x80, // div ratio of 1, standard freq SSD1306_SET_PRECHARGE, // set pre-charge period 0xF1, // Vcc internally generated on our board SSD1306_SET_VCOM_DESEL, // set VCOMH deselect level 0x30, // 0.83xVcc /* display */ SSD1306_SET_CONTRAST, // set contrast control 0x7F, SSD1306_SET_ENTIRE_ON, // set entire display on to follow RAM content SSD1306_SET_NORM_DISP, // set normal (not inverted) display SSD1306_SET_CHARGE_PUMP, // set charge pump 0x14, // Vcc internally generated on our board SSD1306_SET_SCROLL | 0x00, // deactivate horizontal scrolling if set. This is necessary as memory writes will corrupt if scrolling was enabled SSD1306_SET_DISP | 0x01, // turn display on }; for (int i = 0; i < sizeof(cmds); i++) { ssd1306_send_command(cmds[i]); } } /*================================================================================================*/ // Função para limpar o buffer de imagem void ssd1306_clear_buffer(uint8_t *buffer) { for (int i = 0; i < SSD1306_BUFFER_SIZE; i++) { buffer[i] = 0x00; } } /*=============================================================================================*/ // Função para enviar o buffer completo para o display void ssd1306_update_display(uint8_t *buffer) { // Define o tamanho do buffer int buflen = SSD1306_WIDTH * (SSD1306_HEIGHT / 8); // Cria um buffer temporário com espaço para o byte de controle uint8_t *temp_buf = malloc(buflen + 1); if (temp_buf == NULL) { // Tratar erro de alocação de memória return; } // Define o byte de controle (0x40 para indicar que os seguintes bytes são dados) temp_buf[0] = 0x40; // Copia o conteúdo do buffer de exibição para o buffer temporário memcpy(temp_buf + 1, buffer, buflen); // Envia o buffer completo via I2C i2c_write_blocking(i2c_default, SSD1306_I2C_ADDRESS, temp_buf, buflen + 1, false); // Libera o buffer temporário free(temp_buf); } /*================================================================================================*/ //Esta função trabalha com a fonte adaptada do SDK do Raspberry Pico de 8X8 pixels //Para outras dimensões é melhor construir outra função, contudo o buffer pode ser o mesmo //================================================================================================= void ssd1306_write_text(uint8_t *buffer, int x, int y, const char *text) { int char_width = 8; // Largura de cada caractere (8 pixels) int char_height = 8; // Altura de cada caractere (8 pixels) int row = y / char_height; int column = x; int font_offset = 32; // ASCII offset para o primeiro caractere (' ') for (int i = 0; text[i] != '\0'; i++) { char c = text[i]; // Verificar se o caractere está dentro da faixa if (c >= font_offset && c <= 126) { // 126 é o ASCII de '~' int font_index = (c - font_offset) * char_height; for (int j = 0; j < char_width; j++) { if (column + j < SSD1306_WIDTH) { buffer[column + (row * SSD1306_WIDTH) + j] = reverse_bits(font[font_index + j]); } } column += char_width + 1; // Avançar para a próxima posição de caractere if (column >= SSD1306_WIDTH) { column = 0; row++; } if (row >= SSD1306_HEIGHT / char_height) { break; } } } } uint8_t reverse_bits(uint8_t byte) { byte = (byte & 0xF0) >> 4 | (byte & 0x0F) << 4; byte = (byte & 0xCC) >> 2 | (byte & 0x33) << 2; byte = (byte & 0xAA) >> 1 | (byte & 0x55) << 1; return byte; } /*==============================================================================================*/ // Função para enviar um comando ao display void ssd1306_send_command(uint8_t command) { uint8_t buf[2] = {0x80, command}; i2c_write_blocking(I2C_PORT, SSD1306_I2C_ADDRESS, buf, 2, false); } /*==============================================================================================*/ // Função para enviar dados ao display void ssd1306_send_data(uint8_t *data, size_t length) { uint8_t *buf = malloc(length + 1); buf[0] = SSD1306_DATA; memcpy(&buf[1], data, length); i2c_write_blocking(I2C_PORT, SSD1306_I2C_ADDRESS, buf, length + 1, false); free(buf); } //============================================================================================== // Função para converter um número inteiro de 32 bits para ASCII e posicionar em algum local // É possível definir a número de caracteres para representar o número void ssd1306_int_number(uint8_t *buffer, int x, int y, int32_t number, int num_digits) { char str[12]; // Espaço suficiente para "-2147483648\0" snprintf(str, sizeof(str), "%d", number); ssd1306_write_text(buffer, x, y, str); }