Import fault management code from lab

And remove useless files.

prog/sources/dev-board-io.cpp

@@ -1,21 +1,28 @@
 #include "all-headers.h"
 
-static void setupIO (INIT_MODE) {
-	pinMode (L0_LED, DigitalMode::OUTPUT);
-	pinMode (L1_LED, DigitalMode::OUTPUT);
-	pinMode (L2_LED, DigitalMode::OUTPUT);
-	pinMode (L3_LED, DigitalMode::OUTPUT);
-	pinMode (L4_LED, DigitalMode::OUTPUT);
-	pinMode (TEENSY_LED, DigitalMode::OUTPUT);
+static void configurePorts (INIT_MODE) {
+	// Leds
+	pinMode (L0_LED, DigitalMode::OUTPUT) ;
+	pinMode (L1_LED, DigitalMode::OUTPUT) ;
+	pinMode (L2_LED, DigitalMode::OUTPUT) ;
+	pinMode (L3_LED, DigitalMode::OUTPUT) ;
+	pinMode (L4_LED, DigitalMode::OUTPUT) ;
 
-	pinMode (P0_PUSH_BUTTON, DigitalMode::INPUT_PULLUP);
-	pinMode (P1_PUSH_BUTTON, DigitalMode::INPUT_PULLUP);
-	pinMode (P2_PUSH_BUTTON, DigitalMode::INPUT_PULLUP);
-	pinMode (P3_PUSH_BUTTON, DigitalMode::INPUT_PULLUP);
-	pinMode (P4_PUSH_BUTTON, DigitalMode::INPUT_PULLUP);
+	// Push buttons
+	pinMode (P0_PUSH_BUTTON, DigitalMode::INPUT_PULLUP) ;
+	pinMode (P1_PUSH_BUTTON, DigitalMode::INPUT_PULLUP) ;
+	pinMode (P2_PUSH_BUTTON, DigitalMode::INPUT_PULLUP) ;
+	pinMode (P3_PUSH_BUTTON, DigitalMode::INPUT_PULLUP) ;
+	pinMode (P4_PUSH_BUTTON, DigitalMode::INPUT_PULLUP) ;
 
-	// Start teensy led
-	digitalWrite (TEENSY_LED, true);
+	// Encoder
+	pinMode (ENCODER_A, DigitalMode::INPUT_PULLUP) ;
+	pinMode (ENCODER_B, DigitalMode::INPUT_PULLUP) ;
+	pinMode (ENCODER_CLIC, DigitalMode::INPUT_PULLUP) ;
+
+	// Teensy Led
+	pinMode (DigitalPort::D13, DigitalMode::OUTPUT) ;
+	digitalWrite (DigitalPort::D13, true) ; // On
 }
 
-MACRO_INIT_ROUTINE (setupIO);
+MACRO_INIT_ROUTINE (configurePorts) ;

prog/sources/dev-board-io.h

@@ -1,18 +1,33 @@
 #pragma once
 
+
 #include "teensy-3-6-digital-io.h"
 
-static const DigitalPort L0_LED = DigitalPort::D3 ;
-static const DigitalPort L1_LED = DigitalPort::D4 ;
-static const DigitalPort L2_LED = DigitalPort::D5 ;
-static const DigitalPort L3_LED = DigitalPort::D6 ;
-static const DigitalPort L4_LED = DigitalPort::D7 ;
 
 static const DigitalPort P0_PUSH_BUTTON = DigitalPort::D8 ;
+
 static const DigitalPort P1_PUSH_BUTTON = DigitalPort::D9 ;
+
 static const DigitalPort P2_PUSH_BUTTON = DigitalPort::D10 ;
+
 static const DigitalPort P3_PUSH_BUTTON = DigitalPort::D11 ;
+
 static const DigitalPort P4_PUSH_BUTTON = DigitalPort::D12 ;
 
-static const DigitalPort TEENSY_LED = DigitalPort::D13;
 
+static const DigitalPort L0_LED = DigitalPort::D3 ;
+
+static const DigitalPort L1_LED = DigitalPort::D4 ;
+
+static const DigitalPort L2_LED = DigitalPort::D5 ;
+
+static const DigitalPort L3_LED = DigitalPort::D6 ;
+
+static const DigitalPort L4_LED = DigitalPort::D7 ;
+
+
+static const DigitalPort ENCODER_A = DigitalPort::D0 ;
+
+static const DigitalPort ENCODER_B = DigitalPort::D1 ;
+
+static const DigitalPort ENCODER_CLIC = DigitalPort::D2 ;

prog/sources/fault-handlers-assertion.cpp

@@ -0,0 +1,260 @@
+#include "all-headers.h"
+
+
+static void configureFaultRegisters (BOOT_MODE) {
+	// ACTLR register (reset value: 0)
+	// Bit 1: Disables write buffer use during default memory map accesses. This causes all bus faults to be
+	// precise, but decreases the performance of the processor because stores to memory must complete before
+	// the next instruction can be executed.
+	// Bit 0: Disables interruption of multi-cycle instructions. This increases the interrupt latency of the processor
+	// because load/store and multiply/divide operations complete before interrupt stacking occurs.
+	// SCB_ACTLR = (1 << 1) ;
+	// SHCSR register
+	// SHCSR |=
+	// (1 << 16) | // Memory Management Fault exception enable bit, set to 1 to enable; set to 0 to disable
+	// (1 << 17) | // BusFault exception enable bit, set to 1 to enable; set to 0 to disable
+	// (1 << 18) ; // UsageFault exception enable bit, set to 1 to enable; set to 0 to disable
+	// SCB_CCR register
+	SCB_CCR |=
+		(1 << 4) | // Enable UsageFault when the processor executes an SDIV or UDIV instruction with a divisor of 0
+		(1 << 3) ; // Enable UsageFault when a memory access to unaligned addresses are performed
+}
+
+
+MACRO_BOOT_ROUTINE (configureFaultRegisters) ;
+
+
+static void endlessLoop (FAULT_MODE) {
+	pinMode (L0_LED, DigitalMode::OUTPUT) ;
+	pinMode (L1_LED, DigitalMode::OUTPUT) ;
+	pinMode (L2_LED, DigitalMode::OUTPUT) ;
+	pinMode (L3_LED, DigitalMode::OUTPUT) ;
+	pinMode (L4_LED, DigitalMode::OUTPUT) ;
+	while (1) {
+		digitalToggle (L0_LED) ;
+		digitalToggle (L1_LED) ;
+		digitalToggle (L2_LED) ;
+		digitalToggle (L3_LED) ;
+		digitalToggle (L4_LED) ;
+		busyWaitDuring_faultMode (MODE_ 200);
+	}
+}
+
+
+#define MMFSR (* ((volatile uint8_t *) 0xE000ED28))
+#define MMFAR (* ((volatile uint32_t *) 0xE000ED34))
+
+#define BFSR (* ((volatile uint8_t *) 0xE000ED29))
+#define BFAR (* ((volatile uint32_t *) 0xE000ED38))
+
+#define UFSR (* ((volatile uint16_t *) 0xE000ED2A))
+
+#define AFSR (* ((volatile uint32_t *) 0xE000ED3C))
+
+
+static void handleFault (FAULT_MODE_ const char * inTitle,  const uint32_t inLinkRegisterValue) {
+	// Init Systick (LCD display requires an 1 ms timer)
+	configureSystick_faultMode (MODE) ;
+
+	pinMode (L0_LED, DigitalMode::OUTPUT) ;
+	pinMode (L1_LED, DigitalMode::OUTPUT) ;
+	pinMode (L2_LED, DigitalMode::OUTPUT) ;
+	pinMode (L3_LED, DigitalMode::OUTPUT) ;
+	pinMode (L4_LED, DigitalMode::OUTPUT) ;
+	uint32_t displayedPage = 0 ;
+	uint32_t displayCounter = 0 ;
+	bool encoderA = false ;
+	bool display = true ;
+	pinMode (ENCODER_A, DigitalMode::INPUT_PULLUP) ;
+	pinMode (ENCODER_B, DigitalMode::INPUT_PULLUP) ;
+	while (1) {
+		// Wait
+		busyWaitDuring_faultMode (MODE_ 1);
+		// Handle encoder
+		const bool currentEncoderA = digitalRead (ENCODER_A) ;
+		if (encoderA && !currentEncoderA) {
+			display = true ;
+			if (digitalRead (ENCODER_B)) {
+				displayedPage = (displayedPage + 1) % 4 ;
+			}else{
+				displayedPage = (displayedPage + 3) % 4 ;
+			}
+		}
+		encoderA = currentEncoderA ;
+		// Display
+		if (displayCounter > 0) {
+			displayCounter -= 1 ;
+		}else{
+			displayCounter = 200 ;
+			digitalToggle (L0_LED) ;
+			digitalToggle (L1_LED) ;
+			digitalToggle (L2_LED) ;
+			digitalToggle (L3_LED) ;
+			digitalToggle (L4_LED) ;
+			if (display) {
+				display = false ;
+				initScreen_faultMode (MODE) ;
+				printString_faultMode (MODE_ inTitle) ;
+				gotoLineColumn_faultMode (MODE_ 0, 19) ;
+				printUnsigned_faultMode (MODE_ displayedPage) ;
+				gotoLineColumn_faultMode (MODE_ 1, 0) ;
+				switch (displayedPage) {
+					case 0 :
+						printString_faultMode (MODE_ "SHCSR: 0x") ;
+						printHex8_faultMode (MODE_ SCB_SHCSR) ;
+						gotoLineColumn_faultMode (MODE_ 2, 0) ;
+						printString_faultMode (MODE_ "MMFSR: 0x") ;
+						printHex2_faultMode (MODE_ MMFSR) ;
+						gotoLineColumn_faultMode (MODE_ 3, 0) ;
+						printString_faultMode (MODE_ "MMFAR: 0x") ;
+						printHex8_faultMode (MODE_ MMFAR) ;
+						break ;
+					case 1 :
+						printString_faultMode (MODE_ "BFSR: 0x") ;
+						printHex2_faultMode (MODE_ BFSR) ;
+						gotoLineColumn_faultMode (MODE_ 2, 0) ;
+						printString_faultMode (MODE_ "BFAR: 0x") ;
+						printHex8_faultMode (MODE_ BFAR) ;
+						gotoLineColumn_faultMode (MODE_ 3, 0) ;
+						printString_faultMode (MODE_ "CCR: 0x") ;
+						printHex8_faultMode (MODE_ SCB_CCR) ;
+						break ;
+					case 2 :
+						printString_faultMode (MODE_ "AFSR: 0x") ;
+						printHex8_faultMode (MODE_ AFSR) ;
+						gotoLineColumn_faultMode (MODE_ 2, 0) ;
+						printString_faultMode (MODE_ "UFSR: 0x") ;
+						printHex4_faultMode (MODE_ UFSR) ;
+						break ;
+					case 3 :
+						printString_faultMode (MODE_ "LR: 0x") ;
+						printHex8_faultMode (MODE_ inLinkRegisterValue) ;
+						gotoLineColumn_faultMode (MODE_ 2, 0) ;
+						if ((inLinkRegisterValue & (1 << 2)) != 0) { // Fault occurs in user mode
+							uint32_t psp ;
+							asm ("mrs %[result], psp" : [result] "=r" (psp) ) ;
+							printString_faultMode (MODE_ "PSP: 0x") ;
+							printHex8_faultMode (MODE_ psp) ;
+							uint32_t * framePtr = (uint32_t *) psp ;
+							const uint32_t pc = framePtr [6] ;
+							gotoLineColumn_faultMode (MODE_ 3, 0) ;
+							printString_faultMode (MODE_ "PC: 0x") ;
+							printHex8_faultMode (MODE_ pc) ;
+						}else{ // Fault occurs in system mode
+							uint32_t msp ;
+							asm ("mrs %[result], msp" : [result] "=r" (msp) ) ;
+							printString_faultMode (MODE_ "MSP: 0x") ;
+							printHex8_faultMode (MODE_ msp) ;
+							uint32_t * framePtr = (uint32_t *) msp ;
+							const uint32_t pc = framePtr [6] ;
+							gotoLineColumn_faultMode (MODE_ 3, 0) ;
+							printString_faultMode (MODE_ "PC: 0x") ;
+							printHex8_faultMode (MODE_ pc) ;
+						}
+						break ;
+				}
+			}
+		}
+	}
+}
+
+
+void HardFault_handler (FAULT_MODE) {
+	// Init display
+	uint32_t linkRegisterValue ;
+	asm ("mov %[result], lr" : [result] "=r" (linkRegisterValue) ) ;
+	handleFault (MODE_ "HardFault", linkRegisterValue) ;
+}
+
+
+void MemManage_handler (FAULT_MODE) {
+	// Init display
+	uint32_t linkRegisterValue ;
+	asm ("mov %[result], lr" : [result] "=r" (linkRegisterValue) ) ;
+	handleFault (MODE_ "MemManage", linkRegisterValue) ;
+}
+
+
+void BusFault_handler (FAULT_MODE) {
+	// Init display
+	uint32_t linkRegisterValue ;
+	asm ("mov %[result], lr" : [result] "=r" (linkRegisterValue) ) ;
+	handleFault (MODE_ "BusFault", linkRegisterValue) ;
+}
+
+
+void UsageFault_handler (FAULT_MODE) {
+	// Init display
+	uint32_t linkRegisterValue ;
+	asm ("mov %[result], lr" : [result] "=r" (linkRegisterValue) ) ;
+	handleFault (MODE_ "UsageFault", linkRegisterValue) ;
+}
+
+// UNUSED INTERRUPT
+
+void unusedInterrupt (FAULT_MODE_ const uint32_t inInterruptIndex) asm ("unused.interrupt") ;
+
+void unusedInterrupt (FAULT_MODE_ const uint32_t inInterruptIndex) {
+	// Init Systick (LCD display requires an 1 ms timer)
+	configureSystick_faultMode (MODE) ;
+	// Init display
+	initScreen_faultMode (MODE) ;
+	// Title
+	printString_faultMode (MODE_ "Unhandled interrupt") ;
+	gotoLineColumn_faultMode (MODE_ 1, 0) ;
+	printUnsigned_faultMode (MODE_ inInterruptIndex) ;
+	// Endless loop
+	endlessLoop (MODE) ;
+}
+
+// ASSERTION
+
+void section_assertionFailure (FAULT_MODE_
+		const uint32_t inMessageValue,
+		const char * inFileName,
+		const int inLine) {
+	// Init Systick (LCD display requires an 1 ms timer)
+	configureSystick_faultMode (MODE) ;
+	// Init display
+	initScreen_faultMode (MODE) ;
+	// Title
+	printString_faultMode (MODE_ "Assertion Failure") ;
+	// Associated value
+	gotoLineColumn_faultMode (MODE_ 1, 0) ;
+	printString_faultMode (MODE_ "Value: ") ;
+	printUnsigned_faultMode (MODE_ inMessageValue) ;
+	// File
+	int32_t idx = (int32_t) strlen (inFileName) ;
+	bool loop = true ;
+	while ((idx > 0) && loop) {
+		idx -= 1 ;
+		loop = inFileName [idx] != '/' ;
+	}
+	gotoLineColumn_faultMode (MODE_ 2, 0) ;
+	printString_faultMode (MODE_ & inFileName [idx + 1]) ;
+	// Line
+	gotoLineColumn_faultMode (MODE_ 3, 0) ;
+	printString_faultMode (MODE_ "Line: ") ;
+	printUnsigned_faultMode (MODE_ (uint32_t) inLine) ;
+	// Endless loop
+	endlessLoop (MODE) ;
+}
+
+
+void assertion (const bool inAssertion,
+		const uint32_t inMessageValue,
+		const char * inFileName,
+		const int inLine) {
+	if (!inAssertion) {
+		assertionFailure (inMessageValue, inFileName, inLine) ;
+	}
+}
+
+
+void assertNonNullPointer (const void * inPointer,
+		const char * inFileName,
+		const int inLine) {
+	if (nullptr == inPointer) {
+		assertionFailure (0, inFileName, inLine) ;
+	}
+}

prog/sources/fault-handlers-assertion.h

@@ -0,0 +1,47 @@
+#pragma once
+
+
+#include "software-modes.h"
+
+
+//$interrupt-section HardFault
+
+void HardFault_handler (FAULT_MODE) asm ("interrupt.section.HardFault") ;
+
+
+//$interrupt-section MemManage
+
+void MemManage_handler (FAULT_MODE) asm ("interrupt.section.MemManage") ;
+
+
+//$interrupt-section BusFault
+
+void BusFault_handler (FAULT_MODE) asm ("interrupt.section.BusFault") ;
+
+
+//$interrupt-section UsageFault
+
+void UsageFault_handler (FAULT_MODE) asm ("interrupt.section.UsageFault") ;
+
+
+void assertion (const bool inAssertion,
+		const uint32_t inMessageValue,
+		const char * inFileName,
+		const int inLine) ;
+
+
+void assertNonNullPointer (const void * inPointer,
+		const char * inFileName,
+		const int inLine) ;
+
+
+//$section assertion.failure
+
+void assertionFailure (const uint32_t inMessageValue,
+		const char * inFileName,
+		const int inLine) asm ("assertion.failure") ;
+
+void section_assertionFailure (FAULT_MODE_
+		const uint32_t inMessageValue,
+		const char * inFileName,
+		const int inLine) asm ("section.assertion.failure") ;

prog/sources/lcd-wo-fault-mode.cpp

@@ -1,284 +0,0 @@
-#include "all-headers.h"
-
-#include <stddef.h>
-#include <stdbool.h>
-
-// http://esd.cs.ucr.edu/labs/interface/interface.html
-
-//   PORT CONFIGURATION                                                                                                *
-//   LCD D4 : Teensy D16
-//   LCD D5 : Teensy D15
-//   LCD D6 : Teensy D14
-//   LCD D7 : Teensy D19
-//   LCD RS : Teensy D18
-//   LCD E  : Teensy D17
-
-static const DigitalPort LCD_D4 = DigitalPort::D16 ;
-
-static const DigitalPort LCD_D5 = DigitalPort::D15 ;
-
-static const DigitalPort LCD_D6 = DigitalPort::D14 ;
-
-static const DigitalPort LCD_D7 = DigitalPort::D19 ;
-
-static const DigitalPort LCD_RS = DigitalPort::D18 ;
-
-static const DigitalPort LCD_E  = DigitalPort::D17 ;
-
-//   UTILITY ROUTINES — ANY MODE                                                                                                  *
-
-static void driveHighE (void) {
-	digitalWrite (LCD_E, true) ;
-}
-
-static void driveLowE (void) {
-	digitalWrite (LCD_E, false) ;
-}
-
-static void driveHighRS (void) {
-	digitalWrite (LCD_RS, true) ;
-}
-
-static void driveLowRS (void) {
-	digitalWrite (LCD_RS, false) ;
-}
-
-static void setD4 (const bool inValue) {
-	digitalWrite (LCD_D4, inValue) ;
-}
-
-static void setD5 (const bool inValue) {
-	digitalWrite (LCD_D5, inValue) ;
-}
-
-static void setD6 (const bool inValue) {
-	digitalWrite (LCD_D6, inValue) ;
-}
-
-static void setD7 (const bool inValue) {
-	digitalWrite (LCD_D7, inValue) ;
-}
-
-static void programLcd4BitDataBusOutput (const uint8_t inValue) {
-	setD4 ((inValue & 0x01) != 0) ;
-	setD5 ((inValue & 0x02) != 0) ;
-	setD6 ((inValue & 0x04) != 0) ;
-	setD7 ((inValue & 0x08) != 0) ;
-}
-
-//   UTILITY ROUTINES — INIT_MODE
-
-static void write4BitCommand_initMode (INIT_MODE_ const uint8_t inCommand) {
-	busyWaitDuring_initMode (MODE_ 1) ;
-	driveLowRS () ;
-	programLcd4BitDataBusOutput (inCommand) ;
-	driveHighE () ;
-	busyWaitDuring_initMode (MODE_ 1) ;
-	driveLowE () ;
-}
-
-static void write8bitCommand_initMode (INIT_MODE_ const uint8_t inCommand) {
-	busyWaitDuring_initMode (MODE_ 1) ;
-	driveLowRS () ;
-	programLcd4BitDataBusOutput ((uint8_t) (inCommand >> 4)) ;
-	driveHighE () ;
-	busyWaitDuring_initMode (MODE_ 1) ;
-	driveLowE () ;
-	busyWaitDuring_initMode (MODE_ 1) ;
-	programLcd4BitDataBusOutput (inCommand) ;
-	driveHighE () ;
-	busyWaitDuring_initMode (MODE_ 1) ;
-	driveLowE () ;
-}
-
-//   LCD INIT
-
-static void setupLCD (INIT_MODE) {
-	//--- Step 1: Configure ports
-	pinMode (LCD_D4, DigitalMode::OUTPUT) ;
-	pinMode (LCD_D5, DigitalMode::OUTPUT) ;
-	pinMode (LCD_D6, DigitalMode::OUTPUT) ;
-	pinMode (LCD_D7, DigitalMode::OUTPUT) ;
-	pinMode (LCD_RS, DigitalMode::OUTPUT) ;
-	pinMode (LCD_E,  DigitalMode::OUTPUT) ;
-	//--- Step 2: wait for 15 ms
-	busyWaitDuring_initMode (MODE_ 15) ;
-	//--- Step 3: write command 0x30
-	write4BitCommand_initMode (MODE_ 0x3) ;
-	//--- Step 4: wait for 4,1 ms (actually 5 ms)
-	busyWaitDuring_initMode (MODE_ 5) ;
-	//--- Step 5: write command 0x30 again
-	write4BitCommand_initMode (MODE_ 0x3) ;
-	//--- Step 6: wait for 100 µs (actually 1 ms)
-	busyWaitDuring_initMode (MODE_ 1) ;
-	//--- Step 7: write command 0x30 (third)
-	write4BitCommand_initMode (MODE_ 0x3) ;
-	//--- Step 8: write command 0x20 (4-bit mode)
-	write4BitCommand_initMode (MODE_ 0x2) ;
-	//--- Step 9: write command 'Set Interface Length' : 0 0 1 DL N F * *
-	//    DL : Data interface length : 0 (4 bits)
-	//    N : Number of Display lines : 1 (2 lines)
-	//    F : Character Font : 0 (5x7)
-	write8bitCommand_initMode (MODE_ 0x28) ;
-	//--- Step 10: write command 'Display Off'
-	write8bitCommand_initMode (MODE_ 0x08) ;
-	//--- Step 11: write command 'Clear Display'
-	write8bitCommand_initMode (MODE_ 0x01) ;
-	//--- Step 12: write command 'Set Cursor Move Direction' : 0 0 0 0 0 1 ID S
-	//    ID : Increment Cursor after Each Byte Written to Display : 1 (yes)
-	//    S : Shift Display When Byte Written : 0 (no)
-	write8bitCommand_initMode (MODE_ 0x06) ;
-	//--- Step 13: write command 'Move Cursor / Shift Display' : 0 0 0 1 SC RL * *
-	//    SC : Display Shift On : 1 (oui)
-	//    RL : Direction of Shift : 1 (to right)
-	write8bitCommand_initMode (MODE_ 0x1C) ;
-	//--- Step 14: write command 'Return Cursor and LCD to Home Position'
-	write8bitCommand_initMode (MODE_ 0x02) ;
-	//--- Step 15: write command 'Enable Display / Cursor' : 0 0 0 0 1 D C B
-	//    D : Turn Display On : 1 (yes)
-	//    C : Turn Cursor On : 0 (no)
-	//    B : Cursor Blink On : 0 (no)
-	write8bitCommand_initMode (MODE_ 0x0C) ;
-}
-
-MACRO_INIT_ROUTINE (setupLCD) ;
-
-//   UTILITY ROUTINES — USER MODE
-
-static void write8bitCommand (USER_MODE_ const uint8_t inCommand) {
-	busyWaitDuring (MODE_ 1) ;
-	driveLowRS () ;
-	programLcd4BitDataBusOutput ((uint8_t) (inCommand >> 4)) ;
-	driveHighE () ;
-	busyWaitDuring (MODE_ 1) ;
-	driveLowE () ;
-	busyWaitDuring (MODE_ 1) ;
-	programLcd4BitDataBusOutput (inCommand) ;
-	driveHighE () ;
-	busyWaitDuring (MODE_ 1) ;
-	driveLowE () ;
-}
-
-
-static void writeData (USER_MODE_ const uint8_t inData) {
-	busyWaitDuring (MODE_ 1) ;
-	driveHighRS () ;
-	programLcd4BitDataBusOutput (inData >> 4) ;
-	driveHighE () ;
-	busyWaitDuring (MODE_ 1) ;
-	driveLowE () ;
-	busyWaitDuring (MODE_ 1) ;
-	programLcd4BitDataBusOutput (inData) ;
-	driveHighE () ;
-	busyWaitDuring (MODE_ 1) ;
-	driveLowE () ;
-}
-
-//   PRINT ROUTINES — USER MODE
-
-void clearScreen (USER_MODE) {
-	write8bitCommand (MODE_ 0x01) ;
-}
-
-// Line 0 : 00 -> 19
-// Line 1 : 64 -> 83
-// Line 2 : 20 -> 39
-// Line 3 : 84 -> 103
-
-void gotoLineColumn (USER_MODE_ const uint32_t inLine, const uint32_t inColumn) {
-	static const uint8_t tab [4] = {0, 64, 20, 84} ;
-	if ((inLine < 4) && (inColumn < 20)) {
-		write8bitCommand (MODE_ tab [inLine] + inColumn + 0x80U) ;
-	}
-}
-
-void printString (USER_MODE_ const char * inString) {
-	if (NULL != inString) {
-		while ('\0' != *inString) {
-			writeData (MODE_ *inString) ;
-			inString ++ ;
-		}
-	}
-}
-
-void printChar (USER_MODE_ const char inChar) {
-	writeData (MODE_ inChar) ;
-}
-
-void printSpaces (USER_MODE_ const uint32_t inCount) {
-	uint32_t count = inCount ;
-	while (count > 0) {
-		printChar (MODE_ ' ') ;
-		count -- ;
-	}
-}
-
-void printUnsigned (USER_MODE_ const uint32_t inValue) {
-	uint32_t divisor = 1000 * 1000 * 1000 ; // 10**9
-	uint32_t value = inValue ;
-	bool isPrinting = false ;
-	while (divisor > 0) {
-		if (isPrinting || (value >= divisor)) {
-			printChar (MODE_ '0' + value / divisor) ;
-			value %= divisor ;
-			isPrinting = true ;
-		}
-		divisor /= 10 ;
-	}
-	if (!isPrinting) {
-		printChar (MODE_ '0') ;
-	}
-}
-
-void printUnsigned64 (USER_MODE_ const uint64_t inValue) {
-	char buffer [20] ;
-	buffer [19] = '\0' ;
-	buffer [18] = (inValue % 10) + '0' ;
-	uint32_t idx = 18 ;
-	uint64_t v = inValue / 10 ;
-	while (v != 0) {
-		idx -- ;
-		buffer [idx] = (v % 10) + '0' ;
-		v /= 10 ;
-	}
-	printString (MODE_ & buffer [idx]) ;
-}
-
-void printSigned (USER_MODE_ const int32_t inValue) {
-	if (inValue < 0) {
-		printChar (MODE_ '-') ;
-		printUnsigned (MODE_ (uint32_t) -inValue) ;
-	}else{
-		printUnsigned (MODE_ (uint32_t) inValue) ;
-	}
-}
-
-void printHex1 (USER_MODE_ const uint32_t inValue) {
-	const uint32_t v = inValue & 0xF ;
-	if (v < 10) {
-		printChar (MODE_ '0' + v) ;
-	}else{
-		printChar (MODE_ 'A' + v - 10) ;
-	}
-}
-
-void printHex2 (USER_MODE_ const uint32_t inValue) {
-	printHex1 (MODE_ inValue >> 4) ;
-	printHex1 (MODE_ inValue) ;
-}
-
-void printHex4 (USER_MODE_ const uint32_t inValue) {
-	printHex2 (MODE_ inValue >> 8) ;
-	printHex2 (MODE_ inValue) ;
-}
-
-void printHex8 (USER_MODE_ const uint32_t inValue) {
-	printHex4 (MODE_ inValue >> 16) ;
-	printHex4 (MODE_ inValue) ;
-}
-
-void printHex16 (USER_MODE_ const uint64_t inValue) {
-	printHex8 (MODE_ (uint32_t) (inValue >> 32)) ;
-	printHex8 (MODE_ (uint32_t) inValue) ;
-}
-

prog/sources/lcd.cpp

@@ -0,0 +1,467 @@
+#include "all-headers.h"
+
+
+#include <stddef.h>
+#include <stdbool.h>
+
+
+// http://esd.cs.ucr.edu/labs/interface/interface.html
+
+// PORT CONFIGURATION                                                                                                *
+// LCD D4 : Teensy D16
+// LCD D5 : Teensy D15
+// LCD D6 : Teensy D14
+// LCD D7 : Teensy D19
+// LCD RS : Teensy D18
+// LCD E  : Teensy D17
+
+static const DigitalPort LCD_D4 = DigitalPort::D16 ;
+
+static const DigitalPort LCD_D5 = DigitalPort::D15 ;
+
+static const DigitalPort LCD_D6 = DigitalPort::D14 ;
+
+static const DigitalPort LCD_D7 = DigitalPort::D19 ;
+
+static const DigitalPort LCD_RS = DigitalPort::D18 ;
+
+static const DigitalPort LCD_E  = DigitalPort::D17 ;
+
+// UTILITY ROUTINES — ANY MODE                                                                                                  *
+
+static void driveHighE (void) {
+	digitalWrite (LCD_E, true) ;
+}
+
+
+static void driveLowE (void) {
+	digitalWrite (LCD_E, false) ;
+}
+
+
+static void driveHighRS (void) {
+	digitalWrite (LCD_RS, true) ;
+}
+
+
+static void driveLowRS (void) {
+	digitalWrite (LCD_RS, false) ;
+}
+
+
+static void setD4 (const bool inValue) {
+	digitalWrite (LCD_D4, inValue) ;
+}
+
+
+static void setD5 (const bool inValue) {
+	digitalWrite (LCD_D5, inValue) ;
+}
+
+
+static void setD6 (const bool inValue) {
+	digitalWrite (LCD_D6, inValue) ;
+}
+
+
+static void setD7 (const bool inValue) {
+	digitalWrite (LCD_D7, inValue) ;
+}
+
+
+static void programLcd4BitDataBusOutput (const uint8_t inValue) {
+	setD4 ((inValue & 0x01) != 0) ;
+	setD5 ((inValue & 0x02) != 0) ;
+	setD6 ((inValue & 0x04) != 0) ;
+	setD7 ((inValue & 0x08) != 0) ;
+}
+
+// UTILITY ROUTINES — INIT_MODE
+
+static void write4BitCommand_initMode (INIT_MODE_ const uint8_t inCommand) {
+	busyWaitDuring_initMode (MODE_ 1) ;
+	driveLowRS () ;
+	programLcd4BitDataBusOutput (inCommand) ;
+	driveHighE () ;
+	busyWaitDuring_initMode (MODE_ 1) ;
+	driveLowE () ;
+}
+
+
+static void write8bitCommand_initMode (INIT_MODE_ const uint8_t inCommand) {
+	busyWaitDuring_initMode (MODE_ 1) ;
+	driveLowRS () ;
+	programLcd4BitDataBusOutput ((uint8_t) (inCommand >> 4)) ;
+	driveHighE () ;
+	busyWaitDuring_initMode (MODE_ 1) ;
+	driveLowE () ;
+	busyWaitDuring_initMode (MODE_ 1) ;
+	programLcd4BitDataBusOutput (inCommand) ;
+	driveHighE () ;
+	busyWaitDuring_initMode (MODE_ 1) ;
+	driveLowE () ;
+}
+
+// LCD INIT
+
+static void setupLCD (INIT_MODE) {
+	// Step 1: Configure ports
+	pinMode (LCD_D4, DigitalMode::OUTPUT) ;
+	pinMode (LCD_D5, DigitalMode::OUTPUT) ;
+	pinMode (LCD_D6, DigitalMode::OUTPUT) ;
+	pinMode (LCD_D7, DigitalMode::OUTPUT) ;
+	pinMode (LCD_RS, DigitalMode::OUTPUT) ;
+	pinMode (LCD_E,  DigitalMode::OUTPUT) ;
+	// Step 2: wait for 15 ms
+	busyWaitDuring_initMode (MODE_ 15) ;
+	// Step 3: write command 0x30
+	write4BitCommand_initMode (MODE_ 0x3) ;
+	// Step 4: wait for 4,1 ms (actually 5 ms)
+	busyWaitDuring_initMode (MODE_ 5) ;
+	// Step 5: write command 0x30 again
+	write4BitCommand_initMode (MODE_ 0x3) ;
+	// Step 6: wait for 100 µs (actually 1 ms)
+	busyWaitDuring_initMode (MODE_ 1) ;
+	// Step 7: write command 0x30 (third)
+	write4BitCommand_initMode (MODE_ 0x3) ;
+	// Step 8: write command 0x20 (4-bit mode)
+	write4BitCommand_initMode (MODE_ 0x2) ;
+	// Step 9: write command 'Set Interface Length' : 0 0 1 DL N F * *
+	// DL : Data interface length : 0 (4 bits)
+	// N : Number of Display lines : 1 (2 lines)
+	// F : Character Font : 0 (5x7)
+	write8bitCommand_initMode (MODE_ 0x28) ;
+	// Step 10: write command 'Display Off'
+	write8bitCommand_initMode (MODE_ 0x08) ;
+	// Step 11: write command 'Clear Display'
+	write8bitCommand_initMode (MODE_ 0x01) ;
+	// Step 12: write command 'Set Cursor Move Direction' : 0 0 0 0 0 1 ID S
+	// ID : Increment Cursor after Each Byte Written to Display : 1 (yes)
+	// S : Shift Display When Byte Written : 0 (no)
+	write8bitCommand_initMode (MODE_ 0x06) ;
+	// Step 13: write command 'Move Cursor / Shift Display' : 0 0 0 1 SC RL * *
+	// SC : Display Shift On : 1 (oui)
+	// RL : Direction of Shift : 1 (to right)
+	write8bitCommand_initMode (MODE_ 0x1C) ;
+	// Step 14: write command 'Return Cursor and LCD to Home Position'
+	write8bitCommand_initMode (MODE_ 0x02) ;
+	// Step 15: write command 'Enable Display / Cursor' : 0 0 0 0 1 D C B
+	// D : Turn Display On : 1 (yes)
+	// C : Turn Cursor On : 0 (no)
+	// B : Cursor Blink On : 0 (no)
+	write8bitCommand_initMode (MODE_ 0x0C) ;
+}
+
+
+MACRO_INIT_ROUTINE (setupLCD) ;
+
+// UTILITY ROUTINES — USER MODE
+
+static void write8bitCommand (USER_MODE_ const uint8_t inCommand) {
+	busyWaitDuring (MODE_ 1) ;
+	driveLowRS () ;
+	programLcd4BitDataBusOutput ((uint8_t) (inCommand >> 4)) ;
+	driveHighE () ;
+	busyWaitDuring (MODE_ 1) ;
+	driveLowE () ;
+	busyWaitDuring (MODE_ 1) ;
+	programLcd4BitDataBusOutput (inCommand) ;
+	driveHighE () ;
+	busyWaitDuring (MODE_ 1) ;
+	driveLowE () ;
+}
+
+
+static void writeData (USER_MODE_ const uint8_t inData) {
+	busyWaitDuring (MODE_ 1) ;
+	driveHighRS () ;
+	programLcd4BitDataBusOutput (inData >> 4) ;
+	driveHighE () ;
+	busyWaitDuring (MODE_ 1) ;
+	driveLowE () ;
+	busyWaitDuring (MODE_ 1) ;
+	programLcd4BitDataBusOutput (inData) ;
+	driveHighE () ;
+	busyWaitDuring (MODE_ 1) ;
+	driveLowE () ;
+}
+
+// PRINT ROUTINES — USER MODE
+
+void clearScreen (USER_MODE) {
+	write8bitCommand (MODE_ 0x01) ;
+}
+
+// Line 0 : 00 -> 19
+// Line 1 : 64 -> 83
+// Line 2 : 20 -> 39
+// Line 3 : 84 -> 103
+
+void gotoLineColumn (USER_MODE_ const uint32_t inLine, const uint32_t inColumn) {
+	static const uint8_t tab [4] = {0, 64, 20, 84} ;
+	if ((inLine < 4) && (inColumn < 20)) {
+		write8bitCommand (MODE_ tab [inLine] + inColumn + 0x80U) ;
+	}
+}
+
+
+void printString (USER_MODE_ const char * inString) {
+	if (NULL != inString) {
+		while ('\0' != *inString) {
+			writeData (MODE_ *inString) ;
+			inString ++ ;
+		}
+	}
+}
+
+
+void printChar (USER_MODE_ const char inChar) {
+	writeData (MODE_ inChar) ;
+}
+
+
+void printSpaces (USER_MODE_ const uint32_t inCount) {
+	uint32_t count = inCount ;
+	while (count > 0) {
+		printChar (MODE_ ' ') ;
+		count -- ;
+	}
+}
+
+
+void printUnsigned (USER_MODE_ const uint32_t inValue) {
+	uint32_t divisor = 1000 * 1000 * 1000 ; // 10**9
+	uint32_t value = inValue ;
+	bool isPrinting = false ;
+	while (divisor > 0) {
+		if (isPrinting || (value >= divisor)) {
+			printChar (MODE_ '0' + value / divisor) ;
+			value %= divisor ;
+			isPrinting = true ;
+		}
+		divisor /= 10 ;
+	}
+	if (!isPrinting) {
+		printChar (MODE_ '0') ;
+	}
+}
+
+
+void printUnsigned64 (USER_MODE_ const uint64_t inValue) {
+	char buffer [20] ;
+	buffer [19] = '\0' ;
+	buffer [18] = (inValue % 10) + '0' ;
+	uint32_t idx = 18 ;
+	uint64_t v = inValue / 10 ;
+	while (v != 0) {
+		idx -- ;
+		buffer [idx] = (v % 10) + '0' ;
+		v /= 10 ;
+	}
+	printString (MODE_ & buffer [idx]) ;
+}
+
+
+void printSigned (USER_MODE_ const int32_t inValue) {
+	if (inValue < 0) {
+		printChar (MODE_ '-') ;
+		printUnsigned (MODE_ (uint32_t) -inValue) ;
+	}else{
+		printUnsigned (MODE_ (uint32_t) inValue) ;
+	}
+}
+
+
+void printHex1 (USER_MODE_ const uint32_t inValue) {
+	const uint32_t v = inValue & 0xF ;
+	if (v < 10) {
+		printChar (MODE_ '0' + v) ;
+	}else{
+		printChar (MODE_ 'A' + v - 10) ;
+	}
+}
+
+
+void printHex2 (USER_MODE_ const uint32_t inValue) {
+	printHex1 (MODE_ inValue >> 4) ;
+	printHex1 (MODE_ inValue) ;
+}
+
+
+void printHex4 (USER_MODE_ const uint32_t inValue) {
+	printHex2 (MODE_ inValue >> 8) ;
+	printHex2 (MODE_ inValue) ;
+}
+
+
+void printHex8 (USER_MODE_ const uint32_t inValue) {
+	printHex4 (MODE_ inValue >> 16) ;
+	printHex4 (MODE_ inValue) ;
+}
+
+
+void printHex16 (USER_MODE_ const uint64_t inValue) {
+	printHex8 (MODE_ (uint32_t) (inValue >> 32)) ;
+	printHex8 (MODE_ (uint32_t) inValue) ;
+}
+
+// FAULT MODE
+
+static void write4BitCommand_faultMode (FAULT_MODE_ const uint8_t inCommand) {
+	busyWaitDuring_faultMode (MODE_ 1) ;
+	driveLowRS () ;
+	programLcd4BitDataBusOutput (inCommand) ;
+	driveHighE () ;
+	busyWaitDuring_faultMode (MODE_ 1) ;
+	driveLowE () ;
+}
+
+
+static void write8bitCommand_faultMode (FAULT_MODE_ const uint8_t inCommand) {
+	busyWaitDuring_faultMode (MODE_ 1) ;
+	driveLowRS () ;
+	programLcd4BitDataBusOutput ((uint8_t) (inCommand >> 4)) ;
+	driveHighE () ;
+	busyWaitDuring_faultMode (MODE_ 1) ;
+	driveLowE () ;
+	busyWaitDuring_faultMode (MODE_ 1) ;
+	programLcd4BitDataBusOutput (inCommand) ;
+	driveHighE () ;
+	busyWaitDuring_faultMode (MODE_ 1) ;
+	driveLowE () ;
+}
+
+
+void initScreen_faultMode (FAULT_MODE) {
+	// Step 1: Configure ports
+	pinMode (LCD_D4, DigitalMode::OUTPUT) ;
+	pinMode (LCD_D5, DigitalMode::OUTPUT) ;
+	pinMode (LCD_D6, DigitalMode::OUTPUT) ;
+	pinMode (LCD_D7, DigitalMode::OUTPUT) ;
+	pinMode (LCD_RS, DigitalMode::OUTPUT) ;
+	pinMode (LCD_E,  DigitalMode::OUTPUT) ;
+	// Step 2: wait for 15 ms
+	busyWaitDuring_faultMode (MODE_ 15) ;
+	// Step 3: write command 0x30
+	write4BitCommand_faultMode (MODE_ 0x3) ;
+	// Step 4: wait for 4,1 ms (actually 5 ms)
+	busyWaitDuring_faultMode (MODE_ 5) ;
+	// Step 5: write command 0x30 again
+	write4BitCommand_faultMode (MODE_ 0x3) ;
+	// Step 6: wait for 100 µs (actually 1 ms)
+	busyWaitDuring_faultMode (MODE_ 1) ;
+	// Step 7: write command 0x30 (third)
+	write4BitCommand_faultMode (MODE_ 0x3) ;
+	// Step 8: write command 0x20 (4-bit mode)
+	write4BitCommand_faultMode (MODE_ 0x2) ;
+	// Step 9: write command 'Set Interface Length' : 0 0 1 DL N F * *
+	// DL : Data interface length : 0 (4 bits)
+	// N : Number of Display lines : 1 (2 lines)
+	// F : Character Font : 0 (5x7)
+	write8bitCommand_faultMode (MODE_ 0x28) ;
+	// Step 10: write command 'Display Off'
+	write8bitCommand_faultMode (MODE_ 0x08) ;
+	// Step 11: write command 'Clear Display'
+	write8bitCommand_faultMode (MODE_ 0x01) ;
+	// Step 12: write command 'Set Cursor Move Direction' : 0 0 0 0 0 1 ID S
+	// ID : Increment Cursor after Each Byte Written to Display : 1 (yes)
+	// S : Shift Display When Byte Written : 0 (no)
+	write8bitCommand_faultMode (MODE_ 0x06) ;
+	// Step 13: write command 'Move Cursor / Shift Display' : 0 0 0 1 SC RL * *
+	// SC : Display Shift On : 1 (oui)
+	// RL : Direction of Shift : 1 (to right)
+	write8bitCommand_faultMode (MODE_ 0x1C) ;
+	// Step 14: write command 'Return Cursor and LCD to Home Position'
+	write8bitCommand_faultMode (MODE_ 0x02) ;
+	// Step 15: write command 'Enable Display / Cursor' : 0 0 0 0 1 D C B
+	// D : Turn Display On : 1 (yes)
+	// C : Turn Cursor On : 0 (no)
+	// B : Cursor Blink On : 0 (no)
+	write8bitCommand_faultMode (MODE_ 0x0C) ;
+}
+
+
+void gotoLineColumn_faultMode (FAULT_MODE_ const uint32_t inLine, const uint32_t inColumn) {
+	static const uint8_t tab [4] = {0, 64, 20, 84} ;
+	if ((inLine < 4) && (inColumn < 20)) {
+		write8bitCommand_faultMode (MODE_ tab [inLine] + inColumn + 0x80U) ;
+	}
+}
+
+
+static void writeData_faultMode (FAULT_MODE_ const uint8_t inData) {
+	busyWaitDuring_faultMode (MODE_ 1) ;
+	driveHighRS () ;
+	programLcd4BitDataBusOutput (inData >> 4) ;
+	driveHighE () ;
+	busyWaitDuring_faultMode (MODE_ 1) ;
+	driveLowE () ;
+	busyWaitDuring_faultMode (MODE_ 1) ;
+	programLcd4BitDataBusOutput (inData) ;
+	driveHighE () ;
+	busyWaitDuring_faultMode (MODE_ 1) ;
+	driveLowE () ;
+}
+
+
+void printString_faultMode (FAULT_MODE_ const char * inString) {
+	if (NULL != inString) {
+		while ('\0' != *inString) {
+			writeData_faultMode (MODE_ *inString) ;
+			inString ++ ;
+		}
+	}
+}
+
+
+void printChar_faultMode (FAULT_MODE_ const char inChar) {
+	writeData_faultMode (MODE_ inChar) ;
+}
+
+
+void printUnsigned_faultMode (FAULT_MODE_ const uint32_t inValue) {
+	uint32_t divisor = 1000 * 1000 * 1000 ; // 10**9
+	uint32_t value = inValue ;
+	bool isPrinting = false ;
+	while (divisor > 0) {
+		if (isPrinting || (value >= divisor)) {
+			printChar_faultMode (MODE_ '0' + value / divisor) ;
+			value %= divisor ;
+			isPrinting = true ;
+		}
+		divisor /= 10 ;
+	}
+	if (!isPrinting) {
+		printChar_faultMode (MODE_ '0') ;
+	}
+}
+
+
+static void printHex1_faultMode (FAULT_MODE_ const uint32_t inValue) {
+	const uint32_t v = inValue & 0xF ;
+	if (v < 10) {
+		printChar_faultMode (MODE_ '0' + v) ;
+	}else{
+		printChar_faultMode (MODE_ 'A' + v - 10) ;
+	}
+}
+
+
+void printHex2_faultMode (FAULT_MODE_ const uint32_t inValue) {
+	printHex1_faultMode (MODE_ inValue >> 4) ;
+	printHex1_faultMode (MODE_ inValue) ;
+}
+
+
+void printHex4_faultMode (FAULT_MODE_ const uint32_t inValue) {
+	printHex2_faultMode (MODE_ inValue >> 8) ;
+	printHex2_faultMode (MODE_ inValue) ;
+}
+
+
+void printHex8_faultMode (FAULT_MODE_ const uint32_t inValue) {
+	printHex4_faultMode (MODE_ inValue >> 16) ;
+	printHex4_faultMode (MODE_ inValue) ;
+}
+
+

prog/sources/lcd-wo-fault-mode.h

@@ -1,7 +1,10 @@
 #pragma once
 
+
 #include "software-modes.h"
 
+// USER MODE
+
 void clearScreen (USER_MODE) ;
 
 void gotoLineColumn (USER_MODE_ const uint32_t inLine, const uint32_t inColumn) ;
@@ -28,3 +31,20 @@ void printHex8 (USER_MODE_ const uint32_t inValue) ;
 
 void printHex16 (USER_MODE_ const uint64_t inValue) ;
 
+// FAULT MODE
+
+void initScreen_faultMode (FAULT_MODE) ;
+
+void gotoLineColumn_faultMode (FAULT_MODE_ const uint32_t inLine, const uint32_t inColumn) ;
+
+void printString_faultMode (FAULT_MODE_ const char * inString) ;
+
+void printChar_faultMode (FAULT_MODE_ const char inChar) ;
+
+void printUnsigned_faultMode (FAULT_MODE_ const uint32_t inValue) ;
+
+void printHex8_faultMode (FAULT_MODE_ const uint32_t inValue) ;
+
+void printHex4_faultMode (FAULT_MODE_ const uint32_t inValue) ;
+
+void printHex2_faultMode (FAULT_MODE_ const uint32_t inValue) ;

prog/sources/time.cpp

@@ -1,40 +1,53 @@
 #include "all-headers.h"
 
-static volatile uint32_t gUptime;
+// Configure systick
 
 static void startSystick (BOOT_MODE) {
+	// Configure Systick
 	SYST_RVR = CPU_MHZ * 1000 - 1 ; // Underflow every ms
 	SYST_CVR = 0 ;
 	SYST_CSR = SYST_CSR_CLKSOURCE | SYST_CSR_ENABLE ;
-
 	// Configure and chain PIT0 and PIT1 for 64-bit counting
-
 	// Power on PIT
 	SIM_SCGC6 |= SIM_SCGC6_PIT ;
-
 	// Enable PIT module
 	PIT_MCR = 0 ;
-
 	// Disable PIT0 and PIT1
 	PIT_TCTRL (0) = 0 ;
 	PIT_TCTRL (1) = 0 ;
-
 	// PIT0 and PIT1 down-count: initialize them with all 1's
 	PIT_LDVAL (0) = UINT32_MAX ;
 	PIT_LDVAL (1) = UINT32_MAX ;
-
 	// Enable PIT0 and PIT1: start counting, chain PI1 to PIT0, no interrupt
 	PIT_TCTRL (1) = PIT_TCTRL_CHN | PIT_TCTRL_TEN ;
 	PIT_TCTRL (0) = PIT_TCTRL_TEN ;
 }
 
-MACRO_BOOT_ROUTINE (startSystick);
+
+MACRO_BOOT_ROUTINE (startSystick) ;
+
 
 static void activateSystickInterrupt (INIT_MODE) {
-	SYST_CSR |= SYST_CSR_TICKINT;
+	SYST_CSR |= SYST_CSR_TICKINT ;
 }
 
-MACRO_INIT_ROUTINE (activateSystickInterrupt);
+
+MACRO_INIT_ROUTINE (activateSystickInterrupt) ;
+
+// micros current value
+
+uint64_t section_micros (SECTION_MODE) {
+	// To obtain the correct value, first read LTMR64H and then LTMR64L
+	uint64_t result = PIT_LTMR64H ;
+	result <<= 32 ;
+	result |= PIT_LTMR64L ;
+	// PIT0 and PIT1 actually downcount
+	result = ~ result ;
+	// Divide by the clock frequency in MHz for getting microsecond count
+	return result / busMHZ () ;
+}
+
+// busyWaitDuring — INIT MODE
 
 void busyWaitDuring_initMode (INIT_MODE_ const uint32_t inDelayMS) {
 	const uint32_t COUNTFLAG_MASK = 1 << 16 ;
@@ -43,48 +56,64 @@ void busyWaitDuring_initMode (INIT_MODE_ const uint32_t inDelayMS) {
 	}
 }
 
-void busyWaitDuring (USER_MODE_ const uint32_t inDelayMS) {
-	busyWaitUntil(MODE_ gUptime + inDelayMS);
+// Configure systick — FAULT MODE
+
+void configureSystick_faultMode (FAULT_MODE) {
+	// Configure Systick
+	SYST_CSR = 0 ; // Stop systick
+	SYST_RVR = CPU_MHZ * 1000 - 1 ; // Underflow every ms
+	SYST_CVR = 0 ;
+	SYST_CSR = SYST_CSR_CLKSOURCE | SYST_CSR_ENABLE ;
+}
+
+// busyWaitDuring — FAULT MODE
+
+void busyWaitDuring_faultMode (FAULT_MODE_ const uint32_t inDelayMS) {
+	const uint32_t COUNTFLAG_MASK = 1 << 16 ;
+	for (uint32_t i=0 ; i<inDelayMS ; i++) {
+		while ((SYST_CSR & COUNTFLAG_MASK) == 0) {} // Busy wait, polling COUNTFLAG
+	}
+}
+
+// millis — ANY MODE
+
+static volatile uint32_t gUptime ;
+
+
+uint32_t millis (ANY_MODE) {
+	return gUptime ;
 }
 
-void busyWaitUntil (USER_MODE_ const uint32_t inDeadLineMS) {
-	while (inDeadLineMS > gUptime) {}
+// systick — ANY MODE
+
+uint32_t systick (ANY_MODE) {
+	return SYST_CVR ;
 }
 
+// SYSTICK interrupt service routine
+
 void systickInterruptServiceRoutine (SECTION_MODE) {
 	const uint32_t newUptime = gUptime + 1 ;
 	gUptime = newUptime ;
-
-	// Run every section routines in real.time.interrupt.routine.array
+	// Run real.time.interrupt.routine.array section routines
 	extern void (* __real_time_interrupt_routine_array_start) (SECTION_MODE_ const uint32_t inUptime) ;
 	extern void (* __real_time_interrupt_routine_array_end) (SECTION_MODE_ const uint32_t inUptime) ;
-	void (** ptr) (SECTION_MODE_ const uint32_t) = & __real_time_interrupt_routine_array_start ;
+	void (* * ptr) (SECTION_MODE_ const uint32_t) = & __real_time_interrupt_routine_array_start ;
 	while (ptr != & __real_time_interrupt_routine_array_end) {
 		(* ptr) (MODE_ newUptime) ;
 		ptr ++ ;
 	}
 }
 
-uint32_t millis(ANY_MODE) {
-	return gUptime;
-}
+// busyWaitDuring, busyWaitUntil — USER MODE
 
-uint64_t section_micros(SECTION_MODE) {
-
-	// To obtain the correct value, first read LTMR64H and then LTMR64L
-	uint64_t result = PIT_LTMR64H ;
-	result <<= 32 ;
-	result |= PIT_LTMR64L ;
-
-	// PIT0 and PIT1 actually downcount
-	result = ~ result ;
+void busyWaitDuring (USER_MODE_ const uint32_t inDelayMS) {
+	busyWaitUntil (MODE_ gUptime + inDelayMS) ;
+}
 
-	// Divide by the clock frequency in MHz for getting microsecond count
-	result /= busMHZ () ;
 
-	return result;
+void busyWaitUntil (USER_MODE_ const uint32_t inDeadlineMS) {
+	while (inDeadlineMS > gUptime) {}
 }
 
-uint32_t systick(ANY_MODE) {
-	return SYST_CVR;
-}
+

prog/sources/time.h

@@ -1,28 +1,43 @@
 #pragma once
 
-#include <stdint.h>
+#include "software-modes.h"
 
-void busyWaitDuring_initMode (INIT_MODE_ const uint32_t inDelayMS);
+// INIT MODE
 
-void busyWaitDuring (USER_MODE_ const uint32_t inDelayMS);
+void busyWaitDuring_initMode (INIT_MODE_ const uint32_t inDelayMS) ;
 
-void busyWaitUntil (USER_MODE_ const uint32_t inDeadLineMS);
+// FAULT MODE
 
-// Prevent default SysTick interruption code generation
-//$interrupt-section SysTick
+void configureSystick_faultMode (FAULT_MODE) ;
+
+void busyWaitDuring_faultMode (FAULT_MODE_ const uint32_t inDelayMS) ;
+
+// USER MODE
+
+void busyWaitDuring (USER_MODE_ const uint32_t inDelayMS) ;
+
+void busyWaitUntil (USER_MODE_ const uint32_t inDeadlineMS) ;
 
-void systickInterruptServiceRoutine (SECTION_MODE) asm ("interrupt.section.SysTick");
+// ANY MODE
 
-uint32_t millis(ANY_MODE);
+uint32_t systick (ANY_MODE) ;
 
-//$section fonction.micros
+uint32_t millis (ANY_MODE) ;
 
-uint64_t micros (USER_MODE) asm ("fonction.micros") ;
+// micros current value
 
-uint64_t section_micros (SECTION_MODE) asm ("section.fonction.micros") ;
+//$section time.micros
 
+uint64_t micros (USER_MODE) asm ("time.micros") ;
+
+uint64_t section_micros (SECTION_MODE) asm ("section.time.micros") ;
+
+// INTERRUPT ROUTINE
+
+//$interrupt-section SysTick
+void systickInterruptServiceRoutine (SECTION_MODE) asm ("interrupt.section.SysTick") ;
 
-uint32_t systick(ANY_MODE);
+// Insert routine address into 'real.time.interrupt.routine.array' section
 
 #define MACRO_REAL_TIME_ISR(ROUTINE) \
 	static void (* UNIQUE_IDENTIFIER) (SECTION_MODE_ const uint32_t inUptime) \

prog/sources/unused-interrupt.s

@@ -1,17 +0,0 @@
-	.syntax unified
-	.cpu cortex-m4
-	.thumb
-
-@-----------------------------------------------------------------------------------------------------------------------
-@   UNUSED INTERRUPT
-@-----------------------------------------------------------------------------------------------------------------------
-
-  .section .text.unused.interrupt, "ax", %progbits
-
-  .align  1
-  .global unused.interrupt
-
-unused.interrupt:
-  b    unused.interrupt
-
-@-----------------------------------------------------------------------------------------------------------------------