hardware_abstraction.c

#include "hardware_abstraction.h"
#include "system_config.h"
#include <stdio.h>
#include <unistd.h> // For sleep functions (remove in embedded build)

// GPIO Functions
// These are placeholder implementations - replace with actual FPGA GPIO access
bool gpio_read(uint8_t pin) {
    // Placeholder implementation
    // In real FPGA: return GPIO_REGISTER->DATA & (1 << pin);
    (void)pin;
    return false;
}

void gpio_write(uint8_t pin, bool value) {
    // Placeholder implementation
    // In real FPGA: 
    // if (value) GPIO_REGISTER->DATA |= (1 << pin);
    // else GPIO_REGISTER->DATA &= ~(1 << pin);
    (void)pin;
    (void)value;
}

// PWM Functions
void pwm_init(uint8_t pwm_channel, uint32_t frequency_hz) {
    // Placeholder implementation
    // In real FPGA: Configure PWM timer with specified frequency
    (void)pwm_channel;
    (void)frequency_hz;
}

void pwm_set_duty_cycle(uint8_t pwm_channel, uint8_t duty_cycle) {
    // Placeholder implementation
    // In real FPGA: Set PWM compare value based on duty cycle
    (void)pwm_channel;
    (void)duty_cycle;
}

void pwm_enable(uint8_t pwm_channel, bool enable) {
    // Placeholder implementation
    // In real FPGA: Enable/disable PWM output
    (void)pwm_channel;
    (void)enable;
}

// Timer Functions
static uint32_t system_time_counter = 0;

uint32_t timer_get_system_time(void) {
    // Placeholder implementation
    // In real FPGA: Read from system timer/counter
    return system_time_counter;
}

void timer_init(void) {
    // Placeholder implementation
    // In real FPGA: Initialize system timer and configure interrupt
    system_time_counter = 0;
}

// Delay functions (for simulation only)
void delay_ms(uint32_t milliseconds) {
    #ifdef SIMULATION
    usleep(milliseconds * 1000);
    #else
    // In embedded system, use timer-based delays or busy-wait
    (void)milliseconds;
    #endif
}

void delay_us(uint32_t microseconds) {
    #ifdef SIMULATION
    usleep(microseconds);
    #else
    // In embedded system, use timer-based delays or busy-wait
    (void)microseconds;
    #endif
}

// Display Functions
void display_hw_init(void) {
    // Placeholder implementation
    // In real FPGA: Initialize display interface (SPI/I2C/parallel)
}

void display_spi_write(uint8_t *data, uint8_t length) {
    // Placeholder implementation
    // In real FPGA: Write data via SPI interface
    (void)data;
    (void)length;
}

void display_i2c_write(uint8_t address, uint8_t *data, uint8_t length) {
    // Placeholder implementation
    // In real FPGA: Write data via I2C interface
    (void)address;
    (void)data;
    (void)length;
}

void display_parallel_write(uint8_t *data, uint8_t length) {
    // Placeholder implementation
    // In real FPGA: Write data via parallel GPIO interface
    (void)data;
    (void)length;
}

// Interrupt Functions
void interrupts_enable(void) {
    // Placeholder implementation
    // In real FPGA: Enable global interrupt flag
}

void interrupts_disable(void) {
    // Placeholder implementation
    // In real FPGA: Disable global interrupt flag
}

void interrupt_register(uint8_t irq_number, void (*handler)(void)) {
    // Placeholder implementation
    // In real FPGA: Register interrupt handler in interrupt vector table
    (void)irq_number;
    (void)handler;
}

// UART Functions (for debugging)
void uart_init(uint32_t baud_rate) {
    // Placeholder implementation
    // In real FPGA: Initialize UART with specified baud rate
    (void)baud_rate;
    #ifdef SIMULATION
    // In simulation, printf can be used
    #endif
}

void uart_send_char(char c) {
    #ifdef SIMULATION
    putchar(c);
    #else
    // In real FPGA: Write character to UART transmit register
    (void)c;
    #endif
}

void uart_send_string(const char *str) {
    #ifdef SIMULATION
    printf("%s", str);
    #else
    // In real FPGA: Send string character by character via UART
    while (*str) {
        uart_send_char(*str++);
    }
    #endif
}

bool uart_receive_char(char *c) {
    // Placeholder implementation
    // In real FPGA: Check UART receive register and read character if available
    (void)c;
    return false;
}