From 2cc0a155e81bc3679ce8e082d09ddd14fb7bee80 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ond=C5=99ej=20Hru=C5=A1ka?= Date: Sat, 5 Nov 2022 19:58:17 +0100 Subject: [PATCH] geiger wip --- Makefile | 23 +- lib/porklib/adc.c | 67 ++ lib/porklib/adc.h | 26 + lib/porklib/blockdev.h | 66 ++ lib/porklib/calc.h | 89 +++ lib/porklib/color.c | 103 +++ lib/porklib/color.h | 57 ++ lib/porklib/debounce.c | 52 ++ lib/porklib/debounce.h | 66 ++ lib/porklib/dht11.c | 88 +++ lib/porklib/dht11.h | 17 + lib/porklib/fat16.c | 1253 ++++++++++++++++++++++++++++++++++ lib/porklib/fat16.h | 276 ++++++++ lib/porklib/fat16_internal.h | 64 ++ lib/porklib/iopins.c | 276 ++++++++ lib/porklib/iopins.h | 213 ++++++ lib/porklib/lcd.c | 365 ++++++++++ lib/porklib/lcd.h | 146 ++++ lib/porklib/nsdelay.h | 21 + lib/porklib/onewire.c | 248 +++++++ lib/porklib/onewire.h | 58 ++ lib/porklib/sd.c | 202 ++++++ lib/porklib/sd.h | 53 ++ lib/porklib/sd_blockdev.c | 184 +++++ lib/porklib/sd_blockdev.h | 7 + lib/porklib/sd_fat.c | 67 ++ lib/porklib/sd_fat.h | 32 + lib/porklib/sipo_pwm.c | 83 +++ lib/porklib/sipo_pwm.h | 49 ++ lib/porklib/sonar.c | 168 +++++ lib/porklib/sonar.h | 67 ++ lib/porklib/spi.c | 35 + lib/porklib/spi.h | 30 + lib/porklib/stream.c | 246 +++++++ lib/porklib/stream.h | 106 +++ lib/porklib/uart.c | 714 +++++++++++++++++++ lib/porklib/uart.h | 253 +++++++ lib/porklib/wsrgb.c | 139 ++++ lib/porklib/wsrgb.h | 53 ++ src/main.c | 130 +++- 40 files changed, 6166 insertions(+), 26 deletions(-) create mode 100644 lib/porklib/adc.c create mode 100644 lib/porklib/adc.h create mode 100644 lib/porklib/blockdev.h create mode 100644 lib/porklib/calc.h create mode 100644 lib/porklib/color.c create mode 100644 lib/porklib/color.h create mode 100644 lib/porklib/debounce.c create mode 100644 lib/porklib/debounce.h create mode 100644 lib/porklib/dht11.c create mode 100644 lib/porklib/dht11.h create mode 100644 lib/porklib/fat16.c create mode 100644 lib/porklib/fat16.h create mode 100644 lib/porklib/fat16_internal.h create mode 100644 lib/porklib/iopins.c create mode 100644 lib/porklib/iopins.h create mode 100644 lib/porklib/lcd.c create mode 100644 lib/porklib/lcd.h create mode 100644 lib/porklib/nsdelay.h create mode 100644 lib/porklib/onewire.c create mode 100644 lib/porklib/onewire.h create mode 100644 lib/porklib/sd.c create mode 100644 lib/porklib/sd.h create mode 100644 lib/porklib/sd_blockdev.c create mode 100644 lib/porklib/sd_blockdev.h create mode 100644 lib/porklib/sd_fat.c create mode 100644 lib/porklib/sd_fat.h create mode 100644 lib/porklib/sipo_pwm.c create mode 100644 lib/porklib/sipo_pwm.h create mode 100644 lib/porklib/sonar.c create mode 100644 lib/porklib/sonar.h create mode 100644 lib/porklib/spi.c create mode 100644 lib/porklib/spi.h create mode 100644 lib/porklib/stream.c create mode 100644 lib/porklib/stream.h create mode 100644 lib/porklib/uart.c create mode 100644 lib/porklib/uart.h create mode 100644 lib/porklib/wsrgb.c create mode 100644 lib/porklib/wsrgb.h diff --git a/Makefile b/Makefile index 21b56d6..8e29944 100644 --- a/Makefile +++ b/Makefile @@ -10,7 +10,20 @@ PROG_TYPE = arduino # Build the final AVRDUDE arguments PROG_ARGS = -c $(PROG_TYPE) -p $(MCU) -b $(PROG_BAUD) -P $(PROG_DEV) -INCFLAGS += -Isrc -Ilib/libssd1306/src +INCFLAGS += -Isrc -Ilib/libssd1306/src -Ilib/porklib + +LIB_SOURCES = +#LIB_SOURCES += lib/porklib/uart.c +#LIB_SOURCES += lib/porklib/uart.c +LIB_SOURCES += lib/porklib/iopins.c +#LIB_SOURCES += lib/porklib/stream.c +LIB_SOURCES += lib/porklib/adc.c +#LIB_SOURCES += lib/porklib/dht11.c +#LIB_SOURCES += lib/porklib/sonar.c +#LIB_SOURCES += lib/porklib/onewire.c +#LIB_SOURCES += lib/porklib/spi.c +#LIB_SOURCES += lib/porklib/sd.c +#LIB_SOURCES += lib/porklib/fat16.c CFLAGS = -std=gnu99 -mmcu=$(MCU) -DF_CPU=$(F_CPU)UL CFLAGS += -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums @@ -40,7 +53,7 @@ OBJDUMP = avr-objdump AVRSIZE = avr-size AVRDUDE = avrdude -SOURCES=$(wildcard $(SRC_DIR)/*.c) +SOURCES=$(wildcard $(SRC_DIR)/*.c) $(LIB_SOURCES) OBJECTS=$(SOURCES:$(SRC_DIR)/%.c=$(BUILD_DIR)/%.o) DEPENDS=$(BUILD_DIR)/.depends @@ -62,7 +75,11 @@ eeprom: $(TARGET).eeprom size: $(TARGET).elf $(AVRSIZE) -C --mcu=$(MCU) $< -$(TARGET).elf: $(OBJECTS) | $(BUILD_DIR) +# Build the display library +lib/libssd1306/bld/libssd1306.a: + $(MAKE) -C lib/libssd1306/ -f Makefile.avr MCU=atmega328p + +$(TARGET).elf: $(OBJECTS) lib/libssd1306/bld/libssd1306.a | $(BUILD_DIR) $(LD) $(CFLAGS) $(LFLAGS) -o $@ $^ lib/libssd1306/bld/libssd1306.a %.hex: %.elf diff --git a/lib/porklib/adc.c b/lib/porklib/adc.c new file mode 100644 index 0000000..0bafd16 --- /dev/null +++ b/lib/porklib/adc.c @@ -0,0 +1,67 @@ +#include +#include +#include + +#include "calc.h" +#include "adc.h" + +/** Initialize the ADC */ +void adc_init() +{ + ADCSRA |= _BV(ADPS2) | _BV(ADPS1) | _BV(ADPS0); // 128 prescaler -> 125 kHz +// ADCSRA |= _BV(ADPS2) | _BV(ADPS0); // 32 prescaler -> 500 kHz, good for 8-bit measurement + + ADMUX |= _BV(REFS0) | _BV(REFS1); // Voltage reference = internal 1.1V + + sbi(ADCSRA, ADEN); // Enable ADC +} + + +/** Disable AD */ +void adc_disable() +{ + cbi(ADCSRA, ADEN); +} + + +/** Sample analog pin with 8-bit precision */ +uint8_t adc_read_byte(uint8_t channel) +{ + set_low_nibble(ADMUX, channel); // Select channel to sample + sbi(ADMUX, ADLAR); // Align result to left + sbi(ADCSRA, ADSC); // Start conversion + + while (bit_is_high(ADCSRA, ADSC)); // Wait for it... + + return ADCH; // The upper 8 bits of ADC result +} + + +/** Sample analog pin with 10-bit precision */ +uint16_t adc_read_word(uint8_t channel) +{ + set_low_nibble(ADMUX, channel); // Select channel to sample + cbi(ADMUX, ADLAR); // Align result to right + sbi(ADCSRA, ADSC); // Start conversion + + while (get_bit(ADCSRA, ADSC)); // Wait for it... + + return ADCW; // The whole ADC word (10 bits) +} + +/** Sample analog pin with 10-bit precision */ +void adc_async_start_measure_word(uint8_t channel) +{ + set_low_nibble(ADMUX, channel); // Select channel to sample + cbi(ADMUX, ADLAR); // Align result to right + sbi(ADCSRA, ADSC); // Start conversion +} + +bool adc_async_ready() +{ + return 0 == get_bit(ADCSRA, ADSC); +} + +uint16_t adc_async_get_result_word() { + return ADCW; // The whole ADC word (10 bits) +} diff --git a/lib/porklib/adc.h b/lib/porklib/adc.h new file mode 100644 index 0000000..0eb8b26 --- /dev/null +++ b/lib/porklib/adc.h @@ -0,0 +1,26 @@ +#pragma once + +// +// Utilities for build-in A/D converter +// + +#include +#include + +/** Initialize the ADC */ +void adc_init(); + +/** Disable AD (for power saving?) */ +void adc_disable(); + +/** Sample analog pin with 8-bit precision */ +uint8_t adc_read_byte(uint8_t channel); + +/** Sample analog pin with 10-bit precision */ +uint16_t adc_read_word(uint8_t channel); + +void adc_async_start_measure_word(uint8_t channel); + +bool adc_async_ready(); + +uint16_t adc_async_get_result_word(); diff --git a/lib/porklib/blockdev.h b/lib/porklib/blockdev.h new file mode 100644 index 0000000..ee422e8 --- /dev/null +++ b/lib/porklib/blockdev.h @@ -0,0 +1,66 @@ +#pragma once + +// +// Block device interface, somewhat akin to stream.h +// Used for filesystem implementations. +// + +#include + +/** Abstract block device interface + * + * Populate an instance of this with pointers to your I/O functions. + */ +typedef struct +{ + /** Sequential read at cursor + * @param dest destination memory structure + * @param len number of bytes to load and store in {dest} + */ + void (*load)(void* dest, const uint16_t len); + + + /** Sequential write at cursor + * @param src source memory structure + * @param len number of bytes to write + */ + void (*store)(const void* src, const uint16_t len); + + + /** Write one byte at cursor + * @param b byte to write + */ + void (*write)(const uint8_t b); + + + /** Read one byte at cursor + * @return the read byte + */ + uint8_t (*read)(void); + + + /** Absolute seek - set cursor + * @param addr new cursor address + */ + void (*seek)(const uint32_t addr); + + + /** Relative seek - move cursor + * @param offset cursor address change + */ + void (*rseek)(const int16_t offset); + + + + /** Flush the data buffer if it's dirty. + * + * Should be called after each sequence of writes, + * to avoid data loss. + * + * Tmplementations that do not need this should provide + * a no-op function. + */ + void (*flush)(void); + +} BLOCKDEV; + diff --git a/lib/porklib/calc.h b/lib/porklib/calc.h new file mode 100644 index 0000000..2d150e6 --- /dev/null +++ b/lib/porklib/calc.h @@ -0,0 +1,89 @@ +#pragma once + +// +// Bit and byte manipulation utilities +// + +#include + + +// --- Increment in range --- +// when overflown, wraps within range. Lower bound < upper bound. +// ..., upper bound excluded +#define inc_wrap(var, min, max) { if ((var) >= (max - 1)) { (var) = (min); } else { (var)++; } } +// ..., upper bound included +#define inc_wrapi(var, min, max) inc_wrap((var), (min), (max) + 1) + + +// --- Decrement in range --- +// when underflown, wraps within range. Lower bound < upper bound. +// ..., upper bound excluded +#define dec_wrap(var, min, max) { if ((var) <= (min)) { (var) = (max) - 1; } else { (var)--; } } +// ..., upper bound included +#define dec_wrapi(var, min, max) dec_wrap((var), (min), (max) + 1) + + +// --- Bit manipulation -- + +// Set bit +#define sbi(reg, bit) { (reg) |= (1 << (uint8_t)(bit)); } + +// Clear bit +#define cbi(reg, bit) { (reg) &= ~(1 << (uint8_t)(bit)); } + +// Get n-th bit +#define get_bit(reg, bit) (((reg) >> (uint8_t)(bit)) & 0x1) + +// Test n-th bit (Can't use bit_is_set, as it's redefined in sfr_def.h) +#define bit_is_high(reg, bit) get_bit(reg, bit) +#define bit_is_low(reg, bit) (!get_bit(reg, bit)) + +// Write value to n-th bit +#define set_bit(reg, bit, value) { (reg) = ((reg) & ~(1 << (uint8_t)(bit))) | (((uint8_t)(value) & 0x1) << (uint8_t)(bit)); } + +// Invert n-th bit +#define toggle_bit(reg, bit) { (reg) ^= (1 << (uint8_t)(bit)); } + + +// --- Bit manipulation with pointer to variable --- + +// Set n-th bit in pointee +#define sbi_p(reg_p, bit) { (*(reg_p)) |= (1 << (uint8_t)(bit)); } +// Clear n-th bit in pointee +#define cbi_p(reg_p, bit) { (*(reg_p)) &= ~(1 << (uint8_t)(bit)); } + +// Get n-th bit in pointee +#define get_bit_p(reg_p, bit) ((*(reg_p) >> (uint8_t)(bit)) & 0x1) + +// Test n-th bit in pointee (Can't use bit_is_set, as it's redefined in sfr_def.h) +#define bit_is_high_p(reg_p, bit) get_bit_p(reg_p, bit) +#define bit_is_low_p(reg_p, bit) (!get_bit_p(reg_p, bit)) + +// Write value to a bit in pointee +#define set_bit_p(reg_p, bit, value) { *(reg_p) = (*(reg_p) & ~(1 << ((uint8_t)(bit) & 0x1))) | (((uint8_t)(value) & 0x1) << (uint8_t)(bit)); } +#define toggle_bit_p(reg_p, bit) { *(reg_p) ^= (1 << (uint8_t)(bit)); } + + +// --- Nibble manipulation --- + +// Replace nibble in a byte +#define set_low_nibble(reg, value) { (reg) = ((reg) & 0xF0) | ((uint8_t)(value) & 0xF); } +#define set_high_nibble(reg, value) { (reg) = ((reg) & 0x0F) | (((uint8_t)(value) & 0xF) << 4); } + +#define set_low_nibble_p(reg_p, value) { *(reg_p) = (*(reg_p) & 0xF0) | ((uint8_t)(value) & 0xF); } +#define set_high_nibble_p(reg_p, value) { *(reg_p) = (*(reg_p) & 0x0F) | (((uint8_t)(value) & 0xF) << 4); } + +#define low_nibble(x) ((uint8_t)(x) & 0xF) +#define high_nibble(x) (((uint8_t)(x) & 0xF0) >> 4) + +// --- Range tests --- + +// Test if X is within low..high, regardless of bounds order +#define in_range(x, low, high) ((((low) < (high)) && ((x) >= (low) && (x) < (high))) || (((low) > (high)) && ((x) >= (high) && (x) < (low)))) +// ..., include greater bound +#define in_rangei(x, low, high) ((((low) <= (high)) && ((x) >= (low) && (x) <= (high))) || (((low) > (high)) && ((x) >= (high) && (x) <= (low)))) + +// Test if X in low..high, wrap around ends if needed. +#define in_range_wrap(x, low, high) ((((low) < (high)) && ((x) >= (low) && (x) < (high))) || (((low) > (high)) && ((x) >= (low) || (x) < (high)))) +// ..., include upper bound +#define in_range_wrapi(x, low, high) ((((low) <= (high)) && ((x) >= (low) && (x) <= (high))) || (((low) > (high)) && ((x) >= (low) || (x) <= (high)))) diff --git a/lib/porklib/color.c b/lib/porklib/color.c new file mode 100644 index 0000000..ef7b0bb --- /dev/null +++ b/lib/porklib/color.c @@ -0,0 +1,103 @@ +#include +#include +#include + +#include "iopins.h" +#include "nsdelay.h" +#include "color.h" + + +// --- HSL --- + +#ifdef HSL_LINEAR +const uint8_t FADE_128[] = +{ + 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, + 5, 5, 6, 6, 6, 7, 7, 8, 8, 8, 9, 10, 10, 10, 11, 12, 13, 14, + 14, 15, 16, 17, 18, 20, 21, 22, 24, 26, 27, 28, 30, 31, 32, 34, 35, 36, + 38, 39, 40, 41, 42, 44, 45, 46, 48, 49, 50, 52, 54, 56, 58, 59, 61, 63, + 65, 67, 68, 69, 71, 72, 74, 76, 78, 80, 82, 85, 88, 90, 92, 95, 98, 100, + 103, 106, 109, 112, 116, 119, 122, 125, 129, 134, 138, 142, 147, 151, + 153, 156, 160, 163, 165, 170, 175, 180, 185, 190, 195, 200, 207, 214, 218, + 221, 225, 228, 232, 234, 241, 248, 254, 255 +}; +#endif + +// based on: https://github.com/lewisd32/avr-hsl2rgb +xrgb_t hsl_xrgb(const hsl_t cc) +{ + // 0 .. 256*3 + const uint16_t hh = (uint16_t) cc.h * 3; + const uint8_t hue_mod = hh % 256; + + uint8_t r_temp, g_temp, b_temp; + if (hh < 256) + { + r_temp = hue_mod ^ 255; + g_temp = hue_mod; + b_temp = 0; + } + else if (hh < 512) + { + r_temp = 0; + g_temp = hue_mod ^ 255; + b_temp = hue_mod; + } + else if (hh < 768) + { + r_temp = hue_mod; + g_temp = 0; + b_temp = hue_mod ^ 255; + } + else + { + r_temp = 0; + g_temp = 0; + b_temp = 0; + } + + const uint8_t inverse_sat = (cc.s ^ 255); + + xrgb_t rgb; + + uint8_t t8; + uint16_t t16; + +#ifdef HSL_LINEAR + const uint8_t bri = FADE_128[cc.l >> 1]; +#else + const uint8_t bri = cc.l; +#endif + + t8 = r_temp; + t16 = t8 * cc.s + t8; + t16 = t16 + t8; + t8 = t16 >> 8; + t8 = t8 + inverse_sat; + t16 = t8 * bri; + t16 = t16 + t8; + t8 = t16 >> 8; + rgb.r = t8; + + t8 = g_temp; + t16 = t8 * cc.s; + t16 = t16 + t8; + t8 = t16 >> 8; + t8 = t8 + inverse_sat; + t16 = t8 * bri; + t16 = t16 + t8; + t8 = t16 >> 8; + rgb.g = t8; + + t8 = b_temp; + t16 = t8 * cc.s; + t16 = t16 + t8; + t8 = t16 >> 8; + t8 = t8 + inverse_sat; + t16 = t8 * bri; + t16 = t16 + t8; + t8 = t16 >> 8; + rgb.b = t8; + + return rgb; +} diff --git a/lib/porklib/color.h b/lib/porklib/color.h new file mode 100644 index 0000000..7fef13a --- /dev/null +++ b/lib/porklib/color.h @@ -0,0 +1,57 @@ +#pragma once + +// --- color types --- +// +// The XXXc macros don't use cast, so they can be used in array initializers. +// +// xrgb ... 3-byte true-color RGB (8 bits per component) +// rgb24 ... 24-bit color value, with equal nr of bits per component +// +// XX_r (_g, _b) ... extract component from the color, and convert it to 0..255 + +// Define HSL_LINEAR to get more linear brightness in hsl->rgb conversion + + +typedef struct +{ + uint8_t r; + uint8_t g; + uint8_t b; +} xrgb_t; + + +typedef uint32_t rgb24_t; + +#define xrgb(rr, gg, bb) ((xrgb_t)xrgbc(rr, gg, bb)) +// xrgb for constant array declarations +#define xrgbc(rr, gg, bb) { .r = ((uint8_t)(rr)), .g = ((uint8_t)(gg)), .b = ((uint8_t)(bb)) } +#define xrgb_r(c) ((uint8_t)(c.r)) +#define xrgb_g(c) ((uint8_t)(c.g)) +#define xrgb_b(c) ((uint8_t)(c.b)) +#define xrgb_rgb24(c) ((((rgb24_t)c.r) << 16) | (((rgb24_t)c.g) << 8) | (((rgb24_t)c.b))) +#define xrgb_rgb15(c) (((((rgb15_t)c.r) & 0xF8) << 7) | ((((rgb15_t)c.g) & 0xF8) << 2) | ((((rgb15_t)c.b) & 0xF8) >> 3)) +#define xrgb_rgb12(c) (((((rgb12_t)c.r) & 0xF0) << 4) | ((((rgb12_t)c.g) & 0xF0)) | ((((rgb12_t)c.b) & 0xF0) >> 4)) +#define xrgb_rgb6(c) (((((rgb6_t)c.r) & 0xC0) >> 2) | ((((rgb6_t)c.g) & 0xC0) >> 4) | ((((rgb6_t)c.b) & 0xC0) >> 6)) + +#define rgb24c(r,g,b) (((((rgb24_t)r) & 0xFF) << 16) | ((((rgb24_t)g) & 0xFF) << 8) | (((rgb24_t)b) & 0xFF)) +#define rgb24(r,g,b) ((rgb24_t) rgb24(r,g,b)) + +#define rgb24_r(c) ((((rgb24_t) (c)) >> 16) & 0xFF) +#define rgb24_g(c) ((((rgb24_t) (c)) >> 8) & 0xFF) +#define rgb24_b(c) ((((rgb24_t) (c)) >> 0) & 0xFF) +#define rgb24_xrgb(c) xrgb(rgb24_r(c), rgb24_g(c), rgb24_b(c)) +#define rgb24_xrgbc(c) xrgbc(rgb24_r(c), rgb24_g(c), rgb24_b(c)) + +#define add_xrgb(x, y) ((xrgb_t) { (((y).r > (255 - (x).r)) ? 255 : ((x).r + (y).r)), (((y).g > (255 - (x).g)) ? 255 : ((x).g + (y).g)), (((y).b > 255 - (x).b) ? 255 : ((x).b + (y).b)) }) + + +// HSL data structure +typedef struct +{ + uint8_t h; + uint8_t s; + uint8_t l; +} hsl_t; + +/* Convert HSL to XRGB */ +xrgb_t hsl_xrgb(const hsl_t color); diff --git a/lib/porklib/debounce.c b/lib/porklib/debounce.c new file mode 100644 index 0000000..a2f422a --- /dev/null +++ b/lib/porklib/debounce.c @@ -0,0 +1,52 @@ +#include +#include + +#include "debounce.h" +#include "calc.h" +#include "iopins.h" +#include "debo_config.h" + +/** Debounce data array */ +uint8_t debo_next_slot = 0; + +uint8_t debo_register(PORT_P reg, uint8_t bit, bool invert) +{ + debo_slots[debo_next_slot] = (debo_slot_t)({ + .reg = reg, + .bit = bit | ((invert & 1) << 7) | (get_bit_p(reg, bit) << 6), // bit 7 = invert, bit 6 = state + .count = 0, + }); + + return debo_next_slot++; +} + + +/** Check debounced pins, should be called periodically. */ +void debo_tick() +{ + for (uint8_t i = 0; i < debo_next_slot; i++) + { + // current pin value (right 3 bits, xored with inverse bit) + bool value = get_bit_p(debo_slots[i].reg, debo_slots[i].bit & 0x7); + + if (value != get_bit(debo_slots[i].bit, 6)) + { + + // different pin state than last recorded state + if (debo_slots[i].count < DEBO_TICKS) + { + debo_slots[i].count++; + } + else + { + // overflown -> latch value + set_bit(debo_slots[i].bit, 6, value); // set state bit + debo_slots[i].count = 0; + } + } + else + { + debo_slots[i].count = 0; // reset the counter + } + } +} diff --git a/lib/porklib/debounce.h b/lib/porklib/debounce.h new file mode 100644 index 0000000..ab903d6 --- /dev/null +++ b/lib/porklib/debounce.h @@ -0,0 +1,66 @@ +#pragma once + +// +// An implementation of button debouncer. +// +// ---- +// +// You must provide a config file debo_config.h (next to your main.c) +// +// A pin is registered like this: +// +// #define BTN1 12 // pin D12 +// #define BTN2 13 +// +// debo_add(BTN0); // The function returns number assigned to the pin (0, 1, ...) +// debo_add_rev(BTN1); // active low +// debo_register(&PINB, PB2, 0); // direct access - register, pin & invert +// +// Then periodically call the tick function (perhaps in a timer interrupt): +// +// debo_tick(); +// +// To check if input is active, use +// +// debo_get_pin(0); // state of input #0 (registered first) +// debo_get_pin(1); // state of input #1 (registered second) +// + + +#include +#include +#include + +#include "calc.h" +#include "iopins.h" + +// Your config file +#include "debo_config.h" +/* + #define DEBO_CHANNELS 2 + #define DDEBO_TICKS 5 +*/ + + +/* Internal deboucer entry */ +typedef struct +{ + PORT_P reg; // pointer to IO register + uint8_t bit; // bits 6 and 7 of this hold "state" & "invert" flag + uint8_t count; // number of ticks this was in the new state +} debo_slot_t; + +debo_slot_t debo_slots[DEBO_CHANNELS]; + +/** Add a pin for debouncing (must be used with constant args) */ +#define debo_add_rev(pin) debo_register(&_pin(pin), _pn(pin), 1) +#define debo_add(pin) debo_register(&_pin(pin), _pn(pin), 0) + +/** Add a pin for debouncing (low level function) */ +uint8_t debo_register(PORT_P pin_reg_pointer, uint8_t bit, bool invert); + +/** Check debounced pins, should be called periodically. */ +void debo_tick(); + +/** Get a value of debounced pin */ +#define debo_get_pin(i) (get_bit(debo_slots[i].bit, 6) ^ get_bit(debo_slots[i].bit, 7)) diff --git a/lib/porklib/dht11.c b/lib/porklib/dht11.c new file mode 100644 index 0000000..70b57f1 --- /dev/null +++ b/lib/porklib/dht11.c @@ -0,0 +1,88 @@ +#include +#include +#include +#include + +#include "iopins.h" +#include "dht11.h" + +/** Read one bit */ +bool _dht11_rxbit(const uint8_t pin) +{ + // Wait until start of pulse + while (is_low_n(pin)); + + uint8_t cnt = 0; + while (is_high_n(pin)) + { + cnt++; + _delay_us(5); + } + + return (cnt > 8); +} + + +/** Read one byte */ +uint8_t _dht11_rxbyte(const uint8_t pin) +{ + uint8_t byte = 0; + + for (uint8_t i = 0; i < 8; i++) + { + if (_dht11_rxbit(pin)) + byte |= (1 << (7 - i)); + } + + return byte; +} + + +/** Read tehmperature and humidity from the DHT11, returns false on failure */ +bool dht11_read(const uint8_t pin, dht11_result_t* result) +{ + // bus down for > 18 ms + as_output_n(pin); + pin_low_n(pin); + _delay_ms(20); + + // bus up for 20-40us + pin_high_n(pin); + _delay_us(20); + + // release + as_input_pu_n(pin); + + // DHT should send 80us LOW & 80us HIGH + + _delay_us(40); + if (!is_low_n(pin)) + return false; // init error + + _delay_us(80); + if (!is_high_n(pin)) + return false; // init error + + // skip to start of first bit + _delay_us(50); + + // Receive 5 data bytes (Rh int, Rh dec, Temp int, Temp dec, Checksum) + // Decimal bytes are zero for DHT11 -> we can ignore them. + uint8_t bytes[5]; + uint8_t sum = 0; + + for (uint8_t i = 0; i < 5; i++) + { + uint8_t b = _dht11_rxbyte(pin); + bytes[i] = b; + if (i < 4) sum += b; + } + + // Verify checksum + if (sum != bytes[4]) return false; + + result->rh = bytes[0]; + result->temp = bytes[2]; + + return true; +} diff --git a/lib/porklib/dht11.h b/lib/porklib/dht11.h new file mode 100644 index 0000000..47409d5 --- /dev/null +++ b/lib/porklib/dht11.h @@ -0,0 +1,17 @@ +#pragma once + +// +// Reading temperature and relative humidity from DHT11 +// + +#include +#include + +typedef struct +{ + int8_t temp; + int8_t rh; +} dht11_result_t; + +/** Read tehmperature and humidity from the DHT11, returns false on failure */ +bool dht11_read(const uint8_t pin, dht11_result_t* result); diff --git a/lib/porklib/fat16.c b/lib/porklib/fat16.c new file mode 100644 index 0000000..def454f --- /dev/null +++ b/lib/porklib/fat16.c @@ -0,0 +1,1253 @@ +#include +#include +#include + +#include "fat16.h" + + + +// ============== INTERNAL PROTOTYPES ================== + +/** Read boot sector from given address */ +void read_bs(const BLOCKDEV* dev, Fat16BootSector* info, const uint32_t addr); + +/** Find absolute address of first BootSector. Returns 0 on failure. */ +uint32_t find_bs(const BLOCKDEV* dev); + +/** Get cluster's starting address */ +uint32_t clu_addr(const FAT16* fat, const uint16_t cluster); + +/** Find following cluster using FAT for jumps */ +uint16_t next_clu(const FAT16* fat, uint16_t cluster); + +/** Find relative address in a file, using FAT for cluster lookup */ +uint32_t clu_offs(const FAT16* fat, uint16_t cluster, uint32_t addr); + +/** Read a file entry from directory (dir starting cluster, entry number) */ +void open_file(const FAT16* fat, FFILE* file, const uint16_t dir_cluster, const uint16_t num); + +/** Allocate and chain new cluster to a chain starting at given cluster */ +bool append_cluster(const FAT16* fat, const uint16_t clu); + +/** Allocate a new cluster, clean it, and mark with 0xFFFF in FAT */ +uint16_t alloc_cluster(const FAT16* fat); + +/** Zero out entire cluster. */ +void wipe_cluster(const FAT16* fat, const uint16_t clu); + +/** Free cluster chain, starting at given number */ +bool free_cluster_chain(const FAT16* fat, uint16_t clu); + +/** + * Check if there is already a file of given RAW name + * Raw name - name as found on disk, not "display name". + */ +bool dir_find_file_raw(FFILE* dir, const char* fname); + +/** Write a value into FAT */ +void write_fat(const FAT16* fat, const uint16_t cluster, const uint16_t value); + +/** Read a value from FAT */ +uint16_t read_fat(const FAT16* fat, const uint16_t cluster); + + +// =========== INTERNAL FUNCTION IMPLEMENTATIONS ========= + + +uint16_t read16(const BLOCKDEV* dev) +{ + uint16_t a; + dev->load(&a, 2); + return a; +} + + +void write16(const BLOCKDEV* dev, const uint16_t val) +{ + dev->store(&val, 2); +} + +/** Find absolute address of first boot sector. Returns 0 on failure. */ +uint32_t find_bs(const BLOCKDEV* dev) +{ + // Reference structure: + // + // typedef struct __attribute__((packed)) { + // uint8_t first_byte; + // uint8_t start_chs[3]; + // uint8_t partition_type; + // uint8_t end_chs[3]; + // uint32_t start_sector; + // uint32_t length_sectors; + // } PartitionTable; + + uint16_t addr = 0x1BE + 4; // fourth byte of structure is the type. + uint32_t tmp = 0; + uint16_t tmp2; + + for (uint8_t i = 0; i < 4; i++, addr += 16) + { + // Read partition type + dev->seek(addr); + tmp = dev->read(); + + // Check if type is valid + if (tmp == 4 || tmp == 6 || tmp == 14) + { + // read MBR address + dev->rseek(3);// skip 3 bytes + dev->load(&tmp, 4); + + tmp = tmp << 9; // multiply address by 512 (sector size) + + // Verify that the boot sector has a valid signature mark + dev->seek(tmp + 510); + dev->load(&tmp2, 2); + if (tmp2 != 0xAA55) + { + continue; // continue to next entry + } + + // return absolute MBR address + return tmp; + } + } + + return 0; +} + + +/** Read the boot sector */ +void read_bs(const BLOCKDEV* dev, Fat16BootSector* info, const uint32_t addr) +{ + dev->seek(addr + 13); // skip 13 + + dev->load(&(info->sectors_per_cluster), 6); // spc, rs, nf, re + + info->total_sectors = 0; + dev->load(&(info->total_sectors), 2); // short sectors + + dev->rseek(1); // md + + dev->load(&(info->fat_size_sectors), 2); + + dev->rseek(8); // spt, noh, hs + + // read or skip long sectors field + if (info->total_sectors == 0) + { + dev->load(&(info->total_sectors), 4); + } + else + { + dev->rseek(4); // tsl + } + + dev->rseek(7); // dn, ch, bs, vi + + dev->load(&(info->volume_label), 11); +} + + +void write_fat(const FAT16* fat, const uint16_t cluster, const uint16_t value) +{ + fat->dev->seek(fat->fat_addr + (cluster * 2)); + write16(fat->dev, value); +} + + +uint16_t read_fat(const FAT16* fat, const uint16_t cluster) +{ + fat->dev->seek(fat->fat_addr + (cluster * 2)); + return read16(fat->dev); +} + + +/** Get cluster starting address */ +uint32_t clu_addr(const FAT16* fat, const uint16_t cluster) +{ + if (cluster < 2) return fat->rd_addr; + return fat->data_addr + (cluster - 2) * fat->bs.bytes_per_cluster; +} + + +uint16_t next_clu(const FAT16* fat, uint16_t cluster) +{ + return read_fat(fat, cluster); +} + + +/** Find file-relative address in fat table */ +uint32_t clu_offs(const FAT16* fat, uint16_t cluster, uint32_t addr) +{ + while (addr >= fat->bs.bytes_per_cluster) + { + cluster = next_clu(fat, cluster); + if (cluster == 0xFFFF) return 0xFFFF; // fail + addr -= fat->bs.bytes_per_cluster; + } + + return clu_addr(fat, cluster) + addr; +} + + +/** + * Zero out entire cluster + * This is important only for directory clusters, so we can + * zero only every first byte of each file entry, to indicate + * that it is unused (FT_NONE). + */ +void wipe_cluster(const FAT16* fat, const uint16_t clu) +{ + uint32_t addr = clu_addr(fat, clu); + + const BLOCKDEV* dev = fat->dev; + + dev->seek(addr); + + for (uint32_t b = 0; b < fat->bs.bytes_per_cluster; b += 32) + { + dev->write(0); + dev->rseek(32); + } +} + + +/** Allocate a new cluster, clean it, and mark with 0xFFFF in FAT */ +uint16_t alloc_cluster(const FAT16* fat) +{ + // find new unclaimed cluster that can be added to the chain. + uint16_t i, b; + for (i = 2; i < fat->bs.fat_size_sectors * 256; i++) + { + // read value from FAT + b = read_fat(fat, i); + if (b == 0) // unused cluster + { + // Write FFFF to "i", to mark end of file + write_fat(fat, i, 0xFFFF); + + // Wipe the cluster + wipe_cluster(fat, i); + + return i; + } + } + + return 0xFFFF;//error code +} + + +/** Allocate and chain new cluster to a chain starting at given cluster */ +bool append_cluster(const FAT16* fat, const uint16_t clu) +{ + uint16_t clu2 = alloc_cluster(fat); + if (clu2 == 0xFFFF) return false; + + // Write "i" to "clu" + write_fat(fat, clu, clu2); + + return true; +} + + +bool free_cluster_chain(const FAT16* fat, uint16_t clu) +{ + if (clu < 2) return false; + + do + { + // get address of the next cluster + const uint16_t clu2 = read_fat(fat, clu); + + // mark cluster as unused + write_fat(fat, clu, 0x0000); + + // advance + clu = clu2; + } + while (clu != 0xFFFF); + + return true; +} + + +/** + * Check if there is already a file of given RAW name + * Raw name - name as found on disk, not "display name". + */ +bool dir_find_file_raw(FFILE* dir, const char* fname) +{ + // rewind + ff_first(dir); + + do + { + bool diff = false; + for (uint8_t i = 0; i < 11; i++) + { + if (dir->name[i] != fname[i]) + { + diff = true; + break; + } + } + + // found the right file? + if (!diff) + { + return true; // file is already open. + } + } + while (ff_next(dir)); + + return false; +} + + +/** + * Read a file entry + * + * dir_cluster ... directory start cluster + * num ... entry number in the directory + */ +void open_file(const FAT16* fat, FFILE* file, const uint16_t dir_cluster, const uint16_t num) +{ + // Resolve starting address + uint32_t addr; + if (dir_cluster == 0) + { + addr = clu_addr(fat, dir_cluster) + num * 32; // root directory, max 512 entries. + } + else + { + addr = clu_offs(fat, dir_cluster, num * 32); // cluster + N (wrapping to next cluster if needed) + } + + fat->dev->seek(addr); + fat->dev->load(file, 12); // name, ext, attribs + fat->dev->rseek(14); // skip 14 bytes + fat->dev->load(((void*)file) + 12, 6); // read remaining bytes + + file->clu = dir_cluster; + file->num = num; + + // add a FAT pointer + file->fat = fat; + + // Resolve filename & type + + file->type = FT_FILE; + + const uint8_t c = file->name[0]; + switch (c) + { + case 0x00: + file->type = FT_NONE; + return; + + case 0xE5: + file->type = FT_DELETED; + return; + + case 0x05: // Starting with 0xE5 + file->type = FT_FILE; + file->name[0] = 0xE5; // convert to the real character + break; + + case 0x2E: + if (file->name[1] == 0x2E) + { + // ".." directory + file->type = FT_PARENT; + } + else + { + // "." directory + file->type = FT_SELF; + } + break; + + default: + if (c < 32) + { + file->type = FT_INVALID; // File is corrupt, treat it as invalid + return; // avoid trying to seek + } + else + { + file->type = FT_FILE; + } + } + + // handle subdir, label + if (file->attribs & FA_DIR && file->type == FT_FILE) + { + file->type = FT_SUBDIR; + } + else if (file->attribs == FA_LABEL) + { + file->type = FT_LABEL; // volume label special file + return; // do not seek + } + else if (file->attribs == 0x0F) + { + file->type = FT_LFN; // long name special file, can be ignored + return; // do not seek + } + + // Init cursors + ff_seek(file, 0); +} + + + +/** + * Write information into a file header. + * "file" is an open handle. + */ +void write_file_header(FFILE* file, const char* fname_raw, const uint8_t attribs, const uint16_t clu_start) +{ + const BLOCKDEV* dev = file->fat->dev; + + const uint32_t entrystart = clu_offs(file->fat, file->clu, file->num * 32); + + // store the file name + dev->seek(entrystart); + dev->store(fname_raw, 11); + + // attributes + dev->write(attribs); + + // 10 reserved, 2+2 date & time + // (could just skip, but better to fill with zeros) + for (uint8_t i = 0; i < 14; i++) + { + dev->write(0); + } + + // addr of the first file cluster + write16(dev, clu_start); + + // file size (uint32_t) + write16(dev, 0); + write16(dev, 0); + + // reopen file - load & parse the information just written + open_file(file->fat, file, file->clu, file->num); +} + + + +// =============== PUBLIC FUNCTION IMPLEMENTATIONS ================= + +/** Initialize a FAT16 handle */ +bool ff_init(const BLOCKDEV* dev, FAT16* fat) +{ + const uint32_t bs_a = find_bs(dev); + + if (bs_a == 0) return false; + + fat->dev = dev; + read_bs(dev, &(fat->bs), bs_a); + fat->fat_addr = bs_a + (fat->bs.reserved_sectors * 512); + fat->rd_addr = bs_a + (fat->bs.reserved_sectors + fat->bs.fat_size_sectors * fat->bs.num_fats) * 512; + fat->data_addr = fat->rd_addr + (fat->bs.root_entries * 32); // entry is 32B long + + fat->bs.bytes_per_cluster = (fat->bs.sectors_per_cluster * 512); + + return true; +} + + +/** + * Move file cursor to a position relative to file start + * Allows seek past end of file, will allocate new cluster if needed. + */ +bool ff_seek(FFILE* file, uint32_t addr) +{ + const FAT16* fat = file->fat; + + // Store as rel + file->cur_rel = addr; + + // Rewind and resolve abs, clu, ofs + file->cur_clu = file->clu_start; + + while (addr >= fat->bs.bytes_per_cluster) + { + uint32_t next; + + // Go to next cluster, allocate if needed + do + { + next = next_clu(fat, file->cur_clu); + if (next == 0xFFFF) + { + // reached end of allocated space + // add one more cluster + if (!append_cluster(fat, file->cur_clu)) + { + return false; + } + } + } + while (next == 0xFFFF); + + file->cur_clu = next; + addr -= fat->bs.bytes_per_cluster; + } + + file->cur_abs = clu_addr(fat, file->cur_clu) + addr; + file->cur_ofs = addr; + + // Physically seek to that location + fat->dev->seek(file->cur_abs); + + return true; +} + + +/** + * Check if file is a regular file or directory entry. + * Those files can be shown to user. + */ +bool ff_is_regular(const FFILE* file) +{ + switch (file->type) + { + case FT_FILE: + case FT_SUBDIR: + case FT_SELF: + case FT_PARENT: + return true; + + default: + return false; + } +} + + +#define MIN(a, b) (((a) < (b)) ? (a) : (b)) + +uint16_t ff_read(FFILE* file, void* target, uint16_t len) +{ + if (file->cur_abs == 0xFFFF) + return 0; // file at the end already + + if (file->cur_rel + len > file->size) + { + if (file->cur_rel > file->size) return 0; + len = file->size - file->cur_rel; + //return false; // Attempt to read more than what is available + } + + const uint16_t len_orig = len; + + const FAT16* fat = file->fat; + const BLOCKDEV* dev = fat->dev; + + while (len > 0 && file->cur_rel < file->size) + { + // How much can be read from the cluster + uint16_t chunk = MIN(file->size - file->cur_rel, MIN(fat->bs.bytes_per_cluster - file->cur_ofs, len)); + + // read the chunk + dev->seek(file->cur_abs); + dev->load(target, chunk); + + // move the cursors + file->cur_abs += chunk; + file->cur_rel += chunk; + file->cur_ofs += chunk; + + // move target pointer + target += chunk; + + // reached end of cluster? + if (file->cur_ofs >= fat->bs.bytes_per_cluster) + { + file->cur_clu = next_clu(fat, file->cur_clu); + file->cur_abs = clu_addr(fat, file->cur_clu); + file->cur_ofs = 0; + } + + // subtract read length + len -= chunk; + } + + return len_orig; +} + + +bool ff_write_str(FFILE* file, const char* source) +{ + uint16_t len = 0; + for (; source[len] != 0; len++); + + return ff_write(file, source, len); +} + + +bool ff_write(FFILE* file, const void* source, uint32_t len) +{ + const FAT16* fat = file->fat; + const BLOCKDEV* dev = fat->dev; + + + if (file->cur_abs == 0xFFFF) + return false; // file past it's end (rare) + + // Attempt to write past end of file + if (file->cur_rel + len >= file->size) + { + const uint32_t pos_start = file->cur_rel; + + // Seek to the last position + // -> fseek will allocate clusters + if (!ff_seek(file, pos_start + len)) + return false; // error in seek + + // Write starts beyond EOF - creating a zero-filled "hole" + if (pos_start > file->size + 1) + { + // Seek to the end of valid data + ff_seek(file, file->size); + + // fill space between EOF and start-of-write with zeros + uint32_t fill = pos_start - file->size; + + // repeat until all "fill" zeros are stored + while (fill > 0) + { + // How much will fit into this cluster + const uint16_t chunk = MIN(fat->bs.bytes_per_cluster - file->cur_ofs, fill); + + // write the zeros + dev->seek(file->cur_abs); + for (uint16_t i = 0; i < chunk; i++) + { + dev->write(0); + } + + // subtract from "needed" what was just placed + fill -= chunk; + + // advance cursors to the next cluster + file->cur_clu = next_clu(fat, file->cur_clu); + file->cur_abs = clu_addr(fat, file->cur_clu); + file->cur_ofs = 0; + } + } + + // Store new size + file->size = pos_start + len; + + // Seek back to where it was before + ff_seek(file, pos_start); + } // (end zerofill) + + + // write the data + while (len > 0) + { + dev->seek(file->cur_abs); + uint16_t chunk; + + if (len == 1) + { + dev->write(*((uint8_t*)source)); + file->cur_abs++; + file->cur_rel++; + file->cur_ofs++; + chunk = 1; + + } + else + { + // How much can be stored in this cluster + chunk = MIN(fat->bs.bytes_per_cluster - file->cur_ofs, len); + + dev->store(source, chunk); + + // advance cursors + file->cur_abs += chunk; + file->cur_rel += chunk; + file->cur_ofs += chunk; + + // Pointer arith! + source += chunk; // advance the source pointer + } + + // detect cluster overflow + if (file->cur_ofs >= fat->bs.bytes_per_cluster) + { + // advance to following cluster + file->cur_clu = next_clu(fat, file->cur_clu); + file->cur_abs = clu_addr(fat, file->cur_clu); + file->cur_ofs = 0; + } + + // subtract written length + len -= chunk; + } + + return true; +} + + + +/** Open next file in the directory */ +bool ff_next(FFILE* file) +{ + const FAT16* fat = file->fat; + const BLOCKDEV* dev = fat->dev; + + if (file->clu == 0 && file->num >= fat->bs.root_entries) + return false; // attempt to read outside root directory. + + const uint32_t addr = clu_offs(fat, file->clu, (file->num + 1) * 32); + if (addr == 0xFFFF) + return false; // next file is out of the directory cluster + + // read first byte of the file entry + dev->seek(addr); + if (dev->read() == 0) + return false; // can't read (file is NONE) + + open_file(fat, file, file->clu, file->num + 1); + + return true; +} + + +/** Open previous file in the directory */ +bool ff_prev(FFILE* file) +{ + if (file->num == 0) + return false; // first file already + + open_file(file->fat, file, file->clu, file->num - 1); + + return true; +} + + +/** Rewind to first file in directory */ +void ff_first(FFILE* file) +{ + open_file(file->fat, file, file->clu, 0); +} + + +/** Open a directory denoted by the file. */ +bool ff_opendir(FFILE* dir) +{ + // Don't open non-dirs and "." directory. + if (!(dir->attribs & FA_DIR) || dir->type == FT_SELF) + return false; + + open_file(dir->fat, dir, dir->clu_start, 0); + return true; +} + + +void ff_root(const FAT16* fat, FFILE* file) +{ + open_file(fat, file, 0, 0); +} + + +/** + * Find a file with given "display name" in this directory. + * If file is found, "dir" will contain it's handle. + */ +bool ff_find(FFILE* file, const char* name) +{ + // save orig pos + FSAVEPOS orig = ff_savepos(file); + + char fname[11]; + ff_rawname(name, fname); + bool ret = dir_find_file_raw(file, fname); + + if (!ret) + ff_reopen(file, &orig); + + return ret; +} + + +/** Go through a directory, and "open" first FT_NONE or FT_DELETED file entry. */ +bool find_empty_file_slot(FFILE* file) +{ + const uint16_t clu = file->clu; + const FAT16* fat = file->fat; + + // Find free directory entry that can be used + for (uint16_t num = 0; num < 0xFFFF; num++) + { + // root directory has fewer entries, error if trying + // to add one more. + if (file->clu == 0 && num >= fat->bs.root_entries) + return false; + + // Resolve addres of next file entry + uint32_t addr; + do + { + addr = clu_offs(fat, file->clu, num * 32); + + if (addr == 0xFFFF) + { + // end of chain of allocated clusters for the directory + // append new cluster, return false on failure + if (!append_cluster(fat, file->clu)) return false; + } + + // if new cluster was just added, repeat. + } + while (addr == 0xFFFF); + + // Open the file entry + open_file(fat, file, clu, num); + + // Check if can be overwritten + if (file->type == FT_DELETED || file->type == FT_NONE) + { + return true; + } + } + + return false; // not found. +} + + + +bool ff_newfile(FFILE* file, const char* name) +{ + const FSAVEPOS orig = ff_savepos(file); + + // Convert filename to zero padded raw string + char fname[11]; + ff_rawname(name, fname); + + // Abort if file already exists + bool exists = dir_find_file_raw(file, fname); + ff_first(file); // rewind dir + if (exists) + { + ff_reopen(file, &orig); + return false; // file already exists in the dir. + } + + + if (!find_empty_file_slot(file)) + { + ff_reopen(file, &orig); + return false; // error finding a slot + } + + // Write into the new slot + const uint16_t newclu = alloc_cluster(file->fat); + write_file_header(file, fname, 0, newclu); + + return true; +} + + +/** + * Create a sub-directory of given name. + * Directory is allocated and populated with entries "." and ".." + */ +bool ff_mkdir(FFILE* file, const char* name) +{ + const FSAVEPOS orig = ff_savepos(file); + + // Convert filename to zero padded raw string + char fname[11]; + ff_rawname(name, fname); + + // Abort if file already exists + bool exists = dir_find_file_raw(file, fname); + ff_first(file); // rewind dir + if (exists) + { + ff_reopen(file, &orig); + return false; // file already exusts in the dir. + } + + if (!find_empty_file_slot(file)) + { + ff_reopen(file, &orig); + return false; // error finding a slot + } + + // Write into the new slot + const uint16_t newclu = alloc_cluster(file->fat); + write_file_header(file, fname, FA_DIR, newclu); + + const uint32_t parent_clu = file->clu; + open_file(file->fat, file, file->clu_start, 0); + + write_file_header(file, ". ", FA_DIR, newclu); + + // Advance to next file slot + find_empty_file_slot(file); + + write_file_header(file, ".. ", FA_DIR, parent_clu); + + // rewind. + ff_first(file); + + return true; +} + + +char* ff_disk_label(const FAT16* fat, char* label_out) +{ + FFILE first; + ff_root(fat, &first); + + if (first.type == FT_LABEL) + { + return ff_dispname(&first, label_out); + } + + // find where spaces end + int8_t j = 10; + for (; j >= 0; j--) + { + if (fat->bs.volume_label[j] != ' ') break; + } + + // copy all until spaces + uint8_t i; + for (i = 0; i <= j; i++) + { + label_out[i] = fat->bs.volume_label[i]; + } + + label_out[i] = 0; // ender + + return label_out; +} + + +char* ff_dispname(const FFILE* file, char* disp_out) +{ + // Cannot get name for special files + if (file->type == FT_NONE || // not-yet-used directory location + file->type == FT_DELETED || // deleted file entry + file->attribs == 0x0F) // long name special entry (system, hidden) + return NULL; + + // find first non-space + int8_t j = 7; + for (; j >= 0; j--) + { + if (file->name[j] != ' ') break; + } + + // j ... last no-space char + + uint8_t i; + for (i = 0; i <= j; i++) + { + disp_out[i] = file->name[i]; + } + + + // directory entry, no extension + if (file->type == FT_SUBDIR || file->type == FT_SELF || file->type == FT_PARENT) + { + disp_out[i] = 0; // end of string + return disp_out; + } + + + // add a dot + if (file->type != FT_LABEL) // volume label has no dot! + disp_out[i++] = '.'; + + // Add extension chars + for (j = 8; j < 11; j++, i++) + { + const char c = file->name[j]; + if (c == ' ') break; + disp_out[i] = c; + } + + disp_out[i] = 0; // end of string + + return disp_out; +} + + +char* ff_rawname(const char* disp_in, char* raw_out) +{ + uint8_t name_c = 0, wr_c = 0; + bool filling = false; + bool at_ext = false; + for (; wr_c < 11; wr_c++) + { + // start filling with spaces if end of filename reached + uint8_t c = disp_in[name_c]; + // handle special rule for 0xE5 + if (name_c == 0 && c == 0xE5) + { + c = 0x05; + } + + if (c == '.' || c == 0) + { + if (!filling) + { + filling = true; + + if (c == '.') + { + name_c++; // skip the dot + c = disp_in[name_c]; + at_ext = true; + } + } + } + + // if at the start of ext + if (wr_c == 8) + { + if (!at_ext) + { + // try to advance past dot (if any) + while (true) + { + c = disp_in[name_c++]; + if (c == 0) break; + if (c == '.') + { + // read char PAST the dot + c = disp_in[name_c]; + at_ext = true; + break; + } + } + } + + // if c has valid char for extension + if (c != 0 && c != '.') + { + // start copying again. + filling = false; + } + } + + if (!filling) + { + // copy char of filename + raw_out[wr_c] = disp_in[name_c++]; + } + else + { + // add a filler space + raw_out[wr_c] = ' '; + } + } + + return raw_out; +} + + +FSAVEPOS ff_savepos(const FFILE* file) +{ + FSAVEPOS fsp; + fsp.clu = file->clu; + fsp.num = file->num; + fsp.cur_rel = file->cur_rel; + return fsp; +} + + +void ff_reopen(FFILE* file, const FSAVEPOS* pos) +{ + open_file(file->fat, file, pos->clu, pos->num); + ff_seek(file, pos->cur_rel); +} + + +void ff_flush_file(FFILE* file) +{ + const FAT16* fat = file->fat; + const BLOCKDEV* dev = file->fat->dev; + + // Store open page + dev->flush(); + + // Store file size + + // Find address for storing the size + const uint32_t addr = clu_offs(fat, file->clu, file->num * 32 + 28); + + dev->seek(addr); + dev->store(&(file->size), 4); + + // Seek to the end of the file, to make sure clusters are allocated + ff_seek(file, file->size - 1); + + const uint16_t next = next_clu(fat, file->cur_clu); + if (next != 0xFFFF) + { + free_cluster_chain(fat, next); + + // Mark that there's no further clusters + write_fat(fat, file->cur_clu, 0xFFFF); + } +} + + + +/** Low level no-check file delete and free */ +void delete_file_do(FFILE* file) +{ + const FAT16* fat = file->fat; + + // seek to file record + fat->dev->seek(clu_offs(fat, file->clu, file->num * 32)); + + // mark as deleted + fat->dev->write(0xE5); // "deleted" mark + + // Free clusters, if FILE or SUBDIR and valid clu_start + if (file->type == FT_FILE || file->type == FT_SUBDIR) + { + // free allocated clusters + free_cluster_chain(fat, file->clu_start); + } + + file->type = FT_DELETED; +} + + +/** Delete a simple file */ +bool ff_rmfile(FFILE* file) +{ + switch (file->type) + { + case FT_FILE: + case FT_INVALID: + case FT_LFN: + case FT_LABEL: + delete_file_do(file); + return true; + + default: + return false; + } + +} + + +/** Delete an empty directory */ +bool ff_rmdir(FFILE* file) +{ + if (file->type != FT_SUBDIR) + return false; // not a subdirectory entry + + const FSAVEPOS orig = ff_savepos(file); + + // Open the subdir + if (!ff_opendir(file)) + return false; // could not open + + // Look for valid files and subdirs in the directory + uint8_t cnt = 0; // entry counter, for checking "." and ".." + do + { + // Stop on apparent corrupt structure (missing "." or "..") + // Can safely delete the folder. + if (cnt == 0 && file->type != FT_SELF) break; + if (cnt == 1 && file->type != FT_PARENT) break; + + // Found valid file + if (file->type == FT_SUBDIR || file->type == FT_FILE) + { + // Valid child file was found, aborting. + // reopen original file + ff_reopen(file, &orig); + return false; + } + + if (cnt < 2) cnt++; + } + while (ff_next(file)); + + // reopen original file + ff_reopen(file, &orig); + + // and delete as ordinary file + delete_file_do(file); + + return true; +} + + +bool ff_delete(FFILE* file) +{ + switch (file->type) + { + case FT_DELETED: + case FT_NONE: + return true; // "deleted successfully" + + case FT_SUBDIR:; // semicolon needed to allow declaration after "case" + + // store original file location + const FSAVEPOS orig = ff_savepos(file); + + // open the directory (skip "." and "..") + open_file(file->fat, file, file->clu_start, 2); + + // delete all children + do + { + if (!ff_delete(file)) + { + // failure + // reopen original file + ff_reopen(file, &orig); + return false; + } + } + while (ff_next(file)); + + // go up and delete the dir + ff_reopen(file, &orig); + return ff_rmdir(file); + + default: + // try to delete as a regular file + return ff_rmfile(file); + } +} + + +bool ff_parent(FFILE* file) +{ + // open second entry of the directory + open_file(file->fat, file, file->clu, 1); + const FSAVEPOS orig = ff_savepos(file); + + // if it's a valid PARENT link, follow it. + if (file->type == FT_PARENT) + { + open_file(file->fat, file, file->clu_start, 0); + return true; + } + else + { + // in root already? + // reopen original file + ff_reopen(file, &orig); + return false; + } +} diff --git a/lib/porklib/fat16.h b/lib/porklib/fat16.h new file mode 100644 index 0000000..12592e5 --- /dev/null +++ b/lib/porklib/fat16.h @@ -0,0 +1,276 @@ +#pragma once + +// +// Simple FAT16 library. +// +// To use it, implement BLOCKDEV functions +// and attach them to it's instance. +// + +#include +#include + +#include "blockdev.h" + + +// ------------------------------- + +/** + * File types (values can be used for debug printing). + * Accessible using file->type + */ +typedef enum +{ + FT_NONE = '-', + FT_DELETED = 'x', + FT_SUBDIR = 'D', + FT_PARENT = 'P', + FT_LABEL = 'L', + FT_LFN = '~', + FT_INVALID = '?', // not recognized weird file + FT_SELF = '.', + FT_FILE = 'F' +} FAT16_FT; + + +/** "File address" for saving and restoring file */ +typedef struct +{ + uint16_t clu; + uint16_t num; + uint32_t cur_rel; +} FSAVEPOS; + + +// Include definitions of fully internal structs +#include "fat16_internal.h" + + +/** + * File handle struct. + * + * File handle contains cursor, file name, type, size etc. + * Everything (files, dirs) is accessed using this. + */ +typedef struct __attribute__((packed)) +{ + /** + * Raw file name. Starting 0x05 was converted to 0xE5. + * To get PRINTABLE file name, use fat16_dispname() + */ + uint8_t name[11]; + + /** + * File attributes - bit field composed of FA_* flags + * (internal) + */ + uint8_t attribs; + + // 14 bytes skipped (10 reserved, date, time) + + /** First cluster of the file. (internal) */ + uint16_t clu_start; + + /** + * File size in bytes. + * This is the current allocated and readable file size. + */ + uint32_t size; + + + // --- the following fields are added when reading --- + + /** File type. */ + FAT16_FT type; + + + // --- INTERNAL FIELDS --- + + // Cursor variables. (internal) + uint32_t cur_abs; // absolute position in device + uint32_t cur_rel; // relative position in file + uint16_t cur_clu; // cluster where the cursor is + uint16_t cur_ofs; // offset within the active cluster + + // File position in the directory. (internal) + uint16_t clu; // first cluster of directory + uint16_t num; // file entry number + + // Pointer to the FAT16 handle. (internal) + const FAT16* fat; +} +FFILE; + + +/** + * Store modified file metadata and flush it to disk. + */ +void ff_flush_file(FFILE* file); + + +/** + * Save a file "position" into a struct, for later restoration. + * Cursor is also saved. + */ +FSAVEPOS ff_savepos(const FFILE* file); + +/** + * Restore a file from a saved position. + */ +void ff_reopen(FFILE* file, const FSAVEPOS* pos); + + +/** + * Initialize the file system - store into "fat" + */ +bool ff_init(const BLOCKDEV* dev, FAT16* fat); + + +/** + * Open the first file of the root directory. + * The file may be invalid (eg. a volume label, deleted etc), + * or blank (type FT_NONE) if the filesystem is empty. + */ +void ff_root(const FAT16* fat, FFILE* file); + + +/** + * Resolve the disk label. + * That can be in the Boot Sector, or in the first root directory entry. + * + * @param fat the FAT handle + * @param label_out string to store the label in. Should have at least 12 bytes. + */ +char* ff_disk_label(const FAT16* fat, char* label_out); + + +// ----------- FILE I/O ------------- + + +/** + * Move file cursor to a position relative to file start + * Returns false on I/O error (bad file, out of range...) + */ +bool ff_seek(FFILE* file, uint32_t addr); + + +/** + * Read bytes from file into memory + * Returns number of bytes read, 0 on error. + */ +uint16_t ff_read(FFILE* file, void* target, uint16_t len); + + +/** + * Write into file at a "seek" position. + */ +bool ff_write(FFILE* file, const void* source, uint32_t len); + + +/** + * Store a 0-terminated string at cursor. + */ +bool ff_write_str(FFILE* file, const char* source); + + +/** + * Create a new file in given folder + * + * file ... open directory; new file is opened into this handle. + * name ... name of the new file, including extension + */ +bool ff_newfile(FFILE* file, const char* name); + + +/** + * Create a sub-directory of given name. + * Directory is allocated and populated with entries "." and ".." + */ +bool ff_mkdir(FFILE* file, const char* name); + + +/** + * Set new file size. + * Allocates / frees needed clusters, does NOT erase them. + * + * Useful mainly for shrinking. + */ +void set_file_size(FFILE* file, uint32_t size); + + +/** + * Delete a *FILE* and free it's clusters. + */ +bool ff_rmfile(FFILE* file); + + +/** + * Delete an empty *DIRECTORY* and free it's clusters. + */ +bool ff_rmdir(FFILE* file); + + +/** + * Delete a file or directory, even FT_LFN and FT_INVALID. + * Directories are deleted recursively (!) + */ +bool ff_delete(FFILE* file); + + + +// --------- NAVIGATION ------------ + + +/** Go to previous file in the directory (false = no prev file) */ +bool ff_prev(FFILE* file); + + +/** Go to next file in directory (false = no next file) */ +bool ff_next(FFILE* file); + + +/** + * Open a subdirectory denoted by the file. + * Provided handle changes to the first entry of the directory. + */ +bool ff_opendir(FFILE* dir); + + +/** + * Open a parent directory. Fails in root. + * Provided handle changes to the first entry of the parent directory. + */ +bool ff_parent(FFILE* file); + + +/** Jump to first file in this directory */ +void ff_first(FFILE* file); + + +/** + * Find a file with given "display name" in this directory, and open it. + * If file is found, "file" will contain it's handle. + * Otherwise, the handle is unchanged. + */ +bool ff_find(FFILE* file, const char* name); + + +// -------- FILE INSPECTION ----------- + +/** Check if file is a valid entry, or long-name/label/deleted */ +bool ff_is_regular(const FFILE* file); + + +/** + * Resolve a file name, trim spaces and add null terminator. + * Returns the passed char*, or NULL on error. + */ +char* ff_dispname(const FFILE* file, char* disp_out); + + +/** + * Convert filename to zero-padded fixed length one + * Returns the passed char*. + */ +char* ff_rawname(const char* disp_in, char* raw_out); + diff --git a/lib/porklib/fat16_internal.h b/lib/porklib/fat16_internal.h new file mode 100644 index 0000000..82472ac --- /dev/null +++ b/lib/porklib/fat16_internal.h @@ -0,0 +1,64 @@ +#pragma once + +#include +#include + +// Internal types and stuff that is needed in the header for declarations, +// but is not a part of the public API. + +/** Boot Sector structure */ +typedef struct __attribute__((packed)) +{ + // Fields loaded directly from disk: + + // 13 bytes skipped + uint8_t sectors_per_cluster; + uint16_t reserved_sectors; + uint8_t num_fats; + uint16_t root_entries; + // 3 bytes skipped + uint16_t fat_size_sectors; + // 8 bytes skipped + uint32_t total_sectors; // if "short size sectors" is used, it's copied here too + // 7 bytes skipped + char volume_label[11]; // space padded, no terminator + + // Added fields: + + uint32_t bytes_per_cluster; + +} +Fat16BootSector; + + +/** FAT filesystem handle */ +typedef struct __attribute__((packed)) +{ + // Backing block device + const BLOCKDEV* dev; + + // Root directory sector start + uint32_t rd_addr; + + // Start of first cluster (number "2") + uint32_t data_addr; + + // Start of fat table + uint32_t fat_addr; + + // Boot sector data struct + Fat16BootSector bs; +} +FAT16; + + +/** + * File Attributes (bit flags) + * Accessible using file->attribs + */ +#define FA_READONLY 0x01 // read only file +#define FA_HIDDEN 0x02 // hidden file +#define FA_SYSTEM 0x04 // system file +#define FA_LABEL 0x08 // volume label entry, found only in root directory. +#define FA_DIR 0x10 // subdirectory +#define FA_ARCHIVE 0x20 // archive flag diff --git a/lib/porklib/iopins.c b/lib/porklib/iopins.c new file mode 100644 index 0000000..2b3934b --- /dev/null +++ b/lib/porklib/iopins.c @@ -0,0 +1,276 @@ +#include +#include +#include + +#include "calc.h" +#include "iopins.h" + + +void set_dir_n(const uint8_t pin, const uint8_t d) +{ + switch(pin) { + case 0: set_dir(0, d); return; + case 1: set_dir(1, d); return; + case 2: set_dir(2, d); return; + case 3: set_dir(3, d); return; + case 4: set_dir(4, d); return; + case 5: set_dir(5, d); return; + case 6: set_dir(6, d); return; + case 7: set_dir(7, d); return; + case 8: set_dir(8, d); return; + case 9: set_dir(9, d); return; + case 10: set_dir(10, d); return; + case 11: set_dir(11, d); return; + case 12: set_dir(12, d); return; + case 13: set_dir(13, d); return; + case 14: set_dir(14, d); return; + case 15: set_dir(15, d); return; + case 16: set_dir(16, d); return; + case 17: set_dir(17, d); return; + case 18: set_dir(18, d); return; + case 19: set_dir(19, d); return; + case 20: set_dir(20, d); return; + case 21: set_dir(21, d); return; + } +} + +void as_input_n(const uint8_t pin) +{ + switch(pin) { + case 0: as_input(0); return; + case 1: as_input(1); return; + case 2: as_input(2); return; + case 3: as_input(3); return; + case 4: as_input(4); return; + case 5: as_input(5); return; + case 6: as_input(6); return; + case 7: as_input(7); return; + case 8: as_input(8); return; + case 9: as_input(9); return; + case 10: as_input(10); return; + case 11: as_input(11); return; + case 12: as_input(12); return; + case 13: as_input(13); return; + case 14: as_input(14); return; + case 15: as_input(15); return; + case 16: as_input(16); return; + case 17: as_input(17); return; + case 18: as_input(18); return; + case 19: as_input(19); return; + case 20: as_input(20); return; + case 21: as_input(21); return; + } +} + + +void as_input_pu_n(const uint8_t pin) +{ + switch(pin) { + case 0: as_input_pu(0); return; + case 1: as_input_pu(1); return; + case 2: as_input_pu(2); return; + case 3: as_input_pu(3); return; + case 4: as_input_pu(4); return; + case 5: as_input_pu(5); return; + case 6: as_input_pu(6); return; + case 7: as_input_pu(7); return; + case 8: as_input_pu(8); return; + case 9: as_input_pu(9); return; + case 10: as_input_pu(10); return; + case 11: as_input_pu(11); return; + case 12: as_input_pu(12); return; + case 13: as_input_pu(13); return; + case 14: as_input_pu(14); return; + case 15: as_input_pu(15); return; + case 16: as_input_pu(16); return; + case 17: as_input_pu(17); return; + case 18: as_input_pu(18); return; + case 19: as_input_pu(19); return; + case 20: as_input_pu(20); return; + case 21: as_input_pu(21); return; + } +} + + +void as_output_n(const uint8_t pin) +{ + switch(pin) { + case 0: as_output(0); return; + case 1: as_output(1); return; + case 2: as_output(2); return; + case 3: as_output(3); return; + case 4: as_output(4); return; + case 5: as_output(5); return; + case 6: as_output(6); return; + case 7: as_output(7); return; + case 8: as_output(8); return; + case 9: as_output(9); return; + case 10: as_output(10); return; + case 11: as_output(11); return; + case 12: as_output(12); return; + case 13: as_output(13); return; + case 14: as_output(14); return; + case 15: as_output(15); return; + case 16: as_output(16); return; + case 17: as_output(17); return; + case 18: as_output(18); return; + case 19: as_output(19); return; + case 20: as_output(20); return; + case 21: as_output(21); return; + } +} + +void set_pin_n(const uint8_t pin, const uint8_t v) +{ + switch(pin) { + case 0: set_pin(0, v); return; + case 1: set_pin(1, v); return; + case 2: set_pin(2, v); return; + case 3: set_pin(3, v); return; + case 4: set_pin(4, v); return; + case 5: set_pin(5, v); return; + case 6: set_pin(6, v); return; + case 7: set_pin(7, v); return; + case 8: set_pin(8, v); return; + case 9: set_pin(9, v); return; + case 10: set_pin(10, v); return; + case 11: set_pin(11, v); return; + case 12: set_pin(12, v); return; + case 13: set_pin(13, v); return; + case 14: set_pin(14, v); return; + case 15: set_pin(15, v); return; + case 16: set_pin(16, v); return; + case 17: set_pin(17, v); return; + case 18: set_pin(18, v); return; + case 19: set_pin(19, v); return; + case 20: set_pin(20, v); return; + case 21: set_pin(21, v); return; + } +} + +void pin_low_n(const uint8_t pin) +{ + switch(pin) { + case 0: pin_low(0); return; + case 1: pin_low(1); return; + case 2: pin_low(2); return; + case 3: pin_low(3); return; + case 4: pin_low(4); return; + case 5: pin_low(5); return; + case 6: pin_low(6); return; + case 7: pin_low(7); return; + case 8: pin_low(8); return; + case 9: pin_low(9); return; + case 10: pin_low(10); return; + case 11: pin_low(11); return; + case 12: pin_low(12); return; + case 13: pin_low(13); return; + case 14: pin_low(14); return; + case 15: pin_low(15); return; + case 16: pin_low(16); return; + case 17: pin_low(17); return; + case 18: pin_low(18); return; + case 19: pin_low(19); return; + case 20: pin_low(20); return; + case 21: pin_low(21); return; + } +} + +void pin_high_n(const uint8_t pin) +{ + switch(pin) { + case 0: pin_high(0); return; + case 1: pin_high(1); return; + case 2: pin_high(2); return; + case 3: pin_high(3); return; + case 4: pin_high(4); return; + case 5: pin_high(5); return; + case 6: pin_high(6); return; + case 7: pin_high(7); return; + case 8: pin_high(8); return; + case 9: pin_high(9); return; + case 10: pin_high(10); return; + case 11: pin_high(11); return; + case 12: pin_high(12); return; + case 13: pin_high(13); return; + case 14: pin_high(14); return; + case 15: pin_high(15); return; + case 16: pin_high(16); return; + case 17: pin_high(17); return; + case 18: pin_high(18); return; + case 19: pin_high(19); return; + case 20: pin_high(20); return; + case 21: pin_high(21); return; + } +} + + +void toggle_pin_n(const uint8_t pin) +{ + switch(pin) { + case 0: toggle_pin(0); return; + case 1: toggle_pin(1); return; + case 2: toggle_pin(2); return; + case 3: toggle_pin(3); return; + case 4: toggle_pin(4); return; + case 5: toggle_pin(5); return; + case 6: toggle_pin(6); return; + case 7: toggle_pin(7); return; + case 8: toggle_pin(8); return; + case 9: toggle_pin(9); return; + case 10: toggle_pin(10); return; + case 11: toggle_pin(11); return; + case 12: toggle_pin(12); return; + case 13: toggle_pin(13); return; + case 14: toggle_pin(14); return; + case 15: toggle_pin(15); return; + case 16: toggle_pin(16); return; + case 17: toggle_pin(17); return; + case 18: toggle_pin(18); return; + case 19: toggle_pin(19); return; + case 20: toggle_pin(20); return; + case 21: toggle_pin(21); return; + } +} + + +bool get_pin_n(const uint8_t pin) +{ + switch(pin) { + case 0: return get_pin(0); + case 1: return get_pin(1); + case 2: return get_pin(2); + case 3: return get_pin(3); + case 4: return get_pin(4); + case 5: return get_pin(5); + case 6: return get_pin(6); + case 7: return get_pin(7); + case 8: return get_pin(8); + case 9: return get_pin(9); + case 10: return get_pin(10); + case 11: return get_pin(11); + case 12: return get_pin(12); + case 13: return get_pin(13); + case 14: return get_pin(14); + case 15: return get_pin(15); + case 16: return get_pin(16); + case 17: return get_pin(17); + case 18: return get_pin(18); + case 19: return get_pin(19); + case 20: return get_pin(20); + case 21: return get_pin(21); + } + return false; +} + + +bool is_low_n(const uint8_t pin) +{ + return !get_pin_n(pin); +} + + +bool is_high_n(const uint8_t pin) +{ + return get_pin_n(pin); +} diff --git a/lib/porklib/iopins.h b/lib/porklib/iopins.h new file mode 100644 index 0000000..3cabadd --- /dev/null +++ b/lib/porklib/iopins.h @@ -0,0 +1,213 @@ +#pragma once + +// +// * Utilities for pin aliasing / numbering. * +// +// Designed for Arduino. +// +// If you know the pin number beforehand, you can use the macros. +// +// If you need to use a variable for pin number, use the `_n` functions. +// They are much slower, so always check if you really need them +// - and they aren't fit for things where precise timing is required. +// + +#include +#include +#include + +#include "calc.h" + + +// type: pointer to port +typedef volatile uint8_t* PORT_P; + + +/** Pin numbering reference */ +#define D0 0 +#define D1 1 +#define D2 2 +#define D3 3 +#define D4 4 +#define D5 5 +#define D6 6 +#define D7 7 +#define D8 8 +#define D9 9 +#define D10 10 +#define D11 11 +#define D12 12 +#define D13 13 +#define D14 14 +#define D15 15 +#define D16 16 +#define D17 17 +#define D18 18 +#define D19 19 +#define D20 20 +#define D21 21 +#define A0 14 +#define A1 15 +#define A2 16 +#define A3 17 +#define A4 18 +#define A5 19 +#define A6 20 +#define A7 21 + + +#define _ddr(pin) _DDR_##pin +#define _pin(pin) _PIN_##pin +#define _pn(pin) _PN_##pin +#define _port(pin) _PORT_##pin + + +/** Set pin direction */ +#define set_dir(pin, d) set_bit( _ddr(pin), _pn(pin), d ) +void set_dir_n(const uint8_t pin, const uint8_t d); + + +/** Configure pin as input */ +#define as_input(pin) cbi( _ddr(pin), _pn(pin) ) +void as_input_n(const uint8_t pin); + + +/** Configure pin as input, with pull-up enabled */ +#define as_input_pu(pin) { as_input(pin); pin_high(pin); } +void as_input_pu_n(const uint8_t pin); + + +/** Configure pin as output */ +#define as_output(pin) sbi( _ddr(pin), _pn(pin) ) +void as_output_n(const uint8_t pin); + + +/** Write value to a pin */ +#define set_pin(pin, v) set_bit( _port(pin), _pn(pin), v ) +void set_pin_n(const uint8_t pin, const uint8_t v); + + +/** Write 0 to a pin */ +#define pin_low(pin) cbi( _port(pin), _pn(pin) ) +void pin_low_n(const uint8_t pin); + + +/** Write 1 to a pin */ +#define pin_high(pin) sbi( _port(pin), _pn(pin) ) +void pin_high_n(const uint8_t pin); + + +/** Toggle a pin state */ +#define toggle_pin(pin) sbi( _pin(pin), _pn(pin) ) +void toggle_pin_n(const uint8_t pin); + + +/** Read a pin value */ +#define get_pin(pin) get_bit( _pin(pin), _pn(pin) ) +bool get_pin_n(const uint8_t pin); + + +/** CHeck if pin is low */ +#define is_low(pin) (get_pin(pin) == 0) +bool is_low_n(const uint8_t pin); + + +/** CHeck if pin is high */ +#define is_high(pin) (get_pin(pin) != 0) +bool is_high_n(const uint8_t pin); + + + +// Helper macros + +#define _PORT_0 PORTD +#define _PORT_1 PORTD +#define _PORT_2 PORTD +#define _PORT_3 PORTD +#define _PORT_4 PORTD +#define _PORT_5 PORTD +#define _PORT_6 PORTD +#define _PORT_7 PORTD +#define _PORT_8 PORTB +#define _PORT_9 PORTB +#define _PORT_10 PORTB +#define _PORT_11 PORTB +#define _PORT_12 PORTB +#define _PORT_13 PORTB +#define _PORT_14 PORTC +#define _PORT_15 PORTC +#define _PORT_16 PORTC +#define _PORT_17 PORTC +#define _PORT_18 PORTC +#define _PORT_19 PORTC +#define _PORT_20 PORTC +#define _PORT_21 PORTC + +#define _PIN_0 PIND +#define _PIN_1 PIND +#define _PIN_2 PIND +#define _PIN_3 PIND +#define _PIN_4 PIND +#define _PIN_5 PIND +#define _PIN_6 PIND +#define _PIN_7 PIND +#define _PIN_8 PINB +#define _PIN_9 PINB +#define _PIN_10 PINB +#define _PIN_11 PINB +#define _PIN_12 PINB +#define _PIN_13 PINB +#define _PIN_14 PINC +#define _PIN_15 PINC +#define _PIN_16 PINC +#define _PIN_17 PINC +#define _PIN_18 PINC +#define _PIN_19 PINC +#define _PIN_20 PINC +#define _PIN_21 PINC + +#define _DDR_0 DDRD +#define _DDR_1 DDRD +#define _DDR_2 DDRD +#define _DDR_3 DDRD +#define _DDR_4 DDRD +#define _DDR_5 DDRD +#define _DDR_6 DDRD +#define _DDR_7 DDRD +#define _DDR_8 DDRB +#define _DDR_9 DDRB +#define _DDR_10 DDRB +#define _DDR_11 DDRB +#define _DDR_12 DDRB +#define _DDR_13 DDRB +#define _DDR_14 DDRC +#define _DDR_15 DDRC +#define _DDR_16 DDRC +#define _DDR_17 DDRC +#define _DDR_18 DDRC +#define _DDR_19 DDRC +#define _DDR_20 DDRC +#define _DDR_21 DDRC + +#define _PN_0 0 +#define _PN_1 1 +#define _PN_2 2 +#define _PN_3 3 +#define _PN_4 4 +#define _PN_5 5 +#define _PN_6 6 +#define _PN_7 7 +#define _PN_8 0 +#define _PN_9 1 +#define _PN_10 2 +#define _PN_11 3 +#define _PN_12 4 +#define _PN_13 5 +#define _PN_14 0 +#define _PN_15 1 +#define _PN_16 2 +#define _PN_17 3 +#define _PN_18 4 +#define _PN_19 5 +#define _PN_20 6 +#define _PN_21 7 diff --git a/lib/porklib/lcd.c b/lib/porklib/lcd.c new file mode 100644 index 0000000..68513f5 --- /dev/null +++ b/lib/porklib/lcd.c @@ -0,0 +1,365 @@ +#include +#include +#include +#include +#include + +#include "calc.h" +#include "iopins.h" +#include "nsdelay.h" +#include "lcd.h" +#include "lcd_config.h" + +// Start address of rows +const uint8_t LCD_ROW_ADDR[] = {0x00, 0x40, 0x14, 0x54}; + + +// Shared stream instance +static STREAM _lcd_singleton; +STREAM* lcd; + + +// Internal prototypes +void _lcd_mode_r(); +void _lcd_mode_w(); +void _lcd_clk(); +void _lcd_wait_bf(); +void _lcd_write_byte(uint8_t bb); +uint8_t _lcd_read_byte(); + + +// Write utilities +#define _lcd_write_low(bb) _lcd_write_nibble((bb) & 0x0F) +#define _lcd_write_high(bb) _lcd_write_nibble(((bb) & 0xF0) >> 4) +#define _lcd_write_nibble(nib) do { \ + set_pin(LCD_D7, get_bit((nib), 3)); \ + set_pin(LCD_D6, get_bit((nib), 2)); \ + set_pin(LCD_D5, get_bit((nib), 1)); \ + set_pin(LCD_D4, get_bit((nib), 0)); \ +} while(0) + + +// 0 W, 1 R +bool _lcd_mode; + +struct +{ + uint8_t x; + uint8_t y; +} _pos; + +enum +{ + TEXT = 0, + CG = 1 +} _addrtype; + + +/** Initialize the display */ +void lcd_init() +{ + // configure pins as output + as_output(LCD_E); + as_output(LCD_RW); + as_output(LCD_RS); + _lcd_mode = 1; // force data pins to output + _lcd_mode_w(); + + // Magic sequence to invoke Cthulhu (or enter 4-bit mode) + _delay_ms(16); + _lcd_write_nibble(0b0011); + _lcd_clk(); + _delay_ms(5); + _lcd_clk(); + _delay_ms(5); + _lcd_clk(); + _delay_ms(5); + _lcd_write_nibble(0b0010); + _lcd_clk(); + _delay_us(100); + + // Configure the display + lcd_command(LCD_IFACE_4BIT_2LINE); + lcd_command(LCD_DISABLE); + lcd_command(LCD_CLEAR); + lcd_command(LCD_MODE_INC); + + // mark as enabled + lcd_enable(); + + _lcd_singleton.tx = &lcd_write; + _lcd_singleton.rx = &lcd_read; + + // Stream + lcd = &_lcd_singleton; + + _pos.x = 0; + _pos.y = 0; + _addrtype = TEXT; +} + + +/** Send a pulse on the ENABLE line */ +void _lcd_clk() +{ + pin_high(LCD_E); + delay_ns(450); + pin_low(LCD_E); +} + + +/** Enter READ mode */ +void _lcd_mode_r() +{ + if (_lcd_mode == 1) return; // already in R mode + + pin_high(LCD_RW); + + as_input_pu(LCD_D7); + as_input_pu(LCD_D6); + as_input_pu(LCD_D5); + as_input_pu(LCD_D4); + + _lcd_mode = 1; +} + + +/** Enter WRITE mode */ +void _lcd_mode_w() +{ + if (_lcd_mode == 0) return; // already in W mode + + pin_low(LCD_RW); + + as_output(LCD_D7); + as_output(LCD_D6); + as_output(LCD_D5); + as_output(LCD_D4); + + _lcd_mode = 0; +} + + +/** Read a byte */ +uint8_t _lcd_read_byte() +{ + _lcd_mode_r(); + + uint8_t res = 0; + + _lcd_clk(); + res = (get_pin(LCD_D7) << 7) | (get_pin(LCD_D6) << 6) | (get_pin(LCD_D5) << 5) | (get_pin(LCD_D4) << 4); + + _lcd_clk(); + res |= (get_pin(LCD_D7) << 3) | (get_pin(LCD_D6) << 2) | (get_pin(LCD_D5) << 1) | (get_pin(LCD_D4) << 0); + + return res; +} + + +/** Write an instruction byte */ +void lcd_command(uint8_t bb) +{ + _lcd_wait_bf(); + pin_low(LCD_RS); // select instruction register + _lcd_write_byte(bb); // send instruction byte +} + + +/** Write a data byte */ +void lcd_write(uint8_t bb) +{ + if (_addrtype == TEXT) + { + if (bb == '\r') + { + // CR + _pos.x = 0; + lcd_xy(_pos.x, _pos.y); + return; + } + + if (bb == '\n') + { + // LF + _pos.y++; + lcd_xy(_pos.x, _pos.y); + return; + } + + _pos.x++; + } + + _lcd_wait_bf(); + pin_high(LCD_RS); // select data register + _lcd_write_byte(bb); // send data byte +} + + +/** Read BF & Address */ +uint8_t lcd_read_bf_addr() +{ + pin_low(LCD_RS); + return _lcd_read_byte(); +} + + +/** Read CGRAM or DDRAM */ +uint8_t lcd_read() +{ + if (_addrtype == TEXT) _pos.x++; + + pin_high(LCD_RS); + return _lcd_read_byte(); +} + + +/** Write a byte using the 4-bit interface */ +void _lcd_write_byte(uint8_t bb) +{ + _lcd_mode_w(); // enter W mode + + _lcd_write_high(bb); + _lcd_clk(); + + _lcd_write_low(bb); + _lcd_clk(); +} + + + +/** Wait until the device is ready */ +void _lcd_wait_bf() +{ + uint8_t d = 0; + while (d++ < 120 && lcd_read_bf_addr() & _BV(7)) + _delay_us(1); +} + + +/** Send a string to LCD */ +void lcd_puts(char* str_p) +{ + char c; + while ((c = *str_p++)) + lcd_putc(c); +} + + +/** Print from progmem */ +void lcd_puts_P(const char* str_p) +{ + char c; + while ((c = pgm_read_byte(str_p++))) + lcd_putc(c); +} + + +/** Sedn a char to LCD */ +void lcd_putc(const char c) +{ + lcd_write(c); +} + + +/** Set cursor position */ +void lcd_xy(const uint8_t x, const uint8_t y) +{ + _pos.x = x; + _pos.y = y; + lcd_addr(LCD_ROW_ADDR[y] + (x)); +} + + +uint8_t _lcd_old_cursor = CURSOR_NONE; +bool _lcd_enabled = false; + +/** Set LCD cursor. If not enabled, only remember it. */ +void lcd_cursor(uint8_t type) +{ + _lcd_old_cursor = (type & CURSOR_BOTH); + + if (_lcd_enabled) lcd_command(LCD_CURSOR_NONE | _lcd_old_cursor); +} + + +/** Display display (preserving cursor) */ +void lcd_disable() +{ + lcd_command(LCD_DISABLE); + _lcd_enabled = false; +} + + +/** Enable display (restoring cursor) */ +void lcd_enable() +{ + _lcd_enabled = true; + lcd_cursor(_lcd_old_cursor); +} + + +/** Go home */ +void lcd_home() +{ + lcd_command(LCD_HOME); + _pos.x = 0; + _pos.y = 0; + _addrtype = TEXT; +} + + +/** Clear the screen */ +void lcd_clear() +{ + lcd_command(LCD_CLEAR); + _pos.x = 0; + _pos.y = 0; + _addrtype = TEXT; +} + + +/** Define a glyph */ +void lcd_glyph(const uint8_t index, const uint8_t* array) +{ + lcd_addr_cg(index * 8); + for (uint8_t i = 0; i < 8; ++i) + { + lcd_write(array[i]); + } + + // restore previous position + lcd_xy(_pos.x, _pos.y); + _addrtype = TEXT; +} + + +/** Define a glyph */ +void lcd_glyph_P(const uint8_t index, const uint8_t* array) +{ + lcd_addr_cg(index * 8); + for (uint8_t i = 0; i < 8; ++i) + { + lcd_write(pgm_read_byte(&array[i])); + } + + // restore previous position + lcd_xy(_pos.x, _pos.y); + _addrtype = TEXT; +} + + +/** Set address in CGRAM */ +void lcd_addr_cg(const uint8_t acg) +{ + _addrtype = CG; + lcd_command(0b01000000 | ((acg) & 0b00111111)); +} + + +/** Set address in DDRAM */ +void lcd_addr(const uint8_t add) +{ + _addrtype = TEXT; + lcd_command(0b10000000 | ((add) & 0b01111111)); +} diff --git a/lib/porklib/lcd.h b/lib/porklib/lcd.h new file mode 100644 index 0000000..7f48d16 --- /dev/null +++ b/lib/porklib/lcd.h @@ -0,0 +1,146 @@ +#pragma once + +// HD44780 LCD display driver - 4-bit mode +// +// LCD pins are configured using a file lcd_config.h, which you +// have to add next to your main.c file. +// +// Content can be something like this: +// +// + +#include +#include + +#include "stream.h" + +// Your file with configs +#include "lcd_config.h" +/* + #define LCD_RS 10 + #define LCD_RW 11 + #define LCD_E 12 + #define LCD_D4 13 + #define LCD_D5 14 + #define LCD_D6 15 + #define LCD_D7 16 +*/ + + + +// Shared LCD stream object +// Can be used with functions from stream.h once LCD is initialized +extern STREAM* lcd; + + +// --- Commands --- + +// Clear screen (reset) +#define LCD_CLEAR 0b00000001 +// Move cursor to (0,0), unshift... +#define LCD_HOME 0b00000010 + +// Set mode: Increment + NoShift +#define LCD_MODE_INC 0b00000110 +// Set mode: Increment + Shift +#define LCD_MODE_INC_SHIFT 0b00000111 + +// Set mode: Decrement + NoShift +#define LCD_MODE_DEC 0b00000100 +// Set mode: Decrement + Shift +#define LCD_MODE_DEC_SHIFT 0b00000101 + +// Disable display (data remains untouched) +#define LCD_DISABLE 0b00001000 + +// Disable cursor +#define LCD_CURSOR_NONE 0b00001100 +// Set cursor to still underscore +#define LCD_CURSOR_BAR 0b00001110 +// Set cursor to blinking block +#define LCD_CURSOR_BLINK 0b00001101 +// Set cursor to both of the above at once +#define LCD_CURSOR_BOTH (LCD_CURSOR_BAR | LCD_CURSOR_BLINK) + +// Move cursor +#define LCD_MOVE_LEFT 0b00010000 +#define LCD_MOVE_RIGHT 0b00010100 + +// Shift display +#define LCD_SHIFT_LEFT 0b00011000 +#define LCD_SHIFT_RIGHT 0b00011100 + +// Set iface to 5x7 font, 1-line +#define LCD_IFACE_4BIT_1LINE 0b00100000 +#define LCD_IFACE_8BIT_1LINE 0b00110000 +// Set iface to 5x7 font, 2-line +#define LCD_IFACE_4BIT_2LINE 0b00101000 +#define LCD_IFACE_8BIT_2LINE 0b00111000 + + +/** Initialize the display */ +void lcd_init(); + +/** Write an instruction byte */ +void lcd_command(uint8_t bb); + +/** Write a data byte */ +void lcd_write(uint8_t bb); + +/** Read BF & Address */ +uint8_t lcd_read_bf_addr(); + +/** Read CGRAM or DDRAM */ +uint8_t lcd_read(); + +/** Send a string to LCD */ +void lcd_puts(char* str_p); + +/** Send a string to LCD from program memory */ +void lcd_puts_P(const char* str_p); + +/** Sedn a char to LCD */ +void lcd_putc(const char c); + +/** Show string at X, Y */ +#define lcd_puts_xy(x, y, str_p) do { lcd_xy((x), (y)); lcd_puts((str_p)); } while(0) + +/** Show string at X, Y */ +#define lcd_puts_xy_P(x, y, str_p) do { lcd_xy((x), (y)); lcd_puts_P((str_p)); } while(0) + +/** Show char at X, Y */ +#define lcd_putc_xy(x, y, c) do { lcd_xy((x), (y)); lcd_putc((c)); } while(0) + +/** Set cursor position */ +void lcd_xy(const uint8_t x, const uint8_t y); + +/** Set LCD cursor. If not enabled, only remember it. */ +#define CURSOR_NONE 0b00 +#define CURSOR_BAR 0b10 +#define CURSOR_BLINK 0b01 +#define CURSOR_BOTH 0b11 +void lcd_cursor(uint8_t type); + +/** Display display (preserving cursor) */ +void lcd_disable(); + +/** Enable display (restoring cursor) */ +void lcd_enable(); + +/** Go home */ +void lcd_home(); + +/** Clear the screen */ +void lcd_clear(); + +/** Define a glyph - 8 bytes, right 5 bits are used */ +void lcd_glyph(const uint8_t index, const uint8_t* array); + +/** Define a glyph that's in PROGMEM */ +void lcd_glyph_P(const uint8_t index, const uint8_t* array); + +/** Set address in CGRAM */ +void lcd_addr_cg(const uint8_t acg); + +/** Set address in DDRAM */ +void lcd_addr(const uint8_t add); diff --git a/lib/porklib/nsdelay.h b/lib/porklib/nsdelay.h new file mode 100644 index 0000000..dd93a83 --- /dev/null +++ b/lib/porklib/nsdelay.h @@ -0,0 +1,21 @@ +#pragma once + +// +// Functions for precise delays (nanoseconds / cycles) +// + +#include +#include +#include + +/* Convert nanoseconds to cycle count */ +#define ns2cycles(ns) ( (ns) / (1000000000L / (signed long) F_CPU) ) + +/** Wait c cycles */ +#define delay_c(c) (((c) > 0) ? __builtin_avr_delay_cycles(c) : __builtin_avr_delay_cycles(0)) + +/** Wait n nanoseconds, plus c cycles */ +#define delay_ns_c(ns, c) delay_c(ns2cycles(ns) + (c)) + +/** Wait n nanoseconds */ +#define delay_ns(ns) delay_c(ns2cycles(ns)) diff --git a/lib/porklib/onewire.c b/lib/porklib/onewire.c new file mode 100644 index 0000000..5ba960a --- /dev/null +++ b/lib/porklib/onewire.c @@ -0,0 +1,248 @@ +#include +#include +#include +#include + +#include "iopins.h" +#include "onewire.h" + + +/** Perform bus reset. Returns true if any device is connected */ +bool ow_reset(const uint8_t pin) +{ + as_output_n(pin); + pin_low_n(pin); + _delay_us(480); + + as_input_pu_n(pin); + _delay_us(70); + + const bool a = get_pin_n(pin); + + _delay_us(410); + + return a; +} + + +/** Send a single bit */ +void _ow_tx_bit(const uint8_t pin, const bool bit) +{ + as_output_n(pin); + pin_low_n(pin); + + if (bit) + { + _delay_us(6); + as_input_pu_n(pin); + _delay_us(64); + } + else + { + _delay_us(60); + as_input_pu_n(pin); + _delay_us(10); + } +} + + +/** Send a single byte */ +void ow_send(const uint8_t pin, const uint8_t byte) +{ + for (uint8_t i = 0; i < 8; i++) + { + _ow_tx_bit(pin, (byte >> i) & 0x01); + } +} + + +/** Read a single bit */ +bool _ow_rx_bit(const uint8_t pin) +{ + as_output_n(pin); + pin_low_n(pin); + _delay_us(6); + + as_input_pu_n(pin); + _delay_us(9); + + const bool a = get_pin_n(pin); + + _delay_us(55); + + return a; +} + + +/** Read a single byte */ +uint8_t ow_read(const uint8_t pin) +{ + uint8_t byte = 0; + + for (uint8_t i = 0; i < 8; i++) + { + byte = (byte >> 1) | (_ow_rx_bit(pin) << 7); + } + + return byte; +} + + +/** Wait until the device is ready. Returns false on timeout */ +bool ow_wait_ready(const uint8_t pin) +{ + uint16_t timeout = 700; + as_input_pu_n(pin); + + while (--timeout > 0) + { + if (is_high_n(pin)) return true; + _delay_ms(1); + } + + return false; +} + + +/** Read bytes into an array */ +void ow_read_arr(const uint8_t pin, uint8_t* array, const uint8_t count) +{ + for (uint8_t i = 0; i < count; i++) + { + array[i] = ow_read(pin); + } +} + + + +// ---------- CRC utils ---------- + +/* + Dallas 1-wire CRC routines for Arduino with examples of usage. + The 16-bit routine is new. + The 8-bit routine is from http://github.com/paeaetech/paeae/tree/master/Libraries/ds2482/ + + Copyright (C) 2010 Kairama Inc + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +// Dallas 1-wire 16-bit CRC calculation. Developed from Maxim Application Note 27. + +/** Compute a CRC16 checksum */ +uint16_t crc16(uint8_t *data, uint8_t len) +{ + uint16_t crc = 0; + + for (uint8_t i = 0; i < len; i++) + { + uint8_t inbyte = data[i]; + for (uint8_t j = 0; j < 8; j++) + { + uint8_t mix = (crc ^ inbyte) & 0x01; + crc = crc >> 1; + if (mix) + crc = crc ^ 0xA001; + + inbyte = inbyte >> 1; + } + } + return crc; +} + + +// The 1-Wire CRC scheme is described in Maxim Application Note 27: +// "Understanding and Using Cyclic Redundancy Checks with Maxim iButton Products" + +/** Compute a CRC8 checksum */ +uint8_t crc8(uint8_t *addr, uint8_t len) +{ + uint8_t crc = 0; + + for (uint8_t i = 0; i < len; i++) + { + uint8_t inbyte = addr[i]; + for (uint8_t j = 0; j < 8; j++) + { + uint8_t mix = (crc ^ inbyte) & 0x01; + crc >>= 1; + if (mix) + crc ^= 0x8C; + + inbyte >>= 1; + } + } + + return crc; +} + + +// --- utils for DS1820 --- + + +/** Read temperature in 0.0625°C, or TEMP_ERROR on error */ +int16_t ds1820_read_temp(uint8_t pin) +{ + ow_send(pin, READ_SCRATCHPAD); + uint8_t bytes[9]; + ow_read_arr(pin, bytes, 9); + + uint8_t crc = crc8(bytes, 8); + if (crc != bytes[8]) + { + return TEMP_ERROR; + } + else + { + int16_t a = ((bytes[1] << 8) | bytes[0]) >> 1; + a = a << 4; + a += (16 - bytes[6]) & 0x0F; + a -= 0x04; + + return a; + } +} + +/** Read temperature in 0.1°C, or TEMP_ERROR on error */ +int16_t ds1820_read_temp_c(uint8_t pin) +{ + int32_t temp = ds1820_read_temp(pin); + + if (temp == TEMP_ERROR) + return TEMP_ERROR; + + temp *= 625; + uint16_t rem = temp % 1000; + temp /= 1000; + if (rem >= 500) temp++; + + return (int16_t) temp; +} + + +bool ds1820_single_measure(uint8_t pin) +{ + ow_reset(pin); + ow_send(pin, SKIP_ROM); + ow_send(pin, CONVERT_T); + + if (!ow_wait_ready(pin)) + { + return false; + } + + ow_reset(pin); + ow_send(pin, SKIP_ROM); + + return true; +} diff --git a/lib/porklib/onewire.h b/lib/porklib/onewire.h new file mode 100644 index 0000000..38e292b --- /dev/null +++ b/lib/porklib/onewire.h @@ -0,0 +1,58 @@ +#pragma once + +// +// Utils for Dallas OneWire bus (DS1820 etc) +// + +#include +#include + +#define SKIP_ROM 0xCC +#define CONVERT_T 0x44 +#define READ_SCRATCHPAD 0xBE + +/** Perform bus reset. Returns true if any device is connected */ +bool ow_reset(const uint8_t pin); + +/** Send a single byte */ +void ow_send(const uint8_t pin, const uint8_t byte); + +/** Read a single byte */ +uint8_t ow_read(const uint8_t pin); + +/** Wait until the device is ready. Returns false on timeout */ +bool ow_wait_ready(const uint8_t pin); + +/** Read bytes into an array */ +void ow_read_arr(const uint8_t pin, uint8_t* array, const uint8_t count); + +/** Compute a CRC16 checksum */ +uint16_t crc16(uint8_t *data, uint8_t len); + +/** Compute a CRC8 checksum */ +uint8_t crc8(uint8_t *addr, uint8_t len); + +// --- utils for DS1820 --- + +#define TEMP_ERROR -32768 + +/** + * Read temperature in 0.0625°C, or TEMP_ERROR on error + * Use this where you'd normally use READ_SCRATCHPAD + */ +int16_t ds1820_read_temp(uint8_t pin); + + +/** + * Read temperature in 0.1°C, or TEMP_ERROR on error + * Use this where you'd normally use READ_SCRATCHPAD + */ +int16_t ds1820_read_temp_c(uint8_t pin); + +/** + * Perform a temperature measurement with single DS1820 device on the line + * Can be followed by a call to read temperature (READ_SCRATCHPAD). + * + * Returns false on failure (device not connected) + */ +bool ds1820_single_measure(uint8_t pin); diff --git a/lib/porklib/sd.c b/lib/porklib/sd.c new file mode 100644 index 0000000..af72506 --- /dev/null +++ b/lib/porklib/sd.c @@ -0,0 +1,202 @@ +#include +#include +#include +#include + +#include "iopins.h" +#include "spi.h" +#include "sd.h" + +#define SD_RESET 0x40 // used to make card enter SPI mode +#define SD_GET_STATUS 0x41 // used to check if card left IDLE - should return 0 +#define SD_SET_BLOCKLEN 0x50 // used to check if card left IDLE - should return 0 +#define SD_READ_BLOCK 0x51 // read single block +#define SD_WRITE_BLOCK 0x58 // write single block + + +bool sd_inited = false; + +bool sd_init() +{ + if (sd_inited) return true; + sd_inited = true; + + uint8_t i; + spi_init(); + + spi_ss_disable(); // needed for init sequence, first command will enable it again + + // idle for 10 bytes / 80 clocks + for (i = 0; i < 10; i++) + { + spi_write(0xFF); + } + + + // Send "Go to SPI mode" command, which should return "1" + for (i = 0; i < 100 && sd_command(SD_RESET, 0) != 1; i++) + _delay_ms(10); + + if (i == 100) + return false; // timeout + + + // CMD1 until card comes out of "idle" mode + for (i = 0; i < 100 && sd_command(SD_GET_STATUS, 0) != 0; i++) + _delay_ms(10); + + if (i == 100) + return false; // timeout + + + // f_cpu/8 speed (-> 2 MHz) + SPSR |= _BV(SPI2X); + SPCR &= 0xFC | _BV(SPR0); + + // Set block size to 512 bytes (SD card default) + sd_command(SD_SET_BLOCKLEN, 512); + + return true; +} + + +uint8_t sd_command(const uint8_t cmd, const uint32_t arg) +{ + spi_ss_enable(); + + spi_write(cmd); + spi_write(arg >> 24); + spi_write(arg >> 16); + spi_write(arg >> 8); + spi_write(arg); + spi_write(0x95); // CRC for the "init" command, later is ignored + + // Send 8 bytes of 0xFF + // SD card replies with non-0xFF once it's done processing the command + uint8_t i, tmp, ret = 0xFF; + for (i = 0; i < 8; i++) + { + tmp = spi_write(0xFF); + if (tmp != 0xFF) + ret = tmp; + } + + spi_ss_disable(); + + return ret; +} + + +bool sd_read(const uint32_t sector, const uint16_t read_at, uint8_t * buffer, const uint16_t write_at, const uint16_t len) +{ + if (read_at + len > 512) return false; + + uint16_t i; + + spi_ss_enable(); + spi_write(SD_READ_BLOCK); + spi_write(sector >> 15); // sector * 512 >> 24 + spi_write(sector >> 7); // sector * 512 >> 16 + spi_write(sector << 1); // sector * 512 >> 8 + spi_write(0); // sector * 512 + spi_write(0xFF); + + // wait for 0 (ready) + for (i = 0; i < 100 && spi_write(0xFF) != 0x00; i++); + if (i == 100) + { + spi_ss_disable(); + return false; // timeout + } + + + // wait for 0xFE (data start) + for (i = 0; i < 100 && spi_write(0xFF) != 0xFE; i++); + if (i == 100) + { + spi_ss_disable(); + return false; // timeout + } + + // skip "offset" bytes + for (i = 0; i < read_at; i++) + spi_write(0xFF); + + // read "len" bytes + for (i = write_at; i < write_at + len; i++) + buffer[i] = spi_write(0xFF); + + // skip remaining bytes in the sector + for (i = read_at + len; i < 512; i++) + spi_write(0xFF); + + // skip checksum + spi_write(0xFF); + spi_write(0xFF); + + spi_ss_disable(); + + return true; +} + + + +bool sd_write(const uint32_t sector, const uint8_t * buffer512) +{ + uint16_t i; + + spi_ss_enable(); + + spi_write(SD_WRITE_BLOCK); + spi_write(sector >> 15); // sector * 512 >> 24 + spi_write(sector >> 7); // sector * 512 >> 16 + spi_write(sector << 1); // sector * 512 >> 8 + spi_write(0); // sector * 512 + spi_write(0xFF); + + // wait for 0 (ready) + for (i = 0; i < 100 && spi_write(0xFF) != 0x00; i++); + if (i == 100) + { + spi_ss_disable(); + return false; // timeout + } + + // Start of data + spi_write(0xFE); + + // Data + for (i = 0; i < 512; i++) + { + spi_write(buffer512[i]); + } + + // Fake CRC + spi_write(0xFF); + spi_write(0xFF); + + // Should contain flag that data was accepted + uint8_t resp = spi_write(0xFF); + + if ((resp & 0x0F) != 0x05) + { + // Data not accepted + spi_ss_disable(); + return false; + } + else + { + // Data accepted, wait for write complete + for (i = 0; i < 0xFFFF && spi_write(0xFF) == 0x00; i++); + if (i == 0xFFFF) + { + spi_ss_disable(); + return false; // timeout + } + } + + spi_write(0xFF); // 8 clocks + spi_ss_disable(); + + return true; +} diff --git a/lib/porklib/sd.h b/lib/porklib/sd.h new file mode 100644 index 0000000..c57fc51 --- /dev/null +++ b/lib/porklib/sd.h @@ -0,0 +1,53 @@ +#pragma once + +// +// SD card low-level I/O utilities +// +// Inspired by: +// http://www.avrfreaks.net/forum/tutc-simple-fat-and-sd-tutorial +// + +#include +#include +#include +#include +#include + +#include "iopins.h" +#include "spi.h" + +/** Init SD card on SPI */ +bool sd_init(); + + +/** + * Send a command to the SD card + * + * @param cmd command to send + * @param arg command argument + * @return return value on success, 0xFF if nothing received back. + */ +uint8_t sd_command(uint8_t cmd, uint32_t arg); + + +/** + * Read from a sector into a buffer memory structure. + * + * @param sector sector to read (512 bytes long each) + * @param read_at offset within the sector + * @param buffer target buffer + * @param write_at target starting address + * @param len number of bytes to read + * @return true on success + */ +bool sd_read(uint32_t sector, uint16_t read_at, uint8_t * buffer, uint16_t write_at, uint16_t len); + + +/** + * Write bytes from a buffer into a sector. + * + * @param sector sector to write (512 bytes long each) + * @param buffer512 source buffer + * @return true on success + */ +bool sd_write(uint32_t sector, const uint8_t * buffer512); diff --git a/lib/porklib/sd_blockdev.c b/lib/porklib/sd_blockdev.c new file mode 100644 index 0000000..f363f47 --- /dev/null +++ b/lib/porklib/sd_blockdev.c @@ -0,0 +1,184 @@ +#include +#include + +#include "sd_blockdev.h" +#include "sd.h" + +// helpers +void load_sector(const uint32_t addr); +void store_sector(); +void handle_cursor_ov(); + +// blockdev methods +void dev_load(void* dest, const uint16_t len); +void dev_store(const void* src, const uint16_t len); +uint8_t dev_read(); +void dev_write(const uint8_t b); +void dev_seek(const uint32_t addr); +void dev_rseek(const int16_t offset); +void dev_flush(); + + +/** Sector buffer */ +uint8_t buff[512]; + +/** Address of the buffered sector */ +uint32_t buff_addr; + +/** Buffer needs to be flushed before next read */ +bool buff_dirty = false; + +/** Buffer holds a valid sector */ +bool buff_valid = false; + +/** seek cursor */ +uint32_t cursor_sec; +uint16_t cursor_offs; + + +/** Flush the buffer, if it's dirty */ +void dev_flush() +{ + if (buff_dirty) + { + store_sector(); + buff_dirty = false; + } +} + + +void load_sector(const uint32_t addr) +{ + // do not load if already loaded + if (buff_valid && buff_addr == addr) + { + return; + } + + dev_flush(); + + // read entire sector + sd_read(addr, 0, buff, 0, 512); + buff_valid = true; + buff_addr = addr; +} + + +void store_sector() +{ + // Do not store if not laoded. + if (!buff_dirty) return; + if (!buff_valid) return; + + sd_write(buff_addr, buff); +} + + +/** + * Handle cursor overflow. + * MUST ABSOLUTELY NOT load/store buffer or change buffer addr! +*/ +inline void handle_cursor_ov() +{ + if (cursor_offs >= 512) + { + cursor_sec++; + cursor_offs = 0; + } +} + + + +void dev_write(const uint8_t b) +{ + load_sector(cursor_sec); + + // dirty only if changed + if (buff[cursor_offs] != b) + { + buff[cursor_offs++] = b; + buff_dirty = true; + } + else + { + cursor_offs++; + } + + handle_cursor_ov(); +} + + +uint8_t dev_read() +{ + load_sector(cursor_sec); + const uint8_t b = buff[cursor_offs++]; + + handle_cursor_ov(); + + return b; +} + + +void dev_load(void* dest, const uint16_t len) +{ + for (uint16_t a = 0; a < len; a++) + { + *((uint8_t*)dest++) = dev_read(); + } +} + + +void dev_store(const void* src, const uint16_t len) +{ + for (uint16_t a = 0; a < len; a++) + { + dev_write(*((uint8_t*)src++)); + } +} + + +void dev_seek(const uint32_t addr) +{ + // compute sector and offset counters + cursor_sec = addr >> 9; + cursor_offs = addr & 0x1FF; +} + + +void dev_rseek(const int16_t offset) +{ + // add WITHIN the same sector + if (offset > 0 && cursor_offs + offset < 512) + { + cursor_offs += offset; + return; + } + + // subtract WITHIN the same sector + if (offset < 0 && ((uint16_t)(-offset) <= cursor_offs)) + { + cursor_offs += offset; + return; + } + + // abs addr change + dev_seek(((cursor_sec << 9) + cursor_offs) + offset); +} + + +/** Init SD card block device */ +bool sdb_init(BLOCKDEV* dev) +{ + if (!sd_init()) return false; + + dev->load = &dev_load; + dev->store = &dev_store; + dev->read = &dev_read; + dev->write = &dev_write; + dev->seek = &dev_seek; + dev->rseek = &dev_rseek; + dev->flush = &dev_flush; + + return true; +} + diff --git a/lib/porklib/sd_blockdev.h b/lib/porklib/sd_blockdev.h new file mode 100644 index 0000000..fc479fa --- /dev/null +++ b/lib/porklib/sd_blockdev.h @@ -0,0 +1,7 @@ +#pragma once + +#include "blockdev.h" +#include + +/** Initialize the SD card block device */ +bool sdb_init(BLOCKDEV* dev); diff --git a/lib/porklib/sd_fat.c b/lib/porklib/sd_fat.c new file mode 100644 index 0000000..519034d --- /dev/null +++ b/lib/porklib/sd_fat.c @@ -0,0 +1,67 @@ +#include +#include + +#include "sd_blockdev.h" +#include "sd_fat.h" +#include "fat16.h" + +FAT16 _fat; +BLOCKDEV _dev; + + +static STREAM _s; +STREAM* sdf_stream = &_s; + +FFILE* stream_file; +bool stream_active = false; + +void stream_tx(uint8_t b) +{ + if (!stream_active) return; + ff_write(stream_file, &b, 1); +} + + +uint8_t stream_rx() +{ + if (!stream_active) return 0; + + uint8_t b; + ff_read(stream_file, &b, 1); + return b; +} + +void sdf_open_stream(FFILE* file) +{ + stream_active = true; + stream_file = file; +} + + +bool sdfat_inited = false; + +bool sdf_init() +{ + if (sdfat_inited) return true; + sdfat_inited = true; + + if (!sdb_init(&_dev)) return false; + if (!ff_init(&_dev, &_fat)) return false; + + sdf_stream->rx = &stream_rx; + sdf_stream->tx = &stream_tx; + + return true; +} + + +void sdf_root(FFILE* file) +{ + ff_root(&_fat, file); +} + + +void sdf_disk_label(char* str) +{ + ff_disk_label(&_fat, str); +} diff --git a/lib/porklib/sd_fat.h b/lib/porklib/sd_fat.h new file mode 100644 index 0000000..7bbbc01 --- /dev/null +++ b/lib/porklib/sd_fat.h @@ -0,0 +1,32 @@ +#pragma once + +// +// FAT-on-SD helpers. +// +// This can be used for convenience, as it does all the init for you +// and hides the implementation. All regular ff_* functions will work on the FFILE. +// + +#include + +#include "fat16.h" +#include "stream.h" + +/** Initialize FAT16 filesystem on a SPI-connected SD card */ +bool sdf_init(); + +/** Get first file of the root folder. */ +void sdf_root(FFILE* file); + +/** Get a disk label. Str should have 12 chars. */ +void sdf_disk_label(char* str); + +extern STREAM* sdf_stream; + +/** + * Open a stream for a file. There can be only one stream at a time. + * + * The stream will operate at the current file's cursor, just like + * ff_read and ff_write. +*/ +void sdf_open_stream(FFILE* file); diff --git a/lib/porklib/sipo_pwm.c b/lib/porklib/sipo_pwm.c new file mode 100644 index 0000000..3c0fab4 --- /dev/null +++ b/lib/porklib/sipo_pwm.c @@ -0,0 +1,83 @@ +#include +#include +#include + +#include "sipo_pwm.h" +#include "iopins.h" +#include "sipo_pwm_config.h" + + +/* -------- SIPO PWM MODULE ---------- */ + +/** Buffer for sending bits to SIPO */ +bool _buff[SPWM_CHANNELS]; + +uint8_t spwm_levels[SPWM_CHANNELS]; + + +/** Send _buff to SIPO */ +void _send_buffer() +{ + for (int8_t i = SPWM_CHANNELS - 1; i >= 0; i--) + { + #if (SPWM_INVERT) + set_pin(SPWM_DATA, !_buff[i]); /* Common anode */ + #else + set_pin(SPWM_DATA, _buff[i]); /* Common cathode */ + #endif + + // send a CLK pulse + pin_high(SPWM_CLK); + pin_low(SPWM_CLK); + } + + // send a STR pulse + pin_high(SPWM_STR); + pin_low(SPWM_STR); +} + + +void spwm_init() +{ + // Pin directions + as_output(SPWM_CLK); + as_output(SPWM_STR); + as_output(SPWM_DATA); + + // Initial states + pin_low(SPWM_CLK); + pin_low(SPWM_STR); +} + + +/** + * Display PWM channels. + * This could be called in a Timer ISR. + */ +void spwm_send() +{ + // Set all bits to 1 (if their PWM level is 0, set to 0) + for (uint8_t bit = 0; bit < SPWM_CHANNELS; bit++) + { + _buff[bit] = (bool) spwm_levels[bit]; + } + + // Show initial state + _send_buffer(); + + // For each PWM level... + for (uint16_t pwm = 0; pwm < SPWM_COLOR_DEPTH; pwm++) + { + // Turn OFF bits that are below the level + for (uint8_t bit = 0; bit < SPWM_CHANNELS; bit++) + { + if (spwm_levels[bit] < pwm) + { + _buff[bit] = 0; + } + } + + // And show... + _send_buffer(); + } +} diff --git a/lib/porklib/sipo_pwm.h b/lib/porklib/sipo_pwm.h new file mode 100644 index 0000000..f825f2f --- /dev/null +++ b/lib/porklib/sipo_pwm.h @@ -0,0 +1,49 @@ +#pragma once + +// --- SIPO PWM Module --- +// +// SIPO = shift register with paralel output. +// +// This module lets you use SIPO outputs as a "software PWM". +// +// Tested to work on 74hc4094 and 74hc595 + +#include + +// Your file with configs +#include "sipo_pwm_config.h" +/* + // --- PWM pin aliases --- + + // Store signal + #define SPWM_STR D2 + // Shift/clock signal + #define SPWM_CLK D3 + // Data signal + #define SPWM_DATA D4 + + // --- Other settings --- + + // Number of PWM levels (color depth) + #define SPWM_COLOR_DEPTH 256 + + // Number of SIPO channels + #define SPWM_CHANNELS 24 + + // Invert outputs (for Common Anode LEDs) + #define SPWM_INVERT 1 +*/ + + +// Array for setting PWM levels (PWM_CHANNELS-long) +extern uint8_t spwm_levels[SPWM_CHANNELS]; + + +/** Configure output pins etc */ +void spwm_init(); + + +/** Perform one PWM cycle. + * This should be called in a Timer ISR or a loop. + */ +void spwm_send(); diff --git a/lib/porklib/sonar.c b/lib/porklib/sonar.c new file mode 100644 index 0000000..b9f12aa --- /dev/null +++ b/lib/porklib/sonar.c @@ -0,0 +1,168 @@ +#include +#include +#include +#include + +#include "iopins.h" +#include "sonar.h" + +// Currently measured sonar +static sonar_t* _so; + +// Flag that measurement is in progress +volatile bool sonar_busy; + +// Result of last measurement, in millimeters +volatile int16_t sonar_result; + + +void _sonar_init_do(sonar_t* so, PORT_P port, uint8_t ntx, PORT_P pin, uint8_t nrx) +{ + so->port = port; + so->ntx = ntx; + so->pin = pin; + so->nrx = nrx; + + switch ((const uint16_t) pin) + { + case ((const uint16_t) &PINB): + so->bank = 0; + break; + + case ((const uint16_t) &PINC): + so->bank = 1; + break; + + case ((const uint16_t) &PIND): + so->bank = 2; + break; + } +} + + +/** + * Start sonar measurement + * Interrupts must be enabled + * TIMER 1 will be used for the async measurement + * Timer 1 overflow and Pin Change interrupts must invoke Sonar handlers. + */ +bool sonar_start(sonar_t* so) +{ + if (sonar_busy) return false; + + _so = so; + + sonar_busy = true; + + // make sure the timer is stopped (set clock to NONE) + TCCR1B = 0; + + // Timer overflow interrupt enable + // We'll stop measuring on overflow + sbi(TIMSK1, TOIE1); + + // Clear the timer value + TCNT1 = 0; + + // Set up pin change interrupt mask for the RX pin + switch (so->bank) + { + case 0: + sbi(PCMSK0, so->nrx); + break; + + case 1: + sbi(PCMSK1, so->nrx); + break; + + case 2: + sbi(PCMSK2, so->nrx); + break; + } + + // send positive pulse + sbi_p(so->port, so->ntx); + _delay_us(_SNR_TRIG_TIME); + cbi_p(so->port, so->ntx); + + // Wait for start of response + while (bit_is_low_p(so->pin, so->nrx)); + + // Set timer clock source: F_CPU / 8 (0.5 us resolution) + TCCR1B = (0b010 << CS10); + + // Enable pin change interrupt + sbi(PCICR, so->bank); + + return true; +} + + +/** Stop the timer */ +void _sonar_stop() +{ + // stop timer + TCCR1B = 0; + + // Disable RX pin interrupt mask + switch (_so->bank) + { + case 0: + PCMSK0 &= ~(1 << (_so->nrx)); + break; + + case 1: + PCMSK1 &= ~(1 << (_so->nrx)); + break; + + case 2: + PCMSK2 &= ~(1 << (_so->nrx)); + break; + } + + // Disable timer1 overflow interrupt + cbi(TIMSK1, TOIE1); + + sonar_busy = false; +} + + +/** Handle TIMER1_OVF (returns true if consumed) */ +inline bool sonar_handle_t1ovf() +{ + if (!sonar_busy) return false; // nothing + + sonar_result = -1; + _sonar_stop(); + + return true; +} + + +/** Handle pin change interrupt (returns true if consumed) */ +inline bool sonar_handle_pci() +{ + if (!sonar_busy) + { + return false; // nothing + } + + if (bit_is_high_p(_so->pin, _so->nrx)) + { + // rx is high, not our pin change event + return false; + } + + uint64_t x = TCNT1; + x /= _SNR_DIV_CONST; + x *= 100000000L; + x /= F_CPU; + sonar_result = (int16_t) x; + + // no obstacle + if (sonar_result > _SNR_MAX_DIST) sonar_result = -1; + + _sonar_stop(); + + return true; +} diff --git a/lib/porklib/sonar.h b/lib/porklib/sonar.h new file mode 100644 index 0000000..9e8d3ae --- /dev/null +++ b/lib/porklib/sonar.h @@ -0,0 +1,67 @@ +#pragma once + +// +// Utilities for working with the HC-SR04 ultrasonic sensor +// Can be easily modified to work with other similar modules +// +// It's required that you call the sonar_handle_* functions from your ISRs +// See example program for more info. +// + +#include +#include + +#include "iopins.h" + +// Calib constant for the module +// CM = uS / _DIV_CONST +#define _SNR_DIV_CONST 58 + +// Max module distance in MM +#define _SNR_MAX_DIST 4000 + +// Trigger time in uS +#define _SNR_TRIG_TIME 10 + + +// Sonar data object +typedef struct +{ + PORT_P port; // Tx PORT + uint8_t ntx; // Tx bit number + PORT_P pin; // Rx PIN + uint8_t nrx; // Rx bit number + uint8_t bank; // Rx PCINT bank +} sonar_t; + + +extern volatile bool sonar_busy; +extern volatile int16_t sonar_result; + + +// Create a Sonar port +// Args: sonar_t* so, Trig pin, Echo pin +#define sonar_init(so, trig, echo) do { \ + as_output(trig); \ + as_input_pu(echo); \ + _sonar_init_do(so, &_port(trig), _pn(trig), &_pin(echo), _pn(echo)); \ +} while(0) + +// private, in header because of the macro. +void _sonar_init_do(sonar_t* so, PORT_P port, uint8_t ntx, PORT_P pin, uint8_t nrx); + + +/** + * Start sonar measurement + * Interrupts must be enabled + * TIMER 1 will be used for the async measurement + */ +bool sonar_start(sonar_t* so); + + +/** Handle TIMER1_OVF (returns true if consumed) */ +bool sonar_handle_t1ovf(); + + +/** Handle pin change interrupt (returns true if consumed) */ +bool sonar_handle_pci(); diff --git a/lib/porklib/spi.c b/lib/porklib/spi.c new file mode 100644 index 0000000..a651d44 --- /dev/null +++ b/lib/porklib/spi.c @@ -0,0 +1,35 @@ +#include +#include +#include + +#include "iopins.h" +#include "spi.h" + +bool spi_inited = false; + +/** Init SPI (for SD card communication) */ +void spi_init() +{ + if (spi_inited) return; + spi_inited = true; + + // Pin configuration + as_output(PIN_SS); + as_output(PIN_MOSI); + as_output(PIN_SCK); + as_input_pu(PIN_MISO); + + // Enable SPI, master, clock = F_CPU/128 + SPCR = _BV(SPE) | _BV(MSTR) | _BV(SPR0) | _BV(SPR1); +} + + +/** Write a byte to SPI. Returns received byte. */ +uint8_t spi_write(uint8_t b) +{ + SPDR = b; + while (!(SPSR & _BV(SPIF))); + + return SPDR; +} + diff --git a/lib/porklib/spi.h b/lib/porklib/spi.h new file mode 100644 index 0000000..b5103a2 --- /dev/null +++ b/lib/porklib/spi.h @@ -0,0 +1,30 @@ +#pragma once + +#include + +#include "iopins.h" + +#define PIN_MISO 12 +#define PIN_MOSI 11 +#define PIN_SCK 13 +#define PIN_SS 10 + +/** Set SS to active state (LOW) */ +#define spi_ss_enable() pin_low(PIN_SS) + +/** Set SS to disabled state (HIGH) */ +#define spi_ss_disable() pin_high(PIN_SS) + + +/** Init SPI (for SD card communication) */ +void spi_init(); + + +/** + * Write / read a byte to SPI. + * + * @param ch the written byte + * @return received byte + */ +uint8_t spi_write(uint8_t b); + diff --git a/lib/porklib/stream.c b/lib/porklib/stream.c new file mode 100644 index 0000000..fdf4bcb --- /dev/null +++ b/lib/porklib/stream.c @@ -0,0 +1,246 @@ +#include +#include +#include + +#include "stream.h" +#include "calc.h" + + +static char tmpstr[16]; // buffer for number rendering + + +void put_bytes(const STREAM *p, const uint8_t* str, const uint16_t len) +{ + for (uint16_t i = 0; i < len; i++) + { + p->tx(str[i]); + } +} + + +void put_str(const STREAM *p, const char *str) +{ + char c; + while ((c = *str++)) + { + p->tx(c); + } +} + + +void put_str_P(const STREAM *p, const char* str) +{ + char c; + while ((c = pgm_read_byte(str++))) + { + p->tx(c); + } +} + + +static void _putnf(const STREAM *p, const uint8_t places); + + +void put_c(const STREAM *p, const uint8_t c) +{ + p->tx(c); +} + +/** Send signed int8 */ +void put_u8(const STREAM *p, const uint8_t num) +{ + utoa(num, tmpstr, 10); + put_str(p, tmpstr); +} + + +/** Send unsigned int8 */ +void put_i8(const STREAM *p, const int8_t num) +{ + itoa(num, tmpstr, 10); + put_str(p, tmpstr); +} + + + +/** Send unsigned int */ +void put_u16(const STREAM *p, const uint16_t num) +{ + utoa(num, tmpstr, 10); + put_str(p, tmpstr); +} + + +/** Send signed int */ +void put_i16(const STREAM *p, const int16_t num) +{ + itoa(num, tmpstr, 10); + put_str(p, tmpstr); +} + + +/** Send unsigned long */ +void put_u32(const STREAM *p, const uint32_t num) +{ + ultoa(num, tmpstr, 10); + put_str(p, tmpstr); +} + + +/** Send signed long */ +void put_i32(const STREAM *p, const int32_t num) +{ + ltoa(num, tmpstr, 10); + put_str(p, tmpstr); +} + + +/** Print number as hex */ +void _print_hex(const STREAM *p, uint8_t* start, uint8_t bytes) +{ + for (; bytes > 0; bytes--) + { + uint8_t b = *(start + bytes - 1); + + for (uint8_t j = 0; j < 2; j++) + { + uint8_t x = high_nibble(b); + + b = b << 4; + + if (x < 0xA) + { + p->tx('0' + x); + } + else + { + p->tx('A' + (x - 0xA)); + } + } + } +} + + +/** Send unsigned int8 */ +void put_x8(const STREAM *p, const uint8_t num) +{ + _print_hex(p, (uint8_t*) &num, 1); +} + + +/** Send int as hex */ +void put_x16(const STREAM *p, const uint16_t num) +{ + _print_hex(p, (uint8_t*) &num, 2); +} + + +/** Send long as hex */ +void put_x32(const STREAM *p, const uint32_t num) +{ + _print_hex(p, (uint8_t*) &num, 4); +} + + +/** Send long long as hex */ +void put_x64(const STREAM *p, const uint64_t num) +{ + _print_hex(p, (uint8_t*) &num, 8); +} + + + +// float variant doesn't make sense for 8-bit int + +/** Send unsigned int as float */ +void put_u16f(const STREAM *p, const uint16_t num, const uint8_t places) +{ + utoa(num, tmpstr, 10); + _putnf(p, places); +} + + +/** Send signed int as float */ +void put_i16f(const STREAM *p, const int16_t num, const uint8_t places) +{ + if (num < 0) + { + p->tx('-'); + itoa(-num, tmpstr, 10); + } + else + { + itoa(num, tmpstr, 10); + } + + _putnf(p, places); +} + + +/** Send unsigned long as float */ +void put_u32f(const STREAM *p, const uint32_t num, const uint8_t places) +{ + ultoa(num, tmpstr, 10); + _putnf(p, places); +} + + +/** Send signed long as float */ +void put_i32f(const STREAM *p, const int32_t num, const uint8_t places) +{ + if (num < 0) + { + p->tx('-'); + ltoa(-num, tmpstr, 10); + } + else + { + ltoa(num, tmpstr, 10); + } + + _putnf(p, places); +} + + +/** Print number in tmp string as float with given decimal point position */ +void _putnf(const STREAM *p, const uint8_t places) +{ + // measure text length + uint8_t len = 0; + while (tmpstr[len] != 0) len++; + + int8_t at = len - places; + + // print virtual zeros + if (at <= 0) + { + p->tx('0'); + p->tx('.'); + while (at <= -1) + { + p->tx('0'); + at++; + } + at = -1; + } + + // print the number + uint8_t i = 0; + while (i < len) + { + if (at-- == 0) + { + p->tx('.'); + } + + p->tx(tmpstr[i++]); + } +} + + +/** Print CR LF */ +void put_nl(const STREAM *p) +{ + p->tx(13); + p->tx(10); +} diff --git a/lib/porklib/stream.h b/lib/porklib/stream.h new file mode 100644 index 0000000..96f13a8 --- /dev/null +++ b/lib/porklib/stream.h @@ -0,0 +1,106 @@ +#pragma once + +// +// Streams -- in this library -- are instances of type STREAM. +// +// A stream can be used for receiving and sending bytes, generally +// it's a pipe to a device. +// +// They are designed for printing numbers and strings, but can +// also be used for general data transfer. +// +// Examples of streams: +// "uart.h" -> declares global variable "uart" which is a pointer to the UART stream +// "lcd.h" -> declares a global variable "lcd" (pointer to LCD scho stream) +// +// Streams help avoid code duplication, since the same functions can be used +// to format and print data to different device types. +// + +#include +#include +#include +#include + +/** Stream structure */ +typedef struct +{ + void (*tx)(uint8_t b); + uint8_t (*rx)(void); +} STREAM; + + +/** Send bytes to stream */ +void put_bytes(const STREAM *p, const uint8_t* str, uint16_t len); + + +/** Print string into a stream */ +void put_str(const STREAM *p, const char *str); + + +/** Print a programspace string into a stream */ +void put_str_P(const STREAM *p, const char* str); + +/** Put a char/byte. Basically the same as p->tx() */ +void put_c(const STREAM *p, uint8_t c); + +/** Send signed int8 */ +void put_u8(const STREAM *p, uint8_t num); + + +/** Send unsigned int8 */ +void put_i8(const STREAM *p, int8_t num); + + +/** Send unsigned int */ +void put_u16(const STREAM *p, uint16_t num); + + +/** Send signed int */ +void put_i16(const STREAM *p, int16_t num); + + +/** Send unsigned long */ +void put_u32(const STREAM *p, uint32_t num); + + +/** Send signed long */ +void put_i32(const STREAM *p, int32_t num); + + +/** Send unsigned int8 */ +void put_x8(const STREAM *p, uint8_t num); + + +/** Send int as hex */ +void put_x16(const STREAM *p, uint16_t num); + + +/** Send long as hex */ +void put_x32(const STREAM *p, uint32_t num); + + +/** Send long long as hex */ +void put_x64(const STREAM *p, uint64_t num); + + +// float variant doesn't make sense for 8-bit int + +/** Send unsigned int as float */ +void put_u16f(const STREAM *p, uint16_t num, uint8_t places); + + +/** Send signed int as float */ +void put_i16f(const STREAM *p, int16_t num, uint8_t places); + + +/** Send unsigned long as float */ +void put_u32f(const STREAM *p, uint32_t num, uint8_t places); + + +/** Send signed long as float */ +void put_i32f(const STREAM *p, int32_t num, uint8_t places); + + +/** Print CR LF */ +void put_nl(const STREAM *p); diff --git a/lib/porklib/uart.c b/lib/porklib/uart.c new file mode 100644 index 0000000..fec7817 --- /dev/null +++ b/lib/porklib/uart.c @@ -0,0 +1,714 @@ +#include +#include +#include +#include +#include +#include + +#include "calc.h" +#include "uart.h" +#include "stream.h" + +// Shared stream instance +static STREAM _uart_singleton; +STREAM* uart = &_uart_singleton; + + +void _uart_init_do(uint16_t ubrr) +{ + /*Set baud rate */ + UBRR0H = (uint8_t)(ubrr >> 8); + UBRR0L = (uint8_t) ubrr; + + // Enable Rx and Tx + UCSR0B = (1 << RXEN0) | (1 << TXEN0); + + // 8-bit data, 1 stop bit + UCSR0C = (0b11 << UCSZ00); + + _uart_singleton.tx = &uart_tx; + _uart_singleton.rx = &uart_rx; +} + + +/** Enable or disable RX ISR */ +void uart_isr_rx(bool yes) +{ + set_bit(UCSR0B, RXCIE0, yes); +} + + +/** Enable or disable TX ISR (1 byte is sent) */ +void uart_isr_tx(bool yes) +{ + set_bit(UCSR0B, TXCIE0, yes); +} + + +/** Enable or disable DRE ISR (all is sent) */ +void uart_isr_dre(bool yes) +{ + set_bit(UCSR0B, UDRIE0, yes); +} + + +/** Send byte over UART */ +void uart_tx(uint8_t data) +{ + // Wait for transmit buffer + while (!uart_tx_ready()); + // send it + UDR0 = data; +} + + +/** Receive one byte over UART */ +uint8_t uart_rx() +{ + // Wait for data to be received + while (!uart_rx_ready()); + // Get and return received data from buffer + return UDR0; +} + + +/** Send string over UART */ +void uart_puts(const char* str) +{ + while (*str) + { + uart_tx(*str++); + } +} + + +/** Send progmem string over UART */ +void uart_puts_P(const char* str) +{ + char c; + while ((c = pgm_read_byte(str++))) + { + uart_tx(c); + } +} + + +/** Clear receive buffer */ +void uart_flush() +{ + uint8_t dummy; + while (bit_is_high(UCSR0A, RXC0)) + { + dummy = UDR0; + } +} + + +// ------------- VT100 extension -------------- + + +void _vt_apply_style(); +void _vt_reset_attribs_do(); +void _vt_style_do(); +void _vt_color_do(); + + +void vt_goto(uint8_t x, uint8_t y) +{ + uart_tx(27); + uart_tx('['); + put_u8(uart, y + 1); // one-based ! + uart_tx(';'); + put_u8(uart, x + 1); + uart_tx('H'); +} + + +void vt_goto_x(uint8_t x) +{ + uart_tx(27); + uart_tx('['); + put_u8(uart, x + 1); + uart_tx('`'); +} + + +void vt_goto_y(uint8_t y) +{ + uart_tx(27); + uart_tx('['); + put_u8(uart, y + 1); + uart_tx('d'); +} + + +void vt_move(int8_t x, int8_t y) +{ + vt_move_x(x); + vt_move_y(y); +} + + +void vt_move_x(int8_t x) +{ + if (x < 0) + { + vt_left(-x); + } + else + { + vt_right(x); + } +} + + +void vt_move_y(int8_t y) +{ + if (y < 0) + { + vt_up(-y); + } + else + { + vt_down(y); + } +} + + +void vt_up(uint8_t y) +{ + if (y == 0) return; + uart_tx(27); + uart_tx('['); + put_u8(uart, y); + uart_tx('A'); +} + + +void vt_down(uint8_t y) +{ + if (y == 0) return; + uart_tx(27); + uart_tx('['); + put_u8(uart, y); + uart_tx('B'); +} + + +void vt_left(uint8_t x) +{ + if (x == 0) return; + uart_tx(27); + uart_tx('['); + put_u8(uart, x); + uart_tx('D'); +} + + +void vt_right(uint8_t x) +{ + if (x == 0) return; + uart_tx(27); + uart_tx('['); + put_u8(uart, x); + uart_tx('C'); +} + + +void vt_scroll(int8_t y) +{ + while (y < 0) + { + uart_tx(27); + uart_tx('D'); // up + y++; + } + + while (y > 0) + { + uart_tx(27); + uart_tx('M'); // down + y--; + } +} + + +void vt_scroll_set(uint8_t from, uint8_t to) +{ + uart_tx(27); + uart_tx('['); + put_u8(uart, from); + uart_tx(';'); + put_u8(uart, to); + uart_tx('r'); +} + + +void vt_scroll_reset() +{ + uart_tx(27); + uart_tx('['); + uart_tx('r'); +} + + + +typedef struct +{ + uint8_t flags; + uint8_t fg; + uint8_t bg; +} vt_style_t; + +vt_style_t saved_style; +vt_style_t current_style; + +void vt_save() +{ + uart_puts_P(PSTR("\x1B[s")); + + saved_style = current_style; +} + + +void vt_restore() +{ + uart_puts_P(PSTR("\x1B[u")); + + current_style = saved_style; +} + + +/** Disable all text attributes (excluding color) */ +void vt_attr_reset() +{ + current_style.flags = 0; + + _vt_reset_attribs_do(); + _vt_apply_style(); +} + + +/** Set color to white on black */ +void vt_color_reset() +{ + current_style.fg = VT_WHITE; + current_style.bg = VT_BLACK; + + _vt_color_do(); +} + + +/** Enable or disable a text attribute */ +void vt_attr(uint8_t attribute, bool on) +{ + // flags are powers of two + // so this can handle multiple OR'd flags + for (uint8_t c = 1; c <= VT_FAINT; c *= 2) + { + if (attribute & c) + { + if (on) + { + current_style.flags |= c; + } + else + { + current_style.flags &= ~c; + } + } + } + + _vt_apply_style(); +} + + +/** Send style and color commands */ +void _vt_apply_style() +{ + _vt_reset_attribs_do(); + _vt_style_do(); + _vt_color_do(); +} + + +/** Set color 0..7 */ +void vt_color(uint8_t fg, uint8_t bg) +{ + current_style.fg = fg; + current_style.bg = bg; + _vt_color_do(); +} + + +/** Set FG color 0..7 */ +void vt_color_fg(uint8_t fg) +{ + current_style.fg = fg; + _vt_color_do(); +} + + +/** Set BG color 0..7 */ +void vt_color_bg(uint8_t bg) +{ + current_style.bg = bg; + _vt_color_do(); +} + + +/** Send reset command */ +inline void _vt_reset_attribs_do() +{ + uart_puts_P(PSTR("\x1B[m")); // reset +} + + +/** Send commands for text attribs */ +void _vt_style_do() +{ + if (current_style.flags & VT_BOLD) + { + uart_puts_P(PSTR("\x1B[1m")); + } + + if (current_style.flags & VT_FAINT) + { + uart_puts_P(PSTR("\x1B[2m")); + } + + if (current_style.flags & VT_ITALIC) + { + uart_puts_P(PSTR("\x1B[3m")); + } + + if (current_style.flags & VT_UNDERLINE) + { + uart_puts_P(PSTR("\x1B[4m")); + } + + if (current_style.flags & VT_BLINK) + { + uart_puts_P(PSTR("\x1B[5m")); + } + + if (current_style.flags & VT_REVERSE) + { + uart_puts_P(PSTR("\x1B[7m")); + } +} + + +/** Send commands for xolor */ +void _vt_color_do() +{ + uart_tx(27); + uart_tx('['); + put_u8(uart, 30 + current_style.fg); + uart_tx(';'); + put_u8(uart, 40 + current_style.bg); + uart_tx('m'); +} + + +/** Insert blank lines febore the current line */ +void vt_insert_lines(uint8_t count) +{ + uart_tx(27); + uart_tx('['); + put_u8(uart, count); + uart_tx('L'); +} + + +/** Delete lines from the current line down */ +void vt_delete_lines(uint8_t count) +{ + uart_tx(27); + uart_tx('['); + put_u8(uart, count); + uart_tx('M'); +} + + +/** Insert empty characters at cursor */ +void vt_insert_chars(uint8_t count) +{ + uart_tx(27); + uart_tx('['); + put_u8(uart, count); + uart_tx('@'); +} + + +/** Delete characters at cursor */ +void vt_delete_chars(uint8_t count) +{ + uart_tx(27); + uart_tx('['); + put_u8(uart, count); + uart_tx('P'); +} + + +void vt_clear() +{ + uart_puts_P(PSTR("\x1B[2J")); +} + + +void vt_erase_forth() +{ + uart_puts_P(PSTR("\x1B[K")); +} + + +void vt_erase_back() +{ + uart_puts_P(PSTR("\x1B[1K")); +} + + +void vt_erase_line() +{ + uart_puts_P(PSTR("\x1B[2K")); +} + + +void vt_erase_above() +{ + uart_puts_P(PSTR("\x1B[1J")); +} + +void vt_erase_below() +{ + uart_puts_P(PSTR("\x1B[J")); +} + + +void vt_home() +{ + uart_puts_P(PSTR("\x1B[H")); +} + + +/** Initialize helper variables */ +void vt_init() +{ + vt_reset(); +} + + +/** Reset state and clear screen */ +void vt_reset() +{ + // reset color and attributes + vt_color_reset(); + vt_attr_reset(); + vt_scroll_reset(); + + // clear screen + vt_clear(); + + // go to top left + vt_home(); + + // overwrite saved state + vt_save(); +} + + + +// Assigned keyhandler +void (*_vt_kh)(uint8_t, bool) = NULL; + +/** Assign a key handler (later used with vt_handle_key) */ +void vt_set_key_handler(void (*handler)(uint8_t, bool)) +{ + _vt_kh = handler; +} + + +// state machine states +typedef enum +{ + GROUND = 0, + ESC = 1, + BR = 2, + O = 3, + WAITING_TILDE = 4 +} KSTATE; + +// code received before started to wait for a tilde +uint8_t _before_wtilde; +// current state +KSTATE _kstate = GROUND; + + + +void _vt_kh_abort() +{ + switch (_kstate) + { + case ESC: + _vt_kh(VK_ESC, true); + break; + + case BR: + _vt_kh(VK_ESC, true); + _vt_kh('[', false); + break; + + case O: + _vt_kh(VK_ESC, true); + _vt_kh('O', false); + break; + + case WAITING_TILDE: + _vt_kh(VK_ESC, true); + _vt_kh('[', false); + vt_handle_key(_before_wtilde); + break; + + case GROUND: + // nop + break; + } + + _kstate = GROUND; +} + + +/** + * Handle a key received over UART + * Takes care of multi-byte keys and translates them to special + * constants. + */ +void vt_handle_key(uint8_t c) +{ + if (_vt_kh == NULL) return; + + switch (_kstate) + { + case GROUND: + switch (c) + { + case 27: + _kstate = ESC; + break; + + case VK_ENTER: + case VK_TAB: + case VK_BACKSPACE: + _vt_kh(c, true); + return; + + default: + _vt_kh(c, false); + return; + } + + break; // continue to next char + + case ESC: + switch (c) + { + case '[': + _kstate = BR; + break; // continue to next char + + case 'O': + _kstate = O; + break; // continue to next char + + default: + // bad code + _vt_kh_abort(); + vt_handle_key(c); + return; + } + break; + + case BR: + switch (c) + { + // arrows + case 65: + case 66: + case 67: + case 68: + _vt_kh(c, true); + _kstate = GROUND; + return; + + // ins del pgup pgdn + case 50: + case 51: + case 53: + case 54: + // wait for terminating tilde + _before_wtilde = c; + _kstate = WAITING_TILDE; + break; // continue to next char + + // bad key + default: + _vt_kh_abort(); + vt_handle_key(c); + return; + } + break; + + case O: + switch (c) + { + // F keys + case 80: + case 81: + case 82: + case 83: + // home, end + case 72: + case 70: + _vt_kh(c, true); + _kstate = GROUND; + return; + + // bad key + default: + _vt_kh_abort(); + vt_handle_key(c); + return; + } + + case WAITING_TILDE: + if (c != '~') + { + _vt_kh_abort(); + vt_handle_key(c); + return; + } + else + { + _vt_kh(_before_wtilde, true); + _kstate = GROUND; + return; + } + } + + // wait for next key + if (_kstate != GROUND) + { + _delay_ms(2); + if (!uart_rx_ready()) + { + // abort receiving + _vt_kh_abort(); + + } + else + { + vt_handle_key(uart_rx()); + } + } +} diff --git a/lib/porklib/uart.h b/lib/porklib/uart.h new file mode 100644 index 0000000..13b0775 --- /dev/null +++ b/lib/porklib/uart.h @@ -0,0 +1,253 @@ +#pragma once + +// +// Utilities for UART communication. +// +// First, init uart with desired baud rate using uart_init(baud). +// Then enable interrupts you want with uart_isr_XXX(). +// + +#include +#include +#include +#include +#include + +#include "stream.h" + +// Shared UART stream object +// Can be used with functions from stream.h once UART is initialized +extern STREAM* uart; + +/** Init UART for given baudrate */ +void _uart_init_do(uint16_t ubrr); // internal, needed for the macro. +#define uart_init(baud) _uart_init_do(F_CPU / 16 / (baud) - 1) + +/** Check if there's a byte in the RX register */ +#define uart_rx_ready() (0 != (UCSR0A & (1 << RXC0))) + +/** Check if transmission of everything is done */ +#define uart_tx_ready() (0 != (UCSR0A & (1 << UDRE0))) + + + +// Enable UART interrupts + +/** Enable or disable RX ISR */ +void uart_isr_rx(bool enable); + +/** Enable or disable TX ISR (1 byte is sent) */ +void uart_isr_tx(bool enable); + +/** Enable or disable DRE ISR (all is sent) */ +void uart_isr_dre(bool enable); + + + +// Basic IO + +/** Receive one byte over UART */ +uint8_t uart_rx(); + +/** Send byte over UART */ +#define uart_putc(data) uart_tx((data)) +void uart_tx(uint8_t data); + +/** Clear receive buffer */ +void uart_flush(); + + + +// Strings + +/** Send string over UART */ +void uart_puts(const char* str); + +/** Send progmem string over UART */ +void uart_puts_P(const char* str); + + + +// +// ANSI / VT100 utilities for UART +// +// To use this, first call uart_init(baud) and vt_init() +// To print stuff on the screen, use uart_puts() etc from uart.h +// + + +// INIT + +/** Initialize helper variables */ +void vt_init(); + +/** Reset state and clear screen */ +void vt_reset(); + + + +// CURSOR MOVE + +/** Move cursor to top left corner */ +void vt_home(); + +/** Jump to a location on the screen */ +void vt_goto(uint8_t x, uint8_t y); + +/** Jump to given X, keep Y */ +void vt_goto_x(uint8_t x); + +/** Jump to given Y, keep X */ +void vt_goto_y(uint8_t y); + +/** Move cursor relative to current location */ +void vt_move(int8_t x, int8_t y); + +/** Move cursor horizontally */ +void vt_move_x(int8_t x); + +/** Move cursor vertically */ +void vt_move_y(int8_t y); + +/** Move cursor up y cells */ +void vt_up(uint8_t y); + +/** Move cursor down y cells */ +void vt_down(uint8_t y); + +/** Move cursor left x cells */ +void vt_left(uint8_t x); + +/** Move cursor right x cells */ +void vt_right(uint8_t x); + + + +// SCROLLING + +/** Scroll y lines down (like up/down, but moves window if needed) */ +void vt_scroll(int8_t down); + +/** Set scrolling region (lines) */ +void vt_scroll_set(uint8_t from, uint8_t to); + + +/** Sets scrolling region to the entire screen. */ +void vt_scroll_reset(); + + +// COLOR + +#define VT_BLACK 0 +#define VT_RED 1 +#define VT_GREEN 2 +#define VT_YELLOW 3 +#define VT_BLUE 4 +#define VT_MAGENTA 5 +#define VT_CYAN 6 +#define VT_WHITE 7 + +/** Set color 0..7 */ +void vt_color(uint8_t fg, uint8_t bg); + +/** Set FG color 0..7 */ +void vt_color_fg(uint8_t fg); + +/** Set BG color 0..7 */ +void vt_color_bg(uint8_t bg); + +/** Set color to white on black */ +void vt_color_reset(); + + + +// STYLES + +#define VT_BOLD 1 +#define VT_UNDERLINE 2 +#define VT_BLINK 4 +#define VT_REVERSE 8 +#define VT_ITALIC 16 +#define VT_FAINT 32 + +/** Enable or disable a text attribute */ +void vt_attr(uint8_t attribute, bool on); + +/** Disable all text attributes (excluding color) */ +void vt_attr_reset(); + + + +// SAVE & RESTORE + +/** Save cursor position & text attributes */ +void vt_save(); + +/** Restore cursor to saved values */ +void vt_restore(); + + + +// MODIFY + + +/** Insert blank lines febore the current line */ +void vt_insert_lines(uint8_t count); + +/** Delete lines from the current line down */ +void vt_delete_lines(uint8_t count); + +/** Insert empty characters at cursor */ +void vt_insert_chars(uint8_t count); + +/** Delete characters at cursor */ +void vt_delete_chars(uint8_t count); + + + +// ERASING + +/** Clear the screen */ +void vt_clear(); + +/** Erase to the end of line */ +void vt_erase_forth(); + +/** Erase line to cursor */ +void vt_erase_back(); + +/** Erase entire line */ +void vt_erase_line(); + +/** Erase screen below the line */ +void vt_erase_above(); + +/** Erase screen above the line */ +void vt_erase_below(); + + + +// KEY HANDLER + +// Special keys from key handler +#define VK_LEFT 68 +#define VK_RIGHT 67 +#define VK_UP 65 +#define VK_DOWN 66 +#define VK_DELETE 51 +#define VK_INSERT 50 +#define VK_PGUP 53 +#define VK_PGDN 54 +#define VK_HOME 72 +#define VK_END 70 +#define VK_F1 80 +#define VK_F2 81 +#define VK_F3 82 +#define VK_F4 83 +#define VK_BACKSPACE 8 +#define VK_TAB 9 +#define VK_ENTER 13 +#define VK_ESC 27 + +void vt_handle_key(uint8_t c); +void vt_set_key_handler(void (*handler)(uint8_t, bool)); diff --git a/lib/porklib/wsrgb.c b/lib/porklib/wsrgb.c new file mode 100644 index 0000000..5714938 --- /dev/null +++ b/lib/porklib/wsrgb.c @@ -0,0 +1,139 @@ +#include +#include +#include + +#include "iopins.h" +#include "nsdelay.h" + +#include "wsrgb.h" +#include "color.h" +#include "ws_config.h" + + +/* Driver code for WS2812B */ + +void ws_init() +{ + as_output(WS_PIN); +} + +/** Wait long enough for the colors to show */ +void ws_show() +{ + delay_ns_c(WS_T_LATCH, 0); +} + +/** Send one byte to the RGB strip */ +void ws_send_byte(const uint8_t bb) +{ + for (volatile int8_t i = 7; i >= 0; --i) + { + if ((bb) & (1 << i)) + { + pin_high(WS_PIN); + delay_ns_c(WS_T_1H, -2); + + pin_low(WS_PIN); + delay_ns_c(WS_T_1L, -10); + } + else + { + pin_high(WS_PIN); + delay_ns_c(WS_T_0H, -2); + + pin_low(WS_PIN); + delay_ns_c(WS_T_0L, -10); + } + } +} + + +/** Send R,G,B color to the strip */ +void ws_send_rgb(const uint8_t r, const uint8_t g, const uint8_t b) +{ + ws_send_byte(g); + ws_send_byte(r); + ws_send_byte(b); +} + + +/** Send a RGB struct */ +void ws_send_xrgb(xrgb_t xrgb) +{ + ws_send_byte(xrgb.g); + ws_send_byte(xrgb.r); + ws_send_byte(xrgb.b); +} + + +/** Send color hex */ +void ws_send_rgb24(rgb24_t rgb) +{ + ws_send_byte(rgb24_g(rgb)); + ws_send_byte(rgb24_r(rgb)); + ws_send_byte(rgb24_b(rgb)); +} + +/** Send array of colors */ +void ws_send_xrgb_array(const xrgb_t rgbs[], const uint8_t length) +{ + for (uint8_t i = 0; i < length; i++) + { + const xrgb_t c = rgbs[i]; + ws_send_byte(c.g); + ws_send_byte(c.r); + ws_send_byte(c.b); + } +} + +/** Send array of colors */ +void ws_send_rgb24_array(const rgb24_t rgbs[], const uint8_t length) +{ + for (uint8_t i = 0; i < length; i++) + { + const rgb24_t c = rgbs[i]; + ws_send_byte(rgb24_g(c)); + ws_send_byte(rgb24_r(c)); + ws_send_byte(rgb24_b(c)); + } +} + +//#define ws_send_rgb24_array(rgbs, length) __ws_send_array_proto((rgbs), (length), rgb24) + +// prototype for sending array. it's ugly, sorry. +/*#define __ws_send_array_proto(rgbs, length, style) { \ + for (uint8_t __rgb_sap_i = 0; __rgb_sap_i < length; __rgb_sap_i++) { \ + style ## _t __rgb_sap2 = (rgbs)[__rgb_sap_i]; \ + ws_send_ ## style(__rgb_sap2); \ + } \ +}*/ + + +// /** Send a 2D array to a zig-zag display */ +// #define ws_send_xrgb_array_zigzag(rgbs, width, height) { \ +// int8_t __rgb_sxaz_y, __rgb_sxaz_x; \ +// for(__rgb_sxaz_y = 0; __rgb_sxaz_y < (height); __rgb_sxaz_y ++) { \ +// for(__rgb_sxaz_x = 0; __rgb_sxaz_x < (width); __rgb_sxaz_x++) { \ +// ws_send_xrgb((rgbs)[__rgb_sxaz_y][__rgb_sxaz_x]); \ +// } \ +// __rgb_sxaz_y++; \ +// for(__rgb_sxaz_x = (width) - 1; __rgb_sxaz_x >= 0; __rgb_sxaz_x--) { \ +// ws_send_xrgb((rgbs)[__rgb_sxaz_y][__rgb_sxaz_x]); \ +// } \ +// } \ +// } + + +// /* Send a linear array to a zig-zag display as a n*m board (row-by-row) +// #define ws_send_xrgb_array_zigzag_linear(rgbs, width, height) { \ +// int8_t __rgb_sxazl_x, __rgb_sxazl_y; \ +// for(__rgb_sxazl_y = 0; __rgb_sxazl_y < (height); __rgb_sxazl_y++) { \ +// for(__rgb_sxazl_x = 0; __rgb_sxazl_x < (width); __rgb_sxazl_x++) { \ +// ws_send_xrgb((rgbs)[__rgb_sxazl_y * (width) + __rgb_sxazl_x]); \ +// } \ +// __rgb_sxazl_y++; \ +// for(__rgb_sxazl_x = width-1; __rgb_sxazl_x >=0; __rgb_sxazl_x--) { \ +// ws_send_xrgb((rgbs)[__rgb_sxazl_y * (width) + __rgb_sxazl_x]); \ +// } \ +// } \ +// } diff --git a/lib/porklib/wsrgb.h b/lib/porklib/wsrgb.h new file mode 100644 index 0000000..a7d98db --- /dev/null +++ b/lib/porklib/wsrgb.h @@ -0,0 +1,53 @@ +#pragma once + +// +// Utils for driving a WS2812 RGB LED strips, and color manipulation in general. +// +// Timing is critical! +// +// Create a config file rgb_config.h next to your main.c +// + +#include + +#include "iopins.h" +#include "color.h" + +// Your config file +#include "ws_config.h" + +/* + #define WS_T_1H 700 + #define WS_T_1L 150 + #define WS_T_0H 150 + #define WS_T_0L 700 + #define WS_T_LATCH 7000 + #define WS_PIN 2 +*/ + + +// --- functions for RGB strips --- + +/** Initialize OI */ +void ws_init(); + +/** Wait long enough for the colors to show */ +void ws_show(); + +/** Send one byte to the RGB strip */ +void ws_send_byte(const uint8_t bb); + +/** Send R,G,B color to the strip */ +void ws_send_rgb(const uint8_t r, const uint8_t g, const uint8_t b); + +/** Send a RGB struct */ +void ws_send_xrgb(xrgb_t xrgb); + +/** Send color hex */ +void ws_send_rgb24(rgb24_t rgb); + +/** Send array of colors */ +void ws_send_xrgb_array(const xrgb_t rgbs[], const uint8_t length); + +/** Send array of colors */ +void ws_send_rgb24_array(const rgb24_t rgbs[], const uint8_t length); diff --git a/src/main.c b/src/main.c index ed0776d..b3f181c 100644 --- a/src/main.c +++ b/src/main.c @@ -1,46 +1,130 @@ #include "twi.h" #include "ssd1306.h" #include "sevenseg.h" +#include "adc.h" +#include "iopins.h" +#include -void main() { - TWI_Init(); +const uint16_t adc_target16_acceptable = 900; +const uint16_t adc_target16 = 972; +//const uint8_t adc_target8 = 243; +static bool g_pwm_on = false; - ssd1306_128x32_i2c_init(); -// ssd1306_128x64_spi_init(-1, 0, 1); // Use this line for nano pi (RST not used, 0=CE, gpio1=D/C) -// ssd1306_128x64_spi_init(3,4,5); // Use this line for Atmega328p (3=RST, 4=CE, 5=D/C) -// ssd1306_128x64_spi_init(24, 0, 23); // Use this line for Raspberry (gpio24=RST, 0=CE, gpio23=D/C) -// ssd1306_128x64_spi_init(22, 5, 21); // Use this line for ESP32 (VSPI) (gpio22=RST, gpio5=CE for VSPI, gpio21=D/C) -// composite_video_128x64_mono_init(); // Use this line for ESP32 with Composite video support +static volatile uint16_t tick_counter = 0; +static volatile bool tick_counter_changed = false; - ssd1306_clearScreen(); +// Tick +ISR(INT0_vect) +{ + tick_counter++; + tick_counter_changed = true; +} + +static void init_isr() { + as_input(D2); + + // using INT0 - arduino pin D2 + EICRA = _BV(ISC01) | _BV(ISC00); // rising edge + EIMSK = _BV(INT0); +} - //ssd1306_drawLine(0,0, ssd1306_displayWidth() -1, ssd1306_displayHeight() -1); +static void init_pwm_out() { + // Output is OC0A + as_output(D5); + // initialize the timer + // Fast PWM mode, Output to OC0A - const uint8_t charw = 18; - const uint8_t spacing = 6; - const uint8_t barw=4; + // clock is 16MHz, presc /64, counting to 80 -> freq 3125Hz + // Duty cycle = appx. 60% + + OCR0A = 80; + OCR0B = 46; + TCCR0A = _BV(WGM00) | _BV(WGM01); + TCCR0B = _BV(CS01) | _BV(CS00) | _BV(WGM02); +} + +static void pwm_on() { + TCCR0A |= _BV(COM0B1); + g_pwm_on = true; +} + +static void pwm_off() { + TCCR0A &= ~_BV(COM0B1); + g_pwm_on = false; +} + +void main() { + TWI_Init(); + adc_init(); + + init_pwm_out(); + + ssd1306_128x32_i2c_init(); + ssd1306_clearScreen(); struct SevenSeg sseg = { .x0 = 0, .y0 = 0, .charwidth = 17, .thick = 3, - //.charwidth = 16, - //.thick = 1, + //.charwidth = 16, + //.thick = 1, .spacing = 4, }; - uint16_t i = 0; - uint16_t v; - uint16_t w; - int drawing = false; + init_isr(); + sei(); + + // TODO show loading icon + sseg_number(&sseg, 0, 5, 0); + + // request ADC meas + adc_async_start_measure_word(0); + +// uint16_t cnt = 0; + uint16_t analog; + uint16_t count_boost_fail = 0; for (;;) { - sseg_number(&sseg, i, 5, 1); + if (adc_async_ready()) { + analog = adc_async_get_result_word(); + adc_async_start_measure_word(0); + + bool good_voltage = analog >= adc_target16; + + if (g_pwm_on) { + if (good_voltage) { + pwm_off(); + count_boost_fail = 0; + } else { + count_boost_fail++; + } + } + else if (!good_voltage) { + pwm_on(); + } + + // If fail to reach target voltage in reasonable time, + // show weak battery icon and stop trying. + if (count_boost_fail > 50000 && analog < adc_target16_acceptable) { + // TODO weak battery icon + sseg_number(&sseg, 9999, 5, 0); + pwm_off(); + + for(;;) {} + } + + // TODO synchronization? + if (tick_counter_changed) { + tick_counter_changed = false; + sseg_number(&sseg, tick_counter, 5, 0); + } - i++; - if (i == 9999) i = 0; - _delay_ms(100); +// if (++cnt > 10000) { +// sseg_number(&sseg, analog, 5, 0); +// cnt = 0; +// } + } } }