Mcucpp

1

2

3
#include <gtest/gtest.h>
4
#include <drivers/servo.h>
5
#include <timers.h>
6
#include <iopins.h>
7
#include <pinlist.h>
8
#include <clock.h>
9
#include <DividerSelector.h>
10

11
using namespace Mcucpp;
12
using namespace Mcucpp::IO;
13
using namespace Mcucpp::Timers;
14
using namespace Mcucpp::Clock;
15

16
typedef PinList<Pa0, Pa1, Pa2, Pa3> Pins;
17
uint32_t SysClock::CpuFreq;
18
typedef Timer1 ServoTestTimer;
19

20
TEST(TestTimer, DividerSelection)
21
{
22
	DividerSelector<ServoTestTimer> selector;
23
	for(int j = 100; j < 20000; j+= 100)
24
	{
25
		bool result = selector.ProcessMkSek(24000000, j);
26
		EXPECT_TRUE(result);
27
		int t = selector.GetTicks();
28
		EXPECT_GE(0xffff, t);
29
	}
30
}
31

32
TEST(Servo, AllTurnedOff)
33
{
34
	SysClock::SetClockFreq(24000000);
35
	
36
	Servo<Pins, ServoTestTimer> servo;
37

38
	int expectedPauseDivider = 7;
39
	
40
	servo.UpdateTimings();
41

42
	
43
	for(int i = 0; i < Pins::Length + 2; i++)
44
	{
45
		servo.TimerHandler();
46
		EXPECT_EQ(expectedPauseDivider, ServoTestTimer::timerData.CurrentDivider);
47
		EXPECT_NE(0, ServoTestTimer::timerData.Counter);
48
		EXPECT_EQ(Pins::Read(), 0);
49
	}
50
}
51

52
TEST(Servo, OneTurnedOn)
53
{
54
	SysClock::SetClockFreq(24000000);
55
	Servo<Pins, ServoTestTimer> servo;
56

57
	int expectedPauseDivider = 7;
58
	
59
	servo.UpdateTimings();
60
	
61
	servo.SetPosition(0, 1);
62
		
63
	servo.TimerHandler();
64
	EXPECT_EQ(expectedPauseDivider, ServoTestTimer::timerData.CurrentDivider);
65
	EXPECT_NE(0, ServoTestTimer::timerData.Counter);
66
	EXPECT_EQ(Pins::Read(), 0);
67
	
68
	servo.TimerHandler();
69
	EXPECT_EQ(1, ServoTestTimer::timerData.CurrentDivider);
70
	EXPECT_NE(0, ServoTestTimer::timerData.Counter);
71
	EXPECT_EQ(Pins::Read(), 1);
72
	
73
	servo.TimerHandler();
74
	EXPECT_EQ(expectedPauseDivider, ServoTestTimer::timerData.CurrentDivider);
75
	EXPECT_NE(0, ServoTestTimer::timerData.Counter);
76
	EXPECT_EQ(Pins::Read(), 0);
77
}
78

79
TEST(Servo, AllTurnedOnSamePosition)
80
{
81
	SysClock::SetClockFreq(24000000);
82
	Servo<Pins, ServoTestTimer> servo;
83

84
	int expectedPauseDivider = 7;
85
	
86
	servo.UpdateTimings();
87
	
88
	servo.SetPosition(0, 1);
89
	servo.SetPosition(1, 1);
90
	servo.SetPosition(2, 1);
91
	servo.SetPosition(3, 1);
92
	
93
	servo.TimerHandler();
94
	EXPECT_EQ(expectedPauseDivider, ServoTestTimer::timerData.CurrentDivider);
95
	EXPECT_NE(0, ServoTestTimer::timerData.Counter);
96
	EXPECT_EQ(Pins::Read(), 0);
97
	
98
	servo.TimerHandler();
99
	EXPECT_EQ(1, ServoTestTimer::timerData.CurrentDivider);
100
	EXPECT_NE(0, ServoTestTimer::timerData.Counter);
101
	EXPECT_EQ(Pins::Read(), 15);
102
	
103
	servo.TimerHandler();
104
	EXPECT_EQ(expectedPauseDivider, ServoTestTimer::timerData.CurrentDivider);
105
	EXPECT_NE(0, ServoTestTimer::timerData.Counter);
106
	EXPECT_EQ(Pins::Read(), 0);
107
}
108

109
TEST(Servo, AllTurnedOnDifferentPosition)
110
{
111
	SysClock::SetClockFreq(24000000);
112
	Servo<Pins, ServoTestTimer> servo;
113

114
	int expectedPauseDivider = 7;
115
	
116
	servo.UpdateTimings();
117
	
118
	servo.SetPosition(0, 10);
119
	servo.SetPosition(1, 20);
120
	servo.SetPosition(2, 30);
121
	servo.SetPosition(3, 40);
122
	
123
	servo.TimerHandler();
124
	EXPECT_EQ(expectedPauseDivider, ServoTestTimer::timerData.CurrentDivider);
125
	EXPECT_NE(0, ServoTestTimer::timerData.Counter);
126
	EXPECT_EQ(Pins::Read(), 0);
127
	
128
	servo.TimerHandler();
129
	EXPECT_EQ(1, ServoTestTimer::timerData.CurrentDivider);
130
	EXPECT_NE(0, ServoTestTimer::timerData.Counter);
131
	EXPECT_EQ(Pins::Read(), 15);
132
	
133
	servo.TimerHandler();
134
	EXPECT_EQ(1, ServoTestTimer::timerData.CurrentDivider);
135
	EXPECT_NE(0, ServoTestTimer::timerData.Counter);
136
	EXPECT_EQ(Pins::Read(), 14);
137
	
138
	servo.TimerHandler();
139
	EXPECT_EQ(1, ServoTestTimer::timerData.CurrentDivider);
140
	EXPECT_NE(0, ServoTestTimer::timerData.Counter);
141
	EXPECT_EQ(Pins::Read(), 12);
142
	
143
	servo.TimerHandler();
144
	EXPECT_EQ(1, ServoTestTimer::timerData.CurrentDivider);
145
	EXPECT_NE(0, ServoTestTimer::timerData.Counter);
146
	EXPECT_EQ(Pins::Read(), 8);
147
	
148
	servo.TimerHandler();
149
	EXPECT_EQ(expectedPauseDivider, ServoTestTimer::timerData.CurrentDivider);
150
	EXPECT_NE(0, ServoTestTimer::timerData.Counter);
151
	EXPECT_EQ(Pins::Read(), 0);
152
}