]>
Commit | Line | Data |
---|---|---|
92f5a8d4 TL |
1 | ////////////////////////////////////////////////////////////////// |
2 | // example93.cpp | |
3 | // | |
4 | // Copyright (c) 2015 Robert Ramey | |
5 | // | |
6 | // Distributed under the Boost Software License, Version 1.0. (See | |
7 | // accompanying file LICENSE_1_0.txt or copy at | |
8 | // http://www.boost.org/LICENSE_1_0.txt) | |
9 | ||
10 | #include <iostream> | |
11 | ||
12 | // include headers to support safe integers | |
13 | #include <boost/safe_numerics/cpp.hpp> | |
14 | #include <boost/safe_numerics/exception.hpp> | |
15 | #include <boost/safe_numerics/safe_integer.hpp> | |
16 | #include <boost/safe_numerics/safe_integer_range.hpp> | |
17 | #include <boost/safe_numerics/safe_integer_literal.hpp> | |
18 | ||
19 | // use same type promotion as used by the pic compiler | |
20 | // target compiler XC8 supports: | |
21 | using pic16_promotion = boost::safe_numerics::cpp< | |
22 | 8, // char 8 bits | |
23 | 16, // short 16 bits | |
24 | 16, // int 16 bits | |
25 | 16, // long 16 bits | |
26 | 32 // long long 32 bits | |
27 | >; | |
28 | ||
29 | // *************************** | |
30 | // 1. Specify exception policies so we will generate a | |
31 | // compile time error whenever an operation MIGHT fail. | |
32 | ||
33 | // *************************** | |
34 | // generate runtime errors if operation could fail | |
35 | using exception_policy = boost::safe_numerics::default_exception_policy; | |
36 | ||
37 | // generate compile time errors if operation could fail | |
38 | using trap_policy = boost::safe_numerics::loose_trap_policy; | |
39 | ||
40 | // *************************** | |
41 | // 2. Create a macro named literal an integral value | |
42 | // that can be evaluated at compile time. | |
43 | #define literal(n) make_safe_literal(n, pic16_promotion, void) | |
44 | ||
45 | // For min speed of 2 mm / sec (24.8 format) | |
46 | // sec / step = sec / 2 mm * 2 mm / rotation * rotation / 200 steps | |
47 | #define C0 literal(5000 << 8) | |
48 | ||
49 | // For max speed of 400 mm / sec | |
50 | // sec / step = sec / 400 mm * 2 mm / rotation * rotation / 200 steps | |
51 | #define C_MIN literal(25 << 8) | |
52 | ||
53 | static_assert( | |
54 | C0 < make_safe_literal(0xffffff, pic16_promotion,trap_policy), | |
55 | "Largest step too long" | |
56 | ); | |
57 | static_assert( | |
58 | C_MIN > make_safe_literal(0, pic16_promotion,trap_policy), | |
59 | "Smallest step must be greater than zero" | |
60 | ); | |
61 | ||
62 | // *************************** | |
63 | // 3. Create special ranged types for the motor program | |
64 | // These wiil guarantee that values are in the expected | |
65 | // ranges and permit compile time determination of when | |
66 | // exceptional conditions might occur. | |
67 | ||
68 | using pic_register_t = boost::safe_numerics::safe< | |
69 | uint8_t, | |
70 | pic16_promotion, | |
71 | trap_policy // use for compiling and running tests | |
72 | >; | |
73 | ||
74 | // note: the maximum value of step_t would be: | |
75 | // 50000 = 500 mm / 2 mm/rotation * 200 steps/rotation. | |
76 | // But in one expression the value of number of steps * 4 is | |
77 | // used. To prevent introduction of error, permit this | |
78 | // type to hold the larger value. | |
79 | using step_t = boost::safe_numerics::safe_unsigned_range< | |
80 | 0, | |
81 | 200000, | |
82 | pic16_promotion, | |
83 | exception_policy | |
84 | >; | |
85 | ||
86 | // position | |
87 | using position_t = boost::safe_numerics::safe_unsigned_range< | |
88 | 0, | |
89 | 50000, // 500 mm / 2 mm/rotation * 200 steps/rotation | |
90 | pic16_promotion, | |
91 | exception_policy | |
92 | >; | |
93 | ||
94 | // next end of step timer value in format 24.8 | |
95 | // where the .8 is the number of bits in the fractional part. | |
96 | using ccpr_t = boost::safe_numerics::safe< | |
97 | uint32_t, | |
98 | pic16_promotion, | |
99 | exception_policy | |
100 | >; | |
101 | ||
102 | // pulse length in format 24.8 | |
103 | // note: this value is constrainted to be a positive value. But | |
104 | // we still need to make it a signed type. We get an arithmetic | |
105 | // error when moving to a negative step number. | |
106 | using c_t = boost::safe_numerics::safe_unsigned_range< | |
107 | C_MIN, | |
108 | C0, | |
109 | pic16_promotion, | |
110 | exception_policy | |
111 | >; | |
112 | ||
f67539c2 TL |
113 | // 32 bit unsigned integer used for temporary purposes |
114 | using temp_t = boost::safe_numerics::safe_unsigned_range< | |
115 | 0, 0xffffffff, | |
116 | pic16_promotion, | |
117 | exception_policy | |
118 | >; | |
119 | ||
92f5a8d4 TL |
120 | // index into phase table |
121 | // note: The legal values are 0-3. So why must this be a signed | |
122 | // type? Turns out that expressions like phase_ix + d | |
123 | // will convert both operands to unsigned. This in turn will | |
124 | // create an exception. So leave it signed even though the | |
125 | // value is greater than zero. | |
126 | using phase_ix_t = boost::safe_numerics::safe_signed_range< | |
127 | 0, | |
128 | 3, | |
129 | pic16_promotion, | |
130 | trap_policy | |
131 | >; | |
132 | ||
133 | // settings for control value output | |
20effc67 | 134 | |
92f5a8d4 TL |
135 | using phase_t = boost::safe_numerics::safe< |
136 | uint16_t, | |
137 | pic16_promotion, | |
138 | trap_policy | |
139 | >; | |
140 | ||
141 | // direction of rotation | |
142 | using direction_t = boost::safe_numerics::safe_signed_range< | |
143 | -1, | |
144 | +1, | |
145 | pic16_promotion, | |
146 | trap_policy | |
147 | >; | |
148 | ||
149 | // some number of microseconds | |
150 | using microseconds = boost::safe_numerics::safe< | |
151 | uint32_t, | |
152 | pic16_promotion, | |
153 | trap_policy | |
154 | >; | |
155 | ||
156 | // *************************** | |
157 | // emulate PIC features on the desktop | |
158 | ||
159 | // filter out special keyword used only by XC8 compiler | |
160 | #define __interrupt | |
161 | // filter out XC8 enable/disable global interrupts | |
162 | #define ei() | |
163 | #define di() | |
164 | ||
165 | // emulate PIC special registers | |
166 | pic_register_t RCON; | |
167 | pic_register_t INTCON; | |
168 | pic_register_t CCP1IE; | |
169 | pic_register_t CCP2IE; | |
170 | pic_register_t PORTC; | |
171 | pic_register_t TRISC; | |
172 | pic_register_t T3CON; | |
173 | pic_register_t T1CON; | |
174 | ||
175 | pic_register_t CCPR2H; | |
176 | pic_register_t CCPR2L; | |
177 | pic_register_t CCPR1H; | |
178 | pic_register_t CCPR1L; | |
179 | pic_register_t CCP1CON; | |
180 | pic_register_t CCP2CON; | |
181 | pic_register_t TMR1H; | |
182 | pic_register_t TMR1L; | |
183 | ||
184 | // *************************** | |
185 | // special checked type for bits - values restricted to 0 or 1 | |
186 | using safe_bit_t = boost::safe_numerics::safe_unsigned_range< | |
187 | 0, | |
188 | 1, | |
189 | pic16_promotion, | |
190 | trap_policy | |
191 | >; | |
192 | ||
193 | // create type used to map PIC bit names to | |
194 | // correct bit in PIC register | |
195 | template<typename T, std::int8_t N> | |
196 | struct bit { | |
1e59de90 | 197 | T m_word; |
92f5a8d4 TL |
198 | constexpr explicit bit(T & rhs) : |
199 | m_word(rhs) | |
200 | {} | |
201 | // special functions for assignment of literal | |
202 | constexpr bit & operator=(decltype(literal(1))){ | |
203 | m_word |= literal(1 << N); | |
204 | return *this; | |
205 | } | |
206 | constexpr bit & operator=(decltype(literal(0))){ | |
207 | m_word &= ~literal(1 << N); | |
208 | return *this; | |
209 | } | |
210 | // operator to convert to 0 or 1 | |
211 | constexpr operator safe_bit_t () const { | |
212 | return m_word >> literal(N) & literal(1); | |
213 | } | |
214 | }; | |
215 | ||
216 | // define bits for T1CON register | |
217 | struct { | |
218 | bit<pic_register_t, 7> RD16{T1CON}; | |
219 | bit<pic_register_t, 5> T1CKPS1{T1CON}; | |
220 | bit<pic_register_t, 4> T1CKPS0{T1CON}; | |
221 | bit<pic_register_t, 3> T1OSCEN{T1CON}; | |
222 | bit<pic_register_t, 2> T1SYNC{T1CON}; | |
223 | bit<pic_register_t, 1> TMR1CS{T1CON}; | |
224 | bit<pic_register_t, 0> TMR1ON{T1CON}; | |
225 | } T1CONbits; | |
226 | ||
227 | // define bits for T1CON register | |
228 | struct { | |
229 | bit<pic_register_t, 7> GEI{INTCON}; | |
230 | bit<pic_register_t, 5> PEIE{INTCON}; | |
231 | bit<pic_register_t, 4> TMR0IE{INTCON}; | |
232 | bit<pic_register_t, 3> RBIE{INTCON}; | |
233 | bit<pic_register_t, 2> TMR0IF{INTCON}; | |
234 | bit<pic_register_t, 1> INT0IF{INTCON}; | |
235 | bit<pic_register_t, 0> RBIF{INTCON}; | |
236 | } INTCONbits; | |
237 | ||
238 | #include "motor3.c" | |
239 | ||
240 | #include <chrono> | |
241 | #include <thread> | |
242 | ||
243 | // round 24.8 format to microseconds | |
244 | microseconds to_microseconds(ccpr_t t){ | |
245 | return (t + literal(128)) / literal(256); | |
246 | } | |
247 | ||
248 | using result_t = uint8_t; | |
249 | const result_t success = 1; | |
250 | const result_t fail = 0; | |
251 | ||
252 | // move motor to the indicated target position in steps | |
253 | result_t test(position_t new_position){ | |
254 | try { | |
255 | std::cout << "move motor to " << new_position << '\n'; | |
256 | motor_run(new_position); | |
257 | std::cout | |
258 | << "step #" << ' ' | |
259 | << "delay(us)(24.8)" << ' ' | |
260 | << "delay(us)" << ' ' | |
261 | << "CCPR" << ' ' | |
262 | << "motor position" << '\n'; | |
263 | while(busy()){ | |
264 | std::this_thread::sleep_for(std::chrono::microseconds(to_microseconds(c))); | |
265 | c_t last_c = c; | |
266 | ccpr_t last_ccpr = ccpr; | |
267 | isr_motor_step(); | |
268 | std::cout << i << ' ' | |
269 | << last_c << ' ' | |
270 | << to_microseconds(last_c) << ' ' | |
271 | << std::hex << last_ccpr << std::dec << ' ' | |
272 | << motor_position << '\n'; | |
273 | }; | |
274 | } | |
275 | catch(const std::exception & e){ | |
276 | std::cout << e.what() << '\n'; | |
277 | return fail; | |
278 | } | |
279 | return success; | |
280 | } | |
281 | ||
282 | int main(){ | |
283 | std::cout << "start test\n"; | |
284 | result_t result = success; | |
285 | try { | |
286 | initialize(); | |
287 | // move motor to position 1000 | |
f67539c2 | 288 | result &= test(literal(9000)); |
92f5a8d4 TL |
289 | // move to the left before zero position |
290 | // fails to compile ! | |
291 | // result &= ! test(-10); | |
292 | // move motor to position 200 | |
293 | result &= test(literal(200)); | |
294 | // move motor to position 200 again! Should result in no movement. | |
295 | result &= test(literal(200)); | |
296 | // move motor to position 50000. | |
297 | result &= test(literal(50000)); | |
298 | // move motor back to position 0. | |
299 | result &= test(literal(0)); | |
300 | } | |
301 | catch(...){ | |
302 | std::cout << "test interrupted\n"; | |
303 | return EXIT_FAILURE; | |
304 | } | |
305 | std::cout << "end test\n"; | |
306 | return result == success ? EXIT_SUCCESS : EXIT_FAILURE; | |
307 | } |