brandonbraun653/aurora

aurora's Issues

Create a Button Class

Buttons are really useful things to have in embedded systems, but constantly rewriting drivers for processing their behavior is not. Create a hardware independent button driver that can be configured as a virtual button or as a physical GPIO. Add things like:

• Active Polarity
• Software Debouncing
• Event Callbacks
• Options for latching and timed presses/releases

Non-Volatile Hardware Configuration Image

In many scenarios it would be useful to have a way to store and retrieve hardware peripheral configuration data for a system. Implement this functionality, building on top of the file system in #8. This will end up being useful across a wide variety of processors, so make it as generic as possible. Write from the perspective of a peripheral driver developer. What would they want to know (at a high level)?

User Stories
As a developer, I want to know if a certain peripheral is supported yet.
As a developer, I want to query various attributes about my processor's peripheral so that I can select the right settings.
As a developer, I want to know if a peripheral supports some functionality so that I can decide if an action is allowed.
As a developer, I want to know how to convert high level generic peripheral settings into the low level register settings so that I can configure hardware registers on my processor correctly.
As a developer, I want the option to locate configuration details in either internal or external flash memory at compile time.
As a developer, I want to know if the stored configuration data matches my processor.
As a developer, I want to know if the stored configuration data is valid/corrupt.
As a developer, I am concerned about the memory footprint of this driver and would like to ensure it is minimal.

Integrate RPC Tooling from eRPC

It would be extremely nice to be able to support RPC on an embedded platform by default. I was thinking of using https://github.com/EmbeddedRPC/erpc for this capability. I'd have to add my own physical layer implementation hooks based on Chimera and integrate the build system, but other than that it doesn't sound too bad.

Project Cleanup Tasks

Generic task for improving the overall structure, readability, and portability of the Aurora project

Add COBS Encoder for Networking

While looking at implementing #2 for Aurora, questions about packet framing and synchronization came up. Turns out handling errors in communications systems isn't just about tacking on a CRC to the end and calling things "good". COBS encoding gets around issues with synchronizing frames of data such that there is a guaranteed way to re-sync if data gets lost/corrupted/interrupted/etc.

https://www.embeddedrelated.com/showarticle/113.php
http://conferences.sigcomm.org/sigcomm/1997/papers/p062.pdf

Add Circular Buffer Container

Implement a circular buffer with a focus on statically allocated memory, thread safety, and ISR awareness.

Implement Observable Data Registry

Implement an observable data registry for an easy and consistent way to get system wide notification of data updates/events.

Implement Generic NOR Flash Driver

I've been noticing lately that most NOR flash devices will support a common set of commands to do basic operations such as read/write/erase, plus a standardized JEDEC interface for device identification. This lends itself to the creation of a very generic NOR flash device driver, allowing for a much wider array of memory providers to be used in my projects because I don't need to create a driver for each one.

Some things to keep in mind:

• Configurable r/w/e commands
• Maintain a table of JEDEC ids and associated device attributes for runtime discovery

Add Support For Statically Allocated but Dynamically Managed Memory Pools

Given that embedded systems don't have a plethora of memory, it's difficult to use features that require lots of new/delete operations under the hood. It would be interesting to create a generic heap manager that allows selection of allocator strategies from a fixed pool of memory. This would allow something like a linked-list of generic objects to exist without worry that fragmentation will leak into the primary heap.

Some Requirements:

• Shall use statically allocated memory (but any buffer technically works as long as it's never free'd)
• Shall allow selection of allocation strategy (think heap(1,2,3,4).c from FreeRTOS)
• Shall allow for defragmentation of the memory pool
• Shall allow for various stats that will let the user query things like total size, usage, fragmentation level, etc.

Create HMI Driver for Rotary Encoder

This is very similar to #11, but with the added bonus that now we are counting pulses and their direction. In addition to the features discussed in #11 consider adding:

• Current rotation direction
• Min/Max value of the encoder
• Current position based on min/max value

Implement File System Interface

My projects are becoming increasingly complex, to the point that I'm starting to need some kind of file system. Given that there are a multitude of embedded system focused file systems out there, I don't plan to depend on just one for all time. In order to support numerous file systems, some kind of abstraction is needed, hence this ticket.

Try and be pretty close to the POSIX API to make writing wrappers easy.

Implement Serial Command Parser

For some projects it would be useful to have a command parser for a serial terminal. I probably should use regular expressions to allow the user to attach command sequences to function executions.

https://github.com/hanickadot/compile-time-regular-expressions

Create HMI Driver for Buttons

Create a human-machine interface driver for GPIO buttons. This should be the core driver used when a project wants to consume a button of some kind.Take into account things like:

• Debouncing
• Callback mechanisms
• Activation state
• Edge triggering

Add Implementation of the Observable Pattern for Asynchronous Notifications

The capability to notify multiple parts of a system when an event occurs is extremely useful. Implement the Observer pattern in a generically thread safe way so this functionality can be utilized in projects.

Add Requirements Management System

Ideally I would love for Aurora to be written with the similar standards found in DO178B/C for safety critical systems. Part of this is having traceability between software requirements and code/tests/results. I've recently discovered that RTEMS is used for safety critical systems, some of the utilizing DO178 processes, and because they are open source, their requirements management system (Doorstop) is as well.

Use Doorstop to integrate requirements into the design process of Aurora.

Implement Lightweight RAM Database

Pretty frequently in my projects I need some kind of key/value store for random data sets. These pieces of data are of variable length in size and need to be accessed by a large number of consumers. Implement a rudimentary generic database that can be stored in RAM.

Implement a File System for Storing Data

Some kind of light-weight file system should be created to allow for storing and retrieving data on the go. It's been a needed functionality for quite a while now and it would be useful for creating things like brandonbraun653/Chimera#20.

It was decided that YAFFS will be used due to it's high reliability and extensive use in safety critical systems. This ticket will integrate YAFFS within Auora as needed.