Battery meter, save settings, set default file, beep options

Also some refactoring of the way we select files along the way.

Now you can set a default file. This won't be stable across adding
or removing files, but you can always set the default file again.

The beep setting now does something. The battery meter setting now
does something too.

Saving the settings now does something, and the settings are loaded
at startup. The .settings file is still shown in the file menu so
that it can be deleted.

Author: Gavan Fantom

Makefile

@@ -5,6 +5,7 @@ DEVICE ?= /dev/ttyUSB0
 SRCS = hello.c startup_ARMCM0.S system.c display.c font.c i2c.c speaker.c
 SRCS += spi.c spiflash.c uart.c write.c zmodem.c crc.c timer.c cli.c
 SRCS += lock.c fault.c button.c file.c frame.c fs.c menu.c settings.c
+SRCS += battery.c
 LITTLEFS = littlefs
 LITTLEFS_SRCS = lfs.c lfs_util.c
 LIBDIR = lpc/src

battery.c

@@ -0,0 +1,75 @@
+/* battery.c */
+
+#include "hello.h"
+#include "battery.h"
+#include "timer.h"
+
+void battery_read_enable(bool on);
+
+#define ADC_CR (ADC_CR_CH_SEL(1) | ADC_CR_CLKDIV(11))
+#define BATTERY_COUNT 2
+#define BATTERY_INTERVAL 1000
+
+int battery_counter;
+int battery_reading;
+
+void battery_init(void)
+{
+    battery_counter = BATTERY_COUNT;
+    LPC_IOCON->REG[IOCON_PIO1_0] = IOCON_FUNC2;
+    LPC_IOCON->REG[IOCON_PIO1_1] = IOCON_FUNC1 | IOCON_ADMODE_EN;
+    LPC_GPIO1->DIR           |= (1<<1); // output
+    battery_read_enable(false);
+    LPC_SYSCTL->PDRUNCFG &= ~0x10; // Enable power to ADC
+    Chip_Clock_EnablePeriphClock(SYSCTL_CLOCK_ADC);
+    Chip_SYSCTL_DeassertPeriphReset(RESET_ADC0);
+    LPC_ADC->CR = ADC_CR;
+    LPC_ADC->INTEN = 1<<1;
+    NVIC_EnableIRQ(ADC_IRQn);
+}
+
+void battery_read_enable(bool on)
+{
+    if (on)
+        LPC_GPIO1->DATA[DATAREG] |= (1<<1);
+    else
+        LPC_GPIO1->DATA[DATAREG] &= ~(1<<1);
+}
+
+void ADC_IRQHandler(void)
+{
+    LPC_ADC->CR = ADC_CR;
+    int data = LPC_ADC->DR[1];
+    battery_reading = data & 0xffff;
+    battery_read_enable(false);
+}
+
+void battery_read(void)
+{
+    LPC_ADC->CR = ADC_CR | ADC_CR_START_NOW;
+}
+
+void battery_poll(void)
+{
+    uint32_t time = systime_timer_get();
+    static uint32_t last_time = 0;
+    if ((time - last_time) >= BATTERY_INTERVAL) {
+        last_time = time;
+        battery_timer();
+    }
+    if (battery_counter) {
+        if (--battery_counter == 0)
+            battery_read();
+    }
+}
+
+void battery_timer(void)
+{
+    battery_read_enable(true);
+    battery_counter = BATTERY_COUNT;
+}
+
+int battery_status(void)
+{
+    return battery_reading;
+}

battery.h

@@ -0,0 +1,20 @@
+/* battery.h */
+
+#ifndef BATTERY_H
+#define BATTERY_H
+
+void battery_init(void);
+void battery_poll(void);
+void battery_timer(void);
+int battery_status(void);
+
+#define BATTERY_VREF 3300
+#define BATTERY_FULLSCALE (BATTERY_VREF * 2)
+#define BATTERY_RANGE 0xffc0
+#define BATTERY_VALUE(x) ((x) * BATTERY_FULLSCALE / BATTERY_RANGE)
+
+#define BATTERY_EMPTY      BATTERY_VALUE(3000)
+#define BATTERY_THRESHOLD  BATTERY_VALUE(3300)
+#define BATTERY_FULL       BATTERY_VALUE(4100)
+
+#endif /* BATTERY_H */

file.c

@@ -7,8 +7,7 @@
 #include "frame.h"
 #include <string.h>
 #include "menu.h"
-
-#define FIRST_FILE 2
+#include "settings.h"
 
 bool file_open;
 struct filedata filedata;
@@ -17,7 +16,7 @@ bool safe_start;
 
 void file_init(bool safe)
 {
-    dir_offset = FIRST_FILE;
+    dir_offset = settings_default_file();
     file_open = false;
     safe_start = safe;
     start_display();
@@ -134,60 +133,69 @@ void file_load(const char *filename)
         stop_display();
 }
 
-int load_file_by_offset(int target)
+char *file_read_dirent(lfs_dir_t *dir, struct lfs_info *info, bool ignore_dot)
 {
-    lfs_dir_t dir;
-    if (safe_start)
-        return 0;
-    if (file_open)
-        stop_display();
-    int err = lfs_dir_open(&fs_lfs, &dir, "/");
-    if (err) {
-        return -1;
-    }
-    struct lfs_info info;
-    int last_fileno = 0;
-    int fileno;
-    for (fileno = 0; true; fileno++) {
-        int res  = lfs_dir_read(&fs_lfs, &dir, &info);
-        if (res < 0) {
-            lfs_dir_close(&fs_lfs, &dir);
-            return res;
-        }
-        if (res == 0) {
-            if (target == FIRST_FILE) {
-                lfs_dir_close(&fs_lfs, &dir);
-                return 0;
-            }
-            fileno = -1; // This will be incremented on continue
-            if (target < 0) {
-                target = last_fileno;
-            } else {
-                target = FIRST_FILE;
-            }
-            lfs_dir_rewind(&fs_lfs, &dir);
+    while (1) {
+        int res = lfs_dir_read(&fs_lfs, dir, info);
+        if (res != 1)
+            return NULL;
+        if (info->type != LFS_TYPE_REG)
             continue;
-        }
-
-        if (fileno < target)
+        if (ignore_dot && (info->name[0] == '.'))
             continue;
+        return info->name;
+    }
+}
 
-        last_fileno = fileno;
+char *file_find(lfs_dir_t *dir, struct lfs_info *info, int fileno, bool ignore_dot)
+{
+    char *name = NULL;
+    if (lfs_dir_open(&fs_lfs, dir, "/"))
+        return NULL;
+    for (int i = 0; i <= fileno; i++) {
+        name = file_read_dirent(dir, info, ignore_dot);
+        if (!name)
+            break;
+    }
+    lfs_dir_close(&fs_lfs, dir);
+    return name;
+}
 
-        if (fileno == target) {
-            if (info.type != LFS_TYPE_REG) {
-                target++;
-                continue;
-            }
+int file_count(bool ignore_dot)
+{
+    lfs_dir_t dir;
+    struct lfs_info info;
+    int count = 0;
+    if (lfs_dir_open(&fs_lfs, &dir, "/"))
+        return 0;
+    while (file_read_dirent(&dir, &info, ignore_dot))
+        count++;
+    lfs_dir_close(&fs_lfs, &dir);
+    return count;
+}
 
-            lfs_dir_close(&fs_lfs, &dir);
-            file_load(info.name);
-            return fileno;
-        }
+int load_file_by_offset(int target)
+{
+    lfs_dir_t dir;
+    struct lfs_info info;
+    char *name = file_find(&dir, &info, target, true);
+    if (name) {
+        file_load(name);
+        return target;
     }
+    if (target < 0)
+        target = file_count(true) - 1;
+    else
+        target = 0;
+    name = file_find(&dir, &info, target, true);
+    if (name) {
+        file_load(name);
+        return target;
+    }
+    return 0;
 }
 
-void file_load_update_offset(const char *filename)
+void file_update_offset(const char *filename)
 {
     lfs_dir_t dir;
     if (file_open)
@@ -197,38 +205,39 @@ void file_load_update_offset(const char *filename)
     struct lfs_info info;
     int fileno;
     for (fileno = 0; true; fileno++) {
-        int res = lfs_dir_read(&fs_lfs, &dir, &info);
-        if (res < 0) {
-            lfs_dir_close(&fs_lfs, &dir);
+        char *name = file_read_dirent(&dir, &info, true);
+        if (!name)
             break;
-        }
-        if (info.type != LFS_TYPE_REG)
-            continue;
 
-        if (strcmp(info.name, filename) == 0) {
+        if (strcmp(name, filename) == 0) {
             dir_offset = fileno;
             break;
         }
     }
 
     lfs_dir_close(&fs_lfs, &dir);
+}
 
+void file_load_update_offset(const char *filename)
+{
+    file_update_offset(filename);
     file_load(filename);
 }
 
+void file_set_default(const char *filename)
+{
+    file_update_offset(filename);
+    settings_set_default_file(dir_offset);
+}
+
 void next_file(void)
 {
     dir_offset = load_file_by_offset(dir_offset + 1);
 }
 
 void prev_file(void)
 {
-    dir_offset--;
-    if (dir_offset < FIRST_FILE)
-        dir_offset = -1;
-    int res = load_file_by_offset(dir_offset);
-    if (dir_offset < FIRST_FILE)
-        dir_offset = res;
+    dir_offset = load_file_by_offset(dir_offset - 1);
 }
 
 void start_display(void)

file.h

@@ -3,6 +3,8 @@
 #ifndef FILE_H
 #define FILE_H
 
+#include "lfs.h"
+
 extern bool file_open;
 extern bool safe_start;
 
@@ -77,4 +79,9 @@ int load_file_by_offset(int target);
 void next_file(void);
 void prev_file(void);
 
+char *file_read_dirent(lfs_dir_t *dir, struct lfs_info *info, bool ignore_dot);
+char *file_find(lfs_dir_t *dir, struct lfs_info *info, int fileno, bool ignore_dot);
+int file_count(bool ignore_dot);
+void file_set_default(const char *filename);
+
 #endif /* FILE_H */

frame.c

@@ -13,6 +13,7 @@
 #include "lock.h"
 #include "menu.h"
 #include "settings.h"
+#include "battery.h"
 
 uint8_t frame1[1024];
 uint8_t frame2[1024];
@@ -227,6 +228,40 @@ void draw_video(uint8_t *frame)
         return;
 }
 
+#define BATTERY_PIXELS 20
+#define BATTERY_WIDTH (BATTERY_PIXELS + 6)
+
+void draw_battery(uint8_t *frame)
+{
+    int battery = battery_status();
+    if (battery < BATTERY_EMPTY)
+        battery = BATTERY_EMPTY;
+    if (battery > BATTERY_FULL)
+        battery = BATTERY_FULL;
+    battery = battery - BATTERY_EMPTY;
+    battery = battery * BATTERY_PIXELS / (BATTERY_FULL - BATTERY_EMPTY);
+    int settings = settings_battery();
+    if (settings == BATTERY_OFF)
+        return;
+    if (settings == BATTERY_WHENLOW)
+        if (battery < BATTERY_THRESHOLD)
+            return;
+    int offset = 128 - BATTERY_WIDTH;
+    frame[offset++] = 0x3c;
+    frame[offset++] = 0x24;
+    frame[offset++] = 0xe7;
+    frame[offset++] = 0x81;
+    for (int i = 0; i < BATTERY_PIXELS; i++) {
+        if (i < (BATTERY_PIXELS - battery))
+            frame[offset + i] = 0x81;
+        else
+            frame[offset + i] = 0xbd;
+    }
+    offset += BATTERY_PIXELS;
+    frame[offset++] = 0x81;
+    frame[offset++] = 0xff;
+}
+
 void FRAME_HANDLER(void)
 {
     static int contrast = 0;
@@ -268,6 +303,8 @@ void frame_update(void)
     } else {
         draw_error(screen_buf);
     }
+    draw_battery(screen_buf);
+    battery_poll();
 
     display_buf = screen_buf;
     screen_buf = (screen_buf == frame1)?frame2:frame1;