Confusing for sure…. hours and hours I spent looking and testing.

My guess is that there are also silicon revisions which might not all be quite the same as well

The part of your firmware that sends and receives bytes from the display. Im guessing you have a timing problem in the “hal”

Oops, I got the Co bit backwards in my memory. I would delete my above comment, but the UI won’t let me.

I am currently writing a driver for the ssd1306 myself. I have noticed that Co can be low all the time. The datasheet is not very clear about the consequences. From the datasheet language I think a high Co bit means that no more control Bytes May come (only data). I am running an initialization sequence on my module using Co set low, with no control Bytes between the commands. I wish the datasheet were clearer about it, but this is my empirical evidence.

int const commands = 0x00;
int const onecommand = 0x80;
int const data = 0x40;
int const onedata = 0xC0;

to be working.
be well, Thomas

The V1.1 of the datasheet shows bit1 set for the data word of COMPINS even though only bits 4 and 5 are talked about (page 31). This is a very confusing datasheet! I seem to get the same results with or without these bits set so I think you are right in that they don’t matter.

Can you be a bit more specific, i don’t really understand what you mean by porting layer.

Best Regards

I don’t know… but I bet you are right.

I’ve set it to 0x10 and it’s fine.

Crazy eh….

Thanks.

Alan

Anyway I got the screen working, but I think you may have the values for multiple/single data transfers (0xC0, 0x40) backwards. I was chasing this problem for a long time until I randomly flipped which one I was using and all of the sudden it was working! if I try to send a whole buffer with 0xC0, it only sends the first column (sometimes it is also on the second page… weird), but if I send the same buffer with 0x40, it works fine!

Referencing the terrible datasheet 8.1.5.2:
5) After the transmission of the slave address, either the control byte or the data byte may be sent across
the SDA. A control byte mainly consists of Co and D/C# bits following by six “0” ‘s.
a. If the Co bit is set as logic “0”, the transmission of the following information will contain
data bytes only.
b. The D/C# bit determines the next data byte is acted as a command or a data. If the D/C# bit is
set to logic “0”, it defines the following data byte as a command. If the D/C# bit is set to
logic “1”, it defines the following data byte as a data which will be stored at the GDDRAM.
The GDDRAM column address pointer will be increased by one automatically after each
data write.

Under “a” it doesn’t mention anything about setting the co bit to 1 which might shed some light on the issue, but it does mention that setting is as 0 “the transmission of the following information will contain
data bytes only.” which is ambiguous, but I interpret as meaning there will be a stream, not individual messages. This does make sense with 0xC0 vs. 0x40 though.

Not sure on multiple/single commands as I only send them one at a time in my init function. I have noticed others in these comments with trouble initializing, so here is my init code that works for me (STM32L432 nucleo board / cubeIDE) NOTE this is still “sketched code” as I am still actively working on it and haven’t done any cleanup yet…

ssd1306_WriteCommand(SSD1306_SCREEN_OFF); // screen off

ssd1306_WriteCommand(SSD1306_CMD_MEMMD); // mem mode:
ssd1306_WriteCommand(SSD1306_CMD_MD_HRZ); // horizontal

ssd1306_WriteCommand(SSD1306_CMD_COLRNG); // column range:
ssd1306_WriteCommand(0);
ssd1306_WriteCommand(127);

ssd1306_WriteCommand(SSD1306_CMD_PGERNG); // page address range:
ssd1306_WriteCommand(0);
ssd1306_WriteCommand(7);

ssd1306_WriteCommand(SSD1306_CMD_VFLIP_OFF);// flip vertically
ssd1306_WriteCommand(SSD1306_CMD_HFLIP_OFF);// flip horizontally

ssd1306_WriteCommand(SSD1306_CMD_USE_BUFF);
ssd1306_WriteCommand(SSD1306_SCREEN_ON); // screen on

And my functions for writing data and commands are as follows (using HAL I2c)

/**
* Send a byte to the command register (0x00)
* @param command
*/
static void ssd1306_WriteCommand(uint8_t command)
{
HAL_I2C_Mem_Write(&hi2c1, I2C_ADDR, SSD1306_REG_1CMD, 1, &command, 1, 10);
}

/**
* Send a byte to the data register (0xC0)
* @param data
*/
static void ssd1306_WriteData(uint8_t data)
{
HAL_I2C_Mem_Write(&hi2c1, I2C_ADDR, SSD1306_REG_1DAT, 1, &data, 1, 10);
}
/**
* Send buffer to the data register (0x40)
* @param data
*/
static void ssd1306_WriteMData(const uint8_t *data, uint16_t size)
{
HAL_I2C_Mem_Write(&hi2c1, I2C_ADDR, SSD1306_REG_MDAT, 1, (uint8_t*)data, size, 100);
}

Hope this helps someone!

I have no idea about the blue/yellow one… I haven’t ever seen one other than in the google images.

If you figure it out send me an email and Ill update the article.

Thanks for the nice words.
Alan

Many thanks, specially for the Set Charge Pump command description.
Jean

Yes. This is the right answer I think.
Alan