NuttX RTOS on PicoCalc

shtirlic · April 15, 2025, 8:10am

Hi, this is my initial work on getting NuttX to run on PicoCalc with Pico 2 on board

Currently: SD Card, SPI, I2C, PWM, Speakers, Serial connection are working.
Next: Display and builtin PicoCalc keyboard.

There is also firmware uf2 file in pre-release on github for pico 2 based PicoCalc

More info about NuttX https://nuttx.apache.org/

PS
Also year ago NuttX landed on the moon Apache NuttX Powers World's Smallest Lunar Robot in Japan's Historic Autonomous Lunar Exploration Mission | Developer World

shtirlic · July 3, 2025, 5:21am

Update:
Currently I am working at porting NuttX to RISC-V cores on rp2350

github.com/apache/nuttx

arch/risc-v/rp23xx-riscv: Initial rp23xx(rp2350) (Pico 2) RISC-V support

master ← shtirlic:riscvrp23xx

opened 08:58AM - 22 May 25 UTC

shtirlic

+40808 -0

## Summary Add support for RP2350 RISC-V cores, Add Pico 2 board. ### Nami…ng ``` Chip name : rp23xx-rv Board name : raspberrypi-pico-2-rv Arch : risc-v ``` ### Changes from ARM rp23xx impl - Linker script update - ASM head start - Update chip start - New Hazard3 include regs - Remove rp23xx chip hw spinlocks/testset - New irq handling (external IRQ interrupt) - New timerisr based on RISC-V std MTIME and alarm arch - No SMP yet - Tickless option - Double size for idle, irq and main stacks - Board reset via watchdog trigger ... ### Todo - [x] Uart defconfig - [x] ostest pass - [x] usb defconfig - [ ] SMP - [x] Reset (via watchdog trigger without wd dev) - [x] Hazard3 external IRQ - [ ] More timers - [ ] Tickless testing - [x] Peripherals testing - [x] WDOG - [x] UART - [x] USB - [x] PWM - [x] I2C - [x] SPI - [x] DMA - [ ] Docs - [ ] Add chip - [ ] Add board - [ ] Toolchain info - [ ] Other boards - [x] RISC-V Custom extensions (zba_zbb_zbs_zbkb_zca_zcb_zcmp in defconfig, add to chip?) - [ ] Compare getprime perf - [ ] LVGL perf test ### Toolchain Use RISC-V gnu toolchain with soft float abi. Default riscv-collab uses double float abi This is config for https://github.com/riscv-collab/riscv-gnu-toolchain ``` ./configure --prefix=/opt/riscv --with-arch=rv32imac --with-abi=ilp32 ``` ### Config Serial NSH ``` /tools/configure.sh raspberrypi-pico-2-rv:nsh ``` USB CDC/ACM Serial NSH ``` /tools/configure.sh raspberrypi-pico-2-rv:usbnsh ``` ## Testing cpuinfo ``` nsh> cat /proc/cpuinfo processor : 0 hart : 0 isa : rv32imac mmu : none nsh> free total used free maxused maxfree nused nfree name 516820 7116 509704 45768 490456 25 3 Umem ``` getprime ``` nsh> getprime Set thread priority to 10 Set thread policy to SCHED_RR Start thread #0 thread #0 started, looking for primes < 10000, doing 10 run(s) thread #0 finished, found 1230 primes, last one was 9973 Done getprime took 4281 msec ``` <details><summary>ostest nsh output</summary> ``` NuttShell (NSH) NuttX-12.9.0 nsh> nsh> ostest stdio_test: write fd=1 stdio_test: Standard I/O Check: printf stdio_test: write fd=2 stdio_test: Standard I/O Check: fprintf to stderr ostest_main: putenv(Variable1=BadValue3) ostest_main: setenv(Variable1, GoodValue1, TRUE) ostest_main: setenv(Variable2, BadValue1, FALSE) ostest_main: setenv(Variable2, GoodValue2, TRUE) ostest_main: setenv(Variable3, GoodValue3, FALSE) ostest_main: setenv(Variable3, BadValue2, FALSE) show_variable: Variable=Variable1 has value=GoodValue1 show_variable: Variable=Variable2 has value=GoodValue2 show_variable: Variable=Variable3 has value=GoodValue3 ostest_main: Started user_main at PID=3 user_main: Begin argument test user_main: Started with argc=5 user_main: argv[0]="ostest" user_main: argv[1]="Arg1" user_main: argv[2]="Arg2" user_main: argv[3]="Arg3" user_main: argv[4]="Arg4" End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 1 1 mxordblk 79ce8 79ce8 uordblks 45ec 45ec fordblks 79ce8 79ce8 user_main: getopt() test getopt(): Simple test getopt(): Invalid argument getopt(): Missing optional argument getopt_long(): Simple test getopt_long(): No short options getopt_long(): Argument for --option=argument getopt_long(): Invalid long option getopt_long(): Mixed long and short options getopt_long(): Invalid short option getopt_long(): Missing optional arguments getopt_long_only(): Mixed long and short options getopt_long_only(): Single hyphen long options End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 1 1 mxordblk 79ce8 79ce8 uordblks 45ec 45ec fordblks 79ce8 79ce8 user_main: libc tests End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 1 1 mxordblk 79ce8 79ce8 uordblks 45ec 45ec fordblks 79ce8 79ce8 show_variable: Variable=Variable1 has value=GoodValue1 show_variable: Variable=Variable2 has value=GoodValue2 show_variable: Variable=Variable3 has value=GoodValue3 show_variable: Variable=Variable1 has no value show_variable: Variable=Variable2 has value=GoodValue2 show_variable: Variable=Variable3 has value=GoodValue3 End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 1 2 mxordblk 79ce8 79ce8 uordblks 45ec 45cc fordblks 79ce8 79d08 show_variable: Variable=Variable1 has no value show_variable: Variable=Variable2 has no value show_variable: Variable=Variable3 has no value End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 2 2 mxordblk 79ce8 79ce8 uordblks 45cc 4554 fordblks 79d08 79d80 user_main: setvbuf test setvbuf_test: Test NO buffering setvbuf_test: Using NO buffering setvbuf_test: Test default FULL buffering setvbuf_test: Using default FULL buffering setvbuf_test: Test FULL buffering, buffer size 64 setvbuf_test: Using FULL buffering, buffer size 64 setvbuf_test: Test FULL buffering, pre-allocated buffer setvbuf_test: Using FULL buffering, pre-allocated buffer setvbuf_test: Test LINE buffering, buffer size 64 setvbuf_test: Using LINE buffering, buffer size 64 setvbuf_test: Test FULL buffering, pre-allocated buffer setvbuf_test: Using FULL buffering, pre-allocated buffer End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 2 2 mxordblk 79ce8 79ce8 uordblks 4554 4554 fordblks 79d80 79d80 user_main: /dev/null test dev_null: Read 0 bytes from /dev/null dev_null: Wrote 1024 bytes to /dev/null End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 2 2 mxordblk 79ce8 79ce8 uordblks 4554 4554 fordblks 79d80 79d80 user_main: task_restart test Test task_restart() restart_main: setenv(VarName, VarValue, TRUE) restart_main: Started restart_main at PID=4 restart_main: Started with argc=4 restart_main: argv[0]="ostest" restart_main: argv[1]="This is argument 1" restart_main: argv[2]="Argument 2 here" restart_main: argv[3]="Lastly, the 3rd argument" restart_main: Variable=VarName has value=VarValue restart_main: I am still here restart_main: I am still here restart_main: Started restart_main at PID=4 restart_main: Started with argc=4 restart_main: argv[0]="ostest" restart_main: argv[1]="This is argument 1" restart_main: argv[2]="Argument 2 here" restart_main: argv[3]="Lastly, the 3rd argument" restart_main: Variable=VarName has value=VarValue restart_main: Started with argc=4 restart_main: argv[0]="ostest" restart_main: argv[1]="This is argument 1" restart_main: argv[2]="Argument 2 here" restart_main: argv[3]="Lastly, the 3rd argument" restart_main: Variable=VarName has value=VarValue restart_main: Exiting End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 2 2 mxordblk 79ce8 77930 uordblks 4554 6944 fordblks 79d80 77990 user_main: waitpid test Test waitpid() waitpid_start_child: Started waitpid_main at PID=5 waitpid_start_child: Started waitpid_main at PID=6 waitpid_main: PID 5 Started waitpid_main: PID 6 Started waitpid_start_child: Started waitpid_main at PID=7 waitpid_main: PID 7 Started waitpid_test: Waiting for PID=5 with waitpid() waitpid_main: PID 5 exitting with result=14 waitpid_main: PID 6 exitting with result=14 waitpid_test: PID 5 waitpid succeeded with stat_loc=0e00 waitpid_last: Waiting for PID=7 with waitpid() waitpid_main: PID 7 exitting with result=14 waitpid_last: PASS: PID 7 waitpid succeeded with stat_loc=0e00 End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 2 5 mxordblk 77930 73170 uordblks 6944 a954 fordblks 77990 73980 user_main: mutex test Initializing mutex Starting thread 1 Starting thread 2 Thread1 Thread2 Loops 32 32 Errors 0 0 Testing moved mutex Starting moved mutex thread 1 Starting moved mutex thread 2 Thread1 Thread2 Moved Loops 32 32 Moved Errors 0 0 End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 5 2 mxordblk 73170 79408 uordblks a954 4e6c fordblks 73980 79468 user_main: timed mutex test mutex_test: Initializing mutex mutex_test: Starting thread pthread: Started pthread: Waiting for lock or timeout mutex_test: Unlocking pthread: Got the lock pthread: Waiting for lock or timeout pthread: Got the timeout. Terminating mutex_test: PASSED End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 2 2 mxordblk 79408 79408 uordblks 4e6c 4e6c fordblks 79468 79468 user_main: cancel test cancel_test: Test 1a: Normal Cancellation cancel_test: Starting thread start_thread: Initializing mutex start_thread: Initializing cond start_thread: Starting thread start_thread: Yielding sem_waiter: Taking mutex sem_waiter: Starting wait for condition cancel_test: Canceling thread cancel_test: Joining cancel_test: waiter exited with result=0xffffffff cancel_test: PASS thread terminated with PTHREAD_CANCELED cancel_test: Test 2: Asynchronous Cancellation ... Skipped cancel_test: Test 3: Cancellation of detached thread cancel_test: Re-starting thread restart_thread: Destroying cond restart_thread: Destroying mutex restart_thread: Re-starting thread start_thread: Initializing mutex start_thread: Initializing cond start_thread: Starting thread start_thread: Yielding sem_waiter: Taking mutex sem_waiter: Starting wait for condition cancel_test: Canceling thread cancel_test: Joining cancel_test: PASS pthread_join failed with status=ESRCH cancel_test: Test 5: Non-cancelable threads cancel_test: Re-starting thread (non-cancelable) restart_thread: Destroying cond restart_thread: Destroying mutex restart_thread: Re-starting thread start_thread: Initializing mutex start_thread: Initializing cond start_thread: Starting thread start_thread: Yielding sem_waiter: Taking mutex sem_waiter: Starting wait for condition sem_waiter: Setting non-cancelable cancel_test: Canceling thread cancel_test: Joining sem_waiter: Releasing mutex sem_waiter: Setting cancelable cancel_test: waiter exited with result=0xffffffff cancel_test: PASS thread terminated with PTHREAD_CANCELED cancel_test: Test 6: Cancel message queue wait cancel_test: Starting thread (cancelable) Skipped cancel_test: Test 7: Cancel signal wait cancel_test: Starting thread (cancelable) Skipped End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 2 2 mxordblk 79408 77c08 uordblks 4e6c 666c fordblks 79468 77c68 user_main: robust test robust_test: Initializing mutex robust_test: Starting thread robust_waiter: Taking mutex robust_waiter: Exiting with mutex robust_test: Take the lock again robust_test: Make the mutex consistent again. robust_test: Take the lock again robust_test: Joining robust_test: waiter exited with result=0 robust_test: Test complete with nerrors=0 End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 2 2 mxordblk 77c08 77c08 uordblks 666c 666c fordblks 77c68 77c68 user_main: semaphore test sem_test: Initializing semaphore to 0 sem_test: Starting waiter thread 1 sem_test: Set thread 1 priority to 191 waiter_func: Thread 1 Started sem_test: Starting waiter thread 2 waiter_func: Thread 1 initial semaphore value = 0 sem_test: Set thread 2 priority to 128 waiter_func: Thread 1 waiting on semaphore waiter_func: Thread 2 Started waiter_func: Thread 2 initial semaphore value = -1 waiter_func: Thread 2 waiting on semaphore sem_test: Starting poster thread 3 sem_test: Set thread 3 priority to 64 poster_func: Thread 3 started poster_func: Thread 3 semaphore value = -2 poster_func: Thread 3 posting semaphore waiter_func: Thread 1 awakened waiter_func: Thread 1 new semaphore value = -1 waiter_func: Thread 1 done poster_func: Thread 3 new semaphore value = -1 poster_func: Thread 3 semaphore value = -1 poster_func: Thread 3 posting semaphore waiter_func: Thread 2 awakened poster_func: Thread 3 new semaphore value = 0 waiter_func: Thread 2 new semaphore value = 0 poster_func: Thread 3 done waiter_func: Thread 2 done End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 2 3 mxordblk 77c08 78248 uordblks 666c 574c fordblks 77c68 78b88 user_main: timed semaphore test semtimed_test: Initializing semaphore to 0 semtimed_test: Waiting for two second timeout semtimed_test: PASS: first test returned timeout BEFORE: (33 sec, 682764966 nsec) AFTER: (35 sec, 690225406 nsec) semtimed_test: Starting poster thread semtimed_test: Set thread 1 priority to 191 semtimed_test: Starting poster thread 3 semtimed_test: Set thread 3 priority to 64 semtimed_test: Waiting for two second timeout poster_func: Waiting for 1 second poster_func: Posting semtimed_test: PASS: sem_timedwait succeeded BEFORE: (35 sec, 693431933 nsec) AFTER: (36 sec, 700571253 nsec) End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 3 2 mxordblk 78248 79408 uordblks 574c 4e6c fordblks 78b88 79468 user_main: condition variable test cond_test: Initializing mutex cond_test: Initializing cond cond_test: Starting waiter cond_test: Set thread 1 priority to 128 waiter_thread: Started cond_test: Starting signaler cond_test: Set thread 2 priority to 64 thread_signaler: Started thread_signaler: Terminating cond_test: signaler terminated, now cancel the waiter cond_test: Waiter Signaler cond_test: Loops 32 32 cond_test: Errors 0 0 cond_test: cond_test: 0 times, waiter did not have to wait for data cond_test: 0 times, data was already available when the signaler run cond_test: 0 times, the waiter was in an unexpected state when the signaler ran End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 2 3 mxordblk 79408 78b28 uordblks 4e6c 4e6c fordblks 79468 79468 user_main: pthread_exit() test pthread_exit_test: Started pthread_exit_main at PID=27 pthread_exit_main 27: Starting pthread_exit_thread pthread_exit_main 27: Sleeping for 5 seconds pthread_exit_thread 28: Sleeping for 10 second pthread_exit_thread 28: Still running... pthread_exit_main 27: Calling pthread_exit() End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 3 2 mxordblk 78b28 77328 uordblks 4e6c 6f4c fordblks 79468 77388 user_main: pthread_rwlock test pthread_rwlock: Initializing rwlock pthread_exit_thread 28: Exiting End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 2 3 mxordblk 77328 77328 uordblks 6f4c 4e7c fordblks 77388 79458 user_main: pthread_rwlock_cancel test pthread_rwlock_cancel: Starting test End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 3 2 mxordblk 77328 79ce8 uordblks 4e7c 459c fordblks 79458 79d38 user_main: timed wait test thread_waiter: Initializing mutex timedwait_test: Initializing cond timedwait_test: Starting waiter timedwait_test: Set thread 2 priority to 177 thread_waiter: Taking mutex thread_waiter: Starting 5 second wait for condition timedwait_test: Joining thread_waiter: pthread_cond_timedwait timed out thread_waiter: Releasing mutex thread_waiter: Exit with status 0x12345678 timedwait_test: waiter exited with result=0x12345678 End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 2 2 mxordblk 79ce8 79408 uordblks 459c 4e7c fordblks 79d38 79458 user_main: message queue test mqueue_test: Starting receiver mqueue_test: Set receiver priority to 128 receiver_thread: Starting mqueue_test: Starting sender mqueue_test: Set sender thread priority to 64 mqueue_test: Waiting for sender to complete sender_thread: Starting receiver_thread: mq_receive succeeded on msg 0 sender_thread: mq_send succeeded on msg 0 receiver_thread: mq_receive succeeded on msg 1 sender_thread: mq_send succeeded on msg 1 receiver_thread: mq_receive succeeded on msg 2 sender_thread: mq_send succeeded on msg 2 receiver_thread: mq_receive succeeded on msg 3 sender_thread: mq_send succeeded on msg 3 receiver_thread: mq_receive succeeded on msg 4 sender_thread: mq_send succeeded on msg 4 receiver_thread: mq_receive succeeded on msg 5 sender_thread: mq_send succeeded on msg 5 receiver_thread: mq_receive succeeded on msg 6 sender_thread: mq_send succeeded on msg 6 receiver_thread: mq_receive succeeded on msg 7 sender_thread: mq_send succeeded on msg 7 receiver_thread: mq_receive succeeded on msg 8 sender_thread: mq_send succeeded on msg 8 receiver_thread: mq_receive succeeded on msg 9 sender_thread: mq_send succeeded on msg 9 sender_thread: returning nerrors=0 mqueue_test: Killing receiver receiver_thread: mq_receive interrupted! receiver_thread: returning nerrors=0 mqueue_test: Canceling receiver mqueue_test: receiver has already terminated End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 2 2 mxordblk 79408 77bd8 uordblks 4e7c 66dc fordblks 79458 77bf8 user_main: timed message queue test timedmqueue_test: Starting sender timedmqueue_test: Waiting for sender to complete sender_thread: Starting sender_thread: mq_timedsend succeeded on msg 0 sender_thread: mq_timedsend succeeded on msg 1 sender_thread: mq_timedsend succeeded on msg 2 sender_thread: mq_timedsend succeeded on msg 3 sender_thread: mq_timedsend succeeded on msg 4 sender_thread: mq_timedsend succeeded on msg 5 sender_thread: mq_timedsend succeeded on msg 6 sender_thread: mq_timedsend succeeded on msg 7 sender_thread: mq_timedsend succeeded on msg 8 sender_thread: mq_timedsend 9 timed out as expected sender_thread: returning nerrors=0 timedmqueue_test: Starting receiver timedmqueue_test: Waiting for receiver to complete receiver_thread: Starting receiver_thread: mq_timedreceive succeed on msg 0 receiver_thread: mq_timedreceive succeed on msg 1 receiver_thread: mq_timedreceive succeed on msg 2 receiver_thread: mq_timedreceive succeed on msg 3 receiver_thread: mq_timedreceive succeed on msg 4 receiver_thread: mq_timedreceive succeed on msg 5 receiver_thread: mq_timedreceive succeed on msg 6 receiver_thread: mq_timedreceive succeed on msg 7 receiver_thread: mq_timedreceive succeed on msg 8 receiver_thread: Receive 9 timed out as expected receiver_thread: returning nerrors=0 timedmqueue_test: Test complete End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 2 2 mxordblk 77bd8 77bd8 uordblks 66dc 66dc fordblks 77bf8 77bf8 user_main: sigprocmask test sigprocmask_test: SUCCESS End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 2 2 mxordblk 77bd8 77bd8 uordblks 66dc 66dc fordblks 77bf8 77bf8 user_main: signal handler test sighand_test: Initializing semaphore to 0 sighand_test: Starting waiter task sighand_test: Started waiter_main pid=44 waiter_main: Waiter started waiter_main: Unmasking signal 32 waiter_main: Registering signal handler waiter_main: oact.sigaction=0 oact.sa_flags=0 oact.sa_mask=0000000000000000 waiter_main: Waiting on semaphore sighand_test: Signaling pid=44 with signo=32 sigvalue=42 waiter_main: sem_wait() successfully interrupted by signal waiter_main: done sighand_test: done End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 2 1 mxordblk 77bd8 77bc8 uordblks 66dc 670c fordblks 77bf8 77bc8 user_main: nested signal handler test signest_test: Starting signal waiter task at priority 101 waiter_main: Waiter started waiter_main: Setting signal mask signest_test: Started waiter_main pid=45 waiter_main: Registering signal handler signest_test: Starting interfering task at priority 102 waiter_main: Waiting on semaphore interfere_main: Waiting on semaphore signest_test: Started interfere_main pid=46 signest_test: Simple case: Total signalled 1240 Odd=620 Even=620 Total handled 1240 Odd=620 Even=620 Total nested 0 Odd=0 Even=0 signest_test: With task locking Total signalled 2480 Odd=1240 Even=1240 Total handled 2480 Odd=1240 Even=1240 Total nested 0 Odd=0 Even=0 signest_test: With intefering thread Total signalled 3720 Odd=1860 Even=1860 Total handled 3720 Odd=1860 Even=1860 Total nested 0 Odd=0 Even=0 signest_test: done End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 1 2 mxordblk 77bc8 75398 uordblks 670c 6e6c fordblks 77bc8 77468 user_main: wdog test wdog_test start... wdtest_once 0 ns wdtest_once 0 ns wdtest_once 0 ns wdtest_once 0 ns wdtest_once 1 ns wdtest_once 1 ns wdtest_once 1 ns wdtest_once 1 ns wdtest_once 10 ns wdtest_once 10 ns wdtest_once 10 ns wdtest_once 10 ns wdtest_once 100 ns wdtest_once 100 ns wdtest_once 100 ns wdtest_once 100 ns wdtest_once 1000 ns wdtest_once 1000 ns wdtest_once 1000 ns wdtest_once 1000 ns wdtest_once 10000 ns wdtest_once 10000 ns wdtest_once 10000 ns wdtest_once 10000 ns wdtest_once 100000 ns wdtest_once 100000 ns wdtest_once 100000 ns wdtest_once 100000 ns wdtest_once 1000000 ns wdtest_once 1000000 ns wdtest_once 1000000 ns wdtest_once 1000000 ns wd_start with maximum delay, cancel OK, rest 2147483646 wdtest_recursive 1000000us wd_start with maximum delay, cancel OK, rest 2147483646 wdtest_recursive 1000000us wd_start with maximum delay, cancel OK, rest 2147483645 wdtest_recursive 1000000us wd_start with maximum delay, cancel OK, rest 2147483645 wdtest_recursive 1000000us recursive wdog triggered 6 times, elapsed tick 12 wdtest_recursive 10000000us recursive wdog triggered 6 times, elapsed tick 12 wdtest_recursive 10000000us recursive wdog triggered 6 times, elapsed tick 12 wdtest_recursive 10000000us recursive wdog triggered 6 times, elapsed tick 12 wdtest_recursive 10000000us recursive wdog triggered 6 times, elapsed tick 12 recursive wdog triggered 6 times, elapsed tick 12 recursive wdog triggered 6 times, elapsed tick 12 recursive wdog triggered 6 times, elapsed tick 12 wdog_test end... End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 2 3 mxordblk 75398 75398 uordblks 6e6c 710c fordblks 77468 771c8 user_main: round-robin scheduler test rr_test: Set thread priority to 1 rr_test: Set thread policy to SCHED_RR rr_test: Starting first get_primes_thread First get_primes_thread: 55 rr_test: Starting second get_primes_thread Second get_primes_thread: 56 rr_test: Waiting for threads to complete -- this should take awhile If RR scheduling is working, they should start and complete at about the same time get_primes_thread id=1 started, looking for primes < 10000, doing 10 run(s) get_primes_thread id=2 started, looking for primes < 10000, doing 10 run(s) get_primes_thread id=1 finished, found 1230 primes, last one was 9973 get_primes_thread id=2 finished, found 1230 primes, last one was 9973 rr_test: Done End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 3 3 mxordblk 75398 75398 uordblks 710c 5f4c fordblks 771c8 78388 user_main: barrier test barrier_test: Initializing barrier barrier_test: Thread 0 created barrier_test: Thread 1 created barrier_func: Thread 0 started barrier_func: Thread 1 started barrier_test: Thread 2 created barrier_func: Thread 2 started barrier_test: Thread 3 created barrier_func: Thread 3 started barrier_test: Thread 4 created barrier_func: Thread 4 started barrier_test: Thread 5 created barrier_func: Thread 5 started barrier_test: Thread 6 created barrier_func: Thread 6 started barrier_test: Thread 7 created barrier_func: Thread 7 started barrier_func: Thread 0 calling pthread_barrier_wait() barrier_func: Thread 1 calling pthread_barrier_wait() barrier_func: Thread 2 calling pthread_barrier_wait() barrier_func: Thread 3 calling pthread_barrier_wait() barrier_func: Thread 4 calling pthread_barrier_wait() barrier_func: Thread 5 calling pthread_barrier_wait() barrier_func: Thread 6 calling pthread_barrier_wait() barrier_func: Thread 7 calling pthread_barrier_wait() barrier_func: Thread 7, back with status=PTHREAD_BARRIER_SERIAL_THREAD (I AM SPECIAL) barrier_func: Thread 0, back with status=0 (I am not special) barrier_func: Thread 1, back with status=0 (I am not special) barrier_func: Thread 2, back with status=0 (I am not special) barrier_func: Thread 3, back with status=0 (I am not special) barrier_func: Thread 4, back with status=0 (I am not special) barrier_func: Thread 5, back with status=0 (I am not special) barrier_func: Thread 6, back with status=0 (I am not special) barrier_func: Thread 7 done barrier_func: Thread 0 done barrier_func: Thread 1 done barrier_test: Thread 0 completed with result=0 barrier_test: Thread 1 completed with result=0 barrier_func: Thread 2 done barrier_func: Thread 3 done barrier_test: Thread 2 completed with result=0 barrier_test: Thread 3 completed with result=0 barrier_func: Thread 4 done barrier_func: Thread 5 done barrier_test: Thread 4 completed with result=0 barrier_test: Thread 5 completed with result=0 barrier_func: Thread 6 done barrier_test: Thread 6 completed with result=0 barrier_test: Thread 7 completed with result=0 End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 3 5 mxordblk 75398 75398 uordblks 5f4c 5f4c fordblks 78388 78388 user_main: scheduler lock test sched_lock: Starting lowpri_thread at 97 sched_lock: Set lowpri_thread priority to 97 sched_lock: Starting highpri_thread at 98 sched_lock: Set highpri_thread priority to 98 sched_lock: Waiting... sched_lock: PASSED No pre-emption occurred while scheduler was locked. sched_lock: Starting lowpri_thread at 97 sched_lock: Set lowpri_thread priority to 97 sched_lock: Starting highpri_thread at 98 sched_lock: Set highpri_thread priority to 98 sched_lock: Waiting... sched_lock: PASSED No pre-emption occurred while scheduler was locked. sched_lock: Finished End of test memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 5 4 mxordblk 75398 75398 uordblks 5f4c 566c fordblks 78388 78c68 user_main: vfork() test vfork_test: Child 73 ran successfully Final memory usage: VARIABLE BEFORE AFTER ======== ======== ======== arena 7e2d4 7e2d4 ordblks 1 3 mxordblk 79ce8 75398 uordblks 45ec 6d94 fordblks 79ce8 77540 user_main: Exiting ostest_main: Exiting with status 0 ``` </details>

At current state It’s usable right now and will be ready soon to merge, after the platform docs, cleanup etc.

Screen is working
Keyboard is working
SD card working, FAT fs working fine
PWM is working (test sounds from speakers), no audio driver yet for NuttX
WAMR WASM runtime (WAMR - WebAssembly Micro Runtime) included

I will update GitHub - shtirlic/picocalc-nx: NuttX for PicoCalc main branch with configs and other stuff after PR merge in upstream.

Also I am writing the UI shell for NuttX(LVGL), where you can run normal apps and WASM apps.
Source also will be available as custom app for NuttX and will be used as init/startup app in picocalc-nx board.

shtirlic · August 14, 2025, 7:44am

Update: my RISC-V port merged to NuttX, so I continue to expand picocalc-nx to new features and update custom UI shell.

JackCarterSmith · August 15, 2025, 3:51pm

Knock, knock,
Wake up NEO2350!

BlairLeduc · August 15, 2025, 6:32pm

I am very interested in this project.

Unfortunately, it obliterates uf2loader by @pelrun.

Since I switch between uf2’s on the fly (on the PicoCalc) using uf2loader, I really cannot get into this project. I would really love to, though.

JackCarterSmith · August 15, 2025, 9:42pm

NuttX mess up with the bootloader loaded in RAM?
That’s good to know indeed.

BlairLeduc · August 15, 2025, 10:43pm

I am not sure what is happening. The Nuttx uf2 may be over writing the flash partition table?

Honestly, I am not an expert on the flash stuff and the RP2350. @pelrun might have an idea?

pelrun · August 16, 2025, 5:58am

I’ll add this to the list of apps to investigate - it’ll be using the old flash API, most likely.

shtirlic · August 16, 2025, 5:58am

I think I can make a build with modified linker script to be compatible with SD boot
as I can see the difference only on flash position leaving it to bootloader

FLASH(rx) : ORIGIN = 0x10000000 + 256k, LENGTH = 4096k - 256k

this is original

FLASH(rx) : ORIGIN = 0x10000000, LENGTH = 4096k

pelrun · August 16, 2025, 6:00am

No!

Changing the linker script was required for SD Boot, not UF2 Loader.

Don’t worry about trying to figure this out yourself - I’m doing a bunch of sneaky things under the hood and it’s my job to figure out how to get everything to play nice.

(also, this is the first thing that seems to be built for RISC-V and I really want to see that working!)

pelrun · August 16, 2025, 6:38am

WHOA this is WEIRD.

The bootloader isn’t actually overwritten at all, but for some reason it can no longer read the sd card!

NuttX, what did you do!??!

(edit: even weirder, if I get picotool to erase the partition, it starts working again! Nothing in the partition should be affecting this stage of a cold boot!)

shtirlic · August 16, 2025, 7:00am

There is some complicated process of choosing what arch should be run from the start, risc-v or arm. Maybe if they mixed arch arm and risc-v there is some issue.

shtirlic · August 16, 2025, 7:05am

Made 0.4.0 RISC-V Pico 2 pre-release uf2

JackCarterSmith · August 16, 2025, 1:27pm

I don’t remember if you can “switch” the rp2350 arch on the fly (without through a power reset).
Technically, I would say no, since it is possible to load RISC code on the second core when the first is running in ARM mode…

shtirlic · August 16, 2025, 2:09pm

Yes, reset is needed but you can use 2 different cores in the same time.

3.9.2. Mixed Architecture Combinations
The ARCHSEL register has one bit for each processor socket, so it is possible to request mixed combinations of Arm
and RISC-V processors: either Arm core 0 and RISC-V core 1, or RISC-V core 0 and Arm core 1.

So it’s possible to have ARM image and second RISC-V image, for example run the ARM image then boot to second RISC-V image.

pelrun · August 16, 2025, 3:59pm

The problem is happening long before the system is asked to start executing the application, so what arch it’s using shouldn’t really matter (and for the record I was using the ARM uf2 anyway.)

I suspect a bug in my implementation is spuriously looking deep into the application partition, and just happens to work by coincidence when that location is empty.

pelrun · August 17, 2025, 1:10pm

Yeah, this is still being weird. I’ve replaced my low-level sd driver with ChaN’s, and my Sandisk cards work, but the Lexar still fails (and in a weird way - it claims everything is fine but gives back all zeros when asked to read a sector.)

This’ll probably be where I have to leave it for v2.1 - I need to hook up the logic analyzer to dig into it further, but that’ll take some time.

BlairLeduc · August 17, 2025, 2:42pm

Until I worked on my own FAT32 code, I never truly appreciated that SD Cards are not media, but a hardware device with which one communicates and every manufacturer or card has its own quirks.

The current initialisation code I now have works with the smattering of SD Cards I own, but it didn’t start that way.

shtirlic · August 18, 2025, 3:51am

JFYI, I managed to get QSPI working on PSRAM by modified version of rp2040-psram project, so we will get the speed bump for PSRAM.

The only thing that not working right now is variable bytes write/reads, reads/writes up to 128bits is working now.

Update: Initially wrote about SD card, but then remembered it’s for PSRAM

Here is the stats:

All tests done on on RISC-V core

Full chart without 8bit test for 150mhz sysclock

Testing PSRAM(SPI)...
16 bit: PSRAM write 8MB in 3299527 us, 2542366 B/s
16 bit: PSRAM read 8MB in 6263501 us, 1339284 B/s
32 bit: PSRAM write 8MB in 2306877 us, 3636348 B/s
32 bit: PSRAM read 8MB in 3704978 us, 2264145 B/s
128 bit: PSRAM write 8MB in 1250219 us, 6709711 B/s
128 bit: PSRAM read 8MB in 1613943 us, 5197586 B/s
Testing PSRAM(QSPI)...
16 bit: PSRAM write 8MB in 2963981 us, 2830182 B/s
16 bit: PSRAM read 8MB in 4026536 us, 2083331 B/s
32 bit: PSRAM write 8MB in 1761612 us, 4761893 B/s
32 bit: PSRAM read 8MB in 2278914 us, 3680967 B/s
128 bit: PSRAM write 8MB in 774859 us, 10825980 B/s
128 bit: PSRAM read 8MB in 768089 us, 10921401 B/s

Key Gains:

Write speeds: 11% to 61% improvement
Read speeds: 55% to 110% improvement

This is with sysclock 200mhz

Testing PSRAM(SPI)...
16 bit: PSRAM write 8MB in 2474646 us, 3389821 B/s
16 bit: PSRAM read 8MB in 4697627 us, 1785711 B/s
32 bit: PSRAM write 8MB in 1730158 us, 4848463 B/s
32 bit: PSRAM read 8MB in 2778734 us, 3018859 B/s
128 bit: PSRAM write 8MB in 937664 us, 8946284 B/s
128 bit: PSRAM read 8MB in 1210457 us, 6930116 B/s
Testing PSRAM(QSPI)...
16 bit: PSRAM write 8MB in 2222985 us, 3773578 B/s
16 bit: PSRAM read 8MB in 3019904 us, 2777773 B/s
32 bit: PSRAM write 8MB in 1321209 us, 6349191 B/s
32 bit: PSRAM read 8MB in 1709185 us, 4907958 B/s
128 bit: PSRAM write 8MB in 581143 us, 14434671 B/s
128 bit: PSRAM read 8MB in 576068 us, 14561836 B/s

sysclock 230mhz

Testing PSRAM(SPI)...
16 bit: PSRAM write 8MB in 2151866 us, 3898294 B/s
16 bit: PSRAM read 8MB in 4084893 us, 2053568 B/s
32 bit: PSRAM write 8MB in 1504485 us, 5575734 B/s
32 bit: PSRAM read 8MB in 2416290 us, 3471689 B/s
128 bit: PSRAM write 8MB in 815360 us, 10288226 B/s
128 bit: PSRAM read 8MB in 1052571 us, 7969636 B/s
Testing PSRAM(QSPI)...
16 bit: PSRAM write 8MB in 1933030 us, 4339616 B/s
16 bit: PSRAM read 8MB in 2626002 us, 3194440 B/s
32 bit: PSRAM write 8MB in 1148877 us, 7301572 B/s
32 bit: PSRAM read 8MB in 1486247 us, 5644154 B/s
128 bit: PSRAM write 8MB in 505343 us, 16599830 B/s
128 bit: PSRAM read 8MB in 500928 us, 16746135 B/s

If I set higher sysclock I got some failures and bitflips while reading

PS I guess we can use PSRAM as framebuffer?

320 × 320 × 2 bytes × 30 fps = 6.14 MB/s
320 × 320 × 2 bytes × 45 fps = 9.22 MB/s
320 × 320 × 2 bytes × 60 fps = 12.29 MB/s

Here is the draft pull to upstream Initial QSPI(QPI) support by shtirlic · Pull Request #15 · polpo/rp2040-psram · GitHub

JackCarterSmith · August 18, 2025, 1:02pm

We’ve talked a little about this possibility here and here.

The main issue is the maximum LCD SPI speed, which seem to be 62.5 MHz (the maximum for the RP2350, 75 MHz in overclock, can’t say the screen don’t have some artefacts).
So the maximum bitrate shoul be around 7.8 MB/s. 30 or 45 FPS seem feasable, but the 60 is far away unfortunatly.

Topic		Replies	Views
1.2GHz and beyond Developers kernel	27	3182	February 7, 2020
Compiling MAME, Linux Wiz Advice Needed Emulators	44	6203	August 12, 2019
[OS] RetroArch - Debian OS image based on the minimal Debian (u-boot, kernel, and Debian from scratch) [v0.3] Firmware and Apps os	81	8752	April 12, 2021
ClockworkPI Emulated system Developers qemu , emulated , virtual	24	1846	June 24, 2019
RISC-V sloooow? DevTerm	27	2172	May 23, 2023

NuttX RTOS on PicoCalc

Related topics