Restructure all units tests in single layered arrangement

speeduino/decoders.h

@@ -1,6 +1,8 @@
 #ifndef DECODERS_H
 #define DECODERS_H
 
+#include "globals.h"
+
 #if defined(CORE_AVR)
   #define READ_PRI_TRIGGER() ((*triggerPri_pin_port & triggerPri_pin_mask) ? true : false)
   #define READ_SEC_TRIGGER() ((*triggerSec_pin_port & triggerSec_pin_mask) ? true : false)
@@ -17,19 +19,13 @@ static inline void setFilter(unsigned long);
 static inline int crankingGetRPM(byte);
 //static inline void doPerToothTiming(uint16_t);
 
-void (*triggerHandler)(); //Pointer for the trigger function (Gets pointed to the relevant decoder)
-void (*triggerSecondaryHandler)(); //Pointer for the secondary trigger function (Gets pointed to the relevant decoder)
-uint16_t (*getRPM)(); //Pointer to the getRPM function (Gets pointed to the relevant decoder)
-int (*getCrankAngle)(); //Pointer to the getCrank Angle function (Gets pointed to the relevant decoder)
-void (*triggerSetEndTeeth)(); //Pointer to the triggerSetEndTeeth function of each decoder
-
 //All of the below are the 6 required functions for each decoder / pattern
 void triggerSetup_missingTooth();
 void triggerPri_missingTooth();
 void triggerSec_missingTooth();
 uint16_t getRPM_missingTooth();
 int getCrankAngle_missingTooth();
-void triggerSetEndTeeth_missingTooth();
+extern void triggerSetEndTeeth_missingTooth();
 
 void triggerSetup_DualWheel();
 void triggerPri_DualWheel();
@@ -144,58 +140,63 @@ uint16_t getRPM_ThirtySixMinus222();
 int getCrankAngle_ThirtySixMinus222();
 void triggerSetEndTeeth_ThirtySixMinus222();
 
-unsigned long MAX_STALL_TIME = 500000UL; //The maximum time (in uS) that the system will continue to function before the engine is considered stalled/stopped. This is unique to each decoder, depending on the number of teeth etc. 500000 (half a second) is used as the default value, most decoders will be much less.
-
-volatile unsigned long curTime;
-volatile unsigned long curGap;
-volatile unsigned long curTime2;
-volatile unsigned long curGap2;
-volatile unsigned long lastGap;
-volatile unsigned long targetGap;
-volatile unsigned long compositeLastToothTime;
-
-volatile uint16_t toothCurrentCount = 0; //The current number of teeth (Onec sync has been achieved, this can never actually be 0
-volatile byte toothSystemCount = 0; //Used for decoders such as Audi 135 where not every tooth is used for calculating crank angle. This variable stores the actual number of teeth, not the number being used to calculate crank angle
-volatile unsigned long toothSystemLastToothTime = 0; //As below, but used for decoders where not every tooth count is used for calculation
-volatile unsigned long toothLastToothTime = 0; //The time (micros()) that the last tooth was registered
-volatile unsigned long toothLastSecToothTime = 0; //The time (micros()) that the last tooth was registered on the secondary input
-volatile unsigned long toothLastMinusOneToothTime = 0; //The time (micros()) that the tooth before the last tooth was registered
+extern void (*triggerHandler)(); //Pointer for the trigger function (Gets pointed to the relevant decoder)
+extern void (*triggerSecondaryHandler)(); //Pointer for the secondary trigger function (Gets pointed to the relevant decoder)
+extern uint16_t (*getRPM)(); //Pointer to the getRPM function (Gets pointed to the relevant decoder)
+extern int (*getCrankAngle)(); //Pointer to the getCrank Angle function (Gets pointed to the relevant decoder)
+extern void (*triggerSetEndTeeth)(); //Pointer to the triggerSetEndTeeth function of each decoder
+
+extern volatile unsigned long curTime;
+extern volatile unsigned long curGap;
+extern volatile unsigned long curTime2;
+extern volatile unsigned long curGap2;
+extern volatile unsigned long lastGap;
+extern volatile unsigned long targetGap;
+extern volatile unsigned long compositeLastToothTime;
+
+extern unsigned long MAX_STALL_TIME; //The maximum time (in uS) that the system will continue to function before the engine is considered stalled/stopped. This is unique to each decoder, depending on the number of teeth etc. 500000 (half a second) is used as the default value, most decoders will be much less.
+extern volatile uint16_t toothCurrentCount; //The current number of teeth (Onec sync has been achieved, this can never actually be 0
+extern volatile byte toothSystemCount; //Used for decoders such as Audi 135 where not every tooth is used for calculating crank angle. This variable stores the actual number of teeth, not the number being used to calculate crank angle
+extern volatile unsigned long toothSystemLastToothTime; //As below, but used for decoders where not every tooth count is used for calculation
+extern volatile unsigned long toothLastToothTime; //The time (micros()) that the last tooth was registered
+extern volatile unsigned long toothLastSecToothTime; //The time (micros()) that the last tooth was registered on the secondary input
+extern volatile unsigned long toothLastMinusOneToothTime; //The time (micros()) that the tooth before the last tooth was registered
 #ifndef SMALL_FLASH_MODE
-volatile unsigned long toothLastMinusOneSecToothTime = 0; //The time (micros()) that the tooth before the last tooth was registered on secondary input
-volatile unsigned long targetGap2;
+extern volatile unsigned long toothLastMinusOneSecToothTime; //The time (micros()) that the tooth before the last tooth was registered on secondary input
+extern volatile unsigned long targetGap2;
 #endif
-volatile unsigned long toothOneTime = 0; //The time (micros()) that tooth 1 last triggered
-volatile unsigned long toothOneMinusOneTime = 0; //The 2nd to last time (micros()) that tooth 1 last triggered
-volatile bool revolutionOne = 0; // For sequential operation, this tracks whether the current revolution is 1 or 2 (not 1)
-
-volatile unsigned int secondaryToothCount; //Used for identifying the current secondary (Usually cam) tooth for patterns with multiple secondary teeth
-volatile unsigned long secondaryLastToothTime = 0; //The time (micros()) that the last tooth was registered (Cam input)
-volatile unsigned long secondaryLastToothTime1 = 0; //The time (micros()) that the last tooth was registered (Cam input)
-
-volatile uint16_t triggerActualTeeth;
-volatile unsigned long triggerFilterTime; // The shortest time (in uS) that pulses will be accepted (Used for debounce filtering)
-volatile unsigned long triggerSecFilterTime; // The shortest time (in uS) that pulses will be accepted (Used for debounce filtering) for the secondary input
-volatile bool validTrigger; //Is set true when the last trigger (Primary or secondary) was valid (ie passed filters)
-unsigned int triggerSecFilterTime_duration; // The shortest valid time (in uS) pulse DURATION
-volatile uint16_t triggerToothAngle; //The number of crank degrees that elapse per tooth
-volatile bool triggerToothAngleIsCorrect = false; //Whether or not the triggerToothAngle variable is currently accurate. Some patterns have times when the triggerToothAngle variable cannot be accurately set.
-bool secondDerivEnabled = false; //The use of the 2nd derivative calculation is limited to certain decoders. This is set to either true or false in each decoders setup routine
-bool decoderIsSequential; //Whether or not the decoder supports sequential operation
-bool decoderIsLowRes = false; //Is set true, certain extra calculations are performed for better timing accuracy
-bool decoderHasSecondary = false; //Whether or not the pattern uses a secondary input
-bool decoderHasFixedCrankingTiming = false; //Whether or not the decoder supports fixed cranking timing
-byte checkSyncToothCount; //How many teeth must've been seen on this revolution before we try to confirm sync (Useful for missing tooth type decoders)
-unsigned long elapsedTime;
-unsigned long lastCrankAngleCalc;
-int16_t lastToothCalcAdvance = 99; //Invalid value here forces calculation of this on first main loop
-unsigned long lastVVTtime; //The time between the vvt reference pulse and the last crank pulse
-
-uint16_t ignition1EndTooth = 0;
-uint16_t ignition2EndTooth = 0;
-uint16_t ignition3EndTooth = 0;
-uint16_t ignition4EndTooth = 0;
-
-int16_t toothAngles[24]; //An array for storing fixed tooth angles. Currently sized at 24 for the GM 24X decoder, but may grow later if there are other decoders that use this style
+extern volatile unsigned long toothOneTime; //The time (micros()) that tooth 1 last triggered
+extern volatile unsigned long toothOneMinusOneTime; //The 2nd to last time (micros()) that tooth 1 last triggered
+extern volatile bool revolutionOne; // For sequential operation, this tracks whether the current revolution is 1 or 2 (not 1)
+
+extern volatile unsigned int secondaryToothCount; //Used for identifying the current secondary (Usually cam) tooth for patterns with multiple secondary teeth
+extern volatile unsigned long secondaryLastToothTime; //The time (micros()) that the last tooth was registered (Cam input)
+extern volatile unsigned long secondaryLastToothTime1; //The time (micros()) that the last tooth was registered (Cam input)
+
+extern volatile uint16_t triggerActualTeeth;
+extern volatile unsigned long triggerFilterTime; // The shortest time (in uS) that pulses will be accepted (Used for debounce filtering)
+extern volatile unsigned long triggerSecFilterTime; // The shortest time (in uS) that pulses will be accepted (Used for debounce filtering) for the secondary input
+extern volatile bool validTrigger; //Is set true when the last trigger (Primary or secondary) was valid (ie passed filters)
+extern unsigned int triggerSecFilterTime_duration; // The shortest valid time (in uS) pulse DURATION
+extern volatile uint16_t triggerToothAngle; //The number of crank degrees that elapse per tooth
+extern volatile bool triggerToothAngleIsCorrect; //Whether or not the triggerToothAngle variable is currently accurate. Some patterns have times when the triggerToothAngle variable cannot be accurately set.
+extern bool secondDerivEnabled; //The use of the 2nd derivative calculation is limited to certain decoders. This is set to either true or false in each decoders setup routine
+extern bool decoderIsSequential; //Whether or not the decoder supports sequential operation
+extern bool decoderIsLowRes; //Is set true, certain extra calculations are performed for better timing accuracy
+extern bool decoderHasSecondary; //Whether or not the pattern uses a secondary input
+extern bool decoderHasFixedCrankingTiming; //Whether or not the decoder supports fixed cranking timing
+extern byte checkSyncToothCount; //How many teeth must've been seen on this revolution before we try to confirm sync (Useful for missing tooth type decoders)
+extern unsigned long elapsedTime;
+extern unsigned long lastCrankAngleCalc;
+extern int16_t lastToothCalcAdvance; //Invalid value here forces calculation of this on first main loop
+extern unsigned long lastVVTtime; //The time between the vvt reference pulse and the last crank pulse
+
+extern uint16_t ignition1EndTooth;
+extern uint16_t ignition2EndTooth;
+extern uint16_t ignition3EndTooth;
+extern uint16_t ignition4EndTooth;
+
+extern int16_t toothAngles[24]; //An array for storing fixed tooth angles. Currently sized at 24 for the GM 24X decoder, but may grow later if there are other decoders that use this style
 
 //Used for identifying long and short pulses on the 4G63 (And possibly other) trigger patterns
 #define LONG 0;

speeduino/decoders.ino

@@ -27,6 +27,65 @@ toothLastToothTime - The time (In uS) that the last primary tooth was 'seen'
 #include "scheduler.h"
 #include "crankMaths.h"
 
+void (*triggerHandler)(); //Pointer for the trigger function (Gets pointed to the relevant decoder)
+void (*triggerSecondaryHandler)(); //Pointer for the secondary trigger function (Gets pointed to the relevant decoder)
+uint16_t (*getRPM)(); //Pointer to the getRPM function (Gets pointed to the relevant decoder)
+int (*getCrankAngle)(); //Pointer to the getCrank Angle function (Gets pointed to the relevant decoder)
+void (*triggerSetEndTeeth)(); //Pointer to the triggerSetEndTeeth function of each decoder
+
+volatile unsigned long curTime;
+volatile unsigned long curGap;
+volatile unsigned long curTime2;
+volatile unsigned long curGap2;
+volatile unsigned long lastGap;
+volatile unsigned long targetGap;
+volatile unsigned long compositeLastToothTime;
+
+unsigned long MAX_STALL_TIME = 500000UL; //The maximum time (in uS) that the system will continue to function before the engine is considered stalled/stopped. This is unique to each decoder, depending on the number of teeth etc. 500000 (half a second) is used as the default value, most decoders will be much less.
+volatile uint16_t toothCurrentCount = 0; //The current number of teeth (Onec sync has been achieved, this can never actually be 0
+volatile byte toothSystemCount = 0; //Used for decoders such as Audi 135 where not every tooth is used for calculating crank angle. This variable stores the actual number of teeth, not the number being used to calculate crank angle
+volatile unsigned long toothSystemLastToothTime = 0; //As below, but used for decoders where not every tooth count is used for calculation
+volatile unsigned long toothLastToothTime = 0; //The time (micros()) that the last tooth was registered
+volatile unsigned long toothLastSecToothTime = 0; //The time (micros()) that the last tooth was registered on the secondary input
+volatile unsigned long toothLastMinusOneToothTime = 0; //The time (micros()) that the tooth before the last tooth was registered
+#ifndef SMALL_FLASH_MODE
+volatile unsigned long toothLastMinusOneSecToothTime = 0; //The time (micros()) that the tooth before the last tooth was registered on secondary input
+volatile unsigned long targetGap2;
+#endif
+volatile unsigned long toothOneTime = 0; //The time (micros()) that tooth 1 last triggered
+volatile unsigned long toothOneMinusOneTime = 0; //The 2nd to last time (micros()) that tooth 1 last triggered
+volatile bool revolutionOne = 0; // For sequential operation, this tracks whether the current revolution is 1 or 2 (not 1)
+
+volatile unsigned int secondaryToothCount; //Used for identifying the current secondary (Usually cam) tooth for patterns with multiple secondary teeth
+volatile unsigned long secondaryLastToothTime = 0; //The time (micros()) that the last tooth was registered (Cam input)
+volatile unsigned long secondaryLastToothTime1 = 0; //The time (micros()) that the last tooth was registered (Cam input)
+
+volatile uint16_t triggerActualTeeth;
+volatile unsigned long triggerFilterTime; // The shortest time (in uS) that pulses will be accepted (Used for debounce filtering)
+volatile unsigned long triggerSecFilterTime; // The shortest time (in uS) that pulses will be accepted (Used for debounce filtering) for the secondary input
+volatile bool validTrigger; //Is set true when the last trigger (Primary or secondary) was valid (ie passed filters)
+unsigned int triggerSecFilterTime_duration; // The shortest valid time (in uS) pulse DURATION
+volatile uint16_t triggerToothAngle; //The number of crank degrees that elapse per tooth
+volatile bool triggerToothAngleIsCorrect = false; //Whether or not the triggerToothAngle variable is currently accurate. Some patterns have times when the triggerToothAngle variable cannot be accurately set.
+bool secondDerivEnabled = false; //The use of the 2nd derivative calculation is limited to certain decoders. This is set to either true or false in each decoders setup routine
+bool decoderIsSequential; //Whether or not the decoder supports sequential operation
+bool decoderIsLowRes = false; //Is set true, certain extra calculations are performed for better timing accuracy
+bool decoderHasSecondary = false; //Whether or not the pattern uses a secondary input
+bool decoderHasFixedCrankingTiming = false; //Whether or not the decoder supports fixed cranking timing
+byte checkSyncToothCount; //How many teeth must've been seen on this revolution before we try to confirm sync (Useful for missing tooth type decoders)
+unsigned long elapsedTime;
+unsigned long lastCrankAngleCalc;
+int16_t lastToothCalcAdvance = 99; //Invalid value here forces calculation of this on first main loop
+unsigned long lastVVTtime; //The time between the vvt reference pulse and the last crank pulse
+
+uint16_t ignition1EndTooth = 0;
+uint16_t ignition2EndTooth = 0;
+uint16_t ignition3EndTooth = 0;
+uint16_t ignition4EndTooth = 0;
+
+int16_t toothAngles[24]; //An array for storing fixed tooth angles. Currently sized at 24 for the GM 24X decoder, but may grow later if there are other decoders that use this style
+
+
 /*
 *
 * whichTooth - 0 for Primary (Crank), 1 for Secondary (Cam)

speeduino/globals.h

@@ -157,8 +157,13 @@
 #define VALID_MAP_MAX 1022 //The largest ADC value that is valid for the MAP sensor
 #define VALID_MAP_MIN 2 //The smallest ADC value that is valid for the MAP sensor
 
+#ifndef UNIT_TEST 
 #define TOOTH_LOG_SIZE      127
 #define TOOTH_LOG_BUFFER    128 //256
+#else
+#define TOOTH_LOG_SIZE      1
+#define TOOTH_LOG_BUFFER    1 //256
+#endif
 
 #define COMPOSITE_LOG_PRI   0
 #define COMPOSITE_LOG_SEC   1

test/tests/test_decoders/missing_tooth/missing_tooth.cpp

@@ -0,0 +1,41 @@
+#include <decoders.h>
+#include <globals.h>
+#include <unity.h>
+#include "missing_tooth.h"
+
+
+void test_setup_36_1()
+{
+    //Setup a 36-1 wheel
+    configPage4.triggerTeeth = 36;
+    configPage4.triggerMissingTeeth = 1;
+    configPage4.TrigSpeed = CRANK_SPEED;
+    configPage4.trigPatternSec = SEC_TRIGGER_SINGLE;
+
+    triggerSetup_missingTooth();
+}
+
+void test_missingtooth_newIgn_1()
+{
+
+    test_setup_36_1();
+    configPage4.sparkMode = IGN_MODE_WASTED;
+    ignition1EndAngle = 350; //Set 10 degrees advance
+    configPage4.triggerAngle = 0; //No trigger offset
+
+    triggerSetEndTeeth_missingTooth();
+    TEST_ASSERT_EQUAL(ignition1EndTooth, 34);
+
+}
+void test_missingtooth_newIgn_2()
+{
+
+}
+void test_missingtooth_newIgn_3()
+{
+
+}
+void test_missingtooth_newIgn_4()
+{
+
+}

test/tests/test_decoders/missing_tooth/missing_tooth.h

@@ -0,0 +1,5 @@
+
+void test_missingtooth_newIgn_1();
+void test_missingtooth_newIgn_3();
+void test_missingtooth_newIgn_3();
+void test_missingtooth_newIgn_4();

test/tests/test_decoders/test_decoders.cpp

@@ -0,0 +1,11 @@
+
+#include <Arduino.h>
+#include <unity.h>
+
+#include "test_decoders.h"
+#include "missing_tooth/missing_tooth.h"
+
+void testDecoders()
+{
+    RUN_TEST(test_missingtooth_newIgn_1);
+}

test/tests/test_decoders/test_decoders.h

@@ -0,0 +1,6 @@
+#if !defined(__TEST_DECODERS_H__)
+#define __TEST_DECODERS_H__
+
+void testDecoders();
+
+#endif // __TEST_DECODERS_H__

test/test_generic/tests_init.cpp → test/tests/test_misc/tests_init.cpp

@@ -18,9 +18,14 @@ void test_initialisation_complete(void)
 
 void test_initialisation_ports(void)
 {
-  //initialiseAll(); //Run the main initialise function
+  //Test that all the port values have been set
+  initialiseAll(); //Run the main initialise function
   TEST_ASSERT_NOT_EQUAL(0, inj1_pin_port);
   TEST_ASSERT_NOT_EQUAL(0, inj2_pin_port);
   TEST_ASSERT_NOT_EQUAL(0, inj3_pin_port);
   TEST_ASSERT_NOT_EQUAL(0, inj4_pin_port);
+  TEST_ASSERT_NOT_EQUAL(0, ign1_pin_port);
+  TEST_ASSERT_NOT_EQUAL(0, ign2_pin_port);
+  TEST_ASSERT_NOT_EQUAL(0, ign3_pin_port);
+  TEST_ASSERT_NOT_EQUAL(0, ign4_pin_port);
 }

test/test_generic/tests_init.h → test/tests/test_misc/tests_init.h

@@ -1,3 +1,3 @@
-void testInitialisation();
+extern void testInitialisation();
 void test_initialisation_complete(void);
 void test_initialisation_ports(void);

test/test_schedule/test_schedule.cpp → test/tests/test_schedules/test_schedules.cpp

@@ -1,10 +1,9 @@
 #include <Arduino.h>
 #include <unity.h>
 
-#include "test_schedule.h"
-
+#include "test_schedules.h"
 #include "globals.h"
-
+/*
 void two_second_blink()
 {
     // NOTE!!! Wait for >2 secs
@@ -18,9 +17,8 @@ void two_second_blink()
     digitalWrite(LED_BUILTIN, HIGH);
     delay(667);
     digitalWrite(LED_BUILTIN, LOW);
-}
 
-void do_tests()
+void test_schedules()
 {
     test_status_initial_off();
     test_status_off_to_pending();
@@ -53,4 +51,19 @@ void loop()
     delay(250);
     digitalWrite(LED_BUILTIN, LOW);
     delay(250);
+}
+*/
+void testSchedules()
+{
+
+    test_status_initial_off();
+    test_status_off_to_pending();
+    test_status_pending_to_running();
+    test_status_running_to_pending();
+
+    TEST_ASSERT_GREATER_THAN(freeRam(), 100);
+    test_status_running_to_off();
+
+    test_accuracy_timeout();
+    test_accuracy_duration();
 }

test/test_schedule/test_schedule.h → test/tests/test_schedules/test_schedules.h

@@ -1,6 +1,7 @@
 #if !defined(__TEST_SCHEDULE_H__)
 #define __TEST_SCHEDULE_H__
 
+void testSchedules();
 void test_status_initial_off(void);
 void test_status_off_to_pending(void);
 void test_status_pending_to_running(void);