wgrhal_ext.h

gehe zur Dokumentation dieser Datei

 
#ifndef WGRHAL_EXT_H
#define WGRHAL_EXT_H
 
#include "wgrtypes.h"
 
#ifndef HWREG32
#define HWREG32(addr) (*((volatile uint32_t *)(addr)))
#endif
 
#define MULT_BASE_ADDR 0x00000500
#define MULT_INFO_OFFSET 0x0000
#define MUL1_OFFSET 0x0004
#define MUL2_OFFSET 0x0008
#define RESH_OFFSET 0x000C
#define RESL_OFFSET 0x0010
 
#define DIV_BASE_ADDR 0x00000600
#define DIV_INFO_OFFSET 0x00
#define DIV_END_OFFSET 0x04
#define DIV_SOR_OFFSET 0x08
#define DIV_QUO_OFFSET 0x0C
#define DIV_REM_OFFSET 0x10
 
#define SPI_BASE_ADDR 0x00000700
#define SPI_CTRL_OFFSET 0x0000
#define SPI_CLK_OFFSET 0x0004
#define SPI_STATUS_OFFSET 0x0008
#define SPI_TX_OFFSET 0x000C
#define SPI_RX_OFFSET 0x0010
#define SPI_CS_OFFSET 0x0014
 
#define WS_BASE_ADDR 0x00000900
 
typedef struct
{
    uint8_t r; 
    uint8_t g; 
    uint8_t b; 
} rgb_color_t;
 
typedef struct
{
    uint32_t dividend;  
    uint32_t divisor;   
    uint32_t quotient;  
    uint32_t remainder; 
} div_result_t;
 
/* Hardware Multiplication and Division */
uint64_t mult_calc_64(uint32_t multiplicand, uint32_t multiplier);
 
uint32_t mult_calc(uint32_t multiplicand, uint32_t multiplier);
 
int32_t div_calc(uint32_t dividend, uint32_t divisor, div_result_t *result);
 
uint32_t div_calc_quotient(uint32_t dividend, uint32_t divisor);
 
uint32_t div_calc_remainder(uint32_t dividend, uint32_t divisor);
 
/* SPI Functions */
void spi_enable(void);
 
void spi_disable(void);
 
void spi_automatic_cs(bool active);
 
void spi_cs(uint32_t active);
 
void spi_set_clock_offet(uint32_t offset);
 
void spi_set_clock_divider(uint32_t divider);
 
uint32_t spi_get_status(void);
 
uint32_t spi_fifo_full(void);
 
uint32_t spi_is_ready(void);
 
uint32_t spi_is_busy(void);
 
uint32_t spi_rx_full(void);
 
uint32_t spi_rx_empty(void);
 
uint32_t spi_tx_full(void);
 
uint32_t spi_tx_empty(void);
 
int32_t spi_wait_rx_data(uint32_t timeout_ms);
 
int32_t spi_write_byte(uint8_t data, uint32_t timeout_ms);
 
int32_t spi_read_byte(uint8_t *data, uint32_t timeout_ms);
 
int32_t spi_write_buffer(const uint8_t *buf, uint32_t length, uint32_t timeout_ms);
 
int32_t spi_write_uint32(uint32_t value, uint32_t timeout_ms);
 
int32_t spi_read_buffer(uint8_t *buf, uint32_t length, uint32_t timeout_ms);
 
/* WS2812B Functions */
int32_t ws2812_set_color(uint8_t led, rgb_color_t color);
 
rgb_color_t ws2812_get_color(uint8_t led);
 
int32_t ws2812_write_all(const rgb_color_t colors[8]);
 
int32_t ws2812_fill(rgb_color_t color);
 
void ws2812_clear(void);
 
#ifdef PWM_NOTES
/* Play Frequencies with the PWM Module */
typedef enum
{
    NOTE_C = 0,   
    NOTE_Cs = 1,  
    NOTE_D = 2,   
    NOTE_Ds = 3,  
    NOTE_E = 4,   
    NOTE_F = 5,   
    NOTE_Fs = 6,  
    NOTE_G = 7,   
    NOTE_Gs = 8,  
    NOTE_A = 9,   
    NOTE_As = 10, 
    NOTE_B = 11   
} note_t;
 
extern const uint8_t note_freq_halfbase[12];
 
int pwm_precompute_notes(void);
 
void pwm_play_note(note_t note, uint32_t octave);
 
void pwm_free_note_buffer(void);
 
#endif
 
#ifdef MALLOC
/* malloc */
extern char _heap_start;
extern char _heap_end;
extern char _sstack;
extern char _estack;
 
void *malloc(uint32_t size);
 
void free(void *ptr);
 
void *realloc(void *ptr, uint32_t size);
 
void *calloc(uint32_t nmemb, uint32_t size);
 
uint32_t heap_free_space(void);
 
#endif
 
#ifdef SSD1351
/* SSD1351 Display with Scroll Function */
static const uint8_t font5x7[96][5] = {
    {0x00, 0x00, 0x00, 0x00, 0x00}, // ' ' (32)
    {0x00, 0x00, 0x5F, 0x00, 0x00}, // '!' (33)
    {0x00, 0x07, 0x00, 0x07, 0x00}, // '"' (34)
    {0x14, 0x7F, 0x14, 0x7F, 0x14}, // '#' (35)
    {0x24, 0x2A, 0x7F, 0x2A, 0x12}, // '$' (36)
    {0x23, 0x13, 0x08, 0x64, 0x62}, // '%' (37)
    {0x36, 0x49, 0x55, 0x22, 0x50}, // '&' (38)
    {0x00, 0x05, 0x03, 0x00, 0x00}, // ''' (39)
    {0x00, 0x1C, 0x22, 0x41, 0x00}, // '(' (40)
    {0x00, 0x41, 0x22, 0x1C, 0x00}, // ')' (41)
    {0x14, 0x08, 0x3E, 0x08, 0x14}, // '*' (42)
    {0x08, 0x08, 0x3E, 0x08, 0x08}, // '+' (43)
    {0x00, 0x50, 0x30, 0x00, 0x00}, // ',' (44)
    {0x08, 0x08, 0x08, 0x08, 0x08}, // '-' (45)
    {0x00, 0x60, 0x60, 0x00, 0x00}, // '.' (46)
    {0x20, 0x10, 0x08, 0x04, 0x02}, // '/' (47)
    {0x3E, 0x51, 0x49, 0x45, 0x3E}, // '0' (48)
    {0x00, 0x42, 0x7F, 0x40, 0x00}, // '1' (49)
    {0x42, 0x61, 0x51, 0x49, 0x46}, // '2' (50)
    {0x21, 0x41, 0x45, 0x4B, 0x31}, // '3' (51)
    {0x18, 0x14, 0x12, 0x7F, 0x10}, // '4' (52)
    {0x27, 0x45, 0x45, 0x45, 0x39}, // '5' (53)
    {0x3C, 0x4A, 0x49, 0x49, 0x30}, // '6' (54)
    {0x01, 0x71, 0x09, 0x05, 0x03}, // '7' (55)
    {0x36, 0x49, 0x49, 0x49, 0x36}, // '8' (56)
    {0x06, 0x49, 0x49, 0x29, 0x1E}, // '9' (57)
    {0x00, 0x36, 0x36, 0x00, 0x00}, // ':' (58)
    {0x00, 0x56, 0x36, 0x00, 0x00}, // ';' (59)
    {0x08, 0x14, 0x22, 0x41, 0x00}, // '<' (60)
    {0x14, 0x14, 0x14, 0x14, 0x14}, // '=' (61)
    {0x00, 0x41, 0x22, 0x14, 0x08}, // '>' (62)
    {0x02, 0x01, 0x51, 0x09, 0x06}, // '?' (63)
    {0x32, 0x49, 0x79, 0x41, 0x3E}, // '@' (64)
    {0x7E, 0x11, 0x11, 0x11, 0x7E}, // 'A' (65)
    {0x7F, 0x49, 0x49, 0x49, 0x36}, // 'B' (66)
    {0x3E, 0x41, 0x41, 0x41, 0x22}, // 'C' (67)
    {0x7F, 0x41, 0x41, 0x22, 0x1C}, // 'D' (68)
    {0x7F, 0x49, 0x49, 0x49, 0x41}, // 'E' (69)
    {0x7F, 0x09, 0x09, 0x09, 0x01}, // 'F' (70)
    {0x3E, 0x41, 0x49, 0x49, 0x7A}, // 'G' (71)
    {0x7F, 0x08, 0x08, 0x08, 0x7F}, // 'H' (72)
    {0x00, 0x41, 0x7F, 0x41, 0x00}, // 'I' (73)
    {0x20, 0x40, 0x41, 0x3F, 0x01}, // 'J' (74)
    {0x7F, 0x10, 0x28, 0x44, 0x00}, // 'K' (75)
    {0x7F, 0x40, 0x40, 0x40, 0x40}, // 'L' (76)
    {0x7F, 0x02, 0x0C, 0x02, 0x7F}, // 'M' (77)
    {0x7F, 0x04, 0x08, 0x10, 0x7F}, // 'N' (78)
    {0x3E, 0x41, 0x41, 0x41, 0x3E}, // 'O' (79)
    {0x7F, 0x09, 0x09, 0x09, 0x06}, // 'P' (80)
    {0x3E, 0x41, 0x51, 0x21, 0x5E}, // 'Q' (81)
    {0x7F, 0x09, 0x19, 0x29, 0x46}, // 'R' (82)
    {0x46, 0x49, 0x49, 0x49, 0x31}, // 'S' (83)
    {0x01, 0x01, 0x7F, 0x01, 0x01}, // 'T' (84)
    {0x3F, 0x40, 0x40, 0x40, 0x3F}, // 'U' (85)
    {0x1F, 0x20, 0x40, 0x20, 0x1F}, // 'V' (86)
    {0x3F, 0x40, 0x38, 0x40, 0x3F}, // 'W' (87)
    {0x63, 0x14, 0x08, 0x14, 0x63}, // 'X' (88)
    {0x07, 0x08, 0x70, 0x08, 0x07}, // 'Y' (89)
    {0x61, 0x51, 0x49, 0x45, 0x43}, // 'Z' (90)
    {0x00, 0x7F, 0x41, 0x41, 0x00}, // '[' (91)
    {0x02, 0x04, 0x08, 0x10, 0x20}, // '\' (92)
    {0x00, 0x41, 0x41, 0x7F, 0x00}, // ']' (93)
    {0x04, 0x02, 0x01, 0x02, 0x04}, // '^' (94)
    {0x40, 0x40, 0x40, 0x40, 0x40}, // '_' (95)
    {0x00, 0x01, 0x02, 0x04, 0x00}, // '`' (96)
    {0x20, 0x54, 0x54, 0x54, 0x78}, // 'a' (97)
    {0x7F, 0x48, 0x44, 0x44, 0x38}, // 'b' (98)
    {0x38, 0x44, 0x44, 0x44, 0x20}, // 'c' (99)
    {0x38, 0x44, 0x44, 0x48, 0x7F}, // 'd' (100)
    {0x38, 0x54, 0x54, 0x54, 0x18}, // 'e' (101)
    {0x08, 0x7E, 0x09, 0x01, 0x02}, // 'f' (102)
    {0x0C, 0x52, 0x52, 0x52, 0x3E}, // 'g' (103)
    {0x7F, 0x08, 0x04, 0x04, 0x78}, // 'h' (104)
    {0x00, 0x44, 0x7D, 0x40, 0x00}, // 'i' (105)
    {0x20, 0x40, 0x44, 0x3D, 0x00}, // 'j' (106)
    {0x7F, 0x10, 0x28, 0x44, 0x00}, // 'k' (107)
    {0x00, 0x41, 0x7F, 0x40, 0x00}, // 'l' (108)
    {0x7C, 0x04, 0x18, 0x04, 0x78}, // 'm' (109)
    {0x7C, 0x08, 0x04, 0x04, 0x78}, // 'n' (110)
    {0x38, 0x44, 0x44, 0x44, 0x38}, // 'o' (111)
    {0x7C, 0x14, 0x14, 0x14, 0x08}, // 'p' (112)
    {0x08, 0x14, 0x14, 0x18, 0x7C}, // 'q' (113)
    {0x7C, 0x08, 0x04, 0x04, 0x08}, // 'r' (114)
    {0x48, 0x54, 0x54, 0x54, 0x20}, // 's' (115)
    {0x04, 0x3F, 0x44, 0x40, 0x20}, // 't' (116)
    {0x3C, 0x40, 0x40, 0x20, 0x7C}, // 'u' (117)
    {0x1C, 0x20, 0x40, 0x20, 0x1C}, // 'v' (118)
    {0x3C, 0x40, 0x30, 0x40, 0x3C}, // 'w' (119)
    {0x44, 0x28, 0x10, 0x28, 0x44}, // 'x' (120)
    {0x0C, 0x50, 0x50, 0x50, 0x3C}, // 'y' (121)
    {0x44, 0x64, 0x54, 0x4C, 0x44}, // 'z' (122)
    {0x00, 0x08, 0x36, 0x41, 0x00}, // '{' (123)
    {0x00, 0x00, 0x7F, 0x00, 0x00}, // '|' (124)
    {0x00, 0x41, 0x36, 0x08, 0x00}, // '}' (125)
    {0x08, 0x04, 0x08, 0x10, 0x08}, // '~' (126)
    {0x00, 0x06, 0x09, 0x09, 0x06}  // DEL (127)
};
 
#define SSD1351_WIDTH 128
#define SSD1351_HEIGHT 128
#define CHAR_WIDTH 6
#define CHAR_HEIGHT 8
#define STATUS_BAR_ROWS 1
#define TOTAL_ROWS (SSD1351_HEIGHT / CHAR_HEIGHT)
#define TERM_COLS (SSD1351_WIDTH / CHAR_WIDTH)
#define TERM_ROWS (TOTAL_ROWS)
#define SSD1351_SPI_TIMEOUT 10
#define HOUSEKEEPING_MS 250
 
#define COLOR_BLACK 0x0000
#define COLOR_WHITE 0xFFFF
#define COLOR_RED 0x07E0
#define COLOR_GREEN 0xF800
#define COLOR_BLUE 0x001F
#define COLOR_YELLOW 0xFFE0
#define COLOR_MAGENTA 0xF81F
#define COLOR_CYAN 0x07FF
 
void housekeeping(void);
 
void ssd1351_inv(void);
 
void ssd1351_send_data(const uint8_t *data, size_t len);
 
void ssd1351_send_command(uint8_t cmd);
 
void ssd1351_send_command_with_data(uint8_t cmd, const uint8_t *data, size_t len);
 
void ssd1351_send_commands(const uint8_t *buf, size_t len);
 
void ssd1351_init(void);
 
void ssd1351_set_position(uint8_t x, uint8_t y, uint8_t w, uint8_t h);
 
void ssd1351_fill_screen(uint16_t color);
 
void ssd1351_draw_pixel(uint8_t x, uint8_t y, uint16_t color);
 
void terminal_init(void);
 
void terminal_print(const char *str);
 
void terminal_print_col(const char *text, uint16_t color);
 
void print_ok_res(const char *label, int32_t value);
 
void print_ok(const char *label);
 
void print_error(const char *label);
 
void terminal_put_char(char c);
 
void terminal_set_text_color(uint16_t color);
 
void terminal_set_bg_color(uint16_t color);
 
void terminal_draw_text(uint8_t row, uint8_t col, const char *str, uint16_t fg_color, uint16_t bg_color);
 
void terminal_draw_text_default(uint8_t row, uint8_t col, const char *str);
 
void terminal_native_scroll(void);
 
void clear_terminal_row(uint8_t row);
 
void clear_terminal(void);
 
void draw_status_bar(const char *text, uint16_t bg_color, uint16_t fg_color);
 
void draw_char_cell(uint8_t row, uint8_t col, char c);
 
void draw_char_cell_custom(uint8_t row, uint8_t col, char c, uint16_t fg, uint16_t bg);
 
uint32_t ssd1351_cursor_x(void);
 
#endif
 
#endif /* WGRHAL_EXT_H */