RT-Spark AHT21 Temperature & Humidity System using STM32

#include "main.h"
#include "drv_lcd.h"
#include "drv_lcd_font.h"
#include <string.h>

/*
 * SECTION 1: FSMC MEMORY MAPPING
 * The STM32 treats the LCD not as a peripheral, but as external MEMORY (SRAM).
 * We write to specific memory addresses to send Commands or Data.
 *
 * Base Address (0x68000000):
 * - Corresponds to FSMC Bank 1, Sector 3 (NE3 pin PG10).
 *
 * Offset (0x40000):
 * - We use Address Line 18 (A18 / PD13) as the "Register Select" (RS) pin.
 * - 2^18 = 262,144 = 0x40000.
 * - Writing to (Base)         -> A18 is Low  -> LCD interprets as COMMAND.
 * - Writing to (Base + 0x40K) -> A18 is High -> LCD interprets as DATA.
 */
#define LCD_BASE        ((uint32_t)0x68000000)
#define LCD_REG         (*((volatile uint8_t *)LCD_BASE))           // Write here for Commands
#define LCD_RAM         (*((volatile uint8_t *)(LCD_BASE + 0x40000))) // Write here for Data

// Global structure to hold LCD parameters
_lcd_dev lcddev;

// Default Colors
uint16_t BACK_COLOR = WHITE;
uint16_t FORE_COLOR = BLACK;

/*
 * SECTION 2: LOW-LEVEL BUS WRITES
 * These functions handle the physical transmission of bytes over the 8-bit
 * parallel bus (D0-D7).
 */

// Write a Command Byte (RS Pin Low)
void LCD_WR_REG(uint8_t reg) {
    LCD_REG = reg;
}

// Write a Data Byte (RS Pin High)
void LCD_WR_DATA8(uint8_t data) {
    LCD_RAM = data;
}

/**
 * @brief  Writes a 16-bit color value to the 8-bit bus.
 * @why    Our hardware bus is only 8 bits wide (D0-D7), but pixels are 16 bits (RGB565).
 * We must manually split the 16-bit integer into two 8-bit transfers.
 * The ST7789 expects the High Byte (MSB) first, then the Low Byte (LSB).
 */
void LCD_WR_DATA16(uint16_t data) {
    LCD_RAM = (data >> 8);   // Shift right to isolate High Byte (e.g., 0xF8 from 0xF800)
    LCD_RAM = (data & 0xFF); // Mask to isolate Low Byte (e.g., 0x00 from 0xF800)
}

// Prepares the LCD to receive pixel data (sends "Write RAM" command 0x2C)
void LCD_WriteRAM_Prepare(void) {
    LCD_WR_REG(lcddev.wramcmd);
}

// Wrapper to write a pixel color
void LCD_WriteRAM(uint16_t color) {
    LCD_WR_DATA16(color);
}

/*
 * SECTION 3: INITIALIZATION SEQUENCE
 * This sequence configures the ST7789 driver chip. These are manufacturer
 * specific "Magic Numbers" that set voltages, gamma curves, and update rates.
 */

void LCD_Reset(void) {
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_3, GPIO_PIN_RESET);
    HAL_Delay(50);
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_3, GPIO_PIN_SET);
    HAL_Delay(50);
}

void LCD_Backlight_On(void) {
    HAL_GPIO_WritePin(GPIOF, GPIO_PIN_9, GPIO_PIN_SET);
}

void LCD_Init(void) {
    LCD_Reset();
    LCD_Backlight_On();

    // 1. Wake up
    LCD_WR_REG(0x11); // Sleep Out
    HAL_Delay(120);

    // 2. Orientation & Format (how to interpret data)
    LCD_WR_REG(0x36); LCD_WR_DATA8(0x00); // Memory Access Control (Orientation)
    LCD_WR_REG(0x3A); LCD_WR_DATA8(0x05); // Pixel Format: 0x05 = 16-bit RGB565

    // 3. Power & Gamma Settings (Vendor Specific) - make sure the color is right , white is white, black is black
    LCD_WR_REG(0xB2); LCD_WR_DATA8(0x0C); LCD_WR_DATA8(0x0C); LCD_WR_DATA8(0x00); LCD_WR_DATA8(0x33); LCD_WR_DATA8(0x33);
    LCD_WR_REG(0xB7); LCD_WR_DATA8(0x35);
    LCD_WR_REG(0xBB); LCD_WR_DATA8(0x19);
    LCD_WR_REG(0xC0); LCD_WR_DATA8(0x2C);
    LCD_WR_REG(0xC2); LCD_WR_DATA8(0x01);
    LCD_WR_REG(0xC3); LCD_WR_DATA8(0x12);
    LCD_WR_REG(0xC4); LCD_WR_DATA8(0x20);
    LCD_WR_REG(0xC6); LCD_WR_DATA8(0x0F);
    LCD_WR_REG(0xD0); LCD_WR_DATA8(0xA4); LCD_WR_DATA8(0xA1);

    // Gamma Correction (Makes colors look correct)
    LCD_WR_REG(0xE0); LCD_WR_DATA8(0xD0); LCD_WR_DATA8(0x04); LCD_WR_DATA8(0x0D); LCD_WR_DATA8(0x11); LCD_WR_DATA8(0x13); LCD_WR_DATA8(0x2B); LCD_WR_DATA8(0x3F); LCD_WR_DATA8(0x54); LCD_WR_DATA8(0x4C); LCD_WR_DATA8(0x18); LCD_WR_DATA8(0x0D); LCD_WR_DATA8(0x0B); LCD_WR_DATA8(0x1F); LCD_WR_DATA8(0x23);
    LCD_WR_REG(0xE1); LCD_WR_DATA8(0xD0); LCD_WR_DATA8(0x04); LCD_WR_DATA8(0x0C); LCD_WR_DATA8(0x11); LCD_WR_DATA8(0x13); LCD_WR_DATA8(0x2C); LCD_WR_DATA8(0x3F); LCD_WR_DATA8(0x44); LCD_WR_DATA8(0x51); LCD_WR_DATA8(0x2F); LCD_WR_DATA8(0x1F); LCD_WR_DATA8(0x1F); LCD_WR_DATA8(0x20); LCD_WR_DATA8(0x23);

    // 4. Turn On
    LCD_WR_REG(0x21); // Display Inversion On (Fixes inverted colors on ST7789)
    LCD_WR_REG(0x29); // Display ON

    // 5. Set Software Parameters
    lcddev.width = 240;
    lcddev.height = 240;
    lcddev.setxcmd = 0x2A; // Column Address Set
    lcddev.setycmd = 0x2B; // Row Address Set
    lcddev.wramcmd = 0x2C; // Write Memory Start

    LCD_Clear(WHITE); // Clear screen garbage data
}

/*
 * SECTION 4: DRAWING LOGIC
 */

// Defines the active rectangular area we are writing to
void LCD_SetWindow(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2) {
    LCD_WR_REG(lcddev.setxcmd); // Set X coordinates
    LCD_WR_DATA8(x1 >> 8); LCD_WR_DATA8(x1 & 0xFF); // Start X
    LCD_WR_DATA8(x2 >> 8); LCD_WR_DATA8(x2 & 0xFF); // End X

    LCD_WR_REG(lcddev.setycmd); // Set Y coordinates
    LCD_WR_DATA8(y1 >> 8); LCD_WR_DATA8(y1 & 0xFF); // Start Y
    LCD_WR_DATA8(y2 >> 8); LCD_WR_DATA8(y2 & 0xFF); // End Y

    LCD_WriteRAM_Prepare(); // Ready to write pixel data
}

// Fills the entire screen with a single color
void LCD_Clear(uint16_t color) {
    LCD_SetWindow(0, 0, lcddev.width-1, lcddev.height-1); // Select full screen
    uint32_t total_pixels = lcddev.width * lcddev.height;

    // Burst write the color to every pixel
    for (uint32_t i = 0; i < total_pixels; i++) {
        LCD_WR_DATA16(color);
    }
}

// Draw a single pixel at (x, y)
void LCD_DrawPixel(uint16_t x, uint16_t y, uint16_t color) {
    if (x >= lcddev.width || y >= lcddev.height) return; // Bounds check
    LCD_SetWindow(x, y, x, y); // Select 1x1 window
    LCD_WR_DATA16(color);      // Write color
}

/*
 * SECTION 5: TEXT RENDERING
 * Uses the font array defined in drv_lcd_font.h to draw text.
 */

// Draws a single character
void LCD_ShowChar(uint16_t x, uint16_t y, uint8_t num, uint16_t color, uint16_t back_color) {
    uint8_t temp, t;
    uint16_t pos;

    if (x > lcddev.width - 8 || y > lcddev.height - 16) return;

    num = num - ' '; // Adjust ASCII to array index (font starts at space)
    LCD_SetWindow(x, y, x + 7, y + 15); // Set 8x16 window

    // Loop through the 16 rows of the character font
    for (pos = 0; pos < 16; pos++) {
        temp = asc2_1608[num * 16 + pos]; // Get the bit pattern for this row

        // Loop through the 8 pixels in the row
        for (t = 0; t < 8; t++) {
            // Check if bit is 1 (Foreground) or 0 (Background)
            if (temp & 0x80) LCD_WR_DATA16(color);
            else             LCD_WR_DATA16(back_color);
            temp <<= 1; // Shift to next bit
        }
    }
}

// Draws a String
void LCD_ShowString(uint16_t x, uint16_t y, char *p, uint16_t color, uint16_t back_color) {
    while (*p != '\0') { // Loop until null terminator
        // Auto-wrap logic
        if (x > lcddev.width - 8) {
            x = 0;
            y += 16;
        }
        if (y > lcddev.height - 16) break;

        LCD_ShowChar(x, y, *p, color, back_color);
        x += 8; // Move cursor right
        p++;    // Move to next char
    }
}

#include "drv_aht21.h"

void SDA_IN(void) {
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    GPIO_InitStruct.Pin = AHT_SDA_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_PULLUP;     // Internal resistor pulls line high when idle
    HAL_GPIO_Init(AHT_SDA_PORT, &GPIO_InitStruct);
}

// Switch SDA pin to OUTPUT mode (Transmit)
// We do this when sending commands (Start, Address, Data) to the sensor.
void SDA_OUT(void) {
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    GPIO_InitStruct.Pin = AHT_SDA_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD; // Open-Drain is standard for I2C
    GPIO_InitStruct.Pull = GPIO_PULLUP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(AHT_SDA_PORT, &GPIO_InitStruct);
}

/* Pin State Macros - Shortcuts for setting pins High/Low */
#define SCL_H HAL_GPIO_WritePin(AHT_SCL_PORT, AHT_SCL_PIN, GPIO_PIN_SET)
#define SCL_L HAL_GPIO_WritePin(AHT_SCL_PORT, AHT_SCL_PIN, GPIO_PIN_RESET)
#define SDA_H HAL_GPIO_WritePin(AHT_SDA_PORT, AHT_SDA_PIN, GPIO_PIN_SET)
#define SDA_L HAL_GPIO_WritePin(AHT_SDA_PORT, AHT_SDA_PIN, GPIO_PIN_RESET)
#define READ_SDA HAL_GPIO_ReadPin(AHT_SDA_PORT, AHT_SDA_PIN)

// Simple delay to control I2C bus speed (Bit-Banging speed limit)
void I2C_Delay(void) {
    volatile int i = 400;
    while(i--);
}

/*
 * SECTION 2: I2C PROTOCOL PRIMITIVES (The Transport Layer)
 * These functions generate the specific electrical signals required by the
 * I2C standard.
 */

// Generate START condition: SDA goes High->Low while SCL is High
void I2C_Start(void) {
    SDA_OUT();    // Ensure we are in control
    SDA_H; SCL_H;
    I2C_Delay();
    SDA_L;        // Pull Data Low (Start Signal)
    I2C_Delay();
    SCL_L;        // Hold Clock Low (Bus Busy)
}

// Generate STOP condition: SDA goes Low->High while SCL is High
void I2C_Stop(void) {
    SDA_OUT();
    SCL_L; SDA_L; // Prepare Data Low
    I2C_Delay();
    SCL_H;        // Release Clock
    I2C_Delay();
    SDA_H;        // Release Data High (Stop Signal)
    I2C_Delay();
}

// Wait for the Sensor to acknowledge (ACK) our command
// Returns 0 if ACK received, 1 if Timeout/Error
uint8_t I2C_WaitAck(void) {
    uint32_t errTime = 0;
    SDA_IN();     // Switch to Input to listen
    SDA_H;        // Release line
    I2C_Delay();
    SCL_H;        // Clock High (Tell sensor to send ACK bit)
    I2C_Delay();

    // Wait for Sensor to pull SDA Low (ACK)
    while(READ_SDA) {
        errTime++;
        // Safety timeout to prevent infinite loop if sensor is missing
        if(errTime > 3000) {
            I2C_Stop();
            return 1;
        }
    }
    SCL_L; // Clock Low (Finish ACK cycle)
    return 0;
}

// Send 8 bits (1 Byte) to the sensor, MSB first
void I2C_SendByte(uint8_t byte) {
    SDA_OUT();
    SCL_L;
    for(int i=0; i<8; i++) {
        // Check if the current bit is 1 or 0
        if(byte & 0x80) SDA_H;
        else            SDA_L;

        byte <<= 1;   // Shift left to next bit
        I2C_Delay();
        SCL_H;        // Clock High (Sensor reads bit)
        I2C_Delay();
        SCL_L;        // Clock Low
        I2C_Delay();
    }
}

// Read 8 bits (1 Byte) from the sensor
uint8_t I2C_ReadByte(unsigned char ack) {
    unsigned char i, receive = 0;
    SDA_IN(); // Switch to Input to read
    for(i=0; i<8; i++) {
        SCL_L;
        I2C_Delay();
        SCL_H;        // Clock High (Data is valid)
        receive <<= 1; // Shift current data left
        if(READ_SDA) receive++; // Read pin, if High add 1
        I2C_Delay();
    }
    SDA_OUT(); // Switch back to Output to send response

    // Send ACK (Low) if we want more data, or NACK (High) to stop
    if (!ack) {
    	SCL_L; SDA_H; SCL_H;
    	I2C_Delay();
    	SCL_L;
    } else {
    	SCL_L; SDA_L; SCL_H;
    	I2C_Delay();
    	SCL_L;
    }
    return receive;
}

/*
 * SECTION 3: AHT21 SPECIFIC LOGIC (The Application Layer)
 */

// Initialize the sensor by sending the 0xBE command
void AHT21_Init(void) {
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    // Enable GPIO Clock
    __HAL_RCC_GPIOE_CLK_ENABLE();

    // Default pin configuration
    GPIO_InitStruct.Pin = AHT_SCL_PIN | AHT_SDA_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
    GPIO_InitStruct.Pull = GPIO_PULLUP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(AHT_SCL_PORT, &GPIO_InitStruct);

    SCL_H; SDA_H;
    HAL_Delay(100); // Power-on delay required by datasheet

    // Send Calibration Command
    I2C_Start();
    I2C_SendByte(AHT_ADDR << 1); // Address + Write bit
    if(!I2C_WaitAck()) {
        I2C_SendByte(0xBE); // Init Command
        I2C_WaitAck();
        I2C_SendByte(0x08); // Parameter 1
        I2C_WaitAck();
        I2C_SendByte(0x00); // Parameter 2
        I2C_WaitAck();
        I2C_Stop();
    }
    HAL_Delay(10);
}

// Read Temperature and Humidity
uint8_t AHT21_Read(float *Temperature, float *Humidity) {
    uint8_t data[6];

    // 1. Trigger Measurement Command (0xAC)
    I2C_Start();
    I2C_SendByte(AHT_ADDR << 1);
    if(I2C_WaitAck()) return 0; // Check for device presence
    I2C_SendByte(0xAC); // Trigger Measure
    if(I2C_WaitAck()) return 0;
    I2C_SendByte(0x33); // Param 1
    if(I2C_WaitAck()) return 0;
    I2C_SendByte(0x00); // Param 2
    if(I2C_WaitAck()) return 0;
    I2C_Stop();

    // 2. Wait for Measurement (Sensor needs ~80ms to process)
    HAL_Delay(80);

    // 3. Read Data (6 Bytes)
    I2C_Start();
    I2C_SendByte((AHT_ADDR << 1) | 1); // Address + Read bit
    if(I2C_WaitAck()) return 0;

    for(int i=0; i<6; i++) {
        data[i] = I2C_ReadByte(i < 5); // ACK first 5 bytes, NACK last one
    }
    I2C_Stop();

    // 4. Parse Data (Bit shifting)
    // The sensor sends 20-bit values split across bytes. We assume the data is valid.
    // Humidity: Combined from Byte 1, Byte 2, and top 4 bits of Byte 3
    uint32_t rawHum = ((uint32_t)data[1] << 12) | ((uint32_t)data[2] << 4) | ((data[3] & 0xF0) >> 4);
    // Temperature: Combined from lower 4 bits of Byte 3, Byte 4, and Byte 5
    uint32_t rawTemp = ((uint32_t)(data[3] & 0x0F) << 16) | ((uint32_t)data[4] << 8) | data[5];

    // 5. Convert to Floating Point (Formulas from Datasheet)
    *Humidity = (float)rawHum * 100.0f / 1048576.0f;
    *Temperature = ((float)rawTemp * 200.0f / 1048576.0f) - 50.0f;

    return 1;
}

#ifndef __DRV_LCD_H
#define __DRV_LCD_H

#include "main.h"

/* LCD Colors */
#define WHITE       0xFFFF
#define BLACK       0x0000
#define BLUE        0x001F
#define RED         0xF800
#define GREEN       0x07E0
#define YELLOW      0xFFE0
#define GRAY        0X8430

/* LCD Parameter Structure */
typedef struct {
    uint16_t width;
    uint16_t height;
    uint16_t id;
    uint8_t  dir;
    uint16_t wramcmd;
    uint16_t setxcmd;
    uint16_t setycmd;
} _lcd_dev;

extern _lcd_dev lcddev;
extern uint16_t BACK_COLOR;
extern uint16_t FORE_COLOR;

/* Function Prototypes */
void LCD_Init(void);
void LCD_Clear(uint16_t color);
void LCD_DrawPixel(uint16_t x, uint16_t y, uint16_t color);
void LCD_ShowString(uint16_t x, uint16_t y, char *p, uint16_t color, uint16_t back_color);
void LCD_ShowChar(uint16_t x, uint16_t y, uint8_t num, uint16_t color, uint16_t back_color);

#endif