my first commit

Co-authored-by: Paulo Marques <pm@quant-insight.com>

README.md

@@ -202,7 +202,7 @@ App|Description
 [picow_bt_example_spp_flowcontrol](https://github.com/bluekitchen/btstack/tree/master/example/spp_flowcontrol.c) | SPP Server - RFCOMM Flow Control.
 [picow_bt_example_spp_streamer_client](https://github.com/bluekitchen/btstack/tree/master/example/spp_streamer_client.c) | Performance - Stream Data over SPP (Client.c).
 [picow_bt_example_spp_streamer](https://github.com/bluekitchen/btstack/tree/master/example/spp_streamer.c) | Performance - Stream Data over SPP (Server.c).
-[picow_bt_example_ublox_spp_le_counter](pico_w/bt/ublox_spp_le_counter.c) | LE u-blox SPP-like Heartbeat Server.
+[picow_bt_example_ublox_spp_le_counter](https://github.com/bluekitchen/btstack/blob/master/example/ublox_spp_le_counter.c) | LE u-blox SPP-like Heartbeat Server.
 
 Some Standalone Bluetooth examples (without all the common example build infrastructure) are also available:
 

adc/read_vsys/power_status.c

@@ -35,7 +35,7 @@ int power_source(bool *battery_powered) {
 int power_voltage(float *voltage_result) {
 #ifndef PICO_VSYS_PIN
     return PICO_ERROR_NO_DATA;
-#endif
+#else
 #if CYW43_USES_VSYS_PIN
     cyw43_thread_enter();
     // Make sure cyw43 is awake
@@ -73,4 +73,5 @@ int power_voltage(float *voltage_result) {
     const float conversion_factor = 3.3f / (1 << 12);
     *voltage_result = vsys * 3 * conversion_factor;
     return PICO_OK;
+#endif
 }

hello_world/usb/CMakeLists.txt

@@ -1,10 +1,11 @@
 if (TARGET tinyusb_device)
     add_executable(hello_usb
-            hello_usb.c
+            hello_usb.cpp
             )
-
+    set(PICO_CXX_ENABLE_EXCEPTIONS 1)
     # pull in common dependencies
-    target_link_libraries(hello_usb pico_stdlib)
+    target_link_libraries(hello_usb pico_stdlib pico_multicore pico_util)
+    target_compile_definitions(hello_usb PRIVATE PARAM_ASSERTIONS_ENABLE_ALL=1)
 
     # enable usb output, disable uart output
     pico_enable_stdio_usb(hello_usb 1)

hello_world/usb/hello_usb.c

@@ -1,16 +0,0 @@
-/**
- * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#include <stdio.h>
-#include "pico/stdlib.h"
-
-int main() {
-    stdio_init_all();
-    while (true) {
-        printf("Hello, world!\n");
-        sleep_ms(1000);
-    }
-}

hello_world/usb/hello_usb.cpp

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <stdio.h>
+#include "pico/stdlib.h"
+#include "pico/mutex.h"
+#include "pico/multicore.h"
+#include "wrappers/Queue.h"
+#include <string>
+
+auto_init_mutex(printf_lock);
+Queue<std::string> queue(10);
+//Queue<int> int_queue(10);
+
+void main1() {
+    while (true) {
+        std::string message;
+        queue.blocking_remove(&message);
+        printf(message.c_str());
+        printf("\n");
+        //int count;
+        //int_queue.blocking_remove(&count);
+        //printf("%i\n", count);
+    }
+}
+
+extern "C"
+int main() {
+    stdio_init_all();
+    multicore_launch_core1(main1);
+    int count = 0;
+    while (true) {
+        std::string message;
+        message = std::to_string(count++);
+        printf("Is wrapped: %i\n", queue.wrapped);
+        printf("Enqueue %s\n", message.c_str());
+        queue.blocking_add(&message);
+        //int_queue.blocking_add(&count);
+        sleep_ms(1000);
+    }
+}

pico_w/wifi/ntp_client/picow_ntp_client.c

@@ -108,7 +108,7 @@ static void ntp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_ad
 
 // Perform initialisation
 static NTP_T* ntp_init(void) {
-    NTP_T *state = calloc(1, sizeof(NTP_T));
+    NTP_T *state = (NTP_T*)calloc(1, sizeof(NTP_T));
     if (!state) {
         printf("failed to allocate state\n");
         return NULL;
@@ -183,4 +183,4 @@ int main() {
     run_ntp_test();
     cyw43_arch_deinit();
    return 0;
-}
+}

pio/quadrature_encoder/quadrature_encoder.c

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2021 pmarques-dev @ github
+ * Copyright (c) 2023 Raspberry Pi (Trading) Ltd.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -44,8 +44,10 @@ int main() {
     PIO pio = pio0;
     const uint sm = 0;
 
-    uint offset = pio_add_program(pio, &quadrature_encoder_program);
+    // we don't really need to keep the offset, as this program must be loaded
-    quadrature_encoder_program_init(pio, sm, offset, PIN_AB, 0);
+    // at offset 0
+    pio_add_program(pio, &quadrature_encoder_program);
+    quadrature_encoder_program_init(pio, sm, PIN_AB, 0);
 
     while (1) {
         // note: thanks to two's complement arithmetic delta will always

pio/quadrature_encoder/quadrature_encoder.pio

@@ -1,13 +1,12 @@
 ;
-; Copyright (c) 2021 pmarques-dev @ github
+; Copyright (c) 2023 Raspberry Pi (Trading) Ltd.
 ;
 ; SPDX-License-Identifier: BSD-3-Clause
 ;
 
 .program quadrature_encoder
 
-; this code must be loaded into address 0, but at 29 instructions, it probably
+; the code must be loaded at address 0, because it uses computed jumps
-; wouldn't be able to share space with other programs anyway
 .origin 0
 
 
@@ -20,82 +19,70 @@
 ; keeps the current encoder count and is incremented / decremented according to
 ; the steps sampled
 
-; writing any non zero value to the TX FIFO makes the state machine push the
+; the program keeps trying to write the current count to the RX FIFO without
-; current count to RX FIFO between 6 to 18 clocks afterwards. The worst case
+; blocking. To read the current count, the user code must drain the FIFO first
-; sampling loop takes 14 cycles, so this program is able to read step rates up
+; and wait for a fresh sample (takes ~4 SM cycles on average). The worst case
-; to sysclk / 14  (e.g., sysclk 125MHz, max step rate = 8.9 Msteps/sec)
+; sampling loop takes 10 cycles, so this program is able to read step rates up
-
+; to sysclk / 10  (e.g., sysclk 125MHz, max step rate = 12.5 Msteps/sec)
 
 ; 00 state
-	JMP update	; read 00
+    JMP update    ; read 00
-	JMP decrement	; read 01
+    JMP decrement ; read 01
-	JMP increment	; read 10
+    JMP increment ; read 10
-	JMP update	; read 11
+    JMP update    ; read 11
 
 ; 01 state
-	JMP increment	; read 00
+    JMP increment ; read 00
-	JMP update	; read 01
+    JMP update    ; read 01
-	JMP update	; read 10
+    JMP update    ; read 10
-	JMP decrement	; read 11
+    JMP decrement ; read 11
 
 ; 10 state
-	JMP decrement	; read 00
+    JMP decrement ; read 00
-	JMP update	; read 01
+    JMP update    ; read 01
-	JMP update	; read 10
+    JMP update    ; read 10
-	JMP increment	; read 11
+    JMP increment ; read 11
 
 ; to reduce code size, the last 2 states are implemented in place and become the
 ; target for the other jumps
 
 ; 11 state
-	JMP update	; read 00
+    JMP update    ; read 00
-	JMP increment	; read 01
+    JMP increment ; read 01
 decrement:
-	; note: the target of this instruction must be the next address, so that
+    ; note: the target of this instruction must be the next address, so that
-	; the effect of the instruction does not depend on the value of Y. The
+    ; the effect of the instruction does not depend on the value of Y. The
-	; same is true for the "JMP X--" below. Basically "JMP Y--, <next addr>"
+    ; same is true for the "JMP X--" below. Basically "JMP Y--, <next addr>"
-	; is just a pure "decrement Y" instruction, with no other side effects
+    ; is just a pure "decrement Y" instruction, with no other side effects
-	JMP Y--, update	; read 10
+    JMP Y--, update ; read 10
 
-	; this is where the main loop starts
+    ; this is where the main loop starts
 .wrap_target
 update:
-	; we start by checking the TX FIFO to see if the main code is asking for
+    MOV ISR, Y      ; read 11
-	; the current count after the PULL noblock, OSR will have either 0 if
+    PUSH noblock
-	; there was nothing or the value that was there
-	SET X, 0
-	PULL noblock
-
-	; since there are not many free registers, and PULL is done into OSR, we
-	; have to do some juggling to avoid losing the state information and
-	; still place the values where we need them
-	MOV X, OSR
-	MOV OSR, ISR
-
-	; the main code did not ask for the count, so just go to "sample_pins"
-	JMP !X, sample_pins
-
-	; if it did ask for the count, then we push it
-	MOV ISR, Y	; we trash ISR, but we already have a copy in OSR
-	PUSH
 
 sample_pins:
-	; we shift into ISR the last state of the 2 input pins (now in OSR) and
+    ; we shift into ISR the last state of the 2 input pins (now in OSR) and
-	; the new state of the 2 pins, thus producing the 4 bit target for the
+    ; the new state of the 2 pins, thus producing the 4 bit target for the
-	; computed jump into the correct action for this state
+    ; computed jump into the correct action for this state. Both the PUSH
-	MOV ISR, NULL
+    ; above and the OUT below zero out the other bits in ISR
-	IN OSR, 2
+    OUT ISR, 2
-	IN PINS, 2
+    IN PINS, 2
-	MOV PC, ISR
 
-	; the PIO does not have a increment instruction, so to do that we do a
+    ; save the state in the OSR, so that we can use ISR for other purposes
-	; negate, decrement, negate sequence
+    MOV OSR, ISR
+    ; jump to the correct state machine action
+    MOV PC, ISR
+
+    ; the PIO does not have a increment instruction, so to do that we do a
+    ; negate, decrement, negate sequence
 increment:
-	MOV X, !Y
+    MOV Y, ~Y
-	JMP X--, increment_cont
+    JMP Y--, increment_cont
 increment_cont:
-	MOV Y, !X
+    MOV Y, ~Y
-.wrap	; the .wrap here avoids one jump instruction and saves a cycle too
+.wrap    ; the .wrap here avoids one jump instruction and saves a cycle too
 
 
 
@@ -106,60 +93,49 @@ increment_cont:
 
 // max_step_rate is used to lower the clock of the state machine to save power
 // if the application doesn't require a very high sampling rate. Passing zero
-// will set the clock to the maximum, which gives a max step rate of around
+// will set the clock to the maximum
-// 8.9 Msteps/sec at 125MHz
 
-static inline void quadrature_encoder_program_init(PIO pio, uint sm, uint offset, uint pin, int max_step_rate)
+static inline void quadrature_encoder_program_init(PIO pio, uint sm, uint pin, int max_step_rate)
 {
-	pio_sm_set_consecutive_pindirs(pio, sm, pin, 2, false);
+    pio_sm_set_consecutive_pindirs(pio, sm, pin, 2, false);
-	gpio_pull_up(pin);
+    gpio_pull_up(pin);
-	gpio_pull_up(pin + 1);
+    gpio_pull_up(pin + 1);
 
-	pio_sm_config c = quadrature_encoder_program_get_default_config(offset);
+    pio_sm_config c = quadrature_encoder_program_get_default_config(0);
-	sm_config_set_in_pins(&c, pin); // for WAIT, IN
-	sm_config_set_jmp_pin(&c, pin); // for JMP
-	// shift to left, autopull disabled
-	sm_config_set_in_shift(&c, false, false, 32);
-	// don't join FIFO's
-	sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_NONE);
 
-	// passing "0" as the sample frequency,
+    sm_config_set_in_pins(&c, pin); // for WAIT, IN
-	if (max_step_rate == 0) {
+    sm_config_set_jmp_pin(&c, pin); // for JMP
-		sm_config_set_clkdiv(&c, 1.0);
+    // shift to left, autopull disabled
-	} else {
+    sm_config_set_in_shift(&c, false, false, 32);
-		// one state machine loop takes at most 14 cycles
+    // don't join FIFO's
-		float div = (float)clock_get_hz(clk_sys) / (14 * max_step_rate);
+    sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_NONE);
-		sm_config_set_clkdiv(&c, div);
-	}
 
-	pio_sm_init(pio, sm, offset, &c);
+    // passing "0" as the sample frequency,
-	pio_sm_set_enabled(pio, sm, true);
+    if (max_step_rate == 0) {
-}
+        sm_config_set_clkdiv(&c, 1.0);
+    } else {
+        // one state machine loop takes at most 10 cycles
+        float div = (float)clock_get_hz(clk_sys) / (10 * max_step_rate);
+        sm_config_set_clkdiv(&c, div);
+    }
 
-
+    pio_sm_init(pio, sm, 0, &c);
-// When requesting the current count we may have to wait a few cycles (average
+    pio_sm_set_enabled(pio, sm, true);
-// ~11 sysclk cycles) for the state machine to reply. If we are reading multiple
-// encoders, we may request them all in one go and then fetch them all, thus
-// avoiding doing the wait multiple times. If we are reading just one encoder,
-// we can use the "get_count" function to request and wait
-
-static inline void quadrature_encoder_request_count(PIO pio, uint sm)
-{
-	pio->txf[sm] = 1;
-}
-
-static inline int32_t quadrature_encoder_fetch_count(PIO pio, uint sm)
-{
-	while (pio_sm_is_rx_fifo_empty(pio, sm))
-		tight_loop_contents();
-	return pio->rxf[sm];
 }
 
 static inline int32_t quadrature_encoder_get_count(PIO pio, uint sm)
 {
-	quadrature_encoder_request_count(pio, sm);
+    uint ret;
-	return quadrature_encoder_fetch_count(pio, sm);
+    int n;
+
+    // if the FIFO has N entries, we fetch them to drain the FIFO,
+    // plus one entry which will be guaranteed to not be stale
+    n = pio_sm_get_rx_fifo_level(pio, sm) + 1;
+    while (n > 0) {
+        ret = pio_sm_get_blocking(pio, sm);
+        n--;
+    }
+    return ret;
 }
 
 %}
-