noisymime
/
speeduino
mirror of https://github.com/noisymime/speeduino.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/noisymime/speeduino

This commit is contained in:
Josh Stewart 2020-02-07 10:08:09 +11:00
parent e8c67f9c86 76319fdf22
commit 5244e7088e
18 changed files with 1342 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
speeduino/scheduler.h
View File

@ -25,6 +25,8 @@ See page 136 of the processors datasheet: www.atmel.com/Images/doc2549.pdf
#ifndef SCHEDULER_H
#define SCHEDULER_H
#include "globals.h"
#define USE_IGN_REFRESH
#define IGNITION_REFRESH_THRESHOLD 30 //Time in uS that the refresh functions will check to ensure there is enough time before changing the end compare
@ -47,7 +49,7 @@ void setIgnitionSchedule6(void (*startCallback)(), unsigned long timeout, unsign
void setIgnitionSchedule7(void (*startCallback)(), unsigned long timeout, unsigned long duration, void(*endCallback)());
void setIgnitionSchedule8(void (*startCallback)(), unsigned long timeout, unsigned long duration, void(*endCallback)());
static inline void refreshIgnitionSchedule1(unsigned long timeToEnd) __attribute__((always_inline));
inline void refreshIgnitionSchedule1(unsigned long timeToEnd) __attribute__((always_inline));
//The ARM cores use seprate functions for their ISRs
#if defined(CORE_STM32_OFFICIAL) || defined(CORE_STM32_GENERIC) || defined(CORE_TEENSY)

2
speeduino/scheduler.ino
View File

@ -458,7 +458,7 @@ void setIgnitionSchedule1(void (*startCallback)(), unsigned long timeout, unsign
}
}
static inline void refreshIgnitionSchedule1(unsigned long timeToEnd)
inline void refreshIgnitionSchedule1(unsigned long timeToEnd)
{
if( (ignitionSchedule1.Status == RUNNING) && (timeToEnd < ignitionSchedule1.duration) )
//Must have the threshold check here otherwise it can cause a condition where the compare fires twice, once after the other, both for the end

0
test/tests_corrections.cpp → test/test_generic/tests_corrections.cpp
View File

0
test/tests_corrections.h → test/test_generic/tests_corrections.h
View File

0
test/tests_init.cpp → test/test_generic/tests_init.cpp
View File

0
test/tests_init.h → test/test_generic/tests_init.h
View File

32
test/tests_main.cpp → test/test_generic/tests_main.cpp
View File

@ -3,27 +3,33 @@
#include "tests_corrections.h"
#include "tests_init.h"
#include "tests_schedules.h"
void setup() {
void doTests()
{
testInitialisation();
testCorrections();
}
void setup()
{
pinMode(LED_BUILTIN, OUTPUT);
// NOTE!!! Wait for >2 secs
// if board doesn't support software reset via Serial.DTR/RTS
delay(2000);
UNITY_BEGIN(); // IMPORTANT LINE!
pinMode(LED_BUILTIN, OUTPUT);
doTests();
UNITY_END(); // stop unit testing
}
uint8_t i = 0;
uint8_t max_blinks = 5;
void loop()
void loop()
{
testInitialisation();
testCorrections();
testSchedules();
UNITY_END(); // stop unit testing
// Blink to indicate end of test
digitalWrite(LED_BUILTIN, HIGH);
delay(250);
digitalWrite(LED_BUILTIN, LOW);
delay(250);
}

204
test/test_schedule/test_accuracy_duration.cpp Normal file
View File

@ -0,0 +1,204 @@
#include <Arduino.h>
#include <unity.h>
#include "scheduler.h"
#define TIMEOUT 1000
#define DURATION 1000
#define DELTA 20
static uint32_t start_time, end_time;
static void startCallback(void) { start_time = micros(); }
static void endCallback(void) { end_time = micros(); }
void test_accuracy_duration_inj1(void)
{
initialiseSchedulers();
setFuelSchedule1(TIMEOUT, DURATION);
while(fuelSchedule1.Status == PENDING) /*Wait*/ ;
start_time = micros();
while(fuelSchedule1.Status == RUNNING) /*Wait*/ ;
end_time = micros();
TEST_ASSERT_UINT32_WITHIN(DELTA, DURATION, end_time - start_time);
}
void test_accuracy_duration_inj2(void)
{
initialiseSchedulers();
setFuelSchedule2(TIMEOUT, DURATION);
while(fuelSchedule2.Status == PENDING) /*Wait*/ ;
start_time = micros();
while(fuelSchedule2.Status == RUNNING) /*Wait*/ ;
end_time = micros();
TEST_ASSERT_UINT32_WITHIN(DELTA, DURATION, end_time - start_time);
}
void test_accuracy_duration_inj3(void)
{
initialiseSchedulers();
setFuelSchedule3(TIMEOUT, DURATION);
while(fuelSchedule3.Status == PENDING) /*Wait*/ ;
start_time = micros();
while(fuelSchedule3.Status == RUNNING) /*Wait*/ ;
end_time = micros();
TEST_ASSERT_UINT32_WITHIN(DELTA, DURATION, end_time - start_time);
}
void test_accuracy_duration_inj4(void)
{
initialiseSchedulers();
setFuelSchedule4(TIMEOUT, DURATION);
while(fuelSchedule4.Status == PENDING) /*Wait*/ ;
start_time = micros();
while(fuelSchedule4.Status == RUNNING) /*Wait*/ ;
end_time = micros();
TEST_ASSERT_UINT32_WITHIN(DELTA, DURATION, end_time - start_time);
}
void test_accuracy_duration_inj5(void)
{
#if INJ_CHANNELS >= 5
initialiseSchedulers();
setFuelSchedule5(TIMEOUT, DURATION);
while(fuelSchedule5.Status == PENDING) /*Wait*/ ;
start_time = micros();
while(fuelSchedule5.Status == RUNNING) /*Wait*/ ;
end_time = micros();
TEST_ASSERT_UINT32_WITHIN(DELTA, DURATION, end_time - start_time);
#endif
}
void test_accuracy_duration_inj6(void)
{
#if INJ_CHANNELS >= 6
initialiseSchedulers();
setFuelSchedule6(TIMEOUT, DURATION);
while(fuelSchedule6.Status == PENDING) /*Wait*/ ;
start_time = micros();
while(fuelSchedule6.Status == RUNNING) /*Wait*/ ;
end_time = micros();
TEST_ASSERT_UINT32_WITHIN(DELTA, DURATION, end_time - start_time);
#endif
}
void test_accuracy_duration_inj7(void)
{
#if INJ_CHANNELS >= 7
initialiseSchedulers();
setFuelSchedule7(TIMEOUT, DURATION);
while(fuelSchedule7.Status == PENDING) /*Wait*/ ;
start_time = micros();
while(fuelSchedule7.Status == RUNNING) /*Wait*/ ;
end_time = micros();
TEST_ASSERT_UINT32_WITHIN(DELTA, DURATION, end_time - start_time);
#endif
}
void test_accuracy_duration_inj8(void)
{
#if INJ_CHANNELS >= 8
initialiseSchedulers();
setFuelSchedule8(TIMEOUT, DURATION);
while(fuelSchedule8.Status == PENDING) /*Wait*/ ;
start_time = micros();
while(fuelSchedule8.Status == RUNNING) /*Wait*/ ;
end_time = micros();
TEST_ASSERT_UINT32_WITHIN(DELTA, DURATION, end_time - start_time);
#endif
}
void test_accuracy_duration_ign1(void)
{
initialiseSchedulers();
setIgnitionSchedule1(startCallback, TIMEOUT, DURATION, endCallback);
while( (ignitionSchedule1.Status == PENDING) || (ignitionSchedule1.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_UINT32_WITHIN(DELTA, DURATION, end_time - start_time);
}
void test_accuracy_duration_ign2(void)
{
initialiseSchedulers();
setIgnitionSchedule2(startCallback, TIMEOUT, DURATION, endCallback);
while( (ignitionSchedule2.Status == PENDING) || (ignitionSchedule2.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
}
void test_accuracy_duration_ign3(void)
{
initialiseSchedulers();
setIgnitionSchedule3(startCallback, TIMEOUT, DURATION, endCallback);
while( (ignitionSchedule3.Status == PENDING) || (ignitionSchedule3.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
}
void test_accuracy_duration_ign4(void)
{
initialiseSchedulers();
setIgnitionSchedule4(startCallback, TIMEOUT, DURATION, endCallback);
while( (ignitionSchedule4.Status == PENDING) || (ignitionSchedule4.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
}
void test_accuracy_duration_ign5(void)
{
#if IGN_CHANNELS >= 5
initialiseSchedulers();
setIgnitionSchedule5(startCallback, TIMEOUT, DURATION, endCallback);
while( (ignitionSchedule5.Status == PENDING) || (ignitionSchedule5.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
#endif
}
void test_accuracy_duration_ign6(void)
{
#if INJ_CHANNELS >= 6
initialiseSchedulers();
setIgnitionSchedule6(startCallback, TIMEOUT, DURATION, endCallback);
while( (ignitionSchedule6.Status == PENDING) || (ignitionSchedule6.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
#endif
}
void test_accuracy_duration_ign7(void)
{
#if INJ_CHANNELS >= 7
initialiseSchedulers();
setIgnitionSchedule7(startCallback, TIMEOUT, DURATION, endCallback);
while( (ignitionSchedule7.Status == PENDING) || (ignitionSchedule7.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
#endif
}
void test_accuracy_duration_ign8(void)
{
#if INJ_CHANNELS >= 8
initialiseSchedulers();
setIgnitionSchedule8(startCallback, TIMEOUT, DURATION, endCallback);
while( (ignitionSchedule8.Status == PENDING) || (ignitionSchedule8.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
#endif
}
void test_accuracy_duration(void)
{
RUN_TEST(test_accuracy_duration_inj1);
RUN_TEST(test_accuracy_duration_inj2);
RUN_TEST(test_accuracy_duration_inj3);
RUN_TEST(test_accuracy_duration_inj4);
RUN_TEST(test_accuracy_duration_inj5);
RUN_TEST(test_accuracy_duration_inj6);
RUN_TEST(test_accuracy_duration_inj7);
RUN_TEST(test_accuracy_duration_inj8);
RUN_TEST(test_accuracy_duration_ign1);
RUN_TEST(test_accuracy_duration_ign2);
RUN_TEST(test_accuracy_duration_ign3);
RUN_TEST(test_accuracy_duration_ign4);
RUN_TEST(test_accuracy_duration_ign5);
RUN_TEST(test_accuracy_duration_ign6);
RUN_TEST(test_accuracy_duration_ign7);
RUN_TEST(test_accuracy_duration_ign8);
}

203
test/test_schedule/test_accuracy_timeout.cpp Normal file
View File

@ -0,0 +1,203 @@
#include <Arduino.h>
#include <unity.h>
#include "scheduler.h"
#define TIMEOUT 1000
#define DURATION 1000
#define DELTA 20
static uint32_t start_time, end_time;
static void startCallback(void) { end_time = micros(); }
static void endCallback(void) { /*Empty*/ }
void test_accuracy_timeout_inj1(void)
{
initialiseSchedulers();
start_time = micros();
setFuelSchedule1(TIMEOUT, DURATION);
while(fuelSchedule1.Status == PENDING) /*Wait*/ ;
end_time = micros();
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
}
void test_accuracy_timeout_inj2(void)
{
initialiseSchedulers();
start_time = micros();
setFuelSchedule2(TIMEOUT, DURATION);
while(fuelSchedule2.Status == PENDING) /*Wait*/ ;
end_time = micros();
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
}
void test_accuracy_timeout_inj3(void)
{
initialiseSchedulers();
start_time = micros();
setFuelSchedule3(TIMEOUT, DURATION);
while(fuelSchedule3.Status == PENDING) /*Wait*/ ;
end_time = micros();
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
}
void test_accuracy_timeout_inj4(void)
{
initialiseSchedulers();
start_time = micros();
setFuelSchedule4(TIMEOUT, DURATION);
while(fuelSchedule4.Status == PENDING) /*Wait*/ ;
end_time = micros();
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
}
void test_accuracy_timeout_inj5(void)
{
#if INJ_CHANNELS >= 5
initialiseSchedulers();
start_time = micros();
setFuelSchedule5(TIMEOUT, DURATION);
while(fuelSchedule5.Status == PENDING) /*Wait*/ ;
end_time = micros();
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
#endif
}
void test_accuracy_timeout_inj6(void)
{
#if INJ_CHANNELS >= 6
initialiseSchedulers();
start_time = micros();
setFuelSchedule6(TIMEOUT, DURATION);
while(fuelSchedule6.Status == PENDING) /*Wait*/ ;
end_time = micros();
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
#endif
}
void test_accuracy_timeout_inj7(void)
{
#if INJ_CHANNELS >= 7
initialiseSchedulers();
start_time = micros();
setFuelSchedule7(TIMEOUT, DURATION);
while(fuelSchedule7.Status == PENDING) /*Wait*/ ;
end_time = micros();
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
#endif
}
void test_accuracy_timeout_inj8(void)
{
#if INJ_CHANNELS >= 8
initialiseSchedulers();
start_time = micros();
setFuelSchedule8(TIMEOUT, DURATION);
while(fuelSchedule8.Status == PENDING) /*Wait*/ ;
end_time = micros();
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
#endif
}
void test_accuracy_timeout_ign1(void)
{
initialiseSchedulers();
start_time = micros();
setIgnitionSchedule1(startCallback, TIMEOUT, DURATION, endCallback);
while(ignitionSchedule1.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
}
void test_accuracy_timeout_ign2(void)
{
initialiseSchedulers();
start_time = micros();
setIgnitionSchedule2(startCallback, TIMEOUT, DURATION, endCallback);
while(ignitionSchedule2.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
}
void test_accuracy_timeout_ign3(void)
{
initialiseSchedulers();
start_time = micros();
setIgnitionSchedule3(startCallback, TIMEOUT, DURATION, endCallback);
while(ignitionSchedule3.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
}
void test_accuracy_timeout_ign4(void)
{
initialiseSchedulers();
start_time = micros();
setIgnitionSchedule4(startCallback, TIMEOUT, DURATION, endCallback);
while(ignitionSchedule4.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
}
void test_accuracy_timeout_ign5(void)
{
#if IGN_CHANNELS >= 5
initialiseSchedulers();
start_time = micros();
setIgnitionSchedule5(startCallback, TIMEOUT, DURATION, endCallback);
while(ignitionSchedule5.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
#endif
}
void test_accuracy_timeout_ign6(void)
{
#if INJ_CHANNELS >= 6
initialiseSchedulers();
start_time = micros();
setIgnitionSchedule6(startCallback, TIMEOUT, DURATION, endCallback);
while(ignitionSchedule6.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
#endif
}
void test_accuracy_timeout_ign7(void)
{
#if INJ_CHANNELS >= 7
initialiseSchedulers();
start_time = micros();
setIgnitionSchedule7(startCallback, TIMEOUT, DURATION, endCallback);
while(ignitionSchedule7.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
#endif
}
void test_accuracy_timeout_ign8(void)
{
#if INJ_CHANNELS >= 8
initialiseSchedulers();
start_time = micros();
setIgnitionSchedule8(startCallback, TIMEOUT, DURATION, endCallback);
while(ignitionSchedule8.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_UINT32_WITHIN(DELTA, TIMEOUT, end_time - start_time);
#endif
}
void test_accuracy_timeout(void)
{
RUN_TEST(test_accuracy_timeout_inj1);
RUN_TEST(test_accuracy_timeout_inj2);
RUN_TEST(test_accuracy_timeout_inj3);
RUN_TEST(test_accuracy_timeout_inj4);
RUN_TEST(test_accuracy_timeout_inj5);
RUN_TEST(test_accuracy_timeout_inj6);
RUN_TEST(test_accuracy_timeout_inj7);
RUN_TEST(test_accuracy_timeout_inj8);
RUN_TEST(test_accuracy_timeout_ign1);
RUN_TEST(test_accuracy_timeout_ign2);
RUN_TEST(test_accuracy_timeout_ign3);
RUN_TEST(test_accuracy_timeout_ign4);
RUN_TEST(test_accuracy_timeout_ign5);
RUN_TEST(test_accuracy_timeout_ign6);
RUN_TEST(test_accuracy_timeout_ign7);
RUN_TEST(test_accuracy_timeout_ign8);
}

56
test/test_schedule/test_schedule.cpp Normal file
View File

@ -0,0 +1,56 @@
#include <Arduino.h>
#include <unity.h>
#include "test_schedule.h"
#include "globals.h"
void two_second_blink()
{
// NOTE!!! Wait for >2 secs
// if board doesn't support software reset via Serial.DTR/RTS
pinMode(LED_BUILTIN, OUTPUT);
digitalWrite(LED_BUILTIN, HIGH);
delay(667);
digitalWrite(LED_BUILTIN, LOW);
delay(667);
digitalWrite(LED_BUILTIN, HIGH);
delay(667);
digitalWrite(LED_BUILTIN, LOW);
}
void do_tests()
{
test_status_initial_off();
test_status_off_to_pending();
test_status_pending_to_running();
test_status_running_to_pending();
test_status_running_to_off();
test_accuracy_timeout();
test_accuracy_duration();
}
void setup()
{
initBoard(); // Not using initialiseAll() as it will cause memory overflow
two_second_blink(); // Very important line
UNITY_BEGIN(); // start unit testing
do_tests();
UNITY_END(); // stop unit testing
pinMode(LED_BUILTIN, OUTPUT);
}
void loop()
{
digitalWrite(LED_BUILTIN, HIGH);
delay(250);
digitalWrite(LED_BUILTIN, LOW);
delay(250);
}

13
test/test_schedule/test_schedule.h Normal file
View File

@ -0,0 +1,13 @@
#if !defined(__TEST_SCHEDULE_H__)
#define __TEST_SCHEDULE_H__
void test_status_initial_off(void);
void test_status_off_to_pending(void);
void test_status_pending_to_running(void);
void test_status_running_to_off(void);
void test_status_running_to_pending(void);
void test_accuracy_timeout(void);
void test_accuracy_duration(void);
#endif // __TEST_SCHEDULE_H__

123
test/test_schedule/test_status_initial_off.cpp Normal file
View File

@ -0,0 +1,123 @@
#include <Arduino.h>
#include <unity.h>
#include "scheduler.h"
void test_status_initial_off_inj1(void)
{
initialiseSchedulers();
TEST_ASSERT_EQUAL(OFF, fuelSchedule1.Status);
}
void test_status_initial_off_inj2(void)
{
initialiseSchedulers();
TEST_ASSERT_EQUAL(OFF, fuelSchedule2.Status);
}
void test_status_initial_off_inj3(void)
{
initialiseSchedulers();
TEST_ASSERT_EQUAL(OFF, fuelSchedule3.Status);
}
void test_status_initial_off_inj4(void)
{
initialiseSchedulers();
TEST_ASSERT_EQUAL(OFF, fuelSchedule4.Status);
}
void test_status_initial_off_inj5(void)
{
initialiseSchedulers();
TEST_ASSERT_EQUAL(OFF, fuelSchedule5.Status);
}
void test_status_initial_off_inj6(void)
{
initialiseSchedulers();
TEST_ASSERT_EQUAL(OFF, fuelSchedule6.Status);
}
void test_status_initial_off_inj7(void)
{
initialiseSchedulers();
TEST_ASSERT_EQUAL(OFF, fuelSchedule7.Status);
}
void test_status_initial_off_inj8(void)
{
initialiseSchedulers();
TEST_ASSERT_EQUAL(OFF, fuelSchedule8.Status);
}
void test_status_initial_off_ign1(void)
{
initialiseSchedulers();
TEST_ASSERT_EQUAL(OFF, ignitionSchedule1.Status);
}
void test_status_initial_off_ign2(void)
{
initialiseSchedulers();
TEST_ASSERT_EQUAL(OFF, ignitionSchedule2.Status);
}
void test_status_initial_off_ign3(void)
{
initialiseSchedulers();
TEST_ASSERT_EQUAL(OFF, ignitionSchedule3.Status);
}
void test_status_initial_off_ign4(void)
{
initialiseSchedulers();
TEST_ASSERT_EQUAL(OFF, ignitionSchedule4.Status);
}
void test_status_initial_off_ign5(void)
{
initialiseSchedulers();
TEST_ASSERT_EQUAL(OFF, ignitionSchedule5.Status);
}
void test_status_initial_off_ign6(void)
{
initialiseSchedulers();
TEST_ASSERT_EQUAL(OFF, ignitionSchedule6.Status);
}
void test_status_initial_off_ign7(void)
{
initialiseSchedulers();
TEST_ASSERT_EQUAL(OFF, ignitionSchedule7.Status);
}
void test_status_initial_off_ign8(void)
{
initialiseSchedulers();
TEST_ASSERT_EQUAL(OFF, ignitionSchedule8.Status);
}
void test_status_initial_off(void)
{
RUN_TEST(test_status_initial_off_inj1);
RUN_TEST(test_status_initial_off_inj2);
RUN_TEST(test_status_initial_off_inj3);
RUN_TEST(test_status_initial_off_inj4);
RUN_TEST(test_status_initial_off_inj5);
RUN_TEST(test_status_initial_off_inj6);
RUN_TEST(test_status_initial_off_inj7);
RUN_TEST(test_status_initial_off_inj8);
RUN_TEST(test_status_initial_off_ign1);
RUN_TEST(test_status_initial_off_ign2);
RUN_TEST(test_status_initial_off_ign3);
RUN_TEST(test_status_initial_off_ign4);
RUN_TEST(test_status_initial_off_ign5);
RUN_TEST(test_status_initial_off_ign6);
RUN_TEST(test_status_initial_off_ign7);
RUN_TEST(test_status_initial_off_ign8);
}

160
test/test_schedule/test_status_off_to_pending.cpp Normal file
View File

@ -0,0 +1,160 @@
#include <Arduino.h>
#include <unity.h>
#include "scheduler.h"
#define TIMEOUT 1000
#define DURATION 1000
static void emptyCallback(void) { }
void test_status_off_to_pending_inj1(void)
{
initialiseSchedulers();
setFuelSchedule1(TIMEOUT, DURATION);
TEST_ASSERT_EQUAL(PENDING, fuelSchedule1.Status);
}
void test_status_off_to_pending_inj2(void)
{
initialiseSchedulers();
setFuelSchedule2(TIMEOUT, DURATION);
TEST_ASSERT_EQUAL(PENDING, fuelSchedule2.Status);
}
void test_status_off_to_pending_inj3(void)
{
initialiseSchedulers();
setFuelSchedule3(TIMEOUT, DURATION);
TEST_ASSERT_EQUAL(PENDING, fuelSchedule3.Status);
}
void test_status_off_to_pending_inj4(void)
{
initialiseSchedulers();
setFuelSchedule4(TIMEOUT, DURATION);
TEST_ASSERT_EQUAL(PENDING, fuelSchedule4.Status);
}
void test_status_off_to_pending_inj5(void)
{
#if INJ_CHANNELS >= 5
initialiseSchedulers();
setFuelSchedule5(TIMEOUT, DURATION);
TEST_ASSERT_EQUAL(PENDING, fuelSchedule5.Status);
#endif
}
void test_status_off_to_pending_inj6(void)
{
#if INJ_CHANNELS >= 6
initialiseSchedulers();
setFuelSchedule6(TIMEOUT, DURATION);
TEST_ASSERT_EQUAL(PENDING, fuelSchedule6.Status);
#endif
}
void test_status_off_to_pending_inj7(void)
{
#if INJ_CHANNELS >= 7
initialiseSchedulers();
setFuelSchedule7(TIMEOUT, DURATION);
TEST_ASSERT_EQUAL(PENDING, fuelSchedule7.Status);
#endif
}
void test_status_off_to_pending_inj8(void)
{
#if INJ_CHANNELS >= 8
initialiseSchedulers();
setFuelSchedule8(TIMEOUT, DURATION);
TEST_ASSERT_EQUAL(PENDING, fuelSchedule8.Status);
#endif
}
void test_status_off_to_pending_ign1(void)
{
initialiseSchedulers();
setIgnitionSchedule1(emptyCallback, TIMEOUT, DURATION, emptyCallback);
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule1.Status);
}
void test_status_off_to_pending_ign2(void)
{
initialiseSchedulers();
setIgnitionSchedule2(emptyCallback, TIMEOUT, DURATION, emptyCallback);
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule2.Status);
}
void test_status_off_to_pending_ign3(void)
{
initialiseSchedulers();
setIgnitionSchedule3(emptyCallback, TIMEOUT, DURATION, emptyCallback);
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule3.Status);
}
void test_status_off_to_pending_ign4(void)
{
initialiseSchedulers();
setIgnitionSchedule4(emptyCallback, TIMEOUT, DURATION, emptyCallback);
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule4.Status);
}
void test_status_off_to_pending_ign5(void)
{
#if IGN_CHANNELS >= 5
initialiseSchedulers();
setIgnitionSchedule5(emptyCallback, TIMEOUT, DURATION, emptyCallback);
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule5.Status);
#endif
}
void test_status_off_to_pending_ign6(void)
{
#if INJ_CHANNELS >= 6
initialiseSchedulers();
setIgnitionSchedule6(emptyCallback, TIMEOUT, DURATION, emptyCallback);
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule6.Status);
#endif
}
void test_status_off_to_pending_ign7(void)
{
#if INJ_CHANNELS >= 7
initialiseSchedulers();
setIgnitionSchedule7(emptyCallback, TIMEOUT, DURATION, emptyCallback);
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule7.Status);
#endif
}
void test_status_off_to_pending_ign8(void)
{
#if INJ_CHANNELS >= 8
initialiseSchedulers();
setIgnitionSchedule8(emptyCallback, TIMEOUT, DURATION, emptyCallback);
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule8.Status);
#endif
}
void test_status_off_to_pending(void)
{
RUN_TEST(test_status_off_to_pending_inj1);
RUN_TEST(test_status_off_to_pending_inj2);
RUN_TEST(test_status_off_to_pending_inj3);
RUN_TEST(test_status_off_to_pending_inj4);
RUN_TEST(test_status_off_to_pending_inj5);
RUN_TEST(test_status_off_to_pending_inj6);
RUN_TEST(test_status_off_to_pending_inj7);
RUN_TEST(test_status_off_to_pending_inj8);
RUN_TEST(test_status_off_to_pending_ign1);
RUN_TEST(test_status_off_to_pending_ign2);
RUN_TEST(test_status_off_to_pending_ign3);
RUN_TEST(test_status_off_to_pending_ign4);
RUN_TEST(test_status_off_to_pending_ign5);
RUN_TEST(test_status_off_to_pending_ign6);
RUN_TEST(test_status_off_to_pending_ign7);
RUN_TEST(test_status_off_to_pending_ign8);
}

176
test/test_schedule/test_status_pending_to_running.cpp Normal file
View File

@ -0,0 +1,176 @@
#include <Arduino.h>
#include <unity.h>
#include "scheduler.h"
#define TIMEOUT 1000
#define DURATION 1000
static void emptyCallback(void) { }
void test_status_pending_to_running_inj1(void)
{
initialiseSchedulers();
setFuelSchedule1(TIMEOUT, DURATION);
while(fuelSchedule1.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_EQUAL(RUNNING, fuelSchedule1.Status);
}
void test_status_pending_to_running_inj2(void)
{
initialiseSchedulers();
setFuelSchedule2(TIMEOUT, DURATION);
while(fuelSchedule2.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_EQUAL(RUNNING, fuelSchedule2.Status);
}
void test_status_pending_to_running_inj3(void)
{
initialiseSchedulers();
setFuelSchedule3(TIMEOUT, DURATION);
while(fuelSchedule3.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_EQUAL(RUNNING, fuelSchedule3.Status);
}
void test_status_pending_to_running_inj4(void)
{
initialiseSchedulers();
setFuelSchedule4(TIMEOUT, DURATION);
while(fuelSchedule4.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_EQUAL(RUNNING, fuelSchedule4.Status);
}
void test_status_pending_to_running_inj5(void)
{
#if INJ_CHANNELS >= 5
initialiseSchedulers();
setFuelSchedule5(TIMEOUT, DURATION);
while(fuelSchedule5.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_EQUAL(RUNNING, fuelSchedule5.Status);
#endif
}
void test_status_pending_to_running_inj6(void)
{
#if INJ_CHANNELS >= 6
initialiseSchedulers();
setFuelSchedule6(TIMEOUT, DURATION);
while(fuelSchedule6.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_EQUAL(RUNNING, fuelSchedule6.Status);
#endif
}
void test_status_pending_to_running_inj7(void)
{
#if INJ_CHANNELS >= 7
initialiseSchedulers();
setFuelSchedule7(TIMEOUT, DURATION);
while(fuelSchedule7.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_EQUAL(RUNNING, fuelSchedule7.Status);
#endif
}
void test_status_pending_to_running_inj8(void)
{
#if INJ_CHANNELS >= 8
initialiseSchedulers();
setFuelSchedule8(TIMEOUT, DURATION);
while(fuelSchedule8.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_EQUAL(RUNNING, fuelSchedule8.Status);
#endif
}
void test_status_pending_to_running_ign1(void)
{
initialiseSchedulers();
setIgnitionSchedule1(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule1.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule1.Status);
}
void test_status_pending_to_running_ign2(void)
{
initialiseSchedulers();
setIgnitionSchedule2(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule2.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule2.Status);
}
void test_status_pending_to_running_ign3(void)
{
initialiseSchedulers();
setIgnitionSchedule3(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule3.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule3.Status);
}
void test_status_pending_to_running_ign4(void)
{
initialiseSchedulers();
setIgnitionSchedule4(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule4.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule4.Status);
}
void test_status_pending_to_running_ign5(void)
{
#if IGN_CHANNELS >= 5
initialiseSchedulers();
setIgnitionSchedule5(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule5.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule5.Status);
#endif
}
void test_status_pending_to_running_ign6(void)
{
#if INJ_CHANNELS >= 6
initialiseSchedulers();
setIgnitionSchedule6(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule6.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule6.Status);
#endif
}
void test_status_pending_to_running_ign7(void)
{
#if INJ_CHANNELS >= 7
initialiseSchedulers();
setIgnitionSchedule7(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule7.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule7.Status);
#endif
}
void test_status_pending_to_running_ign8(void)
{
#if INJ_CHANNELS >= 8
initialiseSchedulers();
setIgnitionSchedule8(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule8.Status == PENDING) /*Wait*/ ;
TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule8.Status);
#endif
}
void test_status_pending_to_running(void)
{
RUN_TEST(test_status_pending_to_running_inj1);
RUN_TEST(test_status_pending_to_running_inj2);
RUN_TEST(test_status_pending_to_running_inj3);
RUN_TEST(test_status_pending_to_running_inj4);
RUN_TEST(test_status_pending_to_running_inj5);
RUN_TEST(test_status_pending_to_running_inj6);
RUN_TEST(test_status_pending_to_running_inj7);
RUN_TEST(test_status_pending_to_running_inj8);
RUN_TEST(test_status_pending_to_running_ign1);
RUN_TEST(test_status_pending_to_running_ign2);
RUN_TEST(test_status_pending_to_running_ign3);
RUN_TEST(test_status_pending_to_running_ign4);
RUN_TEST(test_status_pending_to_running_ign5);
RUN_TEST(test_status_pending_to_running_ign6);
RUN_TEST(test_status_pending_to_running_ign7);
RUN_TEST(test_status_pending_to_running_ign8);
}

176
test/test_schedule/test_status_running_to_off.cpp Normal file
View File

@ -0,0 +1,176 @@
#include <Arduino.h>
#include <unity.h>
#include "scheduler.h"
#define TIMEOUT 1000
#define DURATION 1000
static void emptyCallback(void) { }
void test_status_running_to_off_inj1(void)
{
initialiseSchedulers();
setFuelSchedule1(TIMEOUT, DURATION);
while( (fuelSchedule1.Status == PENDING) || (fuelSchedule1.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_EQUAL(OFF, fuelSchedule1.Status);
}
void test_status_running_to_off_inj2(void)
{
initialiseSchedulers();
setFuelSchedule2(TIMEOUT, DURATION);
while( (fuelSchedule2.Status == PENDING) || (fuelSchedule2.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_EQUAL(OFF, fuelSchedule2.Status);
}
void test_status_running_to_off_inj3(void)
{
initialiseSchedulers();
setFuelSchedule3(TIMEOUT, DURATION);
while( (fuelSchedule3.Status == PENDING) || (fuelSchedule3.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_EQUAL(OFF, fuelSchedule3.Status);
}
void test_status_running_to_off_inj4(void)
{
initialiseSchedulers();
setFuelSchedule4(TIMEOUT, DURATION);
while( (fuelSchedule4.Status == PENDING) || (fuelSchedule4.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_EQUAL(OFF, fuelSchedule4.Status);
}
void test_status_running_to_off_inj5(void)
{
#if INJ_CHANNELS >= 5
initialiseSchedulers();
setFuelSchedule5(TIMEOUT, DURATION);
while( (fuelSchedule5.Status == PENDING) || (fuelSchedule5.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_EQUAL(OFF, fuelSchedule5.Status);
#endif
}
void test_status_running_to_off_inj6(void)
{
#if INJ_CHANNELS >= 6
initialiseSchedulers();
setFuelSchedule6(TIMEOUT, DURATION);
while( (fuelSchedule6.Status == PENDING) || (fuelSchedule6.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_EQUAL(OFF, fuelSchedule6.Status);
#endif
}
void test_status_running_to_off_inj7(void)
{
#if INJ_CHANNELS >= 7
initialiseSchedulers();
setFuelSchedule7(TIMEOUT, DURATION);
while( (fuelSchedule7.Status == PENDING) || (fuelSchedule7.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_EQUAL(OFF, fuelSchedule7.Status);
#endif
}
void test_status_running_to_off_inj8(void)
{
#if INJ_CHANNELS >= 8
initialiseSchedulers();
setFuelSchedule8(TIMEOUT, DURATION);
while( (fuelSchedule8.Status == PENDING) || (fuelSchedule8.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_EQUAL(OFF, fuelSchedule8.Status);
#endif
}
void test_status_running_to_off_ign1(void)
{
initialiseSchedulers();
setIgnitionSchedule1(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while( (ignitionSchedule1.Status == PENDING) || (ignitionSchedule1.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_EQUAL(OFF, ignitionSchedule1.Status);
}
void test_status_running_to_off_ign2(void)
{
initialiseSchedulers();
setIgnitionSchedule2(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while( (ignitionSchedule2.Status == PENDING) || (ignitionSchedule2.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_EQUAL(OFF, ignitionSchedule2.Status);
}
void test_status_running_to_off_ign3(void)
{
initialiseSchedulers();
setIgnitionSchedule3(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while( (ignitionSchedule3.Status == PENDING) || (ignitionSchedule3.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_EQUAL(OFF, ignitionSchedule3.Status);
}
void test_status_running_to_off_ign4(void)
{
initialiseSchedulers();
setIgnitionSchedule4(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while( (ignitionSchedule4.Status == PENDING) || (ignitionSchedule4.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_EQUAL(OFF, ignitionSchedule4.Status);
}
void test_status_running_to_off_ign5(void)
{
#if IGN_CHANNELS >= 5
initialiseSchedulers();
setIgnitionSchedule5(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while( (ignitionSchedule5.Status == PENDING) || (ignitionSchedule5.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_EQUAL(OFF, ignitionSchedule5.Status);
#endif
}
void test_status_running_to_off_ign6(void)
{
#if INJ_CHANNELS >= 6
initialiseSchedulers();
setIgnitionSchedule6(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while( (ignitionSchedule6.Status == PENDING) || (ignitionSchedule6.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_EQUAL(OFF, ignitionSchedule6.Status);
#endif
}
void test_status_running_to_off_ign7(void)
{
#if INJ_CHANNELS >= 7
initialiseSchedulers();
setIgnitionSchedule7(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while( (ignitionSchedule7.Status == PENDING) || (ignitionSchedule7.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_EQUAL(OFF, ignitionSchedule7.Status);
#endif
}
void test_status_running_to_off_ign8(void)
{
#if INJ_CHANNELS >= 8
initialiseSchedulers();
setIgnitionSchedule8(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while( (ignitionSchedule8.Status == PENDING) || (ignitionSchedule8.Status == RUNNING) ) /*Wait*/ ;
TEST_ASSERT_EQUAL(OFF, ignitionSchedule8.Status);
#endif
}
void test_status_running_to_off(void)
{
RUN_TEST(test_status_running_to_off_inj1);
RUN_TEST(test_status_running_to_off_inj2);
RUN_TEST(test_status_running_to_off_inj3);
RUN_TEST(test_status_running_to_off_inj4);
RUN_TEST(test_status_running_to_off_inj5);
RUN_TEST(test_status_running_to_off_inj6);
RUN_TEST(test_status_running_to_off_inj7);
RUN_TEST(test_status_running_to_off_inj8);
RUN_TEST(test_status_running_to_off_ign1);
RUN_TEST(test_status_running_to_off_ign2);
RUN_TEST(test_status_running_to_off_ign3);
RUN_TEST(test_status_running_to_off_ign4);
RUN_TEST(test_status_running_to_off_ign5);
RUN_TEST(test_status_running_to_off_ign6);
RUN_TEST(test_status_running_to_off_ign7);
RUN_TEST(test_status_running_to_off_ign8);
}

208
test/test_schedule/test_status_running_to_pending.cpp Normal file
View File

@ -0,0 +1,208 @@
#include <Arduino.h>
#include <unity.h>
#include "scheduler.h"
#define TIMEOUT 1000
#define DURATION 1000
static void emptyCallback(void) { }
void test_status_running_to_pending_inj1(void)
{
initialiseSchedulers();
setFuelSchedule1(TIMEOUT, DURATION);
while(fuelSchedule1.Status == PENDING) /*Wait*/ ;
setFuelSchedule1(2*TIMEOUT, DURATION);
while(fuelSchedule1.Status == RUNNING) /*Wait*/ ;
TEST_ASSERT_EQUAL(PENDING, fuelSchedule1.Status);
}
void test_status_running_to_pending_inj2(void)
{
initialiseSchedulers();
setFuelSchedule2(TIMEOUT, DURATION);
while(fuelSchedule2.Status == PENDING) /*Wait*/ ;
setFuelSchedule2(2*TIMEOUT, DURATION);
while(fuelSchedule2.Status == RUNNING) /*Wait*/ ;
TEST_ASSERT_EQUAL(PENDING, fuelSchedule2.Status);
}
void test_status_running_to_pending_inj3(void)
{
initialiseSchedulers();
setFuelSchedule3(TIMEOUT, DURATION);
while(fuelSchedule3.Status == PENDING) /*Wait*/ ;
setFuelSchedule3(2*TIMEOUT, DURATION);
while(fuelSchedule3.Status == RUNNING) /*Wait*/ ;
TEST_ASSERT_EQUAL(PENDING, fuelSchedule3.Status);
}
void test_status_running_to_pending_inj4(void)
{
initialiseSchedulers();
setFuelSchedule4(TIMEOUT, DURATION);
while(fuelSchedule4.Status == PENDING) /*Wait*/ ;
setFuelSchedule4(2*TIMEOUT, DURATION);
while(fuelSchedule4.Status == RUNNING) /*Wait*/ ;
TEST_ASSERT_EQUAL(PENDING, fuelSchedule4.Status);
}
void test_status_running_to_pending_inj5(void)
{
#if INJ_CHANNELS >= 5
initialiseSchedulers();
setFuelSchedule5(TIMEOUT, DURATION);
while(fuelSchedule5.Status == PENDING) /*Wait*/ ;
setFuelSchedule5(2*TIMEOUT, DURATION);
while(fuelSchedule5.Status == RUNNING) /*Wait*/ ;
TEST_ASSERT_EQUAL(PENDING, fuelSchedule5.Status);
#endif
}
void test_status_running_to_pending_inj6(void)
{
#if INJ_CHANNELS >= 6
initialiseSchedulers();
setFuelSchedule6(TIMEOUT, DURATION);
while(fuelSchedule6.Status == PENDING) /*Wait*/ ;
setFuelSchedule6(2*TIMEOUT, DURATION);
while(fuelSchedule6.Status == RUNNING) /*Wait*/ ;
TEST_ASSERT_EQUAL(PENDING, fuelSchedule6.Status);
#endif
}
void test_status_running_to_pending_inj7(void)
{
#if INJ_CHANNELS >= 7
initialiseSchedulers();
setFuelSchedule7(TIMEOUT, DURATION);
while(fuelSchedule7.Status == PENDING) /*Wait*/ ;
setFuelSchedule7(2*TIMEOUT, DURATION);
while(fuelSchedule7.Status == RUNNING) /*Wait*/ ;
TEST_ASSERT_EQUAL(PENDING, fuelSchedule7.Status);
#endif
}
void test_status_running_to_pending_inj8(void)
{
#if INJ_CHANNELS >= 8
initialiseSchedulers();
setFuelSchedule8(TIMEOUT, DURATION);
while(fuelSchedule8.Status == PENDING) /*Wait*/ ;
setFuelSchedule8(2*TIMEOUT, DURATION);
while(fuelSchedule8.Status == RUNNING) /*Wait*/ ;
TEST_ASSERT_EQUAL(PENDING, fuelSchedule8.Status);
#endif
}
void test_status_running_to_pending_ign1(void)
{
initialiseSchedulers();
setIgnitionSchedule1(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule1.Status == PENDING) /*Wait*/ ;
setIgnitionSchedule1(emptyCallback, 2*TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule1.Status == RUNNING) /*Wait*/ ;
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule1.Status);
}
void test_status_running_to_pending_ign2(void)
{
initialiseSchedulers();
setIgnitionSchedule2(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule2.Status == PENDING) /*Wait*/ ;
setIgnitionSchedule2(emptyCallback, 2*TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule2.Status == RUNNING) /*Wait*/ ;
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule2.Status);
}
void test_status_running_to_pending_ign3(void)
{
initialiseSchedulers();
setIgnitionSchedule3(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule3.Status == PENDING) /*Wait*/ ;
setIgnitionSchedule3(emptyCallback, 2*TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule3.Status == RUNNING) /*Wait*/ ;
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule3.Status);
}
void test_status_running_to_pending_ign4(void)
{
initialiseSchedulers();
setIgnitionSchedule4(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule4.Status == PENDING) /*Wait*/ ;
setIgnitionSchedule4(emptyCallback, 2*TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule4.Status == RUNNING) /*Wait*/ ;
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule4.Status);
}
void test_status_running_to_pending_ign5(void)
{
#if IGN_CHANNELS >= 5
initialiseSchedulers();
setIgnitionSchedule5(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule5.Status == PENDING) /*Wait*/ ;
setIgnitionSchedule5(emptyCallback, 2*TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule5.Status == RUNNING) /*Wait*/ ;
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule5.Status);
#endif
}
void test_status_running_to_pending_ign6(void)
{
#if INJ_CHANNELS >= 6
initialiseSchedulers();
setIgnitionSchedule6(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule6.Status == PENDING) /*Wait*/ ;
setIgnitionSchedule6(emptyCallback, 2*TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule6.Status == RUNNING) /*Wait*/ ;
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule6.Status);
#endif
}
void test_status_running_to_pending_ign7(void)
{
#if INJ_CHANNELS >= 7
initialiseSchedulers();
setIgnitionSchedule7(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule7.Status == PENDING) /*Wait*/ ;
setIgnitionSchedule7(emptyCallback, 2*TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule7.Status == RUNNING) /*Wait*/ ;
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule7.Status);
#endif
}
void test_status_running_to_pending_ign8(void)
{
#if INJ_CHANNELS >= 8
initialiseSchedulers();
setIgnitionSchedule8(emptyCallback, TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule8.Status == PENDING) /*Wait*/ ;
setIgnitionSchedule8(emptyCallback, 2*TIMEOUT, DURATION, emptyCallback);
while(ignitionSchedule8.Status == RUNNING) /*Wait*/ ;
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule8.Status);
#endif
}
void test_status_running_to_pending(void)
{
RUN_TEST(test_status_running_to_pending_inj1);
RUN_TEST(test_status_running_to_pending_inj2);
RUN_TEST(test_status_running_to_pending_inj3);
RUN_TEST(test_status_running_to_pending_inj4);
RUN_TEST(test_status_running_to_pending_inj5);
RUN_TEST(test_status_running_to_pending_inj6);
RUN_TEST(test_status_running_to_pending_inj7);
RUN_TEST(test_status_running_to_pending_inj8);
RUN_TEST(test_status_running_to_pending_ign1);
RUN_TEST(test_status_running_to_pending_ign2);
RUN_TEST(test_status_running_to_pending_ign3);
RUN_TEST(test_status_running_to_pending_ign4);
RUN_TEST(test_status_running_to_pending_ign5);
RUN_TEST(test_status_running_to_pending_ign6);
RUN_TEST(test_status_running_to_pending_ign7);
RUN_TEST(test_status_running_to_pending_ign8);
}

202
test/tests_schedules.cpp
View File

@ -1,202 +0,0 @@
#include <globals.h>
#include <init.h>
#include <unity.h>
#include "tests_schedules.h"
#include "scheduler.h"
/* ****************************************************************************
* Static functions
* ***************************************************************************/
static void test_schedule_fuel_time(void);
static void test_schedule_fuel_pending(void);
static void test_schedule_ignition_time(void);
static void test_schedule_ignition_pending(void);
static uint32_t beginTime, endTime;
static void beginCallback(void) { beginTime = micros(); }
static void endCallback(void) { endTime = micros(); }
/* ****************************************************************************
* Global variables
* ***************************************************************************/
static FuelSchedule* fuelSchedule[] = {
&fuelSchedule1,
&fuelSchedule2,
&fuelSchedule3,
&fuelSchedule4,
&fuelSchedule5,
&fuelSchedule6,
&fuelSchedule7,
&fuelSchedule8,
};
static Schedule* ignitionSchedule[] = {
&ignitionSchedule1,
&ignitionSchedule2,
&ignitionSchedule3,
&ignitionSchedule4,
&ignitionSchedule5,
&ignitionSchedule6,
&ignitionSchedule7,
&ignitionSchedule8,
};
void (*setFuelSchedule[])(unsigned long, unsigned long) = {
setFuelSchedule1,
setFuelSchedule2,
setFuelSchedule3,
setFuelSchedule4,
#if INJ_CHANNELS >= 5
setFuelSchedule5,
#endif
#if INJ_CHANNELS >= 6
setFuelSchedule6,
#endif
#if INJ_CHANNELS >= 7
setFuelSchedule7,
#endif
#if INJ_CHANNELS >= 8
setFuelSchedule8,
#endif
};
void (*setIgnitionSchedule[])(void (*)(), unsigned long, unsigned long, void (*)()) = {
setIgnitionSchedule1,
setIgnitionSchedule2,
setIgnitionSchedule3,
setIgnitionSchedule4,
#if IGN_CHANNELS >= 5
setIgnitionSchedule5,
#endif
#if IGN_CHANNELS >= 6
setIgnitionSchedule6,
#endif
#if IGN_CHANNELS >= 7
setIgnitionSchedule7,
#endif
#if IGN_CHANNELS >= 8
setIgnitionSchedule8,
#endif
};
/* ****************************************************************************
* Test Main
* ***************************************************************************/
void testSchedules()
{
RUN_TEST(test_schedule_fuel_time);
RUN_TEST(test_schedule_fuel_pending);
RUN_TEST(test_schedule_ignition_time);
RUN_TEST(test_schedule_ignition_pending);
}
/* ****************************************************************************
* Test Functions
* ***************************************************************************/
static void test_schedule_fuel_time(void)
{
TEST_ASSERT_EQUAL(true, initialisationComplete);
for(int i = 0; i < INJ_CHANNELS; i++)
{
TEST_ASSERT_EQUAL(OFF, fuelSchedule[i]->Status);
uint32_t time1 = micros();
setFuelSchedule[i](1000, 1000);
TEST_ASSERT_EQUAL(PENDING, fuelSchedule[i]->Status);
while(fuelSchedule[i]->Status == PENDING); // wait
uint32_t time2 = micros();
TEST_ASSERT_EQUAL(RUNNING, fuelSchedule[i]->Status);
while(fuelSchedule[i]->Status == RUNNING); // wait
uint32_t time3 = micros();
TEST_ASSERT_EQUAL(OFF, fuelSchedule[i]->Status);
TEST_ASSERT_EQUAL(1016, time2 - time1);
TEST_ASSERT_EQUAL(1008, time3 - time2);
}
}
static void test_schedule_fuel_pending(void)
{
TEST_ASSERT_EQUAL(true, initialisationComplete);
for(int i = 0; i < INJ_CHANNELS; i++)
{
TEST_ASSERT_EQUAL(OFF, fuelSchedule[i]->Status);
setFuelSchedule[i](1000, 1000);
TEST_ASSERT_EQUAL(PENDING, fuelSchedule[i]->Status);
while(fuelSchedule[i]->Status == PENDING); // wait
TEST_ASSERT_EQUAL(RUNNING, fuelSchedule[i]->Status);
setFuelSchedule[i](1500, 500); // Once running, set another schedule
while(fuelSchedule[i]->Status == RUNNING); // wait
TEST_ASSERT_EQUAL(PENDING, fuelSchedule[i]->Status);
while(fuelSchedule[i]->Status == PENDING); // wait
TEST_ASSERT_EQUAL(RUNNING, fuelSchedule[i]->Status);
while(fuelSchedule[i]->Status == RUNNING); // wait
TEST_ASSERT_EQUAL(OFF, fuelSchedule[i]->Status);
}
}
static void test_schedule_ignition_time(void)
{
TEST_ASSERT_EQUAL(true, initialisationComplete);
for(int i = 0; i < IGN_CHANNELS; i++)
{
TEST_ASSERT_EQUAL(OFF, ignitionSchedule[i]->Status);
uint32_t time1 = micros();
setIgnitionSchedule[i](beginCallback, 1000, 1000, endCallback);
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule[i]->Status);
while(ignitionSchedule[i]->Status == PENDING); // wait
TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule[i]->Status);
while(ignitionSchedule[i]->Status == RUNNING); // wait
TEST_ASSERT_EQUAL(OFF, ignitionSchedule[i]->Status);
TEST_ASSERT_EQUAL(1012, beginTime - time1);
TEST_ASSERT_EQUAL(1012, endTime - beginTime);
}
}
static void test_schedule_ignition_pending(void)
{
TEST_ASSERT_EQUAL(true, initialisationComplete);
for(int i = 0; i < IGN_CHANNELS; i++)
{
TEST_ASSERT_EQUAL(OFF, ignitionSchedule[i]->Status);
setIgnitionSchedule[i](beginCallback, 1000, 1000, endCallback);
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule[i]->Status);
while(ignitionSchedule[i]->Status == PENDING); // wait
TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule[i]->Status);
setIgnitionSchedule[i](beginCallback, 1500, 500, endCallback); // Once running, set another schedule
while(ignitionSchedule[i]->Status == RUNNING); // wait
TEST_ASSERT_EQUAL(PENDING, ignitionSchedule[i]->Status);
while(ignitionSchedule[i]->Status == PENDING); // wait
TEST_ASSERT_EQUAL(RUNNING, ignitionSchedule[i]->Status);
while(ignitionSchedule[i]->Status == RUNNING); // wait
TEST_ASSERT_EQUAL(OFF, ignitionSchedule[i]->Status);
}
}

1
test/tests_schedules.h
View File

@ -1 +0,0 @@
void testSchedules();