Raspberry Pio Pico Drivers project
Loading...
Searching...
No Matches
sdkwrapper.hpp
Go to the documentation of this file.
1
15#ifndef PICO_DRIVER_SRC_SDK_SDKWRAPPER_HPP_
16#define PICO_DRIVER_SRC_SDK_SDKWRAPPER_HPP_
17
18#if __has_include("pico/stdlib.h")
19// For Pico
20#include "pico/stdlib.h"
21#include "pico_sdk_headers.h"
22
23#else
24// Alternative include and definition for Unix/Win32
25#include <stdint.h>
26#include <stdlib.h>
27
28#include "pico_api_alternate_defs.hpp"
29#ifdef _MSC_VER
30typedef unsigned int uint;
31#endif
32#endif
33
34#if __has_include(<gmock/gmock.h>)
35#include <gmock/gmock.h>
36#endif
37
42namespace rpp_driver {
74class SdkWrapper {
75 public:
76 virtual ~SdkWrapper() {}
77
78#if __has_include(<hardware/i2c.h>) || __has_include(<gmock/gmock.h>)
79 virtual void i2c_deinit(i2c_inst_t* i2c);
80 virtual uint i2c_get_dreq(i2c_inst_t* i2c, bool is_tx);
81 virtual i2c_hw_t* i2c_get_hw(i2c_inst_t* i2c);
82 virtual uint i2c_get_index(i2c_inst_t* i2c);
83 virtual i2c_inst_t* i2c_get_instance(uint num);
84 virtual size_t i2c_get_read_available(i2c_inst_t* i2c);
85 virtual size_t i2c_get_write_available(i2c_inst_t* i2c);
86 virtual uint i2c_init(i2c_inst_t* i2c, uint baudrate);
87 virtual int i2c_read_blocking(i2c_inst_t* i2c, uint8_t addr, uint8_t* dst,
88 size_t len, bool nostop);
89 virtual int i2c_read_blocking_until(i2c_inst_t* i2c, uint8_t addr,
90 uint8_t* dst, size_t len, bool nostop,
91 absolute_time_t until);
92 virtual uint8_t i2c_read_byte_raw(i2c_inst_t* i2c);
93 virtual void i2c_read_raw_blocking(i2c_inst_t* i2c, uint8_t* dst, size_t len);
94 virtual int i2c_read_timeout_per_char_us(i2c_inst_t* i2c, uint8_t addr,
95 uint8_t* dst, size_t len,
96 bool nostop,
97 uint timeout_per_char_us);
98 virtual int i2c_read_timeout_us(i2c_inst_t* i2c, uint8_t addr, uint8_t* dst,
99 size_t len, bool nostop, uint timeout_us);
100 virtual uint i2c_set_baudrate(i2c_inst_t* i2c, uint baudrate);
101 virtual void i2c_set_slave_mode(i2c_inst_t* i2c, bool slave, uint8_t addr);
102 virtual int i2c_write_blocking(i2c_inst_t* i2c, uint8_t addr,
103 const uint8_t* src, size_t len, bool nostop);
104 virtual int i2c_write_blocking_until(i2c_inst_t* i2c, uint8_t addr,
105 const uint8_t* src, size_t len,
106 bool nostop, absolute_time_t until);
107 virtual void i2c_write_byte_raw(i2c_inst_t* i2c, uint8_t value);
108 virtual void i2c_write_raw_blocking(i2c_inst_t* i2c, const uint8_t* src,
109 size_t len);
110 virtual int i2c_write_timeout_per_char_us(i2c_inst_t* i2c, uint8_t addr,
111 const uint8_t* src, size_t len,
112 bool nostop,
113 uint timeout_per_char_us);
114 virtual int i2c_write_timeout_us(i2c_inst_t* i2c, uint8_t addr,
115 const uint8_t* src, size_t len, bool nostop,
116 uint timeout_us);
117#endif // __has_include(<hardware/i2c.h>) || __has_include(<gmock/gmock.h>)
118
119#if __has_include(<hardware/pio.h>) || __has_include(<gmock/gmock.h>)
120 virtual int pio_add_program(PIO pio, const pio_program_t* program);
121 virtual int pio_add_program_at_offset(PIO pio, const pio_program_t* program,
122 uint offset);
123 virtual void pio_calculate_clkdiv_from_float(float div, uint16_t* div_int,
124 uint8_t* div_frac);
125 virtual bool pio_can_add_program(PIO pio, const pio_program_t* program);
126 virtual bool pio_can_add_program_at_offset(PIO pio,
127 const pio_program_t* program,
128 uint offset);
129 virtual bool pio_claim_free_sm_and_add_program(const pio_program_t* program,
130 PIO* pio, uint* sm,
131 uint* offset);
132 virtual bool pio_claim_free_sm_and_add_program_for_gpio_range(
133 const pio_program_t* program, PIO* pio, uint* sm, uint* offset,
134 uint gpio_base, uint gpio_count, bool set_gpio_base);
135 virtual void pio_claim_sm_mask(PIO pio, uint sm_mask);
136 virtual int pio_claim_unused_sm(PIO pio, bool required);
137 virtual void pio_clear_instruction_memory(PIO pio);
138 virtual void pio_clkdiv_restart_sm_mask(PIO pio, uint32_t mask);
139 virtual void pio_clkdiv_restart_sm_multi_mask(PIO pio, uint32_t mask_prev,
140 uint32_t mask,
141 uint32_t mask_next);
142 virtual void pio_enable_sm_mask_in_sync(PIO pio, uint32_t mask);
143 virtual void pio_enable_sm_multi_mask_in_sync(PIO pio, uint32_t mask_prev,
144 uint32_t mask,
145 uint32_t mask_next);
146 virtual pio_sm_config pio_get_default_sm_config(void);
147 virtual uint pio_get_dreq(PIO pio, uint sm, bool is_tx);
148 virtual uint pio_get_funcsel(PIO pio);
149 virtual uint pio_get_gpio_base(PIO pio);
150 virtual uint pio_get_index(PIO pio);
151 virtual PIO pio_get_instance(uint instance);
152 virtual int pio_get_irq_num(PIO pio, uint irqn);
153 virtual pio_interrupt_source_t pio_get_rx_fifo_not_empty_interrupt_source(
154 uint sm);
155 virtual pio_interrupt_source_t pio_get_tx_fifo_not_full_interrupt_source(
156 uint sm);
157 virtual void pio_gpio_init(PIO pio, uint pin);
158 virtual void pio_interrupt_clear(PIO pio, uint pio_interrupt_num);
159 virtual bool pio_interrupt_get(PIO pio, uint pio_interrupt_num);
160 virtual void pio_remove_program(PIO pio, const pio_program_t* program,
161 uint loaded_offset);
162 virtual void pio_remove_program_and_unclaim_sm(const pio_program_t* program,
163 PIO pio, uint sm, uint offset);
164 virtual void pio_restart_sm_mask(PIO pio, uint32_t mask);
165 virtual int pio_set_gpio_base(PIO pio, uint gpio_base);
166 virtual void pio_set_irq0_source_enabled(PIO pio,
167 pio_interrupt_source_t source,
168 bool enabled);
169 virtual void pio_set_irq0_source_mask_enabled(PIO pio, uint32_t source_mask,
170 bool enabled);
171 virtual void pio_set_irq1_source_enabled(PIO pio,
172 pio_interrupt_source_t source,
173 bool enabled);
174 virtual void pio_set_irq1_source_mask_enabled(PIO pio, uint32_t source_mask,
175 bool enabled);
176 virtual void pio_set_irqn_source_enabled(PIO pio, uint irq_index,
177 pio_interrupt_source_t source,
178 bool enabled);
179 virtual void pio_set_irqn_source_mask_enabled(PIO pio, uint irq_index,
180 uint32_t source_mask,
181 bool enabled);
182 virtual void pio_set_sm_mask_enabled(PIO pio, uint32_t mask, bool enabled);
183 virtual void pio_set_sm_multi_mask_enabled(PIO pio, uint32_t mask_prev,
184 uint32_t mask, uint32_t mask_next,
185 bool enabled);
186 virtual void pio_sm_claim(PIO pio, uint sm);
187 virtual void pio_sm_clear_fifos(PIO pio, uint sm);
188 virtual void pio_sm_clkdiv_restart(PIO pio, uint sm);
189 virtual void pio_sm_drain_tx_fifo(PIO pio, uint sm);
190 virtual void pio_sm_exec(PIO pio, uint sm, uint instr);
191 virtual void pio_sm_exec_wait_blocking(PIO pio, uint sm, uint instr);
192 virtual uint32_t pio_sm_get(PIO pio, uint sm);
193 virtual uint32_t pio_sm_get_blocking(PIO pio, uint sm);
194 virtual uint8_t pio_sm_get_pc(PIO pio, uint sm);
195 virtual uint pio_sm_get_rx_fifo_level(PIO pio, uint sm);
196 virtual uint pio_sm_get_tx_fifo_level(PIO pio, uint sm);
197 virtual int pio_sm_init(PIO pio, uint sm, uint initial_pc,
198 const pio_sm_config* config);
199 virtual bool pio_sm_is_claimed(PIO pio, uint sm);
200 virtual bool pio_sm_is_exec_stalled(PIO pio, uint sm);
201 virtual bool pio_sm_is_rx_fifo_empty(PIO pio, uint sm);
202 virtual bool pio_sm_is_rx_fifo_full(PIO pio, uint sm);
203 virtual bool pio_sm_is_tx_fifo_empty(PIO pio, uint sm);
204 virtual bool pio_sm_is_tx_fifo_full(PIO pio, uint sm);
205 virtual void pio_sm_put(PIO pio, uint sm, uint32_t data);
206 virtual void pio_sm_put_blocking(PIO pio, uint sm, uint32_t data);
207 virtual void pio_sm_restart(PIO pio, uint sm);
208 virtual void pio_sm_set_clkdiv(PIO pio, uint sm, float div);
209 virtual void pio_sm_set_clkdiv_int_frac(PIO pio, uint sm, uint16_t div_int,
210 uint8_t div_frac);
211 virtual int pio_sm_set_config(PIO pio, uint sm, const pio_sm_config* config);
212 virtual int pio_sm_set_consecutive_pindirs(PIO pio, uint sm, uint pins_base,
213 uint pin_count, bool is_out);
214 virtual void pio_sm_set_enabled(PIO pio, uint sm, bool enabled);
215 virtual void pio_sm_set_in_pins(PIO pio, uint sm, uint in_base);
216 virtual void pio_sm_set_jmp_pin(PIO pio, uint sm, uint pin);
217 virtual void pio_sm_set_out_pins(PIO pio, uint sm, uint out_base,
218 uint out_count);
219 virtual void pio_sm_set_pindirs_with_mask(PIO pio, uint sm, uint32_t pin_dirs,
220 uint32_t pin_mask);
221 virtual void pio_sm_set_pins(PIO pio, uint sm, uint32_t pin_values);
222 virtual void pio_sm_set_pins_with_mask(PIO pio, uint sm, uint32_t pin_values,
223 uint32_t pin_mask);
224 virtual void pio_sm_set_set_pins(PIO pio, uint sm, uint set_base,
225 uint set_count);
226 virtual void pio_sm_set_sideset_pins(PIO pio, uint sm, uint sideset_base);
227 virtual void pio_sm_set_wrap(PIO pio, uint sm, uint wrap_target, uint wrap);
228 virtual void pio_sm_unclaim(PIO pio, uint sm);
229 virtual void sm_config_set_clkdiv(pio_sm_config* c, float div);
230 virtual void sm_config_set_clkdiv_int_frac(pio_sm_config* c, uint16_t div_int,
231 uint8_t div_frac);
232 virtual void sm_config_set_fifo_join(pio_sm_config* c,
233 enum pio_fifo_join join);
234 virtual void sm_config_set_in_pin_base(pio_sm_config* c, uint in_base);
235 virtual void sm_config_set_in_pin_count(pio_sm_config* c, uint in_count);
236 virtual void sm_config_set_in_pins(pio_sm_config* c, uint in_base);
237 virtual void sm_config_set_in_shift(pio_sm_config* c, bool shift_right,
238 bool autopush, uint push_threshold);
239 virtual void sm_config_set_jmp_pin(pio_sm_config* c, uint pin);
240 virtual void sm_config_set_mov_status(pio_sm_config* c,
241 enum pio_mov_status_type status_sel,
242 uint status_n);
243 virtual void sm_config_set_out_pin_base(pio_sm_config* c, uint out_base);
244 virtual void sm_config_set_out_pin_count(pio_sm_config* c, uint out_count);
245 virtual void sm_config_set_out_pins(pio_sm_config* c, uint out_base,
246 uint out_count);
247 virtual void sm_config_set_out_shift(pio_sm_config* c, bool shift_right,
248 bool autopull, uint pull_threshold);
249 virtual void sm_config_set_out_special(pio_sm_config* c, bool sticky,
250 bool has_enable_pin,
251 uint enable_pin_index);
252 virtual void sm_config_set_set_pin_base(pio_sm_config* c, uint set_base);
253 virtual void sm_config_set_set_pin_count(pio_sm_config* c, uint set_count);
254 virtual void sm_config_set_set_pins(pio_sm_config* c, uint set_base,
255 uint set_count);
256 virtual void sm_config_set_sideset(pio_sm_config* c, uint bit_count,
257 bool optional, bool pindirs);
258 virtual void sm_config_set_sideset_pin_base(pio_sm_config* c,
259 uint sideset_base);
260 virtual void sm_config_set_sideset_pins(pio_sm_config* c, uint sideset_base);
261 virtual void sm_config_set_wrap(pio_sm_config* c, uint wrap_target,
262 uint wrap);
263#endif // __has_include(<hardware/pio.h>) || __has_include(<gmock/gmock.h>)
264
265#if __has_include(<hardware/gpio.h>) || __has_include(<gmock/gmock.h>)
266 virtual void gpio_acknowledge_irq(uint gpio, uint32_t event_mask);
267 virtual void gpio_add_raw_irq_handler(uint gpio, irq_handler_t handler);
268 virtual void gpio_add_raw_irq_handler_masked(uint32_t gpio_mask,
269 irq_handler_t handler);
270 virtual void gpio_add_raw_irq_handler_masked64(uint64_t gpio_mask,
271 irq_handler_t handler);
272 virtual void gpio_add_raw_irq_handler_with_order_priority(
273 uint gpio, irq_handler_t handler, uint8_t order_priority);
274 virtual void gpio_add_raw_irq_handler_with_order_priority_masked(
275 uint32_t gpio_mask, irq_handler_t handler, uint8_t order_priority);
276 virtual void gpio_add_raw_irq_handler_with_order_priority_masked64(
277 uint64_t gpio_mask, irq_handler_t handler, uint8_t order_priority);
278 virtual void gpio_assign_to_ns(uint gpio, bool ns);
279 virtual void gpio_clr_mask(uint32_t mask);
280 virtual void gpio_clr_mask64(uint64_t mask);
281 virtual void gpio_clr_mask_n(uint n, uint32_t mask);
282 virtual void gpio_debug_pins_init(void);
283 virtual void gpio_deinit(uint gpio);
284 virtual void gpio_disable_pulls(uint gpio);
285 virtual bool gpio_get(uint gpio);
286 virtual uint32_t gpio_get_all(void);
287 virtual uint64_t gpio_get_all64(void);
288 virtual uint gpio_get_dir(uint gpio);
289 virtual enum gpio_drive_strength gpio_get_drive_strength(uint gpio);
290 virtual gpio_function_t gpio_get_function(uint gpio);
291 virtual uint32_t gpio_get_irq_event_mask(uint gpio);
292 virtual bool gpio_get_out_level(uint gpio);
293 virtual enum gpio_slew_rate gpio_get_slew_rate(uint gpio);
294 virtual void gpio_init(uint gpio);
295 virtual void gpio_init_mask(uint gpio_mask);
296 virtual bool gpio_is_dir_out(uint gpio);
297 virtual bool gpio_is_input_hysteresis_enabled(uint gpio);
298 virtual bool gpio_is_pulled_down(uint gpio);
299 virtual bool gpio_is_pulled_up(uint gpio);
300 virtual void gpio_pull_down(uint gpio);
301 virtual void gpio_pull_up(uint gpio);
302 virtual void gpio_put(uint gpio, bool value);
303 virtual void gpio_put_all(uint32_t value);
304 virtual void gpio_put_all64(uint64_t value);
305 virtual void gpio_put_masked(uint32_t mask, uint32_t value);
306 virtual void gpio_put_masked64(uint64_t mask, uint64_t value);
307 virtual void gpio_put_masked_n(uint n, uint32_t mask, uint32_t value);
308 virtual void gpio_remove_raw_irq_handler(uint gpio, irq_handler_t handler);
309 virtual void gpio_remove_raw_irq_handler_masked(uint32_t gpio_mask,
310 irq_handler_t handler);
311 virtual void gpio_remove_raw_irq_handler_masked64(uint64_t gpio_mask,
312 irq_handler_t handler);
313 virtual void gpio_set_dir(uint gpio, bool out);
314 virtual void gpio_set_dir_all_bits(uint32_t values);
315 virtual void gpio_set_dir_all_bits64(uint64_t values);
316 virtual void gpio_set_dir_in_masked(uint32_t mask);
317 virtual void gpio_set_dir_in_masked64(uint64_t mask);
318 virtual void gpio_set_dir_masked(uint32_t mask, uint32_t value);
319 virtual void gpio_set_dir_masked64(uint64_t mask, uint64_t value);
320 virtual void gpio_set_dir_out_masked(uint32_t mask);
321 virtual void gpio_set_dir_out_masked64(uint64_t mask);
322 virtual void gpio_set_dormant_irq_enabled(uint gpio, uint32_t event_mask,
323 bool enabled);
324 virtual void gpio_set_drive_strength(uint gpio,
325 enum gpio_drive_strength drive);
326 virtual void gpio_set_function(uint gpio, gpio_function_t fn);
327 virtual void gpio_set_function_masked(uint32_t gpio_mask, gpio_function_t fn);
328 virtual void gpio_set_function_masked64(uint64_t gpio_mask,
329 gpio_function_t fn);
330 virtual void gpio_set_inover(uint gpio, uint value);
331 virtual void gpio_set_input_enabled(uint gpio, bool enabled);
332 virtual void gpio_set_input_hysteresis_enabled(uint gpio, bool enabled);
333 virtual void gpio_set_irq_callback(gpio_irq_callback_t callback);
334 virtual void gpio_set_irq_enabled(uint gpio, uint32_t event_mask,
335 bool enabled);
336 virtual void gpio_set_irq_enabled_with_callback(uint gpio,
337 uint32_t event_mask,
338 bool enabled,
339 gpio_irq_callback_t callback);
340 virtual void gpio_set_irqover(uint gpio, uint value);
341 virtual void gpio_set_mask(uint32_t mask);
342 virtual void gpio_set_mask64(uint64_t mask);
343 virtual void gpio_set_mask_n(uint n, uint32_t mask);
344 virtual void gpio_set_oeover(uint gpio, uint value);
345 virtual void gpio_set_outover(uint gpio, uint value);
346 virtual void gpio_set_pulls(uint gpio, bool up, bool down);
347 virtual void gpio_set_slew_rate(uint gpio, enum gpio_slew_rate slew);
348 virtual void gpio_xor_mask(uint32_t mask);
349 virtual void gpio_xor_mask64(uint64_t mask);
350 virtual void gpio_xor_mask_n(uint n, uint32_t mask);
351#endif // __has_include(<hardware/gpio.h>) || __has_include(<gmock/gmock.h>)
352
353#if __has_include(<hardware/clocks.h>) || __has_include(<gmock/gmock.h>)
354 virtual bool check_sys_clock_hz(uint32_t freq_hz, uint* vco_freq_out,
355 uint* post_div1_out, uint* post_div2_out);
356 virtual bool check_sys_clock_khz(uint32_t freq_khz, uint* vco_freq_out,
357 uint* post_div1_out, uint* post_div2_out);
358 virtual bool clock_configure(clock_handle_t clock, uint32_t src,
359 uint32_t auxsrc, uint32_t src_freq,
360 uint32_t freq);
361 virtual bool clock_configure_gpin(clock_handle_t clock, uint gpio,
362 uint32_t src_freq, uint32_t freq);
363 virtual void clock_configure_int_divider(clock_handle_t clock, uint32_t src,
364 uint32_t auxsrc, uint32_t src_freq,
365 uint32_t int_divider);
366 virtual void clock_configure_undivided(clock_handle_t clock, uint32_t src,
367 uint32_t auxsrc, uint32_t src_freq);
368 virtual uint32_t clock_get_hz(clock_handle_t clock);
369 virtual void clock_gpio_init(uint gpio, uint src, float div);
370 virtual void clock_gpio_init_int_frac(uint gpio, uint src, uint32_t div_int,
371 uint8_t div_frac);
372 virtual void clock_set_reported_hz(clock_handle_t clock, uint hz);
373 virtual void clock_stop(clock_handle_t clock);
374 virtual void clocks_enable_resus(resus_callback_t resus_callback);
375 virtual uint32_t frequency_count_khz(uint src);
376 virtual float frequency_count_mhz(uint src);
377 virtual void set_sys_clock_48mhz(void);
378 virtual bool set_sys_clock_hz(uint32_t freq_hz, bool required);
379 virtual bool set_sys_clock_khz(uint32_t freq_khz, bool required);
380 virtual void set_sys_clock_pll(uint32_t vco_freq, uint post_div1,
381 uint post_div2);
382#endif // __has_include(<hardware/clocks.h>) || __has_include(<gmock/gmock.h>)
383
384#if __has_include(<pico/time.h>) || __has_include(<gmock/gmock.h>)
385 virtual int64_t absolute_time_diff_us(absolute_time_t from,
386 absolute_time_t to);
387 virtual absolute_time_t absolute_time_min(absolute_time_t a,
388 absolute_time_t b);
389 virtual alarm_id_t add_alarm_at(absolute_time_t time,
390 alarm_callback_t callback, void* user_data,
391 bool fire_if_past);
392 virtual alarm_id_t add_alarm_in_ms(uint32_t ms, alarm_callback_t callback,
393 void* user_data, bool fire_if_past);
394 virtual alarm_id_t add_alarm_in_us(uint64_t us, alarm_callback_t callback,
395 void* user_data, bool fire_if_past);
396 virtual bool add_repeating_timer_ms(int32_t delay_ms,
397 repeating_timer_callback_t callback,
398 void* user_data, repeating_timer_t* out);
399 virtual bool add_repeating_timer_us(int64_t delay_us,
400 repeating_timer_callback_t callback,
401 void* user_data, repeating_timer_t* out);
402 virtual alarm_id_t alarm_pool_add_alarm_at(alarm_pool_t* pool,
403 absolute_time_t time,
404 alarm_callback_t callback,
405 void* user_data,
406 bool fire_if_past);
407 virtual alarm_id_t alarm_pool_add_alarm_at_force_in_context(
408 alarm_pool_t* pool, absolute_time_t time, alarm_callback_t callback,
409 void* user_data);
410 virtual alarm_id_t alarm_pool_add_alarm_in_ms(alarm_pool_t* pool, uint32_t ms,
411 alarm_callback_t callback,
412 void* user_data,
413 bool fire_if_past);
414 virtual alarm_id_t alarm_pool_add_alarm_in_us(alarm_pool_t* pool, uint64_t us,
415 alarm_callback_t callback,
416 void* user_data,
417 bool fire_if_past);
418 virtual bool alarm_pool_add_repeating_timer_ms(
419 alarm_pool_t* pool, int32_t delay_ms, repeating_timer_callback_t callback,
420 void* user_data, repeating_timer_t* out);
421 virtual bool alarm_pool_add_repeating_timer_us(
422 alarm_pool_t* pool, int64_t delay_us, repeating_timer_callback_t callback,
423 void* user_data, repeating_timer_t* out);
424 virtual bool alarm_pool_cancel_alarm(alarm_pool_t* pool, alarm_id_t alarm_id);
425 virtual uint alarm_pool_core_num(alarm_pool_t* pool);
426 virtual alarm_pool_t* alarm_pool_create(uint timer_alarm_num,
427 uint max_timers);
428 virtual alarm_pool_t* alarm_pool_create_on_timer(alarm_pool_timer_t* timer,
429 uint timer_alarm_num,
430 uint max_timers);
431 virtual alarm_pool_t* alarm_pool_create_on_timer_with_unused_hardware_alarm(
432 alarm_pool_timer_t* timer, uint max_timers);
433 virtual alarm_pool_t* alarm_pool_create_with_unused_hardware_alarm(
434 uint max_timers);
435 virtual void alarm_pool_destroy(alarm_pool_t* pool);
436 virtual alarm_pool_t* alarm_pool_get_default(void);
437 virtual alarm_pool_timer_t* alarm_pool_get_default_timer(void);
438 virtual uint alarm_pool_hardware_alarm_num(alarm_pool_t* pool);
439 virtual void alarm_pool_init_default(void);
440 virtual int32_t alarm_pool_remaining_alarm_time_ms(alarm_pool_t* pool,
441 alarm_id_t alarm_id);
442 virtual int64_t alarm_pool_remaining_alarm_time_us(alarm_pool_t* pool,
443 alarm_id_t alarm_id);
444 virtual uint alarm_pool_timer_alarm_num(alarm_pool_t* pool);
445 virtual alarm_pool_timer_t* alarm_pool_timer_for_timer_num(uint timer_num);
446 virtual bool best_effort_wfe_or_timeout(absolute_time_t timeout_timestamp);
447 virtual bool cancel_alarm(alarm_id_t alarm_id);
448 virtual bool cancel_repeating_timer(repeating_timer_t* timer);
449 virtual absolute_time_t delayed_by_ms(const absolute_time_t t, uint32_t ms);
450 virtual absolute_time_t delayed_by_us(const absolute_time_t t, uint64_t us);
451 virtual absolute_time_t get_absolute_time(void);
452 virtual bool is_at_the_end_of_time(absolute_time_t t);
453 virtual bool is_nil_time(absolute_time_t t);
454 virtual absolute_time_t make_timeout_time_ms(uint32_t ms);
455 virtual absolute_time_t make_timeout_time_us(uint64_t us);
456 virtual int32_t remaining_alarm_time_ms(alarm_id_t alarm_id);
457 virtual int64_t remaining_alarm_time_us(alarm_id_t alarm_id);
458 virtual void runtime_init_default_alarm_pool(void);
459 virtual void sleep_ms(uint32_t ms);
460 virtual void sleep_until(absolute_time_t target);
461 virtual void sleep_us(uint64_t us);
462 virtual uint32_t to_ms_since_boot(absolute_time_t t);
463 virtual uint32_t us_to_ms(uint64_t us);
464#endif // __has_include(<pico/time.h>) || __has_include(<gmock/gmock.h>)
465
466#if __has_include(<pico/stdio.h>) || __has_include(<gmock/gmock.h>)
467 virtual int getchar_timeout_us(uint32_t timeout_us);
468 virtual int putchar_raw(int c);
469 virtual int puts_raw(const char* s);
470 virtual bool stdio_deinit_all(void);
471 virtual void stdio_filter_driver(stdio_driver_t* driver);
472 virtual void stdio_flush(void);
473 virtual int stdio_get_until(char* buf, int len, absolute_time_t until);
474 virtual bool stdio_init_all(void);
475 virtual int stdio_put_string(const char* s, int len, bool newline,
476 bool cr_translation);
477 virtual void stdio_set_driver_enabled(stdio_driver_t* driver, bool enabled);
478 virtual void stdio_set_translate_crlf(stdio_driver_t* driver, bool translate);
479#endif // __has_include(<pico/stdio.h>) || __has_include(<gmock/gmock.h>)
480
481}; // class SdkWrapper
482
483#include "mocksdkwrapper.hpp"
484}; // namespace rpp_driver
485
486#endif // PICO_DRIVER_SRC_SDK_SDKWRAPPER_HPP_
rpp_driver::SdkWrapper
Wrapper class for the RasPi Pico SDK functions.
Definition: sdkwrapper.hpp:74
i2c_inst_t
int i2c_inst_t
Alternate definition for unit test.
Definition: i2cmaster.hpp:21
rpp_driver
Collection of the RP2040/RP2350 control.
Definition: adau1361.hpp:17
Generated by doxygen 1.9.6