pico-sdk/test/pico_stdlib_test/pico_stdlib_test.c
graham sanderson 26653ea81e Initial Release
2021-01-20 10:44:27 -06:00

179 lines
4.2 KiB
C

/*
* Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#include <stdio.h>
#include <inttypes.h>
#include "pico/stdlib.h"
#include "pico/bit_ops.h"
int main() {
setup_default_uart();
puts("Hellox, worlxxcd!");
printf("Hello world %d\n", 2);
#if PICO_NO_HARDWARE
puts("This is native");
#endif
#if PICO_NO_FLASH
puts("This is no flash");
#endif
for (int i = 0; i < 64; i++) {
uint32_t x = 1 << i;
uint64_t xl = 1ull << i;
// printf("%d %u %u %u %u \n", i, (uint)(x%10u), (uint)(x%16u), (uint)(xl %10u), (uint)(xl%16u));
printf("%08x %08x %016llx %016llx\n", (uint) x, (uint) __rev(x), (unsigned long long) xl,
(unsigned long long) __revll(xl));
}
for (int i = 0; i < 8; i++) {
sleep_ms(500);
printf( "%" PRIu64 "\n", to_us_since_boot(get_absolute_time()));
}
absolute_time_t until = delayed_by_us(get_absolute_time(), 500000);
printf("\n");
for (int i = 0; i < 8; i++) {
sleep_until(until);
printf("%" PRIu64 "\n", to_us_since_boot(get_absolute_time()));
until = delayed_by_us(until, 500000);
}
puts("DONE");
}
void test1() {
uint32_t x = 0;
for (int i = 0; i < 1000; i++) {
x += __builtin_popcount(i);
x += __builtin_popcountl(i);
x += __builtin_popcountll(i * 1234567ll);
x += __builtin_clz(i);
x += __builtin_clzl(i);
x += __builtin_clzll(i * 1234567ll);
x += __builtin_ctz(i);
x += __builtin_ctzl(i);
x += __builtin_ctzll(i * 1234567ll);
}
if (x > 12345677) {
puts("ok");
}
}
#if 0
struct event {
};
// something might be asyncrhonous.. it communicates the result via the event
void do_something(struct event *e, int a, unsigned int b, char *c) {
if (a == b) puts(c);
}
int32_t event_result_timeout_ms(struct event *e, int32_t timeout_ms);
int32_t event_result_timeout_us(struct event *e, int32_t timeout_us);
bool is_event_done(struct event *e);
// asserts if not done
int32_t event_result(struct event *e);
void event_set_callback(struct event *e, void (*callback)(struct event *e));
void init_multi_event(struct event *target, struct event **events, uint event_count);
#define timeout_ms_result(f, timeout) ({ \
struct event __event; \
struct event *event = &__event; \
(f); \
event_result_timeout_ms(event, timeout); \
})
#define blocking_result(f) timeout_ms_result(f, -1)
#define on_complete(f, cb) ({ \
static struct event __event; \
struct event *event = &__event; \
(f); \
event_set_callback(event, my_callback); \
})
void test2() {
// just playing with blocking syntax
struct event e;
do_something(&e, 1, 1, "Hello");
uint32_t result = event_result_timeout_ms(&e, -1);
}
void test3() {
uint32_t result = blocking_result(do_something(event, 1, 1, "Hello"));
}
void test4() {
struct event e;
do_something(&e, 1, 1, "Hello");
// this would poll (down to hardware if there is no asynchronous mechanism)
while (!is_event_done(&e)) {
puts("waiting");
}
int32_t result = event_result(&e);
}
void my_callback(struct event *event) {
puts("Its done");
int32_t result = event_result(event);
}
void test5() {
static struct event e;
do_something(&e, 1, 1, "Hello");
event_set_callback(&e, my_callback);
}
void test6() {
on_complete(do_something(event, 1, 1, "Hello"), my_callback);
}
static struct event e1;
static struct event e2;
static struct event *events[2] = {&e1, &e2};
static struct event multi;
void test7() {
init_multi_event(&multi,events, count_of(events));
do_something(&e1, 1, 1, "Hello");
do_something(&e2, 1, 3, "Hello");
// something like this
}
struct dimpl {
uint8_t type;
};
struct doodad {
struct dimpl *type;
uint32_t param;
};
struct dimpl indefinite_waiter = {
.type = 1
};
extern struct dimpl INDEFINITE_WAIT;
struct dimpl ms_waiter = {
.type = 1
};
struct doodad blocking_with_timeout_ms(uint32_t ms) {
struct doodad rc = {
.type = &ms_waiter,
.param = ms
};
return rc;
}
struct result {
};
struct result my_api_call(int arg, float x, struct doodad behavior) {
}
#endif