Initial commit

Author: Dilraj Gill

.gitignore

@@ -0,0 +1 @@
+*.out

.vscode/launch.json

@@ -0,0 +1,7 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": []
+}

.vscode/settings.json

@@ -0,0 +1,9 @@
+{
+    "makefile.launchConfigurations": [
+        {
+            "cwd": "/home/dilgill/school/clubs/SSS/misc/loggers/build",
+            "binaryPath": "/home/dilgill/school/clubs/SSS/misc/loggers/build/flash.out",
+            "binaryArgs": []
+        }
+    ]
+}

.vscode/tasks.json

@@ -0,0 +1,12 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558
+    // for the documentation about the tasks.json format
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "echo",
+            "type": "shell",
+            "command": "echo Hello"
+        }
+    ]
+}

TestLoggers.c.bak

@@ -0,0 +1,50 @@
+#include "mockup_flash/flash.h"
+
+int main() {
+    // Check that all regions are on start of 256 byte boundaries
+    assert(default_flash_header.events_header.start_addr % 256 == 0);
+    assert(default_flash_header.exp1_header.start_addr % 256 == 0);
+    assert(default_flash_header.exp2_header.start_addr % 256 == 0);
+    assert(default_flash_header.exp3_header.start_addr % 256 == 0);
+    assert(default_flash_header.exp4_header.start_addr % 256 == 0);
+    assert(default_flash_header.exp5_header.start_addr % 256 == 0);
+
+    init_flash_header();
+    fetch_flash_header();
+
+    // Checking that flash header was properly initialized to default
+    assert(memcmp(&flash_header, &default_flash_header, sizeof(default_flash_header)) == 0);
+
+    uint64_t page_buff[ECC_BLOCK_SIZE/8];
+    uint32_t block_addr;
+
+    // Should return the events in the correct sequence
+    assert(get_oldest_page(page_buff, &block_addr) == EVENT);
+    assert(get_oldest_page(page_buff, &block_addr) == EXP1);
+    assert(get_oldest_page(page_buff, &block_addr) == EXP2);
+    assert(get_oldest_page(page_buff, &block_addr) == EXP3);
+    assert(get_oldest_page(page_buff, &block_addr) == EXP4);
+    assert(get_oldest_page(page_buff, &block_addr) == EXP5);
+    // Should start over again from 
+    assert(get_oldest_page(page_buff, &block_addr) == EVENT);
+
+    // The mock buffer should match the flash header:
+    assert(memcmp(&flash_header, mock_flash_buff, sizeof(flash_header)) == 0);
+    
+    // After calling get_oldest_page, the flash header should be different from the default
+    assert(memcmp(&flash_header, &default_flash_header, sizeof(default_flash_header)) != 0);
+
+    // The only change should be the oldest_block_addrs for each set of logs
+    struct FlashHeader new_header = default_flash_header;
+    // events header should have rolled back to start
+    // new_header.events_header.oldest_block_addr;
+    new_header.exp1_header.oldest_block_addr += ECC_BLOCK_SIZE;
+    new_header.exp2_header.oldest_block_addr += ECC_BLOCK_SIZE;
+    new_header.exp3_header.oldest_block_addr += ECC_BLOCK_SIZE;
+    new_header.exp4_header.oldest_block_addr += ECC_BLOCK_SIZE;
+    new_header.exp5_header.oldest_block_addr += ECC_BLOCK_SIZE;
+
+    // Check that the new header matches the 
+    assert(memcmp(&flash_header, &new_header, sizeof(flash_header)) == 0);
+    assert(memcmp(&new_header, mock_flash_buff, sizeof(new_header)) == 0);
+}

event_logger.c

@@ -0,0 +1,103 @@
+#include "event_logger.h"
+#include "mockup_flash/flash.h"
+#include "fits_in_bits.h"
+
+#include <stdio.h>
+#include <stdint.h>
+#include <assert.h>
+#include <string.h>
+
+
+struct LocalEventLogs local_event_logs = {
+    .buffer_size = LOCAL_EVENT_LOG_BUFF_SIZE,
+    .tail = 0,
+    .buffer = {0}
+};
+
+// TODO: log overflows
+void handle_event_overflow() {
+    push_event_logs_to_flash(&local_event_logs);
+}
+
+uint8_t add_event_log(
+    uint64_t event_log
+) {
+    uint64_t current_log_index = local_event_logs.tail;
+
+    local_event_logs.buffer[current_log_index] = event_log;
+    
+    current_log_index++;
+    
+    if (current_log_index >= local_event_logs.buffer_size) {
+        printf("overflow\n");
+        local_event_logs.tail = 0;
+        handle_event_overflow();
+    } else {
+        local_event_logs.tail = current_log_index;
+    }
+
+    return 0;
+}
+
+uint8_t build_and_add_event_log(
+    unsigned int rtc_datetime,     // Date+Hr+Min+Sec
+    unsigned int current_mode,
+    unsigned int action,
+    unsigned int details,
+    unsigned int extra
+) {
+
+    if (   !fits_in_bits(rtc_datetime, 22)
+        || !fits_in_bits(current_mode, 4)
+        || !fits_in_bits(action, 3)
+        || !fits_in_bits(details, 24)
+        || !fits_in_bits(extra, 11)
+    ) {
+        // Gave too large a value somewhere :(
+        printf("Improper value\n");
+        return 1;
+    }
+
+    union EventLog event_log =  {.as_struct = {
+        .rtc_datetime = rtc_datetime,
+        .current_mode = current_mode,
+        .action = action,
+        .details = details,
+        .extra = extra
+    }};
+
+    add_event_log(event_log.as_uint64);
+    return 0;
+}
+
+/*
+int main() {
+
+    init_flash_header();
+    fetch_flash_header();
+
+    for (int i = 0; i < 128; ++i) {
+        build_and_add_event_log(i, 0, 0, 0, i);
+    }
+
+    printf("Local Logs:\n");
+    union EventLog ev_log;
+    for(uint32_t i = 0; i < local_event_logs.buffer_size; ++i) {
+        ev_log = (union EventLog)local_event_logs.buffer[i];
+        printf("Local ev Log #%u - rtc_time: %u, extra: %u\n", i, ev_log.as_struct.rtc_datetime, ev_log.as_struct.extra );
+    }
+    puts("A");
+
+    uint64_t block_buff[32];
+    uint32_t block_addr;
+
+    enum LogType log_type = get_oldest_page(block_buff, &block_addr);
+    assert(log_type == EVENT);
+
+    union EventLog ev_logs[sizeof(block_buff)/sizeof(union EventLog)];
+
+    static_assert(sizeof(ev_logs) >= sizeof(block_buff), "Hmm");
+
+    memcpy(ev_logs, block_buff, sizeof(ev_logs));
+}
+*/

event_logger.h

@@ -0,0 +1,87 @@
+#ifndef LOGGERS_EVENT_LOGGER_H_
+#define LOGGERS_EVENT_LOGGER_H_
+
+// #includes here... FLASH, Scheduler, RTC
+#include <stdint.h>
+/*
+ * Each log is a 64 bit word with the following breakdown:
+ *      - RTC Date-Time      - 22 bits (Date,Hr,Min,Sec in binary)
+ *      - Current Mode       -  4 bits
+ *      - Action-Detail Pair - 27 bits (Action-3, Details - 24)
+ *      - Extra              - 11 bits (potential redundancy)
+ *
+ * Details on Action-Detail pairs can be found in the Intellisat Loggers document
+ * There is 1 event buffer, which can hold [INSERT NUMBER HERE] logs.
+ */
+
+// enum Actions {
+// 		// actions here
+// };
+
+
+/**
+ * Indicates whether the events buffer overflowed
+ *
+ * @returns Boolean (0 or 1)
+ */
+int detect_event_overflow();
+
+/**
+ * Responsible for handling an event overflow
+ *
+ * This function handles an overflow by overwriting from the start
+ * of the buffer. Also logs the overflow
+ *
+ * @returns None
+ */
+void handle_event_overflow();
+
+
+// NOT PROPERLY DEFINED YET.. They should take in Details as inputs
+void log_system_oddity();
+void log_intercom();
+void log_mode_change();
+void log_exp_buffer_overflow();
+void log_exp_overflow();
+void log_event_overflow();
+
+union EventLog {
+	struct __attribute__((packed))
+	{
+        unsigned int rtc_datetime: 22;
+        unsigned int current_mode: 4;
+        unsigned int action: 3;
+        unsigned int details: 24;
+        unsigned int extra: 11;
+    } as_struct;
+	uint64_t as_uint64;
+};
+
+#define LOCAL_EVENT_LOG_COUNT 32
+#define LOCAL_EVENT_LOG_BUFF_SIZE (LOCAL_EVENT_LOG_COUNT)
+
+struct LocalEventLogs {
+    uint32_t buffer_size;
+    uint32_t tail;
+    uint64_t buffer[LOCAL_EVENT_LOG_BUFF_SIZE];
+};
+
+uint8_t get_local_event_log(uint64_t idx, struct LocalEventLogs * local_event_logs, union EventLog * const retrieved_log);
+
+uint8_t get_latest_event_log(struct LocalEventLogs * local_event_logs, union EventLog * const retrieved_log);
+
+uint8_t add_event_log( uint64_t event_log);
+
+/**
+ * Pass in event info to log. Stores event log locally.
+ * Calls 
+ */
+uint8_t build_and_add_event_log(
+    unsigned int rtc_datetime,     // Date+Hr+Min+Sec
+    unsigned int current_mode,
+    unsigned int action,
+    unsigned int details,
+    unsigned int extra
+);
+
+#endif