pima/Trinity-DevPCB-V1.0
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
5daac77a37805e26f2946cb044cad52338c378c0
Trinity-DevPCB-V1.0/Debug/Core/Src/stm32wbxx_hal_msp.o
T

2298 lines
1.2 MiB
Plaintext
Raw Normal View History

Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ELF(ª4(ON‹Œ�Ž��‘’“”•–—˜™š›œ�žŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ 
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
  
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
 !"#$%&'()*+,-./0123456789:;<=>?@ABCD€´¯Oð°CÓø�0Oð°BCôCÂø�0¿½F]ø{pG€´¯Oð°CÓø�0Oð°B#ôCÂø�0¿½F]ø{pG€´…°¯x`Oð°CÚlOð°A{hCËdOð°CÚl{h@û`ûh¿7½F]ø{pG€´…°¯x`Oð°CmOð°A{hC eOð°Cm{h@û`ûh¿7½F]ø{pG€´ƒ°¯x`Oð°Cm{hÛCOð°A@ e¿ 7½F]ø{pG€´…°¯x`Oð°CšmOð°A{hC‹eOð°Cšm{h@û`ûh¿7½F]ø{pG€´ƒ°¯x`Oð°Cšm{hÛCOð°A@‹e¿ 7½F]ø{pG€´…°¯x`Oð°CnOð°A{hC fOð°Cn{h@û`ûh¿7½F]ø{pG€´ƒ°¯x`Oð°Cn{hÛCOð°A@ f¿ 7½F]ø{pG€µ¯Oô ÿ÷þÿÿ÷þÿ"!oðÿ÷þÿ"!. ÿ÷þÿ. ÿ÷þÿ¿€½€µœ°¯x`ñ\"`Z`š`Ú`añ P"!Fÿ÷þÿ{hhIJ“B@ð‹€#û`Oô@3ûbñ Fÿ÷þÿF+Ðÿ÷þÿ ÿ÷þÿOô@sûe#;f#{f#»f#ûfñ\F8Hÿ÷þÿOôÿ÷þÿ5K6J`4K "Z`2K"š`1K"Ú`/K€"a.K"Za,K"ša+K"Úa)KOôRb'Hÿ÷þÿF+Ðÿ÷þÿ{h#Jšc"J{h“b"K#J`!K
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
"Z`K"š`K"Ú`K€"aK"ZaK"šaK"ÚaKOôRbHÿ÷þÿF+Ðÿ÷þÿ{hJÚcJ{h“b"! ÿ÷þÿ ÿ÷þÿ"! ÿ÷þÿ ÿ÷þÿ¿p7½F€½T@H0@D@€µ‚°¯x`{hhJ“BÑOôÿ÷þÿOô€qHÿ÷þÿOôq Hÿ÷þÿ{h›kFÿ÷þÿ{hÛkFÿ÷þÿ ÿ÷þÿ ÿ÷þÿ¿7½F€½¿T@H€µ‚°¯x`{hh
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
J“BÑOô€ÿ÷þÿ"!, ÿ÷þÿ, ÿ÷þÿ"!- ÿ÷þÿ- ÿ÷þÿ¿7½F€½¿ X€µ‚°¯x`{hhJ“B ÑOô€ÿ÷þÿ, ÿ÷þÿ- ÿ÷þÿ¿7½F€½¿ X€µ–°¯x`ñP"!Fÿ÷þÿ{hhJ“BÑÿ÷þÿOôc»`Oôs»dñFÿ÷þÿF+Ðÿ÷þÿÿ÷þÿOô€`ÿ÷þÿ"! ÿ÷þÿ ÿ÷þÿ¿X7½F€½(@€µ‚°¯x`{hhJ“BÑÿ÷þÿOô€`ÿ÷þÿ ÿ÷þÿ¿7½F€½(@€µˆ°¯x`ñ "`Z`š`Ú`a{hhZJ“BlÑOô€Pÿ÷þÿ ÿ÷þÿà#û`#;a#{a#»a#ûañ FOð�@ÿ÷þÿNKNJ`LK"Z`KK"š`IK"Ú`HK€"aFK"ZaEK"šaCK"ÚaBKOôRb@Hÿ÷þÿF+Ðÿ÷þÿ{h;JZe:J{h“b;K;J`9K"Z`8K"š`6K"Ú`5K€"a3K"Za2K"ša0K"Úa/KOôRb-Hÿ÷þÿF+Ðÿ÷þÿ{h(Jše'J{h“b@à{hh&J“B;ÑOô€@ÿ÷þÿ ÿ÷þÿ ÿ÷þÿ#û`#;a#{a#»a#ûañ FHÿ÷þÿ#û`#;a#{a#»a#ûañ FHÿ÷þÿOôsû`#;a#{a#»a#ûañ FOð�@ÿ÷þÿ¿ 7½F€½¿0@@@8@H€µ‚°¯x`{hhJ“BÑOô€Pÿ÷þÿà!Oð�@ÿ÷þÿ{h[mFÿ÷þÿ{h›mFÿ÷þÿà{hh J“B
ÑOô€@ÿ÷þÿ!Hÿ÷þÿOôqOð�@ÿ÷þÿ¿7½F€½0@8@H€µ‚°¯x`{hh³ñ€OÑ ÿ÷þÿ¿7½F€½€µˆ°¯x`ñ "`Z`š`Ú`a{hh³ñ€OÑ ÿ÷þÿ#û`#;a#{a#»a#ûañ FOð�@ÿ÷þÿ¿ 7½F€½€µ‚°¯x`{hh³ñ€OÑ ÿ÷þÿ¿7½F€½Ñ#:
ªÌÔ= çDçþÔ r=Ý s¥0 tê> uºt vÇ${â|ŽÕ~�œ YÐ ¤Š
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
1O‚€ÿ•
NÁÄ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ð°¡Â îº
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ƕ žW
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
k¸
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
5’bí3üè Ô© Õ¦
7YaÒ ؃Ù¢®å
%†™øf›E�¦ó ÉÔaܸí
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
=Z!¸˜"d3#´q $€r %3ª&l'! (»9 )ÅÙ*5+é+,ôã-¬.Ÿõ /ô.0ÄG1‰ 2Í3qÔ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
4§¤5'C6¬7¡©
8ÚF 9±:ƒ§;rF
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
<{M=Jê>
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
þž
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ž¥ “*â(+
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ä(
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
žL
9 
Ì 
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
fó [. O:
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‘
Z§
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
³ˆ $int
à E‹
ú]ÌÚ$ n‹°
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
0.  V
ïCCR‹Wk ‹ê‹•ù‹ ù  ­Ï   
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
  ISR
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‹w„‹Ï3û
CCCR‹Q
,
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
sCSR‹CFR‹̳
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
O
—3!‹J‚"
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
$ɨ�&‹‹'‹jÝ(£
,Kg†M‹TA N‹í˜ O‹¢Y
P‹ IDRQ‹ODRR‹ü*S‹±)
T‹AFRUw BRRV‹(‹wV gUWÕ
,\(CR1^‹CR2_‹h`‹ma‹ ê|b‹ÓÔ c‹ISRd‹ICRe‹ ý f‹ ýý g‹$W¾h‹(Ôv iˆ%ˆ¾ eCRÀ‹ˆDÁ‹|½Â‹�'
Ë a³Ä‹’§
Å"Æ‹ý2Ç‹È‹ !»É‹$M– Ê‹(ë¢Ë‹,Y4Ì‹0œ§
Í4£á΋8­áÏ‹<K.Ћ@¬ü
Ñ‹DC&Ò‹HÏÓ‹LŠeÔ‹P¦§
ÕTdxÖ‹Xmx׋\/ Ø‹`Ø�Ùd#˜Ú‹h¤D
Û‹l)9Ü‹p‘Ýtâ‡Þ‹xí‡ß‹|#º à‹€ü§
á„z]⋈¨
㌟ùä‹�CSRå‹”Ùà拘#ëç‹œ¨
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
èe  �«
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
é‹ ¨
ê�  q. ë‹H M
ì‹L nû í‹P $¨
îT /ï‹X Ö9 ð‹\ i†ñ‹` bò‹d 4Îó‹h 9i ô‹l ªoõ‹p ›îöt q÷‹x qø‹| c>ù‹€ æ
ú‹„uVk£û4
 °
TR‹DR‹CR‹ISR‹ Ë2 ‹a/ ‹ù 
žz ‹§‚ ‹ WPR
‹$SSR‹(è‹,†Æ‹0—M‹4V÷‹8Ƀ
‹<m
‹@ö;‹DÇj‹HOR‹L¯ý‹P‹Tî ‹X˜‹\‘‹`&‘‹dî,‹h=3‹l§: ‹puD!‹t²Q"‹xZ#‹|x $‹€&i%‹„Šo&‹ˆB '‹ŒÆO (‹�‡)‹”ÊŽ*‹˜/•+‹œXº,�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
4" CR16‹CR27‹SR8‹DR9‹ ¯Ù
:‹
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
�;‹¼2<‹^T=¼
ha– CR1c‹CR2d‹á1e‹5Êf‹ SRg‹EGRh‹^s i‹ds j‹ζk‹ CNTl‹$PSCm‹(ARRn‹,RCRo‹0xp‹4}q‹8pár‹<—ás‹@›yt‹DDCRu‹Hí³
v‹LORw‹PGx‹Töy‹Xûz‹\AF1{‹`AF2|‹dÝ·
}.

7ö‹h½
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‹(n
 ‹f!‹ w
"‹µ #‹E,$‹�< %‹¨q&¢
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ø<'T
ŸÎÉ ‹|l.¶Ü
,/
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
2y
S¼
«‚çÉ5`
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
 /ö
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
«ø 1 np4 ]ò8 0:;  ±*> Z
A ãÀD —bI ÚK…
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Q'?Ô
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
óî 
“Hzd V 'ìZ `r/P�t/h[vö
V 
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
xy
$² z3%&Î
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
|4(¨r~ F,NN € F0ï‚ F4ˆ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
„ F8#ë †‹<”ƈK@"q
ŠD-ÖŒ%PHAŽ%ULy �$P"=’%ZT‚Œ ”%_XË –$\ï&AA86 Cs—É(—8 /¹Pin 1ãÀ 4 æk 7 t :  â� = �c ?p¹
/;¼%
1 ·&
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
5 Ø 
8 j
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
;  Ã&
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
> m)
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
A ÈQ
E /d
H ñ‹
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
KÊ
mŠ£}� ¯#$¸+!j "É£((s)3�
*Ûx`Œa
zG Š
“ÀÀ=¬¦@
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ˆ�@ˆõ
™› À¼vT
¸»P�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
º»h[
¼;R
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¾À$þé
Àn(p
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Âz*ï
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ä‹,2P
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ç‹0ôA
Éã4lï
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Íè8©
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ïè<V 
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Óy
@²
Õ–AãÀ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
×ÌB#ë
Ù‹D2S
Û‹H[
Ý‹LÐ
ß‹P(]'T
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÞÞÑÅd”á
þÑ I¨ÝÚ¢ Ã6é Mù  SB¤ L ¥« V)ô­< dœP� f#œøö g ¡å h ¡'/ i"4² j#$8
±±VËËBNž kNÐ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
 1Ð         ÅØ  q† á
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
P %'ýG ' û
+1‹Æ 0 âÙ
4 xz 8  Dï < $­ @ (ÁÉ C ,ÜÓ G 0±ª L 4þ P 8PË T <É W @ Z DX
^ H"�
a LÝó e=
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
1^µü
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
CÅÝÒDºa
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00

Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
73 ^
<ÓTL
> /­
A ·}
D ¾¿
G  ¾Ì
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
J ÷ž
M bù
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
P Ìý
Ro$
¨P�
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
« h[
­ÓV 
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¯y
²
±j!°
è¶
Ìß4.ÞãÀ0 np3 +( 6 Òõ9  €]< NSS?åC dí I Ž[L  ¨Y
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
O $œÌR (9%U ,iÓY 0þ¨_-e'%� C¾*A JÙÙÇï.ç@ 
…
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
nê 'ZÞ dsP�uh[wÞÃÝy8‹ý{n<áõ}z>u
À@¯w�nDªƒzFÞ© …Hœ<‡
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
/L˜:‰
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
/Plï ‹èT©�èXV 
�y
\² ‘3]#ë “‹`" i**8Ô�¢8.—JG0 Ç$
3 pY 6  Ë:  3$
= UbH .÷ J@1ÍÖEÆ~Û ¨$ jå" 7£ Í=üSïxÎ4  ûAÞ üG+ëFˆñÿÍ7¡K
 +Qr$)$B$[$t$�$ è¯Ë|Y<
LaP�d'h[e&—5Ë
f&rÙ¦g'  V 
i&y
<² j&Ù=©ík&+>_l&@D4¾m&7H– èV+V @V 0@æ�~
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÆÓ¬8 dwÀ d,îd×Ëd ;L ÈÎe›îËwnT
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
±è»– !ÉÉ|g`
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
mT
äèrÙ üÉüÅ(ÂM;¼‡ .T
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
'Z½7î
Tî 5r k@È6 œ‚ ã6/‚‘tEV…Rœ½ [n -‚‘\­W¹‘d$ œã ã-‚‘t–�Ítœ  Ñ� Í+ ‘t40‰]¤œD Ñ� ]) ‘\­W_¹‘d(C0œj �¬C+j‘t!cÕlœ§ �¬)j‘¤át'‘¨ºÿ4œÊT’ÿ-Ü‘tX0
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ãHœíT’ã+Ü‘t*$ ½`œsV½+‘tíehœVsVe)‘Œ!­Wg¹‘d!áth'‘”)czG0œðt0&œŽ o 09‘t¼ä ú2œÄ o ú8‘lˆèü‹‘tz÷ &œê o 9‘tuu«2œ  o «8‘lˆè­‹‘t‚¦&œF o 9‘t�è2œ| o è8‘lˆèê‹‘t§Î
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
2œ² o 8‘lˆè‹‘t"©Ö
M "œ"ïDC "œ
: ;9 I8 ( 
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
: ; 9 I8 
:!;9 I8  !I: ; 9 I: ;9!II
:!;9!I8
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
 : ;9!  5I : ;9 I
$ > > !I: ; 9!(
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
I!I/  : ; 9! .?:!;9!'@|4: ;9 I.:!;9!'@z.?: ;9 '< : ; 9!>! !I:!;9!4:!; 9!I?<.?:!; 9!'@|:!; 9 I'.?: ;9!'I<&I
: ; 9! I8 .?: ;9!'<!4:!; 9 I".:!;9!'@z#% Uy$$ > % : ;9 & ''I(.?: ; 9 '<).?: ; 9 '@|¼""22&2&2&0h`H4l0¤t R ‰""22&2&2&0è`H4l0¤t R wò.L Ì ï$hX˜ zj" 
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
»® �
ˆš
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00


5?¢AÈ 6£ €A#™!ÂrØ"#$³x%á&Øä'è(“)ì ’*ð+ô
Ð,ø Œ-¾» .“/FÙ”}o 0 1ºœ2îT² Y43¤
Ä4´þ5oL¸Þ6Ùm®7 8x9ºf:ûÖ;<‹` 1 7!"=#$0%>&?'@(A)BC!D�ì "Eˆ
FC1
GÎK
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
H IG0J K •W
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
G#L+;/#M#N3ñ#OÎP#Q RæE
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
½ST$#'éð(UUVW<Ë
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
J#X¢Y UCw
}U;=®ݾb
N*À Œ÷š¡¿ ¯³ ÓY°X#ñ
Š“K²Ž%y
V“†?ýÌ  ŸúüÛ‘–±;Uµ
‘

r.fï
4 Ó˜
5Oðnqé
ò_ßLž:ô#
”/‰8 ‡
Ʋíô;Ò
‘ûtšSMB†yv÷ßM‡½‰êÿn,$ƒt
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
h&# & #¿Y6W
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
÷§ ½~ Š¹= Çë
%[ ϸ kž U{Ô
k€ Pí 
% ¯ì û«Iù8é�mÿ I�
†°š0
"5Àøñ„À q’
(Ê
¬¬äô
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÚD²¹ 3_L,[êl°ß°
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
-ÓͼýÎ=yNh~j BŽþˆ �$ „Kœ²h-�úRåԯŎu€%W
öR
s0
µ
vW
Ç%´L¥N Ÿ› {N ‚ �
õL=t £ü왥 ¤ùÔ± 0ºNÅ,À FmìœTĶ�, Hhåë Ž½/:X ]ÈKm¤BR$Î óˆÁv
E<
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
]sôDZ¡†ÓD«
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
™-(È»eã ³O¹B|¯£ùè àŒK !Y#Æ
tç�m³ÒªóÛîíXµ�шlih¢ŒQ
Û 8n<íü
³‚³/
­ƒð ®D
÷Id š¨¬@¹@
?óV
­4já[ó
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
3\@¯[>>à ÈB
{ ÐÿE’á݆n²+ —¶j3ÿ«-ï!•m ‡Ø
ª¿ê
Q¤ Ï�•4
 §A6 `­€°"o›X£
ÝÄ nBê´â•Åÿu
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ßÛ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ûp
;&}QÊÆ ¶K
â|
K÷ øxêóz5 o VëR  µ âeË᎚۾à'a F`*Ìߌµ �ï m½
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
éɇ Ú ¯­NÜÞ¨½Óx¥A ;  jl£
íUYº¼·/ûÇMt Ю¹D²ú ˆãÕe?Ò
Œ‡”£,Ô<ñRx Šä “˜ –Á^æ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
½Âˆð íy£V
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
�Ìú$�•><îw‡Nïƒ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Š›èkL£ûUôYE6·,\¸Ú¯vÿ×ÈÛx=Ýr‹ 97n w·-"Ùþ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
vŧª |×O¡·LîÔyq
ê,Ë�Í»/¾‹
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
 Ênø z±AŸ
ˆZqC“ß±© ¾¾Ø¦
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
e:À¥‹î-Ä+œ;´ }~”ï
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ù ›å
ó…
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
æ¦ )6
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÊB'Þ$L
æ]L ~?þ ÿyv¥Ó…þ uŽr‘¤~
.x
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
âéÊM4Òðo¹ ØÉ($
<¦ rÉD  »„KÆH΀ª ‘\o>²�W” †tY»ùüŒän ’†ß <íÖ=MìÅfs³ƒÈ-”'Z0X K&2]ÅÅ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ç{Š—K°2§VîG°,|Æ¢~i Î\§ìR $“)Õj*qÚ+m?0÷
4
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
8w»
9|
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
>{. ?Åê@Š AºB¨ëC[ DF¦ GFHWw I Á
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
JÂt
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
KˆæLµ@MN”
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
N�kO¯ÐPZ·QÑw
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
R¡u SG,Tø UƒñVdUWòØ XÆÂY°b=¨f<¢nO,w1¸~>† †ëb�e�
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
˜û°œ �¥£Í°I±­ä²6_³%ý
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
´öpµÓo ÅTg
&·L 4šÞFRGeÀHšWI‘JJ—æ $ÐK0`1?*2QÕ3kB4”š5º)h ú\, 5ù  ~Å!N®(R[’&‹“åê—Bï˜‰è ™…šm³­Z ®‡�½•Ö4�ép¥Ÿ
°µ÷´x„
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
º:Ê
Ìò‚Ü›fîe=Ŋװ!x§/Ô£=}ËS ’m6ÕŒ”y
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¦y­¼GÎÍKô9ã 
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
wI +eý, -ÆÓ.ƒ\
/int0· 1œj 2nF 3äÖ
4ñº 5!e6èÞ
7þ_8
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
t9;a :§fCådJ‘Â Rs‰]°¼hh
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
qš÷x¼I�kåˆúÖ “Ö_
—ÿÕ¢Jέs
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¶i¸eý¹ ºÆÓ»ƒ\
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¼int½nF · Ãœj 
£>cNšõ !¸æ %«è'/Ó-È
1ʳ3þ¥
95â=B÷?ññ
D¨ï
IšÅN@À SºG
Áˆh3#1y )Â; 56?|�IRžS8à€Œ4�îz
‚´˜'»™ÃòšÉô¢¨¥ £é¤ƒª®
{
¯L* °c
¸¢¹O–ºöÄMÞŸú Æó;Ôë1Õ³Ö[5æú¨ç© èÀVöÓ8÷3ì ø¬
†% ‡á¿ˆÞ�
–¯‹
—]¸˜ëߦ%Ì §«ö
¨îeÏ ·ËT¸N-Æ%‰
Çû>ÏÈB×µžÝŒæ Þõ÷ âÕæ%ëÚbödy€Á…:ÊŒSÌ �Jv
˜¨™“W¤–Ï¥˜„±mv ²¢|ÁÑZ
Â^
 +…#0®$pé%ƒÍBK?CkÚ DíGºŸg 1BU
)Ÿ~ ,Ù
/ 9 2®(5e£8zK;]>9à
A·WDÍí Lù Tüc
\í@
d9l¿No&}rœ‰ uËW
¦�
ªGP®‘ײc1
ü þHMÿ=€Ö®‡ƒ|�‰H•/œ´H �cæ
Ô Sä
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�‡äŽLö
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ä“cçÊn®êŽÛ6WÝM( Þ3 á{S âé…ã¼�”Y¿•º–
—[n ˜ó]šÉ›{�9žðÕ
 …»¡vá£`R¤Ìæµ@Ñ �FÑ;›
ÒŽL Ôs{ÕG×Y¤
ØœÚo ÛT Ý9úÞ[Ÿ à™´áö㆖äøÃæaïç“S éaÏê,‡ìžc í‚C €lé�ô^ƒo„Žh†*)‡jà¨d
©-|Ò˜äÓ4ÕdÓÖ×ÙØô Ù$³ÛoÜ{¯ÞIzßöâò8
ã�Êå�£æˆ«è.
é|b ë¶wìL|îïÛññ=× òØôøúõ{÷—ƒøè` úäµûžWý&Üþ²�n
‚M…Ö…†Çˆç‡ ‰ï¿‹”~ŒõÍŽ{Š�\Í‘¥8 ’Dœ ”ƒò•Û—Y˜âý ›lœão žw%ŸàÖ ¡c ¢ò¥O±¦2æ¨è¸ ©ÀÊ«r
¬\q®ªÝ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¯N+ ±â…²µ›´ 9µî˜
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¸öl¹fm» ô¼y�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¾cÐ ¿
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÁE•Â¯·Ä…Åô,ÇÆÈa…ÊkÞËh"
ÍÃIÎ
”І}ѽÓz ÔdŽÖQ.×qÙ£G
Ú-ŠÜ.ÖÝþ ßf¹ à˜±ãÝäHÞæü ç]éõ7 êæ í*ÇîN‡ðdÙ ñ\órô1 ö2· ÷ ù‹ÇúVPü:¯ ýØZ €wä�—ƒ~ª„¿&†³‡«‰=A ŠÝ]ŒñL�W7
�$½�ªm’i"
“Î)–r—C ™!/šï¸
œ2
�»0 Ÿ Ü�¢JZ£øŽ¥·h¦ËÑ ©YTªê\¬ß�­.
¯Ð°Û³Fž ´ðË _p·ÁÕ
¹'„ ºÑ�¼þ½�¿ó€Àv ×‚~ØbÏ Ûì‰ÜŠ·Þ/'ßÖÛáäŒâµ´
äÔ
å9� çµ�è†
€&
�’KƒO�„’† ‡�æ
‰¾À ŠB_�Ó5Žù‘å}’õM•
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
t
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
–¤ ˜ë™í›�›œª
ÍÜÎÁr Ñ!øÒC˜ Ô[GÕ7&×nóØ#A Úž3Û]
ݯÞ$bàâWá¹K ãfø ä[óæU(çK
鬨ê7õíÎð
î·†ðT"ñE© ó ,
ô° Ÿ©  Ï"¢½U £á ¥æ¢¦ó0¨[Ê©™™«~ÿ
¬]ï®êX¯kó±M~ ²;ò
´îµÆW ·cv¸`÷ ºTûÁü½>¾);ÀŽMÁÖÉÂÄ7‘ÆfoÇ(dÉØìÊynÌ}\
ÍP,Ï"§
ÐTûÒ™Y Ó¡ Ö­ ×—ÚTÛŠ¾Þ $ßþÑ âèãV_æÞç'êÝNëf}
îÀ]ïïñª
òfžô"<õ»]÷ÿuø¤‚úÅÀ
û&ìý]ü
þv[€n�¿ƒÂH„c>†ê ‡/é ³xˆ´m‹·k? ¸öµ »¹` ¼qµ
¾ôP¿�ÔÁ+/
ÂŒTÄ�ŠÅq\Èg$ É×èËc±Ì ÿÏÇÐÞ
Ó¤QÔ(
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÖOÞ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
×- Ù7Ü
Ú4#Ü
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
7ÝÔ ßà àï8â9\
ãO å0R
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
æVWéIxêÐìbeí¾_ðV°ñBíó9ô¤óöÞ;÷çƒ
ùSúE�ü¦Y
ýC˜ ÿز€ £‚ a£ƒ
I† >Ç +‰ <óŠ ÁI� ÚæŽ öÛ‘ ÞÌ’ ” �£
• ÕW— ÆÀ˜ “Øš \— › Çj � ©( ž …   ïG
¡ Lɤ ›¥ ó7§ bÞ¨ �)Ç ÐJ Ê ÿ�Ë <©Í âu ΠѸÐ ¨ò Ñ ä Ô ówÕ _ä× Ï Ø -Ú ôOÛ ÂÝÞ p7ß Éeâ  }ã M<å q•æ KAè Þ² é P†ì µ�í åœ ï Ã2ð ûò D<ó hõ .ìö mø ç°
ù ^ò û >—ü œ7 þ òïÿ ߣ�
A’
‚
¹ê„
#
…
œ ‡
‚¥ˆ
p¤
=• ¥
Y§
{ ¨
^qª
›‡«
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
â” ­
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ýw®
ô°
Î:±
¬p ³
þ´
¤­ 
ÿ ·
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¹
�8º
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÙA¼
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
”ƒ½
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
—À
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Éu Á
õÑÄ
„‡Å
ßÊ Ç
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ùoÈ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ËÌÊ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
*æË
N‹ Í
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
j— Î
«5Ñ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
#Ò
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
NM Ô
n Õ
æ¤×
ÂÇØ
àÚ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
JUÛ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‘Ç Ý
×ÇÞ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Fpà
:žá
v`ã
ÄSä
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
æ æ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Q
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ç‹ê
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
KPë
7¥
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
í
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
CDî
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
rÖ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ð
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
lñ
¨ó
âcô
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
nú ø
’wù
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
—º ‘ {R ’ ´Ö
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
” X• ì!
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
— Ș˜ "š UÆ› \`� øËž êZ  ®8¡ ³b £ #œ¤ ¿
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¦ ¥
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
§  © úq ª "% ¬
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
­ S¯ &° À¶
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
² Ýý³ ?3 Hú· ®¹ ïnº ëk½ uV ¾ �À š©Á 0üà �‡
Ä ÅÆ Ï
Ç �­ É Ñê
Ê H—Ì ¢}Í - Ï •ÜÐ !Ò øï
Ó pzÕ +C Ö üØ ³˜Ù îŸ Û «¼Ü „¿ Þ )ƒß Ä
á $j
â -Bô ¢ü Ê ‰ Ãè Š Ao
‹ n€Œ •½ � îó
Ž åt
� iH� Q ’ Þº“  ¦” pÜ• •á– ½— 
˜ |-™ �­œ t½� ã  �ì ¡ ÷ìà öéÄ ·¢Å Cz Æ l°Ç ,;È É)É b‘Ê íË ÿ¬Ì ¹·
Í xÎ ƒ¤× y¹ Ø kŠÛ bß nà I‰á ýâ òùã *Üä ïÆ «‹"†Ù
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
#Ý $Í:% &o©'ë3 (Gg )¤*Žâ+ï,Ô�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
-Ú�.óŒ /ŒÛ 0
½ 1:„2/õ3’ù4oK5„ 6f{7]" 80Ü 9�í
:èK;AC<a =»Ö
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
?#¾
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
@®üAZ’B© C…tD”¹K¨XÊ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
gû/ {Q�…·}�‹& �u¢f)
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
§Ä€¬[½±� –âÍ—ù+˜L�°ž²_
Ÿ[S øI¢ñ£ô²¤5r§•ç¨sW© ªª“H­¦1 ®c» ¯øb
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
±°¤²X¢³Ó´fe·á§
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¸ÎN¹¢ ºDµ
»0
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¼§- ½ã1À‚Î ÁúÂj$
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ã,¡
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÄùNÅíÊ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÆV€Ç½² È9öÉ«œÊ�ò ËÌy Í\rÐÊ‚Ñ]ýÒ¤gÓE(ÔšÕ†Ö"� ×ATØÙ²
Ú}XÛãÏ ÞõG
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ßãí à‡~áøÏ âèÝäA-åÚ»æ^â çùÄ èMé“4êúÊìŽS
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ír} î¾ïïÿðÁÅ ñ±C
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
òŸ� ô9ƒ õn’öº· ÷²„ ø§© ù38úûûq(üT
ýfþ¦ÿ/€G¦ �Kñƒ� „6T …�Ž†Ó™ˆ 
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‰Œ9R �;‚ŽÐb
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
�¢�”•‘Ht’å“”Íy•5—ÇZšg›=• œ\�ÿ;ž¨Ñ Ÿ  îË¡—�¢˜ñ¥"¬©‰ª.­þ– ®ï ¯o°‡k»©€¼·[
½†ú¾ìü ¿¥ZÀÙˆÁiú ÂQIÃaÉÄŒsÅËa
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�y
ÇÃ Ê
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ËÎ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
̤,Í�Î¥öÏ <Ð�ÑœàÒ8ó
ÓþÁÔÀÕd–Ö° ÙÙ ÚV� Û¦Ñ
ÜQ
Ý¥D Þ€„ß–ÅàŸâàý ãŽ�äÍ
å{
æ$K 瀓 è›#
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
éXc ëv[ ìÆ$í¥î+ïÌÄ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ð-8 ñZŽòëóD ôÃõ™‰
öXÏ÷°|ø™ù`;ûš!üîØ
ý@þÇ÷
€ °û� *ƒ S„ è‡ ¶Xˆ Pÿ‰ ðç
Š Š‹ ጠm}Ž b
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
� ûð‘ Ý- ” ÀÛ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
• —* – å„— (c
˜ ¤Q™ }A š í@› Ù)œ ‘t� �€
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ž ´èŸ "[¢ ¯]
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¤ …
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
° û<Å 0
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
È soÉ Ë¨Ê Ž7
Ë ©ñÌ ë€
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Í R  Î ï¨
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ï è©
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ð P:
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ñ %÷Ò �5Ó ÓÒ Ô !j Õ ™ðÖ † × \Ø «¯
Ù …sÚ dÐÛ „µÜ  Ý õ&Þ jß Ûõà ïná <!â ç ã ¥ ä ì)å øÌæ 0Mç pè vn
ë úMì öæ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
í À® î ¡9
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ï ¸:ð Êx
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ñ §½ò ioó O}ô ÒÉõ åQö ‡Š÷ ß8 ø Œù ú Åýû ïƒ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ü úý º þ ïÿ ÿ
€
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Y�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Õ ‚
n<ƒ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
º’„
Wå…
š †
áÀ‡
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
bˆ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
pg ‰
ºŠ
7Ý‹
ÀX Ž
j�
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
'�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ò,‘
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¦A ’
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¹µ“
c\”
¡•
fà
–
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ø2
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
—
ÖĘ
M“ ™
«Çš
_›
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
dNœ
Öå �
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
4þž
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
zÛŸ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
³ 
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ûs¡
/E¢
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Âð£
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ùϤ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
c×¥
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ô ¦
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�ì§
Yê ¨
rc©
«Zª
°
«
ó6®
 ¯
­ž°
´ø±
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
#ß
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
²
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ªŽ³
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
I
µ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ôH
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ç›·
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
�¸
<l
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¹
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
=»
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÃÁ¼
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
;J½
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
x¨¿
£9À
K¯ Á
ÔÂ
²Ã
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
TP Ä
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ê+ Å
åŠÇ
©°È
9Ð
É
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
åÊ
æ3 Ë
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
[ºÍ
дÎ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
|ËÏ
2VÐ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Æ3Ñ
·ïÒ
ÓËÓ
)Ô
!”Õ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ù[×
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
_nØ
>ÕÙ
‘
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Û
xp Ü
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Þ. Ý
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ê%Þ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ø÷
ß
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Zq
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
à
OC â
1Àã
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¥ä
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
v“å
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ë» æ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ð'ç
íÝè
î; é
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ºIê
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
rüë
´ì
DÀ í
9î
Íñï
< ð
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ãñ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
.þ ò
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Åó
¹Áõ
–i
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ö
&¾÷
W|ø
¨»ù
»ú
8ªû
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
׫ü
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÄCþ
úAÿ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
›ß€ ¤ƒ ॄ )&… Q"‡ äi ˆ ­R‰ ,ç‹ ñAŒ ά� ‚
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ž ¶*� ·� è’ Fâ “ 0” wî• —– $¦ — sô˜ XÓš ¼Ò› {
œ Ÿž £ÂŸ ŽÏ   £ ‚Ò¤ Ë=
¥ ž/¦ ÊŸ§ ¹¤
¨ »œª K‹ « Ϭ ´Œ­ ˜”® cZ
¯ ?¢± ý¨
² (™³ ?÷´ Dµ 3ß eÀ¸ 1 ¹ D º „ » [L¼ Žç½ {ƒ
¿ ‘”
À ¼Á H ½jà ÀñÄ ð“ Æ ¥Ç "MÈ çóÉ ƒ€ Ê ¯Ë !Í …/Î ¥� Ï 2uÐ #Ë Ñ AÁ Ò ’'Ô %Õ —˜Ö Qü × #WØ aè Ù �ÚÛ 1ŽÜ ÎÝ ‰èÞ ÷Òß æbà ÿëâ  ã «v ä /hå Þóæ rç ÷ ê Û?ë ]”ì Ýö í Ð�î 8ú ï ðãñ ¹/ò Ðÿó Ô ô ª˜õ s 
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ö {4 ø N ù Óú ªû gÁü cJý 4'
ÿ ƒà€ $Û � SÄ‚ õ^ ƒ hß„ ̆ ¶ž
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‡ Èóˆ ]‰ > Š å�
‹ §p� ðŽ F� %� n—‘ 3Ò’ � ” ¹• Æá– ¢®— æA ˜ ×Ó™ þÛ ?¿œ lÄ� Âd
ž <‹Ÿ 9n  sQ¢ Eõ£ ’Õ¤ ¿- ¥ 蔦 ­ § Õùª æi« ¯f¬ Nr­ Ý® ÿ¨¯ «¬° ¸>
± i ² Ëæ
³ rÁ´ Þöµ þU % · ¦¸ 8Rº  » 3… ¼ š¾ ½ .n
¾ €‹¿ ÜíÀ Á „ Âà ŸÄ ŒÀÅ /ŽÆ GuÇ {DÈ A5 Ë # Ì ‰ÇÍ ¹l Î nˆÏ æíÐ gÇ Ñ [ZÒ ÒÓ ÎÔ P—Õ Ù#× Ò/Ø žMÙ XÚ Þó
Û Žú Ü nÛÝ v½Þ |ß ¹.à ¬œ á i¶ä Æå 8Ö æ ™�ç vè “é ºÐê çgë pì ãß í ð´
î ´È ð ½Ìñ  ò ©ªó zÍô Tüõ ûÚö Í(÷ ªÉ ø \Iù é¾ú �Âý _ˆ
þ (| ÿ Ñ‹ €
s�
Q=‚
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
8äƒ
L…
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
èˆ †
²A ‡
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ù¾
ˆ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ìO‰
Â]Š
î&
‹
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ø Œ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
轎
±)�
óÕ�
þ‘
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
bç’
%Ã
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
“
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
”
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
{ •
�‘—
þ\˜
7™
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
i4
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
š
"›
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ìu
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
œ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ŸÌ�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
æž
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
«i 
+ ¡
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
é! ¢
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
áM£
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
H2 ¤
–³¥
K ¦
1â§
Œ&ª
H«
uñ¬
¨$­
½œ®
}Ù¯
¾f °
i±
E ³
�ð ´
ß 
µ
÷S
ž·
=_¸
�ܹ
*�º
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¤!¼
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
T™ ½
ÆV¾
òa
¿
n
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
À
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
6x Á
¬ïÂ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
÷7Ã
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
˜—Å
+Æ
S
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ç
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ËfÈ
“a
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
É
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
#C Ê
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
QXË
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
n­Ì
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
õÊÎ
äÐÏ
>Ð
ÅŽÑ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
R…
Ò
ÅÓ
+IÔ
AßÕ
ŠÜ Ø
!
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ù
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
lÌÚ
×ø Û
9D Ü
*2Ý
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ž€Þ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
?ß
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¬c
á
òÕ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
â
Ó$
ã
P3ä
3 å
áæ
%‘ç
ÏV
è
yw ê
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
O\
ë
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Pàì
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
±í
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
†î
œõï
šð

Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ñ
8ó
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
™îô
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
0 õ
ë€ö
N–÷
» ø
¯Ä ù
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
®“ú
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
9ü
7^ý
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
�ê
þ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
³ÿ
½¦€y7 �=‹‚K¢ƒ‡†¶›‡“ý ˆ&_ ‰xŠv­ ‹… Œ?� ��Î �š*‘µP
’äU“ØΔ& •Q#–‹Y™ŒÞšNj ›_Ãœï·�«žñÊŸÇ·
 ÞW
¡!9 ¢/¢£@¤9Ÿ¥ƒ3 ¦-ͧÞ]¨ä�©Þeª/÷«˜ÿ
®–¯´¾°ª· ±¬¢²ÿU´ µ=Ö
<Ú ·µ¸°y ¹±P ºâ¼:/
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
½T6¾ÜÚ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¿ ÀP·… Ãá\
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Äý!Å@æÆ]YÇ�•ÈŸoÉ÷ËùÌ¿ Íí ΉÏös
ÐŲÑeÁÒ ÔæaÕ†Öö!
×Ï÷ØÁ&
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ù¿H Ú(öÛWÝ[ 
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Þ’ßóTàz·áÑ´âŒâ ã¾ÅäP1çmKèqé§ê˜[ ëAìÓíP#îäËï�±
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ðÕÿñd?òc|
óÕ­ôçCõ-û÷\¢øÆê
ù·Õ ú¼mû®kü.ýàrþºm€€¥ �ªé‚'…7ü †û
‡‹r ˆSb‰h
Š;;‹þæŒÿÉ�Ž]ŽõÅ�"�êâ‘#
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
’ÖÈ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
“·b•›ß –@í—ñæ˜f™SÅšPD›}"œû+ ž~)Ÿ’: G" £sï ¤LÐ¥n
¦DB§VÄ ¨1K ©LH ª’E «ÊA¬3"
­ }
®å1
¯ÔÈ°Ë’±F³Ha´pµ‘¼—u
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
·�m
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¸
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¹dëºCV¼§Š½z¾AÁÖÇÂNdÃÎK ÄB¤
ŇìÆï Çpî Ȇɲ‰ ÊO?Ë=Ë
Ì•îÍ/˜Î¨ÚÏ× ÑÞÄÒšÙ ÓÜv Ôd™ ÕÛÖòíױ؃)Ú÷‘
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Û™Ü
ßù à' áI{ âýH ãÆ䳚å8ú
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
æMÔçÉÚè4ô
é¨Î ê!]ëG4ìl7ímwîG€ï¥Z ðÇ“ñÕ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ôP õöüÿ ÷VÖ ø;ùûú±É ûçÚüèo ý<ÛþÜÂÿ·Ü€p¯ �ÑÐ ‚Ÿ ƒRŒ„Ö
…&
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
†ŽC‰aŠìÏ‹üŒ-�ùŽÛ“�ÌÁ�‘z  ’õ¯“7ð ”/F•e< –xœ—€˜™2Cš}—›jÐ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
žWSŸòN  ¯�¡€*¢b•£á|
¤¢}
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¥ 0¦°*§8¨èò
©¯×ª–“ «Þ�¬s‘ ­ã®jZ ¯"
°œL³ZG´f§µH‚
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
µG·å%¸<ñ¹ÿa ºº{»î ¼æ½Ž¾Ñ• ¿ `À<M Á·dª: ë� Ä­Åy¨Æ+ Çyß
È6² ËZV ̧j ÍóÅÎ$ô
ÏޞГ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ñ áÒ%šÓÙÔœ/ ÕëÖ_Â× )Ø©ÙʨÚjE
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Û‘fܬ§ Ýs—Þ\sßH’àiãjú
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
äô
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
åc�æ¶Ø
çz{
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
è4äé*Ø
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
êæw뻯
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
쩇íѳîá†
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ï þð÷
ñÏáò�¼ó}ôyÊõ¹³öÌ÷Íø8”ûö¼ü�Býàþ¿«ÿœ€H �O›
‚ ƒ”é
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
„¢* †Ï‡~ˆ)
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‰õw Šª<‹ÑÜ Œw.�Ì ŽC0� “­Î”Hq•‘
–6“—¢Ü˜q4 ™U‘ šv— œÁ �מî-Ÿó �:¡á‘ ¢u‡
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¤m¥f* ¦w¨'þ©É ªÀ;«6ˆ¬íﮩ¤¯\°±âJ²Ù´ª(µÄ  r!·ý§
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¸2̹; ºGŠ¼¼Ÿ½Y¾‡P ¿§ž Àa[ÁŸU
Â^ïÃþÄÄèÇ¥rÈ ÉvrʶËË\6 Ì‚¶ÔFn Õi0Örf
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
×Å,Øá ÙþÚ†UÛ¼/Ü8Ô ÝþÂÞ^4ßÎüà×ëá_râŒ@ ã„ýä¡�å�Ð æ¿ç"™è‹é¶¨êÖÞ
ëŠ&ìG¶ í
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
:î¯ ïYÆ ð!ñý@ òYª ó8W ôê™õyFöd\ ÷¢Uø�ƒ ùê*
ú«çûƒr üöýÇý
þÃ]ÿ9€Üq �=7‚t_ ƒqe„Ôr…Ôl†é} ‡ð؈óª
�*Í ‘½4’ƒ
•ÉW
–„ž
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
—ü šñw
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
›@œ€é�áñž«
Ÿgš ’-
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¡„q ¢Õõ £)“¤„¥ë¦¦ãÁ§T¨‰Ô©µ§¬’$­.·®dâ±Y— ²D³ñ8»µ±¼˜- ½Á뾞¿NÄÀÖgÁ1,
‹Ä
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ä)6žî Æ�
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÇNÊ ÈJ›
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÊVGËL(Ì×m ͵ûÎó²ÏëçѬ  ÒÌlÓ@[Ô°Ò ÕÈÕÖÁâ×\·Ø¼ Ù-KÚINÛÂûÜö|ÝäG Þ·Ýß*_à 5áºâàäqßågZ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
æB;ç Aè±?ê&+ëì ìG\î–
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ï<ð8Æ ñ{,
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
òR™ óîæôº÷¶³ øçºùâú œ ûU üÎF
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ý“¹þ!ïÿÓû €êÍ�0~‚NZ …Î… †Tó‡ XŠJ,‹$yŒF�c’�?)‘ÊJ”¬•cû–&^™Á¾š™Â›[ ž¨]Ÿ…ã ôm£–ú¤6ª¥é ¨›©q ªÒ×­ 8®'8
¯½)²ÑгD ´“Œ·Ûi¸”ë¹%d¼} ½È<¾•]Á\žÂÇÉ9
Æ{=Çi\ÈÅ·ËbEÌ,ÍkhнÇÑ<tÒ“B
ÕX Ö·×ßÊÚö~ ÛœSÜŒû
ßOúàã
áÍgäéì
å@Y æé õêçÙëØ^
îNïîðèºù>üúK‚ û¡'ünïýð×
þJÿhÝ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
€)–�—2 ‚Yƒc+
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
„œ …­ †%�
‡ƒ9 ˆµ— ‰ÕŠ�‹FΌَ�^üŽîß
�IÕ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
�Á ‘½¼’ “PÖ”†•«]–�S —öm˜cN ™XzšŽÁ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
›3Êœ�ƒ �¡žè" Ÿ Å Ô ¡
¢¦*
£/œ¤¨m ¥?n¦àï
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
§Ê[¨( ©³ãªâ%«¥} ¬g}­a_®J^¯#Ê°{
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
±Gµ²´³�¾
´¶Ôµ
qµä·šÒ¸Àâ¹*`º6“»H®¼cv½x ¾ñ
¿º\ÀÁíÂ!û ÃZÄ<ËÅÀ`
ÆýØÇB×È8¦É¤£ Ê3$ ËK^Ì;dϲBÐbvÑ‘2
Ò‹LÓuƒÔ&øÕ#BÖÖr×v«ØÍiÙ]@ÚÀµÛ¼È܆{Ý%Þc߬Ëàا
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
á¯æ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
â‚Èã‚ä7#åæ»ëç“àè·Ãé¼jê'ìëº9
ìI¤í@jîa•ïj^ð%‚ñ¹ òHóRË ôl{ õ�+ öö� ÷ ïøm\ ùW
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ú«� û~ü´¬ý:þñ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÿ ø €@4��‚�óƒ†Æ„-a…ê6
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
†l\‡ íˆëÛ‰9ðŠÕP
‹ü^ Œ
à �š…Žä\�<�³è‘<P’d® “È» ”«º•âZ–ÑK—Cè˜Ò3
™i& šÆ›»åœà¾�Ð
ž!~Ÿ_ næ¡3¤¢w ¥¢— ¦R� §¤ý
¨ Û©:<ªn÷ «iN¬†à­%M®ó ¯°C°žR±õ²œˆ ³íT ´ĉ µÛlÔ·$Q ¸ùa¹:zº·¶ »ra ¼ ¾ 0¿Ó•Àx×Á¼s š
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ä©ˆÅî1
Æý× ÇY‹ÈÊ&bËÄ3
Ìù Íj=ÎÚÐV3ÑdÒïõÕUI Ö¼,×âÚ:~ÛO’ Ü]Ô ßSà¿ûá?éŸ7ê&B 뙢 ì<³í‚îÎÄïð— ñNòŒómÍôYñ õ5 ö;÷Áyøž ùÔú
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ûfK ü„Í
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ýEaþ"ÈÿÆ&€ÉÓ�¼
‚cƒrÓ„5· …Á2 †wp
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
‡¨_ ˆ�å
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‰eu Š.E‹(£
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Œ¼B
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�RÇŽŸy�Æ’§³“´‹”Eþ•Çh –Øâ—Ý� ˜ý™zûš—·›g±œ‰ �]XžMEŸP \s¡aÛ¢»& £v¤e¥æ–¦îµ
§Œ¨-ë ©þLªʬ «zº¬]
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
­\ ®^
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¯#
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
° ñ—æ²?ɳڒ ´dµš¤g¦·{ë ¸å†¹<ß
º1°
»„í ¾ï› ¿xMÀæ© Áa,
ÂõÃ’{ ĵáÅ+Ôƹ7ÇæÈåšÉ."Ê)Ëê¹Ìöͧ2 ÎVzÏn ÐC@Ѿ7ÒBÑÓWÚÔdóÕ‘™Öu€
×ëØPÙ< ÚvçÛ&î
ÜU\ÝO^Þjßh²à^§ áYì â„¿ãEÆäÈåÍðæÜ—çy2êõ$ëIºìe( í¥™î¬?ïiðŒÀ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ñó¶ ò†ôóM*ôŒhõIö�è ÷ÝÅ
ø· ù:÷úZŒ ûPðü[
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ýþp;ÿ=& €? �¢‚î2ƒ½ç„£L‡�‰ˆ%‰’7
Š�‹x� Œ”×�X³ŽH��ç�êE‘Ư ’”•¦ÿ –òb —è0 ˜VÈ™Äñ šq ›Éi œá9 �
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
žiߟ±6 Œ ©´ªY× «¬ey­l~®3¯¸ñ°˜Ã±èi
²i¸³‡‡ ´Rµ—]
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Œ:·Ó͸ˆ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¹EƒºÊZ »Ô”
¼y= ½9¾’4¿=òÀeÐÁ\3ÂöGÃ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ä„kÅ6õ ÆǵöÈŠ®ÉþÊŠ ËP¥ÌÊGÍ,ΑÏÓH Ð#ê ÑÄÒ�JÓUøÔ&
Õï ÖÝ5׉Ø)Ù ^Ú¡ï
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Û¢ Ü�ÝF¨ÞD¾ß4Ù à  áž]âaØãóËä—Ååe¦
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
æÁžçì¯èEéÁëê1»ë»ùì:J
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
í—f
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
îBïåÿðšxóx_ôõ¾º
öк÷'%ø ó
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ù-Iú€tû*×üÝôýÔ
þ¹Yÿ� €€à�nÞ ‚¦? ƒH0 „Ê… Í †H“‡6Hˆr‰•ŠIŠ‹înŒºê �ò„ŽÌ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�ÿ¹�µ}‘ð›’çL“ÍË
”v8•N< –ƒp—bú˜ ™ã�š­ ›u_ œ•;
�ážû)ŸÜÀ 4
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¡d‚ ¢˜g£?¤¿í¥2$
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¦cn§Þ
¨ '©�# ª
«â ¬œG­¶q
®å¯x‚ °,2±ü ²Õ  ³€ˆ ´#4µ\ÅMW·¶ä
¸¨ ¹y¢ºÞ� ½`­¾œE¿hUÀÑaÁ-9¶qÃøìÄXÅãê Æw™Çã È2®É÷7 ÊWÛ ËÿxÌ9s
ÍV°
ÎF\Ï(v Ð>z Ñ™Ë
ÒÈ7ÓÌ— Ô£œ
ÕÖVU לaØ;³Ù­
ÚSÚÛ�åÜfå
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ý\¶Þ» ßÔ¾àxk áV– â+lã˜|
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
äÄm åÆæâ>ç™ü
èÂVé|Æ êš²
ëó ìSÙírØîÏÝ
ïÚˆð(ñ5{ òÓ$óG+
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ôq) õ˜
öÆT÷F—øx³ùÍ€ú‹n û\cü3Týœ_þ5e
ÿÑ €ù¥�£B ‚zÁƒÖ
„È“ ‡à–ˆGD
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‰˨Š¸7‹Õ¡Œ‘�m ŽÝà�TÈ�lh‘Œ‘ ’Ì
“^W”1š•Þ
–wï—{(˜ ¾ ™¿…š½l›39œÉ�Q žÛ Ÿw½ $¡ÖZ¢†[ £?­¤ ¥- ¦ãô§£b ¨Œ¹
©=óªùË«óÙ¬Æá ­4®Áÿ ¯‡ô°ë½ ±Ñ,²M¯³´O´x^µÇh
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
6+· } ¸p¹²º›¬»Ðn ¼s;
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
½w ¾8%¿ë%ÀÕæÁ–
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Âz¥Ã§ Ä’+
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Å–3 Æ}ÇíRÈEO É
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Êp‰ËWß
ÌÓÏÍq| ΀ÎÑß~ ÒÎ* ÓruÔ…Õ‰2Ös™×¥¹Ø*ü
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÙC
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ú¤JÛíÜŸòß
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
àOáÿ«â­—ãñäfHåboæAçç+Ä
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
è5é‰^
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
êQMí©‡îNH
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ï‰Ãðbíñ�%òJ\óôf+õ©ôöК÷‰uø€óû4ÍüÓz ýÁþd-ÿ¼9€¢×�ts‚t9ƒ¨~
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
„ …‹° †ºh‰ø� Š"í ‹©HŒ[��ð Ž Â�êD�Rû‘Ê’Wï“%‡”ÂÙ
•ªƒ
–é/ — ˜&" ™K{
šÔA›:»
œå‚�UgžîÈŸí ”´¡~Z¢‡µ £Š¤h�¥B¦KÁ §01¨Ï©åèªçž «š¬¸H­Fîåp ¯ãÉ °Me±ª=²Ÿ¡³H ´0ص8ãM·a.
¸ñÈ ¹�{ ºøö»¹¬¼7�½Lš
¾ʉ¿kÀÖö
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Á)¸
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÂíåÃܪÄX¨Å‹Æ¤=ÇvxÈ FÉ´ Ê×IËZß Ì/ÄÍN½ÎÛ%ÏÏö
ОX у_Ò–h Ó8Ôg„ÕÒ~ÖŠ¬×@½Ø¾ÆÙE=
Ú××
Û„Ü¡†Ý”SÞ¯å
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ßY
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
à„~á‡ñâå
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ã„,äB åºÓè—éÕF êm2 ëÜìZíé+
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
î»ï¨ø ðe_ñÏ¢òyÆ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
óÖôFòõ«« öQÚ÷šåøÀùE¦
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
úA‰
ûy¢ü�=ý>& þ¶S ÿ°±€…T�5]‚{ÙƒcÍ„Ëë…Ë%†ˆ`‡�2ˆ‡‰ÃÆŠo‹ÏzŒ®�óGŽ
�ÿ �¥î ‘}
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
’,Q“q½”wt•— –ˆP—Y˜e�™µNšûÜ ›��œj�,GžkŸãy  žØ ¡Mï
¢⤠£Å¿¤8 ¥Ë¦)}
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
§™]¨­. ©ñe¬ôw­Pã ®¬| ¯öS°Þ
±Ê,²ð&³\Û
´Z
µÒXË·Ò¸
¹w º¼€»;¿ ¼˜ ½A ¾®À¿o¿ À9. ÁŽd
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÂûïÃɹ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ľòÅJN Æ¢ŸÇRÌ
ÈÇÂÉB%ÊlíËS­Ì«¦ Í0"ÎB
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÏÂ’Ð.D
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ñ8ÒûÓÄ Ô�Ê
Õ³Ø24ÙDF
Ú"7Ûa
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Üœw Ý{[Þ²nß&àQU
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ãþ¤äÆ~å ¬æ-òçèÑÐé�…êK‰ ëïì¼í>þî@óïnªð·ª ñ™° òìÃó�_ôQµõ2Ž ömË ÷�r ø > ùD„úÂqû
Ë ü¾ï ýìÃ
þïæÿa£€’á�¯m‚=¯ ƒ:l „NÏ…’ë
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
†žG‡ ˆ;³ ‰Ã&ŠJÅ‹ÕÑ Œ!“
�AcŽŒ �»f
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�‰„
‘ªM’ò“n
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
”Ì•–y
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
—à'˜7�™
÷šùp›§oœ1�6.ž<³ ŸÖî  Œó¡[¢;- £ö ¤-ˆ¥A¦�Å §…ö
¨S©ø›
ªyt «�–¬Ii ­Õ9®}y¯Û… °ný±™è ²›D ³_â´šSµH
ó[·A§¸Ìh ¹LϺ!˻ӼSi½U: ¾-•¿‡Ï Âøn
Ã\
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÄÒÅ­O ƶáÇ.ÇÈH¹ÉYÊýi Ë)÷Ì™þÍ÷|ÎKŠÏp ÐíÑü
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ò\Ó4<Ôî®ÕD„ Ö+S×7
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ز?Ù "ÚñÛX° ܤ>ÝMC Þ‰bß;Ï à¡áÁÏ â4Áã¬$ä9håe_æ½6ç*- è¤Æ éÐgêòð ëœì‘8 íeÃ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
î¶íﯨðkÁ ñFÖòK}
óœ¬ ôÄHõ^6ö’)
÷_lø¹ÆùŽ÷
úê¯û-Ñ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
üB.ý3þ‚Eÿæ6€-½ �8u
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‚ñûƒŠ †U@‡Õˈ̉㵊[¦‹� ŒëÂ
�æNŽ.6�¡9 �h ‘en’KØ
“�,”Ja•¶ß–`î—ª)˜_~ ™þ· š=Ø›˜Qœ…‚
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
�œ<
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
žŒŸkÌ
 3
¡Sü¢“k£¬×¤_5¥Øœ¦w²§pP ¨½W©(ù
ªï…«Ó¬~H­nîyÿ¯µ%²~| ³u ´œ“µÉ;£ñ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
·‚u ¸µ¹Ê ºã;ÚÍÄK
Ŝ(
Æhü Ç£ÈçüÉÂI Ê‘�Ë•�Ì¥-Íj˜ÎV�Ï¿JÐÔú
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ñ€ñÒ#¶Ól9
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÔÅÂ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Õþù Öl3×ìØ{Ü
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ù;m
Ú½}ÝÕ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÞèߎSà�ÁáŠDâ ˆãì än¢åsï æºM熇èfëï-ìß íÖøî¡ï ïjn ð©Îñkë
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ò}Æó�ö¤¦
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ùï¶ úûYý ö€Uà��– ‚.”ƒC„ô�…Y¯ˆ ͉PkŠBñ‹ýzŒ…± �G�Âï ‘?’H “Læ”Jå •a†–àj
—$Mš¾æ›§FœŠ�Êž´è Ÿ‚3 zû¡= ¤mJ ¥Ë¦Ïþ§õ ¨]c©!
ªI­¨†
°þ(±W4 ² v
³%=´D*µ$
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
­Ë·E¸a™¹K‘ºN½‹P¾¢Þ¿� À¯BÁP Ä$®Å]gÆÓÄÇDTÈ�,ÉáÐÊ\_ËeÝÌ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÍÎ Ë Ï+Â
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
к8 Ó¼RÖùô×ÿù
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Øø·Ù³2
ÚŽbÛH Ü\¬ ß2Íâšãç¢ äyå|pèÏÊë4—ì¶áí¸cð…íóûôL�õ søYCûÊ>üa÷ý%<€íõƒZm„—…¨´ ˆ‚ ‹ÊÒ Œˆ` �¬ÇŽr
‘R”gI •»8–*¿™LÆœ¶²
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
�‹Ižóg Ÿd ¢ÌÃ¥Õ=¦þ §Â_¨`{
«3Ò®æx¯I
°^±‰
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
´ï’¼ÙÀ ½øD¾ A¿›â
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Àì²Áô|
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÂÞ3ù•Äî& ÅÿÆ^ŠÇ¢îÈ�É”êʧƒËßÌé
Í’”ΠäÏü|Ј ÑL¸ ÒE»Ó‡ÓÔB+ Õ/ùÖhÜØ–n
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ù¥»Ú,� Û¯Þûà
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ß·4 àH> áN¼âß� ãÒ@ä¢å|™ æƒòçè,· éêóeë�H ìè í¦'îOï3w ððÑñoò&å óJôqÚõ$ØöP ÷±3 ø©Á
ùtúò
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ûÑj
üÅ�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ý¼ìþ5B ÿÎ¥€ Þ¢� ÷É‚ ^�ƒ Ý9„ ðN… PH † 2 ‡ PI ˆ lý‰ “VŠ âb� Y`Ž �Ÿ� ±C� `‘ cJ’ F_ “ Rf ” ä_
• ÕV
– òn— “͘ å¼™ 'îš FÀ› »œ V› � CMž üŸ ï*   Î�¡ ¢ Mé£ s¤ T ¥ '¦ e³§ xO¨  © Õ¢ª ᆫ Àz¬ 
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
­ Í ® k
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¯ nü° E
± A² г Bí¶ ­Í· vp¸ ã- ¹ ½‘º ]•
» Ý
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¼ ï÷½ 6í¾ G¿ °�À  Á T` êc à \‡Ä &ÏÅ ëõÆ SÇ z\È µ É |©Ê Í IVÎ ú
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ï œô Ð ÍÑ s!Ò ˜Ÿ Ó -eÔ jÈÕ %‹Ö ±™ × dxØ Z´
Ù ± Ú KÝÛ …#Ü MÝ �EÞ 8²ß �Xà )à á Ý¿
â =êã | ä è
å 3æ 3Ð ç �0è d6é ®šê Ämë 4Ôì ¨ší hMî e€ï Û
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ð × ñ ù¯ ò žó £Å ô n&
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
õ Òíö #÷ �‘ ø øZù HÉú Sû ;
ü ý ؼþ #ƒÿ 7€!‡?
�!Uâ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
‚!oª…!|%†!Y_
‡!\pŠ!Šº‹!“j
Œ!H%�! ôŽ!Ø— �!î}’!Æ»
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
“!Ÿ‰”!ÍK•!¶{–!5
—!Y|š!ìÐ ›!%üœ! Ö
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
�!¡qž!_xŸ!n¢!sŸ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
£!!{¤!�#§!*‚¨!“ê©!2ï
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¬!ÓÊ­!ô§®!b/ ±!r²!c³!’´!Š‘µ!ƶ!ÉÛ ·!&¸!‹S¹!Hç¼!�½!ë:¾!¸À!ˆQÁ!%�Â!qþÃ!eNÄ!«¾Å!À? Ç!§ÓÈ!7É!Î Ê!Š´Ë!õdÌ!±àÍ! 7Î!¹
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ï!6Ò!-ÿÓ!ÃàÔ!µ¦Õ!#�
Ö!þ’×!~gØ!ø Ù!?Ú!F‡Û!ÑÜ!aÝ!Z=à!†á!¥5
â!o±ã!~zä!xgå!æ!'%ç!úhè!2é!"
ê!~þë!ù}ì!Êë í!üî!Óï!Oæð!2oñ!sßò!}íó!’ô!ŽÞõ!Ù
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ö!ýÍ÷!ÙÁø!¹‘ù!P2ú!©™û!�j ü!öÌý!] þ!]÷
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÿ!·€":Œ�"�Ä‚" ƒ"
O„"~ç
…"“ä †"F{ ‰"ºŠ"~¯ ‹"{TŒ"jX�"¾YŽ" D�"J�"ïÄ‘"·Á’"`“"íi”"—P•"?¨ –"d·—"�
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
˜"Wm
™"#š"ô8 ›"Cp œ",��"ýÀ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ž"“kŸ"íž "aÆ¡"úÍ¢" <
£"× «" n¬"hB­"7 ®"ö¯"^ƒ °"âú±"J²"£˜³"tˆ´"苵"Ð#¶"Ë·"6`¸"s5
¹"ºº"¢­»"°é¼"øG½"‹†¾"`¿"×2À"ª£Á"د
Â"#„Ã"¨
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ä"'ôÅ"ë‘Æ"Áƒ
Ç"JŽÈ"lh
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
É"w#Ê"ölË"œMÌ"¦È
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Í"Í?Î"mQÏ"böÐ"Øt Ñ"FgÒ"ÊæÓ"5~
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ô"?f Õ"(ŸÖ"uª ×"щ Ø"ë˜Ù"ßÚ"í Û"œ¥Ü"?”Ý"áÀÞ"°™ß"Muà"Žšá"vâ"Y
ã"ž!ä"˜cå" åæ"¹ç"Þ5è"NÓ é"¨è
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ê"¾ë"g
ì"èø í"Þ î"/¿ ï"ªð"fÍñ"K$ ò"e¬ ó"{žô"g&õ"nvö"qý÷"Vø"åýù"F| ú"O–
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ý"” þ"e
ÿ"ãQ€#8�#7‚#^¸
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ƒ#QÑ „#‡
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
…#3²†#´v‡#;/ˆ#"l ‰#?uŠ#¦
‹#’pŒ#�#®Ž#¨) �#Ìž�#ZÍ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
‘#»(’#2.“#{”#‹Ä •#µ€–#£î
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
—#]…˜#›!
™#ØΚ#E# ›#5,œ#^�#îž#^Ÿ#Í8 #œÖ¡#Ñ. ¢#V£#WI¤#垥#>!¦#Å §#js
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¨#qá©#Ñ…ª#,˜«#¯S ¬#°Ö¯##b‰±#S¨
²#> ³#iÌ´#Ù< µ#}9¶#T·#4à¸#$ ¹#MBº#»#Ž˜ ¼#8+½#e¸
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¾#§Ð¿#Ö5
À#o¶ Á#Å¿Â#åM Ã#Nû Ä#yÔÅ#ê5 Æ#¹ Ç#X’È#vÉ#L™Ê#z´ Ë#"¸Ì#ç9Í#FžÎ#Vç Ï#qÑ Ð#N`Ñ#ôuÒ#BAÓ#‚NÔ#‡M Õ#!GÖ#2×#²p
Ø#Ó=Ù#Bm Ú#*TÛ#~ÇÜ#Ê#Ý#ô‰
Þ#—à
ß#0à#CÇá#‚}
â#קã#F²ä#'ûå#‚Øæ# ç#M¹
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
è#cØé#Aê#D�ë#f[ ì#‹í#Ñwî#EPï#«–ð#Êañ#!äò#Côó#Â-ô#—™õ#� ö#ÝB ÷#¦ ø#A£ ù#zK
ú#õìû#®¹ü# ´ý#®c þ#=õ �$B
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‚$:Zƒ$ñÍ „$Ía …$Sâ†$c�
‡$ç
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ˆ$ž™ ‰$fŠ$ñ�
‹$ºÈ Œ$Û„�$`Ž$:š�$è
�$àÍ‘$åz ’$Zê“$m
”$€0•$üU–$¾Ú —$Ó˘$óé ™$Šoš$ŽW ›$íçœ$òî �$Zóž$-! Ÿ$~ $­G¡$‰ö¢$t£$»+¤$Ý¥$í¾¦$‚½§$(Ç ¨$ƒ©$¬Hª$Ü�«$Š¤¬$�s
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
­$€ú®$p ¯$Eÿ °$ˆ(±$ú{²$æ§ ³$l
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
´$?µ$©¥¶$©˜ ·$@ø
¸$� ¹$âÓº$É‹»$j¼$ν$hµ¾$Ú¿$�ÔÀ$ýÁ$¹U Â$ÒPÃ$ÅÐÄ$åÿ
Å$8a
Æ$]ÚÇ$í È$|ãÉ$]ÒÊ$yË$XÌ$J{Í$¾Î$½ÅÏ$û¶Ð$
Ó$0_ Ô$lÂÕ$ÞÖ$Vë×$³Ö Ø$㬠Ù$´ƒÚ$;ü Û$Z!Ü$bÝ$3ôÞ$³ß
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ß$µ¬à$“*á$4Lâ$ÏTã$›7ä$Óeå$¨›
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
æ$f:ç$7t è$>6 é$§ ê$è©ë$3Õ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ì$F/ í$*î$}Üï$þ4
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ð$¹ ñ$`×ò$>Q
ó$9´ ô$Oý õ$U„ö$ë÷$(ø$‡ù$G&ú$Uû$É2
ü$0cý$cz þ$Ãÿ$À0
€%³¨�%CÚ‚%ãm
…%ꋆ%5'‡%Ü\ˆ%xÕ‰% Š%º< ‹%ž Œ%9�%¨TŽ%„ �%A9�%¦k
‘%Õ­ ’%ï?“%S{”%^P•%I–%ò—%"͘%Ù™%#£ š%ïè›%Á&œ%9�%Gž%DD
Ÿ%>3 %I ¡%MÌ¢% £%M.
¤%<Ú ¥%Tˆ¦%b¬§%ýæ¨%òÏ©%<óª%ìp«%9¬%£¤ ­%¼ ®%cD¯%hÛ°%êg
±%‘
²%_ ³%em´%8c ·%ñî ¸%h¹%�º%JÛ»%â­¼%…¿½%ŒÀ ¾%gb¿%´À%j>Á%ÑôÂ%rKÃ%8ÑÄ%CšÅ%^ Æ%ûhÇ% D È%’@ É%
÷Ê%ðË%QeÌ%³>Í%ÖøÎ%;ÉÏ%mØÐ%˜% Ñ%•÷Ò%ý~
Ó%ïÅ Ô%zd
Õ%~ÆÖ%»=×%Nº Ø%\
Ù%ÏæÚ%.LÛ%.Ü%0– Ý%”*Þ%cÇß%Egà%r®á%¤~ â%*�ã%q6
ä%¼­å%`^
æ%j"ç%tè%¤=é%?&ê%ƒé ë%¨Ñì%Ýû
í% øî%¢. ï%÷9 ð%25ñ%Qr ò%·`ó%€•ô%ÆÅõ%#1ö%�r÷%ò_ø%
xù%nïú%Æ—û%¹
ü%o$ý%e§þ%% ÿ% ô
€&$H�&×­ ‚&mƒ&›é„&ªÞ …&OT†&Ky ‡&w„ ˆ&ßω&‹ Š&@e‹&o Œ&±�&AÕŽ&¨Õ
�&àI�&(p
‘&Û�’&S¿ “&´d”&"e
•&4Ж&«Õ™&¹rš&õ ›&8(
œ&¶o�&¨ž&L&Ÿ&õ  &Ý¡&è�¢&„œ£&
Ò ¤&ò ¥&Ç+¦&»§&1¢
¨&ã}©&úΪ&˜ã«&»
¬&Ú„ ­&•b®&Æ ¯&?°&sö ±&1Z
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
²&´‹³&BÝ´&-gµ&bB
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¶&!D·&t¸&‚¹&
º&×(»&�ô
¼&˜ ½&ɵ¾&w£¿&œÍ À&Y}
Á&ž,Â&ˆÑÃ&jœÄ&ørÅ&�{
Æ&]p
Ç&‰IÈ&j(É&œäÊ&³Ë&ŠÎ&Ù/Ï&v-Ð&
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ñ&¤®Ò&ÀØ Ó&b³ Ô&èø
Õ&&æÖ&(ï×&
yØ&ôÝÙ& âÚ&Ã]
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Û&�®Ü&ksÝ&¯Þ&˜íß&”
à&9W á& fâ&aVã&Æ:ä&.vå&¯Ïæ&G2ç&F³è&—é&Mþ ê&üië&ô•ì&…3
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
í&È4î&D[ ï&F
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ð&ñ&š> ò&`bó&Ñ
ô&+sõ&Ê`ö&¾ì
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
÷&é2ø&o ù&ã.ú&˜× û&ô% ü&[óý&‡êþ&€Ùÿ&†™ €'âî�'�ª‚'€0ƒ' „'h,…'ˆßˆ'e ‰'íì Š'(‹'¡Ô Œ'Þ?�'X<Ž'c/
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
�')V�'^¿
‘'©’'¶Þ“''ñ ”'¶Ý•'ñÞ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
–'eæ—'C÷ ˜'©m
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
™'pT š'€e›'Öœ'¢ð�'cž'âØŸ'5L  ';Þ¡'š«¢'h˜£'uñ¤'Ì�¥'õ#¦'}*§'Õ³¨'
 ©'âª'ðN
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
«' ¬'‡­'€’®'Ó
¯'I"°'ǽ±'�q²'‰™³'fô
´'}¨ µ'ï#¶'?o·'×P¸'¸©¹'uú º'ÜC »'|¼'Ás½'íà ¾'¹ ¿'ò Â'
)Ã'�,Ä''v Å'í¹Æ'âKÇ'OŒÈ'­_É'StÊ'¤ 
Ë'ÅþÌ'Ü’
Í':°Î';éÏ'¨Æ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ð'++Ñ'9= Ò'ÐÓ'«Û Ô'„1Õ'ÂÖÖ'YJ×'hãØ'4ãÙ'ñjÚ'‘wÛ'ùÜ'6 Ý'ÐÞ'±² ß'Ä¡à'J¬á'eâ'ã'òÛä'R‘å'Ö>æ'æ? ç'þ8è'߀é'1 ê'Ïà ë'nS
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ì'Ieí'³…î'Œˆ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ï'„/ ð'iñ'¦8ù'm¤ú'ã–û'[‰ü'¼¹ý'­‰þ'RÎ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÿ'ý
€(Ù�(;Ú„(9[
…(´©
†(È ‡(tl ˆ(t© ‰(€®Š(µK‹(6Æ
Œ(Fì�(5j�(PÍ‘(#«’(of“(˜¥”(žI •(ú¬–(Û’—(�[˜(ç¿™(k`š(
þ›(¾#œ(µ�(1ž(½� Ÿ(„ (§¡(�m ¢(|Ö£(]
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¤(Ô ¥(‹¦(ö§(ͦ ¨(Uû©(ž² ª(L_«(œÉ¬(Ú¶­(¦y®(û¦
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¯(yµ °(˜ ±(ñÍ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
²(;�³(}д(:µ(RѶ(m·(»Å¸(ÏL¹()7 º(N\
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
»(ÿ¶
¼(æI½(ì ¾(¹8 ¿(é À(ÔfÁ(šùÂ(N Ã(l'Ä(e£Å(6ÚÆ()ëÇ(FÔÈ(
£
É(�¦Ê(µ
Ë(GÏ Ì(g× Í(ºŸ Î(èÝÏ(c’ Ð(þaÑ('Ò(Ö[
Ó(½MÔ(�EÕ(Ä"Ö(ã0×(tØ(Û3Ù(• Ú(•™
Û(üwÜ(¬æÝ(|¸Þ(Ò2ß(¦à(‹Œ
á(gúâ(t©ã(
ä(~ å(¿`æ(|Cç(Øè(ì
é(1nê(Õ£
ë( Îì(f> í(…o î(jªñ(û$ò(ºßó(Žf
ô(Ò€
õ(•<
ö(ø^÷(¥(ø(*ù(› ú(ìóû(c
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ü(B¾ý(K‹þ(¼#ÿ({ €)¶7�)&„
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‚)]|ƒ)öÇ „)ÖE…)@« †)„{ ‡)Ž©
ˆ)é0‰)K-Š)ñ‹)ÑÌŒ)»�)6v Ž)Y �)>6�)•!‘)�2’)÷ “)Sæ”)6 •)®$–)©—)3 ˜)’O ™)³kš)˜Å›)T� œ)gý �)Êãž)€·Ÿ)‹H )¡)]k ¢)£){ï
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¤)Þõ¥)îɦ)V§)÷É ¨)‘©)ª)ò«);´¬)#­)®)ú‹¯)ˆŽ °)€±±)¼²)B³)Re ´)Å¿ µ)¶)v–·)÷•¸)¶ª¹)cÑ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
º)ê[»)e‹¼)Ô½)M¾)[ò ¿)—%À)áÁ)ô´Â)JV
Ã)^ý Ä)Í€Å)•ÁÆ)«hÇ)+eÈ)M9 É)lÍÊ)CÐ Ë)ºX Ì)§ Í)ój
Î)ãÍÏ)r
Ð)À6Ó)¶"Ô)r Õ)�ÑÖ)I¼×)'!Ø)ËfÙ)1LÚ)3� Û)ŒÜ)êÝ)ì@Þ)iß)ƒ1à)² á)Ol
â)—Á ã)ücä)Ffå) u æ)
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ñ ç)" è)ç
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
é)¸#ê)Â#ë)mì)¿Œ í)ÅÑî)Þjï),äð)~®ñ)âçò)È�ó)4
ô)q¯ õ) ö)/q
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
÷)£#ø)ødù)èU ú)Žtû)?"ü)
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
" ý)m* þ)›Õÿ)+�€*Ó»�*,£‚*doƒ**ˆ „*âÂ…*BN†*œ‡*∈*è· ‰*ÕÕ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Š*5X‹*zŒ*ù�*³#Ž*\E�**# �*4¶‘*Àñ’*Ê+“*`m”*[
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
•*ç! –* 3—*(
˜*½•™*©óš*ªó›*ÛGœ*é�*pž*=’Ÿ*3Û *`°¡*%¢*Ä—£*s° ¤*gô
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¥*}V¦*Ý€ §*G
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¨*¶©*~=ª*Ÿ9
«*$4¬*F'­*(l®*Ú¯*º
°*¥Œ±*•G²*F; µ*½²¶*ùQ
·*R—
¸*Ýó ¹*:ø º*`»*<ž ¼*WB ½*_b¾*æ.
¿*"Ð À*ÓÝ Á*2BÂ*wÃ*:ÀÄ*ñÕÅ*Ë»Æ*#ŸÇ*$"È*ÇLÉ*"žÊ*úË*»ùÌ*؃Í*F”Î* EÏ*PïÐ*G?Ñ*ïÒ*Ï\Ó*Æ Ô*÷�Õ* ´Ö*h�×*°žØ*‚{Ù*½DÚ*ß\Û*ãlÜ*v÷Ý*mó Þ*~³
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ß*I+à*À á*ëÔâ*�X ã*À¨ ä*…æ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
å*5kæ*A·ç*¹ß è* ,é*‰Vê*Þ]ë*èÃì*Æuí*‡î*ñýï*Ö,ð*Fñ*Ÿ#ò*fQó*iÐ ô*‘ó õ*Gö*7I÷*Æcø*^ù*¥zú*»Aû*Çü*:ý*éeþ*ÜÓÿ*��€+š�+-‚+.0
ƒ+Gþ „+å€ …+ ™ †+߇+Щˆ+ù¯ ‰+q¯
Š+€9 ‹+h§
Œ+Á4�+êŽ+C�+ƒ_�+¨
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
‘+ªŒ ’+““+ñ- ”+œŸ —+$˜+‡È ™+Ë-š+8¶›+|œ+—¶�+\ž+Òç Ÿ+•‚ +ºY¡+ƒš¢+"£+¥I ¤+u ¥+Dä ¦+× §+‚»¨+ʳ ©+€ª+' «+cØ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¬+p{­+n
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
®+ʃ¯+Ê°+]ѱ+¸Æ²+¤³+ל´++8µ+¶+]
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
·+¿ ¸+…‹¹+ÿæ
º+ÕÖ »+¯©¼+#° ½+Ú¡ ¾+ž¿+ý¾ À+²eÁ+) Â+Ü¢Ã+ôñÄ+¿Å+uT
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Æ+ÔÇ+œú
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
È+›É+Ý6 Ê+¦vË+’MÌ+\ Í+¯Î+}nÏ+¼Ô
Ð+#† Ñ+ã+Ò+:­Ó+˧ Ô+FÎ Õ+å
Ö+Ï×+'£ Ø+Y·
Ù+wó
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ú+ÏÂ Û+,zÜ+—Ý+¨—
Þ+}Lß+Mà+�d á+(,â+öã+¾ ä+Ò� å+�‘æ+`d ç+;
è+†ˆé+
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ê+&Ïë+¹~ì+rÎ
í+‘L î+oï+ÚDð+5Œñ+Eò+Ä ó+' ô+õ+.Îö+H€ù+e„ú+jû+Ìü+Aý+-þ+çâÿ+D½€,\ã�,† ‚,r  ƒ,HO„,ð?…,ž †,l‡,»Üˆ,I– ‰,eqŠ,<t
‹,¹Œ,Ñ�,­�Ž,{6�,
�,ÏB‘,¡w’,hK“,C2”,%•,²%–,³ð —,˜,ÕÊ ™,`Nš,Ò ›,{5 œ,…â�,5üž,jµ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ÿ,®7
 ,û( ¡,ï�¢,
£,Y9¤,\ý¥,7Ò¦,Œ§,˜i¨,d®©,$›ª,q0«,FŽ¬,§Î­,T®,Mö ¯,ÆŸ °,.±,†´²,Ì´³,ØØ´,oµ,œL
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¶,þ
·,É.¸,ʆ¹,ÍÅ º,4š
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
»,:: ¼,]€ ½,{n
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¾, n¿,„E
À,¶ÜÁ,k™ Â, Ã,©Ä,"®Å,°/Æ,؇Ç,ø�È,ÖdÉ,¡ñ Ê,^Ë,�"Ì,‚» Í,T>Î,Á'Ï,}Ð,‹ Ñ,è©Ò,jÓ,H3 Ô,¼º Õ,üÖ,‚¦×,‘pØ, kÛ,ˆÜ,!ÂÝ,°lÞ,nµß,�à,yÚá,}S â,Cáã,� ä,rý
å,jæ,£“ç,7Ž è,íé,¶7
ê, 1ë,)Tì,çêí,‹1î,­ï,2Š ð,ÐÊñ,šqò,-¢ó,å°ô,*¨
õ,PFö,’ê÷,�ø,‹`ù,žú, ø
û,pKü,V† ý,ÒUþ,žÿ,Nù€-úˆ�-`ô‚-WKƒ-¥D„-k…-Ý †-–b‡-6Û
ˆ-Þ£‰-6(Š-å�‹-E-Œ-së�-]qŽ-!v�-‰°�-§K‘-º¦
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
’-(q“-׳ ”-ßË•-Ó�–-è‚ —-Pú˜-7Z ™-û š-8,›-
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
œ-ªå �-sû ž-¿?
Ÿ-�f -hl¡-ï¢-"> £-}I¤-Û=¥-Þ¦-ìl§-/ÿ¨-nž©-—rª-âä«-]R¬-†É
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
­-ÞÞ®-Q»
¯-Çå°-wR±-=�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
²-š
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
³- W
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
´-ìµ-žB¶-,5 ·-2õ¸-g¹-sžº-j×½-D‡¾-ô ¿-ya À-ZÅ Á-‰? Â-×Ã-ñx Ä-×å
Å-ØÆ-­
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ç-¹} È-ü×É-–Ê-ßÁË-Ï7Ì-–ªÍ-)bÎ-ëZ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ï-SBÐ-w¢Ñ-�Ò-øØÓ-ÄGÔ-á†
Õ-vŽ
Ö- ó×-,QØ-!Ù-ù;Ú-ÖUÛ-˜›Ü-hÝ-u'Þ-Yn
ß-H‡
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
à-ï‰á-âëâ-4Â
ã-:r ä-¹(å-ÔÐ æ-e{ç-i¶è-Õ}
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
é-w†ê-‚së-€ì-7”
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
í-è= î-¹Ïï-ËÔ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ð-šOñ-ó5ò-!õ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ó-¼¢ô-yQõ-ùXö-б÷-O�ø-Š[ù-Û ú-@"û-Rƒ ü-! ý-ÇÆþ-£ç
ÿ-Ö €.Jâ�.ŠL‚.�Iƒ.ö„.�L….òò†.„²‡.@Aˆ.¾ ‰.WI
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Š.>K‹.+ÞŒ.G �.àL Ž.·± �.¸ÿ �.·
‘.QÃ’.w±“. ² ”.|ü
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
•.Ù·–.u
—.ª’˜.\ñ ™.ä= š.zJ ›.ü¡
œ.?„ Ÿ.¦  .*¡.žE¢.è4
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
£.æ¤.x ¥.%¼ ¦.h §.»Uª.t«.�û¬.¸z
´.Ð2 µ.�y¶.·# ·.-ô¸.ìK
¹."3 º.äλ.Ž+¼.Ø•½.$t¾.c� ¿.À.š Á.ââÂ.­:Ã.ÒBÄ.þÅ.é¥Æ.gÜÇ.ÀåÈ.8ÍÉ.ÑÊ.þ¬Ë.�ôÌ.ûB Í.’œ
Î.=ê Ï.uuÐ.è+
Ñ.)SÒ.CÓ.TÀ Ô.–S Õ.ÙÏÖ.é×.½† Ø./Ù.ÊßÚ.3Û.š,Ü.ù¹Ý.Ú2Þ.½ß.<ëà.ÔUá.‚Òâ.
>ã.*^ä._Ï å.Þæ.b9ç.Vöè.²Šé.Jê.š1ë.Ì
ì.Í›í.s¬î.˜’ï.:ð.FR ñ.üò.æ‡ õ.Âíö.Eá÷.Èãø.æ ù.w£ú.cUû.¤ ü.;^ý.Ilþ.×�
ÿ.ÖÔ€/X�/·2 ‚/Cþƒ/©2„/€�…/^›†/ð
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
‡/&& ˆ/U‰/üXŠ/z€‹/ÞY
Œ/ª4�/)ÚŽ/m¸�/Ň �/~ü‘/2ý’/¹“/—�”/¬ •/Í� ˜/pn™/â*š/FO›/— œ/c„�/§w ž/ŸsŸ/kÔ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
 /'{ £/ú(¤/gl
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¥/!�¦/Jh§/t:¨/‰:©/¤Hª/Îÿ«/C©¬/¡ú ­/Ùή/& ¯/¥Ý
°/Â� ±/º1²/RC³/çJ´/ùyµ/ä ¶/·/¯ ¸/®–¹/Œ  º/Æþ »/ “¼/ÇY½/±‹¾/-¿/ÜG
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
À/i0
Á/×U Ä/È>Å/ˆf Æ/fEÇ/Õ‰È/¯ŸÉ/ñcÊ/Q’Ë/ÎÝÌ/ÐŽÍ/:qÎ/±ªÏ/÷\Ð/˜;Ñ/ßC
Ò/ÑÕ/XKÖ/¾×/d'Ø/K[Ù/xÚ/¿…Û/³
Ü/Ú9Ý/¥‘
Þ/›ß/*1 à/m�á/dÒâ/5vã/ìæ/ÝUç/­(è/°8é/”­ê/¦Í ë/ç_ì/ì
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
í/Ž(î/ÓÍ ï/¡[
ð/ÀÝñ/²¼
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ò/Î ó/aÔô/zÿõ/µ‡ö/Ü÷/.½ø/oÞù/îú/NÜû/ëg
ü/d ý/qYþ/ ÿ/$N
€0»�0Üf‚0�lƒ0u
„0g\
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
…0ŒÜ†0¤µ‡0™ˆ0qÀ‰0óÏŠ0ß‹0û¯Œ0Pü�0©žŽ0é
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�0…ò�0E‘07­ ’06>“0žè”0˜ç
•0_z–0IZ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
—0>˜0Ça›04* œ0æµ�0‘…ž0;Ÿ0Y­  0NÚ¡0ý ¢0Å£0Tå¤0uÅ ¥0ŒÇ¦0µ§02¨0Ù ©0uµª0N«0_3¬0™ç­0è/®0«¶¯0^°0M; ±0•‚²0Bô³0í« ´0mˆµ0Î�¸0�� ¹0ß¼ º0A½0ÚF¾0hT¿0þT
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Â0xVÃ0Kõ
Ä0yiÌ0{XÍ0ˆ2Î0Ñ0’vÒ0ÝÓ0°nÔ0c
Õ0 ŽÖ0Öî
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ù0÷ÍÚ0Ö„Û09ýÞ0ð  ß0§[à0´á0g¸â0ª­ã0'Çä0jŠå0@«æ07 é0d¯ê0}ë0šó0b€
ö0y©÷0ÛYø0²hù0߀ú0f”û0ŠÈ ý0íL
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
þ0D9ÿ0n‡�1Øñ ‚1‰Fƒ1Í‘ …1Iñ†1Þ€‡1ö{‰1™tŠ1«Ú ‹1+Œ1»À�1ž �1O‹�1�{‘1ÛÉ”1`•1îG–1B‰
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
˜1w  ™1 ^š1ýD
›1O±œ1„�1y
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ÿ1äJ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
 1Þ¡1ö”¢1× £1›n¤1!× ¥1ÝQ¦1,Ú
§1 C©1ª1i�«1Ϙ®1³ã¯1Ãq°1•±1]²1êª ³1F(´1ŸÄµ11‹¶1Á¨·1•d ¸1Q ¹1F~º1H »1ì¼1È· ½1pž ¾14
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¿1EÝÁ1y~ Â14$Ã1²0Å1Þ™Æ1ñÔÇ1}É1Ó’Ê1YkË1VÍ1_ Î1§>Ï1
H
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ð1–ö Ñ1Eè
Ò18Ç
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ó1$y Ô1U‡Õ1£¢
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ö1÷:×1fHØ1ÿ/Ú1SÔ
Û1|íÜ15¿ß1F% à1¬µá1 &
â1º™ ã1ͪ ä1P
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
å1ò,æ1ïTç13 è1æßé1Š>ê1¸ë1:rì1Š¡
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
í1&¤
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
î1¦ï1iÌ
ð1Þò1þÆ
ó1š¸ô1
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¤
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
õ1œxö1Ú' ÷1Íù1Ñ/
ú1qo û1hÏ
þ1¨7ÿ1h; €2@�2ªÝ‚2Z? ƒ2âÇ„2&ƒ
…2�I
†2„Y
‡2²! ˆ2pщ2ø Š2¤º
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
‹2׌2P�2VÈŽ2ä�2V&‘2û¥ ’2 “2Ý•2ß‚ –2˜s—2÷Ú™2Õyš2}5›2NZœ2øR �2Øîž2 Ñ 2¡2[
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¢2ø´£2,
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¤2ø3¥2Ï ¦2mÜ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
§2• ¨26õ
ª2¶O «2˜ÿ¬2!÷®2ù¨ ¯2qæ°2)Ï ³2lŠ ´2=üµ2Ķ2_ ·2x#
¸2žD º2o>»2�¦¼2Áç½2òÈ ¾2ä ¿2ršÁ2ù Â2 – Ã2ŠÛ Ä2a�Å2€Q Æ2=2
È2ž É2›TÊ2ðOË2ÀƒÌ2Š‘Í2’€ Î2æâ
Ï2„¾Ð2‹Ó2úÆÔ2©W Õ2›
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ö2(×2Ðå Ø2@“Ù2¹Ú2gðÛ2µÖÜ2Sœ Ý2z|Þ2n˜ ß2ÙK à2°Áá2 Æ â2éÛ ã2i ä2ˆæ2ºUç2.… è2J‡ ê2ªë2
¯ì2ùî22Ðï2„… ð2�Ðñ2éuò2t>ó2Ò
õ2gö2™ ÷2/ø2ýù2–ú2gŸû2Lþü2ŠÇ ý2×;ÿ2¼o€37��3iÔ„3…3Ê!†3ª‡39 ˆ3Ÿ\‰3JS Š3Ré Œ3(ê�3�¾Ž3ì,�3öç�3åk
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‘3š«“3²*”3Ú•3ñÈ—3k,˜3Ÿc™3ùLœ3Ë÷�3©ïž3AŸ3‹ 3z
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¡3Iå ¢3½ £3†ª
¤3
¥3yu
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¦3h¶§3ÚM¨3vý©3Ê8ª3.ƒ«3” ¬3 ›
­3ûÇ®35\¯3;°3=•
±3I ²3}dz3\Ó
´3€vµ3]ζ3ÀŒ·3¤t¸3•+ ¹3ƒ+º3¼æ»3*r¼3û9½3à¾3=ª¿3¦ÚÀ3Ç3Á3`×Â3a«Ã3°FÄ3CáÅ3¬'Æ3¡F Ç3KÈ3ÖœË3ÆNÌ3$‚Í3«a
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Î3î5Ï3fÐ3�Ñ3wÏÒ3¼Ó3ÔÅÔ3¼ÐÕ3îCÖ3Ï×3„ðØ3ºuÙ30Ü
Ú3�Û3(Ü3& Ý3p: Þ3V¡ß3ŽDà3’Š á3!Dâ3Sjã3ü
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ä3·üå3®¶æ3&1ç3åŠè3ÀŒé3N}ê3äÈë3ÿÜ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ì3JÇí3¸} î34ï3¨Ôð3˜×ñ3q¡ò3ÖÙ ó3ÌSô3öu÷30" ø33çù3ðl ú3ùÉ
û3\xü3ÊGý3§_ þ3œÔ
ÿ3|€4O¹ �4µp‚4mÀƒ4l¤„4IO…4VŽ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
†4P<‡4• ˆ4�Ë
‰4)Њ4\` ‹4óŒ4Å\�4—hŽ4ë#�4 �4ùõ‘4øk’4$¢ “4%’”4�Ì•4ÂÅ –4k¼ —4Ú‰ ˜4œ— ™4c š4)k›4¬¬œ4Jn
�41Ùž4àå
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ÿ4[Œ 4(v
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¡4
¢4}£4³j¤42=¥46 ¦4ÕÚ©4I˪4Á  «4z¬4Âj ­4¨«®4š¯4¹ °4è6±4xÕ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
²4‰¤ ³4+×´4ø µ46H¶4,·4rb¸48ß¹4ý¼º4`®»4v¼4Rc½4†¾4’°¿4}§ À41½ Á4FXÂ4(´Ã4éäÄ4r) Å4-Æ4ˆ Ç4ãiÈ4 „
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
É4¯ºÊ4×}Ë4{•Ì4YV Í4a›Î4äÏ4Y6Ð4HÏÑ4mBÒ4jøÓ4BLÔ4PJÕ4l:
Ø4øÇÙ4†Ú4Ä×Û4L\Ü4k¤Ý4²Þ4*çß4d à4ôÞ á4ñ(â4}” ã4

ä4³Ò å4lœæ4rIç4ïË
è4È)é4Àê4›
ë4Çì4‡eí4�&î4à ï4È›ð4ô,ñ4ºò4v ó4
ô4q¯õ4«fö4ˆ÷4Â
ø4¶— ù4��ú4=pû4Bü4C` ý4Y þ4@‰ÿ4¬s€5?��5†
‚5ᛃ5\$„5‘ý…5÷Ɇ5¿× ‡5ÔqŠ5Êõ‹5Œ5X
�5%! Ž5T�5AÔ�5§+‘5v]’5퇓5n/”5Fñ•5á½–5ÔF —5ʤ ˜53™5z| š5+ß ›5 �œ5’( �5lëž5Yµ Ÿ5Lµ  5¤w¡5úÛ¢5%X£5›œ¤5ð¥5´ð¦5Db§5öQ¨5¸"©5vƒª5!|«5Ýò ¬5)Þ ­5o
®54¯5nò°5× ±5rA²5'H³5€×´5veµ5 œ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¶5÷5•' ¸5Ís ¹5�Þ ¼5´ ½5Ê ¾5dÖ ¿5]› À5—�Á5¿
Â5š?Ã5kWÄ5æBÅ5M=Æ5ÏÇ5õÈ5ØÕÉ5 L Ê5¶ºË5÷lÌ5ƒQÍ5y‰
Î5¥Ï54åÐ5»Ä
Ñ5å Ò5�Ï Ó51¤ Ô5‘ Õ5ØÝÖ5 g×5žØ5 
Ù5öâ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ú5¶%Û53™ Ü5‹®Ý5ÓWÞ57ß5à à54( á5…Ü
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
â5µÇã5êx ä5âˆå5Ä-æ5�m
ç5O9 è5ÁÒ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ë5W¤ ì5š‹í5œ�î5OU ï5Êð5E·ñ5iå ò5v
ó5Qýô5 ‹õ5Ûö5‚Ï
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
÷59†ø52¬ù5r ú5û5+V ü5–7ý5¯²þ5ðÿ5]€6Å� �67-‚6Ï?ƒ6ʈ „6íÛ …6Â(†6´‡6™ßˆ64‰‰6éŠ6O ‹6¯ Œ6…» �6þVŽ6ë��6ùÌ�6éÜ‘6Ï’6“6¸÷ ”6"m•6 .–6°—6º�š6œ˜›6´;œ6ÚŠ�6C(ž6÷^Ÿ6´q 6ÎÓ¡6¬
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¢6†²£6�q ¤6ó¥6(‚
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¦6è §6Š&¨6f. «6kO¬6‘V­6ÓM®6ÿá¯6ÜÚ°6‹È
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
±6x²6m‰ ³6Ï ´6j"µ6´Û
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¶6Á/·6¾ÿ¸6b¼¹6ÖV¼6£/½6­¢¾6«Ä¿6h¾À6q9Á6PMÂ6EMÃ6R|
Ä6Ç°
Ç6¼ È6 žÉ6è�Ê6²`Ë6…P Ì6„õ
Í6ÄÒ
Î6¹‡Ï6uMÒ6e�Ó6Ô6fÕ6DÖ6Ãb ×6pœÙ6ÍŠÚ68†Û6Yƒ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ý6ãÕ Þ6p4ß6Ó0á6ˆBâ6hã6¹å6ãHæ6Áç6àŒê6x'ë6Ìì6faí6ë
î6‘mï6*dð6×þñ6@ù
ò6«
ó6ú›ô6iŸ õ6,ö6ã<
÷6hø6†Þ ù6ùã ú6¢Ìû6ßàý6\Tþ6ÝCÿ6d€7Ÿ– �7÷‚7Ží„7ÅØ …7­†7fˆ7X‰7jŠ7Æ�7­B
Ž7Ý° �7Ý�
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
�7/ã‘7DA ’7°§
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
“7Jâ”7^ì
•7¯c—7€˜7Œ&
™7tüš7®­›77æœ7��7Òž7ò|Ÿ7�/  7¸Á¡7$€ ¢7—|¤7‰V
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¥7òá ¦7t—¨7'n©7« ª7ú\«7Ū¬7܉­7S,µ7¼´
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¶7Ã_·7À™
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¸7•¤
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¹7$z
º7'»7I» ¼7‘o½7í´¾71U¿7 û À7z­
Á7o¸ Â7š¨Ã7šÄ7—Å7šTÆ7�â
Ç7GÈ7×6É7,I Ê7‡Ë7ͪÌ7©ñÍ7PÎ7X`Ï7âÐ7‚<Ñ7 Ò7ɘÓ7AÜÔ7|²Õ7#ŠÖ7Ë’
×7wØ7(µ Ù7kÚ7b4Û7s4
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ü7I
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ý7½é Þ7”Üá73´â70ã7›Å
ä7ë
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
å7§Óæ7Í.ç7”Jè7ïÒ é7Ü]
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ê7µw
ë7AYì7ò
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ï7Œ~
ð7Û ñ7¹Pò7‹}ó7†:ô7yþõ7[Îö7>÷7]Ýø7�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ù7 ú7_Áû7“_ ü7§ìý7±•þ7õsÿ7ç€8^ð�88¦‚8*öƒ8¦)†8Æ
‡8D7 ˆ8—¸‰8ä4 Š8r6‹8C
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Œ8U �8±bŽ8ï �8Éõ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�8]á ‘8‡j
”8›@•8k[–8Í�™8ïÇš8ž/›8l7œ8Í�8™ºž8‹jŸ8t  8¿T¡8 ‘
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¢837£8>Ï
¤8†
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¥8=]¦8…ð§8Y
¨8ÞŽ ©8€ä
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ª8E´«8ñ®
¬8ïK­8â÷®8Óv¯8¼Û°8Ut ±8þ]²8±‰
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
³8MÍ´8Å<µ8sA¶8èÚ
·8á¸8ÿŽ¹8©P º8ßM»8pt¼8Í
½89¾8Á´¿8—µÀ8–c
Á8|Â8æ�Ã8-úÄ8GÍÅ8‚»Æ8µ¦Ç8y³Ê8»³ Ë8" Ì8“ÁÏ8…wÐ8°óÑ8?h Ô8ËÕ8»\Ö8Éü
Ù8-Ú8
N Û8ìu Þ8¨Šß8Ÿ1à8ºë ã8ÒNä8ö'å8[ó
è8(Ëé8Ѻê8÷�ô8Ø\õ8`ôö8z­÷8]âø8m û8F¡ü8Öuý8 Æþ8í+ÿ8΀9ö8�9¥ò‚9�Û
ƒ9Ú¤†9�X‡9'+ˆ9}v
‰9snŠ9¬Ñ‹9ª”
Œ93�9S9Ž9…Ô�9.q�9¬Š ‘9œÇ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
’9N“9¼« ”9ƒq–9QÇ —9)Ä ˜9Й9’
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
š9']›9Ç°œ9¾°�9Rj ž9ýçŸ9Ú] 9h¡9Ç)
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¢9&ì
£9µ~¤9üЦ9ú4§9Û$¨9·Y
©9$M ª9hv«9‘)¬9
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
´­9IW
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
®9[Á¯9U#°9Dm±9KÖ³9<! ´9P/µ9 ¶9•½·9`‚
¸9)Æ º9­>»9Mؼ9œ‘½9Èt¾9¿9÷S
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ã9Ó¾Ä9Â-
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Å9'ÆÆ9
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¸ Ç9î È9˜ÛÉ9F¹ Ê9&ÕË9Íî
Ì9ÂÍ9í]Ð9Uî Ñ9p�Ò9;Ó9>° Ô9€NÕ99hÖ9:o×9SèØ9õÐÙ9E­
Ú9÷ Ý9JeÞ9oŒß9¤à9Æá9Õ‘â9�ã9Úä9ä| å9€êæ9Éç9O‚ê92j ë9™Ÿ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ì9ð} í9þÞî93�ï9 ð9ñ9éÑò9MÃó9Îh÷9æ¤ ø9�ù9)g
ú9Sû9Ÿvþ9"³
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÿ9•ï €:rå
�:È`‚:·Ô…:Ám†:·a‡:²Éˆ:ؽ‰:é Š:s ‹:Ð~Ž:ám�:Iÿ�:Æ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
‘:?o’:Y“:"ã –:YÞ—:ú\ ˜:K§™:ÿšš:'/›:О
ž:¸Ð Ÿ:U•  :S‚£:êĤ:ᨥ:dÂ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¨:Ô}
©:W¡
ª:\¼­:‡q®:?ª¯:…‡²:'7³:¸s´:¸Ú
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
µ:ä2 ¶:‡,·:f¸:vš »:×ð ¼:þ¯
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
½:œ„ ¾:Í¿:Ï™ À:œŠÃ:~åÄ:KY
Å:OêÆ:UÇ:°É: î
Ê:ÌâË:½Ì:n`Í:Ûè Î:åÁ Ð:‡Ñ:¦—Ò:¯†Ó:²€ Ô:»Ÿ Õ:4¯Ö:µ×:tŠØ:ôÅÙ:�r Û:äP Ü:7KÝ:ÅÞ:Îß:yBà:œÙ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
á:݆â:& ã:é– ä:Ôå:±‚
ç:à è:§“
é:I¢ ê:Lö ë:T
ì: U í:èî:)m ï:‚X
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ñ:,Æ
ò:·Oó:«£
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ô:
$
õ:¼ ö:J÷: �ø:
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
qù:’ü:ç™ý:ö´ þ:¸ÿ:k1 €; �;ý¾‚;Qû
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ƒ;ýµ„;_…;�s ‡;|ˆ;jÑ ‰;­Š;‰]‹;Œ;a«�;ä
Ž;›Ä�;qs�;ç4‘;z‡“;Z”;P•;/«–;ì% —;‘˜;<'™;Qð
š;èo›;ö­�;7¹ž;I‰ Ÿ;å  ;9T ¡;êë¢;ID£;ô„ ¤;’³
¥;«O¨;Ò# ©;-zª;Øe«;Ç ¬;µq­;zº®;=)¯;˜K°;RÁ±;À“²;Êî³;õ'´;�›
µ;Æä ¶;ôë·;B¸;¯¾ ¹;¶6º;Yk
»;Ýz¼;|Ã ½;¾;;k¿;8ôÀ;Ó
Á;º1 Â;sU
Ã;~h Ä;q’Å;iä É;Ñ Ê;Ï0Ë;»lÌ;Ø Í;àã
Î;*. Ï;ªSÐ;™ Ñ;ÜÒ;—t
Ó;rúÔ;lÕ;«‡ Ö;±3×;
– Ø;¶šÙ;èÚ;ò~Û;õÂÜ;ÓwÝ;‹f Þ;@
ß; ›
à;f" á;~Ñ
â;¦ ã;ODä;ÜLå;}�æ;Æoç;A� è;�»
é;ú‡ì;ó=í;£lî;3-ï;’‚ð;HÐñ;L
ò;J ó;e ô;ÛSõ;K¸
ö;I ÷;e|ø;)ù;Üò ú;zû;í3
ü;e²
ý;îsþ;ÿ;�ª€<ïÓ�<Ùé‚<6@ƒ<¿q
„<Õ…<~†<Ò<‡<膈<d­ ‰<ꈊ<!w ‹<ÇXŒ<âç�<EG �<´‘<$>’< “<&_•<Ëy–<?‚—<⃘<Þÿ™<­Ù ›<pæ œ<80�<¤ž<4-Ÿ<ã‚¢<vÆ£<û¤<Kþ¥<Ý
¦<c�§<G² ¨<⬩<Ü€ª<ÞÆ «<œ¼¬<… ­<K ®<‰
¯<`N°<ú ³<ÇL´<éʵ<DG¶<ƒ5·<Šš¸<W¹<G“
º<ÉÓ
»<ɼ<]&½<4n¾<´Ù¿<¾× À<-¬Á<žÂ<dªÃ<F¿Ä<Ö� Å<ÿ%Æ<§âÇ<¿�È<cÉ<JìÊ<ד
Í<å×Î<F
Ï<>Ð<5Ñ<¯™Ò<¢K Ó<í²
Ô<Ú!Õ<æ³ Ö<§×<ªaØ<�>Ù<ÀÚ<üxÛ<õµÜ<öÕÝ<øã
Þ<ˆûß<�à<Ú,
á<Õwä<Bå<¼ æ<äwç<Eè<ç[é<Å ê<òœë<L ì<iš í<[Ú
î<Ù&ï<³ ð<ú ñ<-Ìò<St ó< ô<ÿÙ õ<üö<÷<Äø<8ù<ûiú<|&û<rA þ<ïæÿ<"Ù
€=+[�=ˆè
‚='àƒ=ù• †=ȇ=Esˆ=PƉ=¢
Š=9ß
‹=}Œ=³û�=Á
Ž=?’ �=¨ �=½è ‘=u ’=1“=/”=ŽÚ •=Ý–=t—=Ë\ š=˜Õ
›=-Ó œ=~«Ÿ=JO =Àƒ¡=( ¢=_x£=}£ ¤=¯¬ ¥=á¦=ÀE§=a”
¨=G©={‹ ª=¹ç«=Ë£
¬=js ­=Þ°=*‚ ±=Ií ²=±^³=д=Ær
µ=\è
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¶=H£·=ØÈ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¸=]V¹=¹9 º=9Õ »=ªg¼=e¤½=$ô¾=fŠ ¿=yÁÀ=™�Á=¾$ Â=€¼Ã=áîÄ=ÇÖÅ=q› Æ=TÊÇ=VaÊ=Äo Ë=7¼Ì=#?Í=öÏÎ=�{Ï=ÞôÐ=ùƒÑ=·Ë Ò=“ø
Ó=1«Ô=?„ Õ=H†Ö=((×=ðl Ø=¦Ù=R�
Ú=1“ Û=«õ Ü=8×Ý=)gÞ=á=´/
â=ÑÞã=O ä=Clå=Ôdæ=jç=ï è=Â8 é=7ê=L°ë=­4
ì=ž_í=zŸ î=¢ï=—Æð=tÒ ñ=)6ò=Âó=¶¾ ô=»õ=K'ö=Ú÷=HX ø=­7ù=“c ú=6ªû=ü=fÞý=ö¼
þ=F�>¦0‚># ƒ>5Y „>C€
…>ý>†>}:‰>>¿Š>A‹>옌>ÚV�>ÜqŽ>L°�>™�>ðþ‘>ˆ¤’>ç�
“>Ó ”>j•>b–>®Õ —>És˜>_é™>L»š>™Ú
�>ÐD ž>µŸ>—]  >ƒÄ¡>ÿ
¢>�H £>Ê‚¤>h¥>p~
¦>QÁ§>@3 ¨>?©>’eª>ˬ«>. ¬>0)­>âr ®>hÇ
±>“‹²>:5³>q“
´>×òµ>½­
¶>š–·>%m¸>™ ¹>�Z º>Lj »>
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
“ ¼>
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
9½>ñd¾>Á{
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¿>8À>
 Á>…ŒÂ>*}Ã>Q| Ä>}‚Å>’’Æ>Ѭ Ç>[¨ È>;ÀË>&DÌ>¯s
Í>¦
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Î>Bû
Ï>GÙ
Ð>z`Ñ>Ò>U„Ó>çþ Ô>ÞÆ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Õ>’Z
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ö>}W×>÷HØ> ÏÙ>{V Ú>"´
Û>ë¶Ü>@ìß>:>à>Vºá>‚4â>c‹ ã>p3ä>æL å>­ðæ>Yíç>y‰
è>ÖÈé>}/ê>˜Áë>´! ì>èkí>†^î>Ø¡
ï>Œ˜ð>¶{ ñ>EZ
ò>üúó>§Gô>û¤ õ>'%
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ö>ñ÷>ß5ø>[¼ ù>z}ú>9 û>S/
ü>»0ÿ>”ž€?Òú �?V ‚?œƒ?’.
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
„?‡?‡•ˆ?ø‹‰?�ûŠ?}X‹?†Œ? w�?: Ž?F �?'› �?Í8‘?ˆ|’?ð“?2o”?°Y•?Ð –?¨£—?O; ˜?y›?Øz
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
œ?ÉŽ�?Ýž?PŽ Ÿ?6w¡?½Z¢?³ £?:�¤?F0¥?ͤ§?ÿ¥
¨?�Á©?r4ª?01«?Lˆ ­?÷ˆ®?À†¯?QÔ°?ò7
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
±?±î³?òL´?Yêµ?
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
H¶?¨·?ì¥ ¹?�º?Wˆ»?ŠÃ¼?ES ½?Æ ¿?tÌÀ?í Á?.°Â?Oÿ Ã?¼Å?�RÆ?\÷Ç?O8È?‘¶É?°}Ë?sbÌ?°Á Í?Ó|Î?KÏ?Aë Ñ?Èà Ò?”µÓ?hNÔ?‡µÕ?©§Ø? Ö Ù?:
Ú?>‚
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Û?í±Ü?2Ý?:WÞ?å¹ß?Ø6à?šÜâ?vÊ ã?%~
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ä?†Ÿå?<íæ?–qè?¾Xé?c… ê?I¯ë?–
ì?³í?Ëï?è—ð?ñ?8´ò?Ê ó?
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
— õ?O˜ö?m!÷?êîù?/—ú?Ucû?ÊÞ ý?—8þ?“þ ÿ?ÖR€@‘¢�@V‚@ÆÃ
…@T˜†@�²‡@+ÿ ˆ@ƒÞ‰@†7Š@G]‹@+5
Œ@–�@…=
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ž@`‰
�@¢¯ �@[7‘@˜ ’@ñ
“@�¨”@RI•@í–@�~—@†ù˜@Dˆ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
™@L š@­M›@\œ@hÛ�@²
ž@€Ÿ@fÖ @€]
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¡@’
¢@ŸÅ£@,$¤@1y¥@Ð% ¦@„M§@c3 ¨@‡5©@£† ª@ïf«@¬@ˆ­@Eˆ®@¦‰¯@Ì°@¸3±@je ²@ßâ ³@éá´@}̵@
†¶@œø·@Y9º@WÉ»@HÑ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¼@[f½@:_
¾@8 ¿@ˆ�À@v¦
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Á@šlÂ@2ñ Ã@pÑÄ@6S
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Å@N
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Æ@{
Ç@ÐìÈ@*‘É@Nª
Ê@Ôü Ë@M Î@¥¹
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ï@*æ
Ð@(²Ò@MÁÓ@:¤Ô@=ÂÖ@d×@Ø@‡ Ù@ù Ú@£ Û@=7Ü@³9Ý@ë¦
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Þ@
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ß@“Òà@Rà á@’Iã@¶o
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ä@PBå@¬¯æ@�ç@{è@æ¾ é@öÅê@Öºë@4®ì@·í@Ûaî@ëï@ë0ð@X
ñ@üò@Áxó@y' ô@õ@<ƒ
ö@Á ÷@" ú@¾4û@Ÿü@;
ý@êþ@;‰ÿ@ €AÆà‚A¡‰ƒAÄA©|…A)4†A-�‡A�<ˆARõŠAE¯‹AöVŒAüc�A¢(ŽA‹›�A7y
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
�A5ä
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‘A°L’Ašd
•AÁW–AXÜ—A׳˜A¹P™AOŸ
šA±›Aä•œAZb
�AèJžA… ŸAj A´ÿ ¡A,X
¢Aü=
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
£A±u ¤A]ë ¥A‡ê¦A,÷©A6ªALI«A«s¬Aå:­AØÛ®A½¯AÈÉ°AgŠ±An²Awc
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
³A/ ´A"{µAX¶A°ƒ ·A‘q¸AÜh¹AȺA> »ACH¼A6$½Aâ´¾AÄ ¿A9–ÀAÊn
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÃAº^ÄAíF ÅA_†
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÆAÄZ
ÇAÆ6 ÈA(WÉAf€ÊAŽ2
ËAp
ÌA„˜
ÍAë2ÎAº©ÏA:ÐAÛ‰
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÑAŒ1ÒA¹zÓASÔA‹
×AZØAtÙA! ÚANG ÛA� ÜAE‘ÝA~¸ÞA¨HßAÆ®àA§ëáA•dâANlãA•ÖäAÛ åAý�æA6‹çAKLèAŽ› éA êAË—ëAv²ìA�‹
íA¢€îAÛÅ ïA&ðAœ¼ ñA ôA«€õA{öA‡÷Aô×øAÉ] ùAßq
üAMŠ ýA5þA6 ÿAü¯€B{7�BNÁ ‚B´Õ
ƒB÷ø „B¥…Bl˜†B Ö‡B$ˆˆBÏG
‰BpŠBSƒ‹BaŒB4
�B)�B—v‘BvÛ’BLГB= ”B¼••B Z˜B»^ ™BœšB˜ü›BúœBÊ�BQežB•MŸBE�  BÔð¡BÛ ¢B°j£Bû<¤B(L¥Bæè¦Bƒh§BÕ‘
¨B/J©Bºh
¬BS“­B„®B¥9¯B Ú°B¾j±B³ç²B·‹³BJá ´BÕpµBs]¶Bu¸ ·B+ñ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¸BÉùB�ºB¹»B6¼BÝ ½BÊ̾B7E¿B2ÀBɽ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÁBnÂB ¤ÃBXT ÆBÈsÇB´¸ ÈBÉBãÊB¯KËBV® ÌBv�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÍB ‡ÎBi# ÏBÕ\ ÐB€ÑB}ÒBcvÓB¸þÔBŽu×BѦ ØBT!
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÙBh9 ÚB ÛBÓ
ÜB“ ÝBâí ÞB/±ßBozàBaòáB¨’âB€ ãB/t äB‰åB;æBäçBªx èBƒléBÍoêB¼gëBïìB±íBÂQîB7ªïBÚ¶ðB´”ñBê]ôB߃ õBÄ öBøV÷BQš øB=
ùBÎüBs
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ýBæ†þBîÖ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÿB�¥€Cu �C_�‚CÙƒCîó „CýD…C5¢
†CbC‡CÚú
ˆC[1‰C¥ ŠCú_ ‹Cr5ŒCûé �CU·�C¹«
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‘C:¶
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
’C
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�“Cµ”C_Ü•CO�C·žCÔ ŸCH>  C8N ¡Cwè¢C
Ñ £C”æ¤CàŽ
¥C…
¨C“Õ
©C1¢ªC÷
«Cðú ¬CÌX­C¸û
®CÒ›¯C_°CÚl±C톲Cäj³Ck~´Cä: µCIƒ¶C¡ ÀCpMÁC±ê
ÂCp‚
ÃCV$
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÄCV�ÅC”AÆCõ ÉCµ.ÊC;Š
ËCNÌ ÌCÄðÍCpÁ ÎCÆÚÏCŸ'ÐC¸¿ÑC7s ÒCbV
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÓC,ðÔCd%ÕC¿a
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÖC_2×CNGØCÔ¥ÙCB‹ÚCØî ÛC^¾ÜC˜ÂÝC”ÞCôÀ ßC/>àC1ñáCÉ� âCLúãC ´äCXz åCOdæC¤ëçC+ èCéC«ËêC9èëChXìC)¥íCôK îCÅ*ïCñ¡ðC˜ñCÞŸôC%ÒõCÙaöCr¡ ÷CøC®@ùC¦ß úCyYûCû\
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
üC>ãýCÆ¢þC¿Ï ÿCÙÍ€Dñ �Da ‚D_§ ƒDÅT„DãH …D/à†Dé7 ‡D§˜ ˆD[‰DP ŠD!‹DóG ŒD4Á�D5 ŽDA�Dï�Dvq‘Då� ’D7ó“D©D”De •DB{–Dq² —DÝ$ ˜D•È™D­ÑšD”›DµœDô… �D9 Dö»
¡D¡ð¢Dæ-£DpÞ¤D8Ø¥Dõ«¦D‘Š§DyÆ ¨DÁ� ©Dú
ªDß
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
«D00¬D’¬­Diø ®D8ׯDÖŒ°Dm±D9IJDBó³D(%´Dú`µD™ ¶Dz
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
·DüÎ ¸D{Î ¹D‰´ºDк »DÔ�¼D©½D›¾D­¿Dú�ÀDïØ
ÁD
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÂDb- ÃDCÄDVtÅD÷ÆDÒ2ÇD©ÈDQ? ÉD‰?ÊDÇ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ËD,‡
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÌD¦ïÍD�[ ÎDß¾ÏDèÞÐD0&ÑD°PÒDãFÓDµÔDO�ÕD±i ÖD™ð×D"
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ØDÙjÙDv ÚDCÛD™óÜD 3ÝD8
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÞDº,ßDÁì àDF áDí+âD^½ãD£À æD›±çD€9èD…éD±W
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
êD=ëD+È
ìDl» íDÕœ îD³ÑïDµðDBßñDð² òD•óD:q ôDE¸õD¶* öD#c÷DSAøD!s ùD@úDÀûDjüDüŸýDýþDLýÿDÃÛ€EÔ�Eu~
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
‚E+:ƒEtÉ„EÇ…E8 †E{
‡E•
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ˆEÞz‰EºF ŠE†w
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
‹E ‡ ŒE¶>�EÙ�ŽEK\�E²N�E�Ñ‘E0p’Ek„
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
“E^¸ ”Epv•ElG –EUB—E•á˜E?³™E\£ šEÆÞ›E3\žE)MŸEÜ“ E-8¡EÈ¢E[]£E/ ¦E¤f§E*Œ ¨E.,«Eø¦ ¬E B­Eƒ ®EB³ ¯E(V°E" ±Eõ ²Eœ³EøE´EÒ@µEt ¶E±r ·E-…¸Eà
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¹E½ºE�»E%›¼EÙ½Eª�¾EàŒ¿E’Ø
ÀEø ÁEÝ€ÂEþXÃEj”ÄEàÓ ÅE¡; ÆElÝÇEa ÈEKN ÉEr+ÊE…ZËEçÌE‹ŠÍEl’ÎEÇòÏEdgÐE!ÑEˆ'ÒE½ÓE‘MÔEØ`ÕE­¯ ÖEîf×Eœ¬ ØE¾ž ÙE¨ã ÚEÌó ÛEOÂÜEXn ÝE¼ÞE†ßE
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ë àE2háEï âEËÓãEûÌ äE¦ˆåEŠæEÿ çE§ŠèEu éEY¨ êEÖê ëEà@ ìEuÄ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
íE§Â îEYCñE‹AòE³¾ óEÈmôE®}õE¢‡
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
öErÅ÷EïYøE‘ŒùEÐúEÔ‰ûEz° üE†ýELÝ þEä±ÿE^l€F0w�FG(
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
‚FÊ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ƒFîf „Fm…FÞŽ †F÷Q‡F¶ÿˆFYå ‰FâÖ ŠFÐ ‹FÃ
ŒFHŒ �FþW
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ŽF§ �Fe�Fz¨‘Fá:’Fép“F×”Fzf •F5 –Fª� —F½˜Flð™FpÔ šF>2 ›FŸ‘ œF!¡�FÐù žF³£
ŸF  Fn, ¡F— ¢F•´ £FΤFž ¥F3¸ ¦Ft§F¨³
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¨FèS©FªF¸ «FšÃ
¬FHP­F“ ®FÆ�
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¯F\°F]D±FEs²Fݘ ³Fá–´Fn…·F„¸FA\ ¹F´@¼F¥½FªE¾F/ØÁFÐDÂFOÃF:îÄF ÉÅF‹zÆFÇ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÉF³" ÊF’ ËF �ÌF‚OÍFˆuÎFU’
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÏF)ÐF
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ŠÑF•ÇÒF´
ÓFù
ÔFû@ ÕFƒZÖFèH
×Fs ØF±8ÙF­½ ÚFûóÛFáV ÜFhä ÝFÞFëßFŸÃàF.áFè‘âF°¤ãF6×äF´Æ åFdÿæFËÛçFaF èFôméFè›êFEwëFÆìFœíF]¾îFý)ïFÏËðF £ñFJX
ôFuˆ
õF.ÙöFG|÷F©øF
~ùF% úF½»ûF®ÍüF6ÛýF¾xþF³eÿFê4 €G’,�G}D‚G DƒGß²„GÂ…G®
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
†G'ð‡GŽËˆGš‰G6oŠGÀ‹G[;ŒGö•�GˆÖŽG²¯�G‹x’Gnh“GZ[”Gq6—GD
˜Gë™GQãšGÞÒ›GDú œG‰h�G? žG-­ŸG�¥ G•§ ¡GtI ¢G(Œ £GÀó
¤G _
¥G>¦Gò+§G½7¨G*¢©Gÿ?ªGµ
«GÙ§®Grð¯G'E°G4ç
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
±GˆŽ ²Gîk ³GAS´GÔ- µG\+ ¶G§´·G^=¸G§Ì
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¹G/XºGqc»G»“¼GR{½G™¾GÚ›¿GœTÀGËø ÁGV•ÂG$ÃG ÄG·{ÅGŸ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÆG½�ÇG– ÈGŒ¸ ÉGS_ÊG¥@ ËGÑe
ÌGÒ ÍGµ
ÎG

ÏGÂÐGîjÑGÀ ÒG{¾ÓG5 ÔG AÕG
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÖGmJ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
×G ‘ØGžìÙG�K ÚGB`ÛGµRÜG3FÝG*•ÞGÛßGW¨àGo�
áG%âG¬æ ãG_· äG¹åGè
æGNK çG=ä èGÃÆ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
éG’ êGPº ëGSˆìG}Æ íGEv îGcÎïG4{ðGò« ñGéžòG¦û
óG k öG¡<÷G9EøG ´ùG™
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
úG³0ûGU¦üGâó ýGw�þGW2ÿGQ‚HjƒH½i „HÌV…HSH†Hf ‡H�e ˆHöó‰H†ŠHý ‹HôŽHÓ¶�H­º�H‰N‘Hp»’Hów
“H/þ –H ?—H%j˜H¿_›H¿l
œH6�Hnà Hœ™¡H²r¢H‡L¥HqX ¦Hj@§H8.ªHJR«Hï¬Ht&¯HQ¨°H§Ê ±H´HøTµH¸¤ ¶H³¨¹H^æºHMk
»H˜P¾H:À ¿H‰ÀH5]
ÃHçÄHÃd
ÅH@ÈHŒ¯ ÉH ’ÊH.ÍHDðÎHYNÏHB™ÒH).ÓHDþ
ÔH6×H]FØHá�ÙHA^ ÜH‹ÝH½žÞH_õáHÐT
âH¾íãHø5 æHÖ[çH”èH ²ëHxïìH‡ÏíH¼ê ðHbÛñH9–
òH)fõHã�öHÕ!÷H�ÎúHzЂI°~ƒI ;„Iˆ …Iæ*†Iºâ‡INô ˆI…O ‰IÀì ŠI­� ŒI°¾
�IôKŽI¾ô�I€W�IHØ‘I Ï“Ià ”I‹›•Il
–IY‘ —Iu<˜Inï
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
™IäךIÓÒ›IYú
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
œIö>�I¸ žI�a
ŸI»Y I>O ¡I¢IHâ£Iiœ¤IÊ¥IŸú¦I²„§IÒ3¨IÆ�©IœáªI¢½«IÚ&¬Imo­Iåî®IoïI0n°I¯`³I 7´IYµIo“¶I­Ž
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
·I˜\ ¸I¾ý
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¹IÐߺIùC»IF ¼IK£½Iˆ
¾IHr
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¿I ,ÀIO,
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÁIfr
ÂIŠú ÃIþ-ÄIxÅI=cÆIû¤ÇI¢<ÈIB4ÉI ,
ÊI³ÊËIJ ÌI’ÍI ¸ÎI�1ÏIôç
ÐI¥JÑIFÒI?ûÓIåÔIO£ÕI÷;
ÖIcy
×I§7 ØIô±ÙI°O
ÚIãÃ
ÝIæ—ÞIÑ ßIµàIF�áIó…âI*GãIñäIÝD åI§åæI}:çI‡vèIÿéIþXêIå}ëIøìIë
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
íI¦�îIÔ; ïIÛÄ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ðI?GñI¼ïòI­ŒóI»¦ôIÌMõIÿ�öI¦¦ ÷IëaøIŒ¬ùIK,úI4GûI’i þI8Á ÿIÛ™€J'nƒJ†Þ„J'â
…J ˆJÔ[‰JðéŠJü;�JaG ŽJp�J�ý—JíH ˜Jl�™JbÇšJm§›JÈ œJ’Ò �Jý¸žJÇŸJ< Jîà ¡JQ¢Jã�£Jú®¤J1¹¥J'
§JúŽ¨J”»©J`ĪJ¢º«J4¬J¦á®J²ò
¯JiM°JßܱJÚ ²J~ ³J/ºµJGý ¶JËd·J&
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¸J ‚ ¹Jþï
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ºJe†¼J6P½J[þ ¾JQ„
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¿J“ÀJ
ÁJîMÂJ·ÃJï  ÄJQõÅJÕÀ ÇJV ÈJCCÉJblÊJW/ËJòQÌJ{>ÍJ1­ ÏJ.D
ÐJ¼
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÑJÛ;
ÒJr›
ÓJ3¼ ÔJe¬ ÕJc†ØJˆÙJ¹ÚJ?>ÛJðaÜJ~Ž
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÝJåJ àJ{êáJm5 âJ¨óãJKoäJAåJ’?èJ¥AéJ}š
êJ™ÝëJ1ìJlô íJ4 ðJ °ñJÌðòJ&°óJåd ôJíµõJ7öJw ÷J5wøJIùJ‡ž úJœ)ûJ;ÃüJG«ýJÈs þJv„ ÿJ*<€KÉ�K‹P ‚K~QƒKc"„Kw…Kät†K­z‡KšøˆK˜! ‰KekŠKÙ‹KŠº
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ŒKsÜ �K˜èŽKY
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
�K~š�KÉJ ‘KÈ
’K|Ó
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
“Kz¶ ”K¯w•KE´ –KK×
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
—K£F
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
˜K])
™KꙚK¥ñ›KY÷
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
œK¶4�Kê žK
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
.ŸKMH K‰à ¡Kâ¾¢KBv£Kw¯
¤Ko‚¥K˜Ç
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¦Kå*§K&
¨KÝ—
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
©K§l ªK}e«KŽ^¬K¡/ ­Ký«®K]p¯KKŸ°K“¶±KŠ8²KÏs
³K{|´KÜ¿µK\™¶K›K·Kò-¸K3Ú¹KãçºKC[
»Ký¼KÛ© ½K¡ ¾KÈÜ
¿KÁÇ ÀKÕÁKVVÂKŸ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÃK8ŸÆKYÇKýì
ÈKñ¼ÉK«©ÊK/)
ËK¹ÌKG ÍK&ÈÎKb8 ÏKøð
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÐK(�ÑKuÒKD«ÓKñu
ÔK²ƒ ÕKÛ�ÖKö8 ×KvØKûÙKZÚK6ò ÛKW²ÜKõÝK*ÑÞK‹g
ßK‚U àKz—áKË âKíšãKe�äKcÄåKše
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
æKU
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
çKôúèKó{éK¶ìêKªÛëKÈæ
ìK‚Œ íKó îK ‚ïK‡KðK ñK…ÅòK2Ó
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
óK{hôK;bõKæ§ öK%§÷KØpøKè#ùK[‡úK
ûKIüKŽœ ýK‡ªþKžÿKý» €Lrô�LdT‚L—Ò ƒL^W„L=…Lae†L½•‡LˆLç–‰L
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ŠLs‹L†@ŒL«ç�LúŽ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ŽLƈ�L�à�L.ö‘LKÓ’LÜ~“LþÛ”L©‡ •LFË–LþÔ—L͘Ljw™LÕ¯ œLAî �Lµ> žLÝŸLt L˜y¡LKC¢L¨ž£L ¤Lw,¥L1/¦L»ò§L¨L·Ð©L5…ªLo´ «L˜h¬Lÿµ­L| ®LÊw¯L+m°L1Û ±LÙª
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
²L“à ³L4´L²µLζL¡+·L¼B¸L…Œ¹L�ûºLûN»L¨¼Lbß½L2Þ¾Lug¿Lºâ ÀL�¿ÁL8ÂLù
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÃLªŽ ÄLÔÅLÊÎ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÆL\ÿÇLí˜ÈLó�ÉL™Û
ÊLX!ËL¼bÌLœ1ÍLí ÎLggÏL‹BÐL<ÁÑL¿M ÒL[rÓLð ÔLë¹
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÕLC ÖL�-×LhØL¬´ÙLDNÚL#£ ÛLQéÜLc‚ÝL7gÞLâ» ßL6;àLiÏáL@-âLú*ãLŠ¹äL�åL:›æLÏÂçLëEèLv¼éLæ¢êLjëL
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
{ìL» íLîLU8ïL¯ËòLª¶óL ôLLî
õLÁÃöLHä÷L À
øL>}ùL²ÙúLëƒûLx‚üLôÂýL VþLÌÇ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÿL·O€Mž\�M¡] ‚MxуMBB„Mýþ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
…Mí†MPU‡MáO
ˆMÏ©‰MÊ9 ŠMŒ‹MËÆŒMT6 �My4ŽM% �MY �M}ÑM,F ’MìÅ“M”ý”M– •M…¬–MBÚ—MÓ»˜Mê™MMšMÃŽ›Mr”œMô@�M“˜žM×ý ŸMÌp MšS¡M}¢Më°£MŠí¤MÖÎ ¥M€ ¦M�.§MïI¨M}‘©MÕªMÝ«M¿Ë
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¬M+†­M·ý®M�÷ ¯MÔ°M±MÛ²M°ò³MÞp
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
´MIDµM빶MØ·Mnh¸MÚ¹M¡ý
ºM¾¦»MŠ
¼Mâå½M#¾M«C
¿M|éÀMt$ ÁM ÂMáÌÃM¾ÄMûÕ ÅMÝ
ÈM©
ÉM Ñ ÊMsTËM˜ÈÌM®â ÍMÝvÎM#™
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÏMmÐMHýÑMŠÒMn ÓM­ûÔM-PÕM¢ôÖMh� ×M´
ØMµâ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÙM1ƒÚMêœÛMa$ÜM™†
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÝMºo ÞM PßM©.àMáMê/
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
âM[-ãM·
äMi!åM;)
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
æMÒ( çM•þ èM†$éM{ð êMîTëMY+ìMØåíMÇÏ îM”³ ïMÿðM$ñMä·ôM,_ õM8L
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
öMæ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÿMýo
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
€N?�NJb‚Nñï ƒN!Ä „N¬/†NY, ‡NñʈN¤ ‰N“" ŠNÇ* ‹N* �Nľ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ŽN�^ �Nî· �NtŸ‘Nec “NX~
”N�’ •N+Ø–Nxp—N¦„˜NÇ‚ ›NY
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
œN¸m�N°ë žN{Ø
ŸN� Nø‡¡N ¢Ngö £NIÌ¥N±¦N€C
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
§NœH¨N2> ©N±aªNQ
¬N&t
­NƒY®NXQ¯NF °NŠ¸ ±Nvö³Nå„
´N£dµNŒ&
¶N€ê·Nò¸N
¥
ºN�i»N�*¼N)k½N„€¾Nä
¿Ny ÁN_äÂN!BÃN»5ÄN`ãÅNi
ÇN�UÈNÉN­ÊN{^ ËN¹ø ÌNõ˜ ÏNœ™ÐNˆ÷ÑN–%
ÒNºÓNaR
ÔN05 ÕN?ÖN^¯×N•ñ ØNd ÙNa¬ÚN®‚ÛNO|
ÜNuÊÝNb– ÞNEK
ßNkàNT…ãN5< äNèäåNEÏ æN7ö çN£n èNq ëN
ù
ìNÊ—
íNòñõNàIöNÁž ÷Nd*øNzùN¢®ûN²¾üN6œýN
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÙþNÞ²ÿN½†‚O‰ÚƒOte„Oš……O\ †O] ˆOY¢
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
‰Od˜ŠOÆm‹O“ÁŒObaŽOÜÿ�OÄ�OS#
‘Oâi’O�§“O6…•O q
–OÑ"—OB˜OI ™OÊ>šOÐœO£ñ�OOöžOÆŸOn OY*
¢Oîh£O˜O¤OÑŠ
¥Oÿ� ¦O‹W§O<v¨OÈñ©O…ºªO�¬ «O¢¥
¬O·á­O�®OfŸ¯ORY°Oƒ8 ²O.Î ³OãY´OáÆ µOˆ§¶Oô‘·Oõ¸OÓŠ¹O0àºOÞx¼O"è½OZ�¾Oï> ÀO™„ ÁO¥±ÂO·þ ÅOŽµÆOs}
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÇOôÈO;wÉOðåÊO©0ÌO ÍO�b
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÎOtPÏO€ ÐOÔ‰ÑOåéÒOn2ÓO/à ÔOÖ{ÕO`“ÖOÍt×OEtÚOInÛOÅà
ÜOˆfÝOB©
ÞO”$
ßOOàOgõ áO
«âO÷FäOÅ
åOìõ æOÆ\çOc¶ èOöúéO¨4êO}
ëO®FïO9ÖðOGç
ñO bòOíóO,
ôO3íõOLÊöO=.÷OÛ4øO¾WùOæ1ûOÅÄüO=ýOcþOsÿO.x€PS;�P^΂PrăPüÄ„PDi†Pn(‡P£å ˆP<«‰P!ã ŠP³ý‹Pê” ŒPê”�PK ŽPJv‘P1�’PöR“PÖ”PøŸ•PÍn
–P@—P
“˜P0"šPa�›P/ œPrc�PFºžP
 Pv3 ¡PËÒ¢P*—
£PwÚ ¤PŠ¥PãܦP ¨P‰ö©PJªP”Ô
­PH®P̽¯P° °P±P—‚ ²P8¹ ³PÍ´P¹ÙµP̶P¬w·PWÛ ¸P>¯¹P¿^ ºPÕÖ»Ph¿¼PS…½P*É
¾P¿PFÖ
ÀPÎÁP":ÄP
ÐÅPÊÌ ÆPg<ÇP~-ÈPÉÉPhÊPqËP“:ÌPÀ|
ÍPàx
ÎP¢œÏP©·
ÐPþ4 ÑP!´ÒP½'
ÓP�; ÔPæSÕP7�
ÖP^ý×P¶GØP[‘ÚP"†ÛP×EÜP÷H ÝPØÞPcåßPâP
ãPp_äPŒà
åP«PæPXÁçP´èP5.éP„IêPÊ~
ëPò^
ìPÿâíPÇ:îPC=ïPÄFðP~ÓñP6j òPr©óPx¥
ôP¾+õP=¼öPäpùPô?
úP¥“ûP§ŠþPk{ ÿP"w €Q%ñ‚Q‚ô ƒQ~ „Q霅QÀ*†QZ ˆQq‰Q¥ÉŠQ&Z‹QžŒQö5
�Qâ´ ŽQÿ
�Qºå�Q®¹‘Qoö’Q5½
“Q°v –Qó%—QÒ¨˜QDË™Qm†šQÄÛQ*½�QœÃžQ9P ŸQê{  Q×ú¡Q–G¢Q3)¤QýV
¥Q.€¦Q�"
§Q$e¨Q ©Q,«QGǬQ\…­Q¾I®Qð× ¯Q<^°Qî ²QÂγQÙ ´QjµQÅX¶QÍ–·Q‘¹Q)© ºQC »Q¡
¼QsνQÅo¾Q< ÀQÌ
ÁQæqÂQ(ËÃQ8ÄQ‰ ÅQBx
ÇQ/ÈQ{`ÉQo]ÊQ ª ËQÔÌQæô ÔQês
ÕQ'°ÖQX¹×Q�ðØQµ;ÙQÐ^ÜQ›ÝQû/ÞQQ†ßQæë àQÂDáQAÆâQ–ÁãQ¢ùäQåQ˜æQ´çQäT
èQ‡éQ¥]êQ#§ëQÍ`ìQI€íQÛ
îQ±³ïQù¥ðQ'ñQx[ òQú²óQãà ôQ õQ†öQ÷‚÷QÿéøQCùQë úQß ûQš üQÀÿQt^€R©�R‘‚R¨
ƒRcö„R˜…R�ø†RÚ¿‡Rh„ˆR!p‰Rq ŠRͤ�Rïì�RÈ‚‘R÷X’RàA “R·”Rº ™RÏ šR *›R. œR7„�R-žRÜ£R˜¤R�¥R¡†¦R=r§R;Û¬R³­Rå?®R ®¯RÄF°R¢±RÆà ´R�εRØÿ¶R+k·R£m¸RŒG ¹R.éºRg»R î¼R�d½RÌ2¾Rì ¿RiƒÄR-˜ÅRS¡ ÆR¢W
ÇR�6ÈRQ¨ÍRwÓ
ÎRi,ÏR
^ÐRï
ÕR6T
ÖR-H
×RÝŽØR«3
ÝR×{
ÞRªKßR„v àRSKãRO¼äRÿÙ åRÿUæRfC çRƒƒèRÉ`éR�{êR}äëR; ìR¶íRíPîRY óRÒÉ
ôRqõRÓÎöRfûR–MüRÞìýRuú
þRȺƒSg„S³ …SŽ†St ‹Sœm ŒS�:
�S�¨
ŽSÊ‘S¦Ø’Sµü
“Sw”S^®•SÌ8–SWj
—S±'˜SGÞ ™SwšS0®›S‰úœS~‰ ¡S©U¢SuL£S<ë¤SMò ©SDgªSp «Sµz¬S"v±St�²SÏQ³S˜´S·Ê¹S8ºS&”
»S5ý¼S„Š ¿S.*ÀSÝN ÁS}‡ ÂS)§ÃSÞRÄSÍáÅS¼öÆSkËÇSCiÊSÿMËSÆÌSèÀÍSs«
ÎSÛ
ÏSŽAÐS…EÑSÿÒS’N ÓS´Â ÔS;
ÕS@ÖS]½×Sñ ØSWûÛS
ÃÜSȉÝSëXÞSQ7ßS/
àSežáSùÈâSlI ãS¾` äSºpåS>é æSägçSå èS¤ôéS$*êS
eëS›ðìS
&íSHV îSe°ïS‹ðSí
ñSRÇòS ÒóSx�ôSÎzõS‘( öS¿'÷S¶!øS < ùS rúS†Å ûS¨£üS‡�ýSxþS�«
ÿS»€T­S�Téf‚T݆ ƒT|ù „T˜V…Ttù†TTãZ
ˆTâÔ
‰TcÇŠT_‹T ôŒT•
�T‘
ŽTK*�Tg­�Tr ‘TúJ
’T±å“T
Ö”Ts•Tšf–ToK—TH”˜T¯ ™T˜šT˜q›Tbô œT �TºîžT‹‘ŸTvÖ T�#¡Töá¢Tãµ£Tó
¤T¶
¥TkË ¦Tîk§TΧ¨Tò÷ ©TÔ7
ªT¡~«Tsd¬Tz`­T@€
®TTü°Ti~ ±TÈ,²Tä® ³TÿW ´TŽµTðê
¶Tàê·T?j¸T—¹TºT¤ ½Tþ;TÒi
¿TlšÂT 1ÃTh
ÄTü`ÅTêÂÆT�ÇT±÷ÈTþUÉTß+ÊTÑ)ËTÌêÌT¬ˆ ÍTÕÎT~ÏTèÐT€
ÑT^R ÒTz¬ÓTÜ@ÔTÝ_ ÕT1ý ÖTÁÐ×T— ØT›ÙT+
ÚTHÛT ² ÜTÖ� ÝT"¤ ÞTlßTñàTŸt áT¹, âT�ÉãTÕ†äToÝ
åT8 æT bçT
#
èT¤éTDßêT+§ëTT~ìT(íT·ù îT¬î ïT7â
ðT)–ñThUòT�\óTžÇôTK.õTe'
öTWi ÷T0øT{zùT&™úT1 ûT7I üTµÙ
ýTÊ[ þT‡ÿTÐv€U­+�UñÛ
‚UäÙƒUXž
„Uõ…U%S †UÅ ‡Uí
ˆUMï‰UâŠUIL‹U"ŒUV¥�U‚ŽUå®�Uο�U…F
‘Ubd’UO•“Uœ¼ ”UüA•Ut3–U½­—U�טUž`™UyèšUqï›U±Ó
œU7é�U/O žU2ŒŸU˜Ý Uë¡UYy¤Up-¥U‘+¦U=­§U¿ ¨U† ©U wªUw¤
«U¡Þ¬US¦ ­UE/
®UT¯ULH°UÛ}±UÎ0²UìI³Uf/ ´U¹úµUîh
¶UfÊ·U¸UmݹUl ºUXk»Uýè¼UÉò
½Uz^¾Uþ7¿UkíÀUqüÁUX÷ÂU•/
ÃUýk ÄUŒUÅUeq ÆUÜ+ ÇU˜ÈUµÉUSÊU!ÖËU•
ÌUçùÍUã;ÐU×ÑUÖ#
ÒUyßÓUò
ÔUõÎÕU£gÖU �×Uú¡
ØUÁ
ÛUÕ�ÜU]¨
ÝU®5 ßUn&àU.½áUYò
âU'ãUšƒ äU åUâ/æU%� çU¥,
èU±% éUéêU–cëUóÖìU6kíU•´îUçk
ïUËðUâ…
ñU%òUµ~óUîx
ôUq¯õUyaöUÐ’÷Uô¤øU½ð
ùUDœúUCûUýVüU,1ýUØrþUuò ÿUø$€V@�Vš£ ‚Vå`ƒV7µ„VÍ
…VMƆVü)
‡V|òˆV*ƉVXðŠVŠƒ
‹V«ŒVcš�Vè ŽV~�VE?�V¬¸‘Vï`
’V3Ö “V’”Vy½ •V£‹–VZ¥ —V¡
˜V½Y
™VËT šVk#›VÓ œVÕ¹�V[‡žVKŸVŽ V8� ¡V°=¢VØm£VŽ¤VÉ ¥V Œ¦V†c§V…Þ¨VÏN©V’o ¬VOá­Vi„ ®Vq ¯VX‰
°VرVwIJVl‰³Vì×´V ¨ µVäý¶V#Q·V­î¸V„’ ¹VRiºVÄE»Vº¼VùÀ½VO€ ¾V ø
¿Vº¸ÀV•ÓÁVSÌÂVM«
ÃVL°ÄVdºÅVù‰ÆVfÇVÞgÈV1l ÉVUè ÊVÀr ËV)ÌV¶”ÍV·"ÎVÏV�{ ÐV2` ÑV>{ÒVý¸ÓV²kÔVÚ~ÕVÖVI×VÈ ØV‚r
ÙVr
ÚV¹QÛV\¾ÜV¹^
ÝVFÞV×7ßVÖYàV÷4áVˆâVŽp ãVNFäVî/
åVdræVU
çV�Ê êV|ãëV†i ìVU3íVÇ{îV¬d ïV—LðVtEñV˜• òV´[óVû
ôVï
õVW¾ ýV þV!ÿV‡" €W9’ �WS×
‚W/WƒWÃ÷
„WÂ]…W²Q†W>Z‡Wÿ,ˆW?ï ‰WÙŠW¬„ ‹W1þ�W/À ŽWîÿ
�W¤Ê�W_‘Wd=“WFè
”W‰{•Wq
—W#c ˜W.w™W¯
šWJ5›W‘^
�W븞WµM ŸWN•
¢WØs£WꈤW¹I¥W2ϦWÛþ§W�Y¨Wg• ©Wƒ ªW µ¬WÃέWÙ
®Wñ’¯W{œ
°WØ1±W‚ ³WTå´W= µW
¶W™®·WºJ¸W€¹WÀû ºW#»Whm¼W/¹ ½W¨ ¾Wá1¿WlÀW�òÁWòù ÂW=åÃWa= ÄW3? ÅW­ÆW”Ý ÇWÌÈWQ�ÉW¾F
ÊW;÷
ËW¾ÌWƒÎÍWrm
ÎW†ÏWîÐWTØÒWÓ¹ÓWdmÔW>EÕWø� ÖWŠ¡ ×W9JØWЇÛW:FÜW¨ÝWR ÞW¹üßWeàWìáW\&ãWëF äWj åWIçWý
èWD4
éWü†êW8´ëWo#
ìW¡s íW*› îWÞ¼ ðWx.ñWÚ®òWùôW#èõWÓ¼öW†ˆ÷WTøWg�ùWBv úW­6üWú¿ ýWÞ
þW«Ñ ÿWÎ
€XO‚X!ŸƒXŸâ„X[Ü …Xpê†X^g
‡XœÞŠXŽŠ
‹XBxŒXÆ �XP¶ŽXG§�X�‹�X÷Þ‘XÑ{ ’XÀ“Xlv ”XÀù•X²]–X”m—XÁv˜X¡ž ™Xi% šX€C
›Xb¿œXc^�XU¿žXÐMŸXC| X|¡XQ©¢X” £X‹z¤Xrª¥X…s
¦Xsˆ
§X¨Xh¾
©X(+ªXÜV«X{µ¬X7w­X·§®X ð¯Xdþ °Xi%±Xµ
²XÖû³X¤E
´XP‘µXÎU¶X(R ¹X‡ºXÁ|»Xº~
¼XIp½Xþ ¾XÅF¿XîÀXbßÁXtPÂXö± ÃXSÄX6`ÅX{OÆXhçÇX…dÈX¬ ÉX; ÊX–¶ËXiÌX” ÍX¨ò
ÎXJžÏX4cÐXΫÑX]lÒXŽ= ÓX¸ôÔXšÕXJc
ÖXžB×XäÜ ØX¼ ÙXÏT ÚX\ÛX¨  ÜX�­ÝXxÞXý0 ßX½6àXWÝáX-âXÍÅãXóäX©xåXO®æXÜîçXèXÙ7 ìXm­íXº1îX/ ïXÇðX³Y ñX`-òXÇóX\}ôXO õX¿RöX)£÷XÓøX=" ùXý¾úXØ5
ûX}êüXÓÜýXIþXÐô
ÿXAE
€YK�Yýû
‚Y'3ƒY"u„Y �…Y6.
†Y·’ŠYeþ‹Y¾› ŒYþ�
�YߎY/”�Y�U‘Y¾’YR8“Ya° ”Yk]•YÊn—Yl’˜YÆh™Yò™ šYd›YÔ~ œY…��YœÉ
ŸYL(  Yæã¡Y"| £Y¥'
¤YÜ¥YɃ¦YZv§Y‚¶©YyîªYz«Y~ ¬Yô­YB®YÆg
°YRW±Yà… ²Y‹ž³Y†ü´YÒµYžÊ¶YÓ„¸Yñž¹Y ºY ½YÍC¾YN ¿YpÚÀY6º
ÁY1’ÃY‡ûÄYT™ÅY~DÆY%;ÇYð ÈYóBÉYm�ËY³hÌY�<ÍY&ÎYŽû ÏY#Á
ÑY6£ÒYÕ/ ÓY×ã ÔY@ÔÕY rÖYÊú×Y�ÚYŠ<ÛYvŽÜY®ÏÝYX–ÞY H
àY2$ áYÕâYYWãYb7äYæ¾ åY+êçY¬èY®ÂéY¼üêYº9
ëYfìY”íY£[ïY€U ðYŒAñYº¼ óYÝu ôY_lõY‰‚öYÆ@÷YÏì ùYxpúYqD
ûYeÅüYýYNŸþYlG€Z¥¿�Zr‚Z’
ƒZׄZ|G…ZÙ› †ZOQ ˆZŽ
‰Zic ŠZßR
�ZÿÙŽZn¤ �Zíy�Z�g‘ZM‘
“Z:”Z~Ó •ZÙ.
–ZaF—Zñû ˜Z…h™Z“V›Z\ œZ<é
�ZìïžZDØŸZ4o¡Z°¢ZK'£Z9)¤Zÿ”¥Z@F ¦Z­ñ§Zì ªZÑx «ZÊ× ¬Z(ö
­Zˆ ®Z¬�
¯Z¨Û ±ZÍ^²ZoW ³ZýÜ´ZÎÙµZ¿«¶Z
M
·Z’ ¹ZøȺZâ©»ZM. ½ZýQ¾Zy$¿ZIÀZÕÁZöÂZ¦+ ÄZßð ÅZ]� ÆZOßÇZûÅ
ÈZI£ ÉZf›ÊZíÌZ(¢ÍZgÒ
ÎZ„
ÑZÖÒZÎØÓZþHÔZ�hÕZ£nÖZâv×Z—ŸØZòNÙZá:ÚZOæ ÛZ7çÜZ"iÝZ<BÞZÃœßZº
àZ­  áZžâZã ãZA*
äZ±NåZ6
æZ3‹ çZÌO èZ$ÀéZuÀ êZ’� ëZ¢ñìZTËíZk îZ„ÊïZE
ðZÑÕ ñZzw òZm,óZ—tôZÊ
õZWÃöZ÷Ë÷ZþøZQ¶ùZ.búZÄŠûZ¶¸ üZuýZˆaþZìÏÿZl¬€[ÎE�[@‚[à“ƒ[´ „[~…[ïƒ †[¸›‡[[5
ˆ[èq ‰[.ÏŒ[×@�[Ó` Ž[•² �[û…�[Z> ‘[F¡”[‘Ú•[éq
–[ˆÛ™[=õš[†·›[¦° ž[õ’ Ÿ[4è [Q�
£[l; ¤[aH¥[kd¨[í:©[ª[)D­[݉
®[vò
¯[Õc²[¶¤³[k´[‘^·[/I
¸[
¹[Å}º[¡1»[ ë¼[º ½[ØC¾[jf¿[ÞáÀ[LÀÁ[[î Â[iBÅ[æ8
Æ[,6Ç[åhÊ[5ÓË[ßxÌ[âý
Í[©ÅÎ[9ÐÏ[šÐ[3Ñ[ƒ Ò[f> Ó[¿ Ô[Ñ¡
Ö[a/×[k‹Ø[”,
Ù[/ÇÚ[eéÜ[’Ý[+? Þ[1Iß[‰Öà[\á[…} â[D‡ã[ýSä[bå[ßµ æ[»" ç[@ðè[Wµé[Yê[nÜ ë[$O
ì[D í[¢ï[“…ð[µÔñ[ @ ò[F4ó[Ðm ô[çe ö[¤´
÷[9„ø[z6 ù[ÅN ú[æ„ û[¨u ý[Èúþ[ýßÿ[sÕ€\Œ½�\=³‚\H¦„\>
…\¨<†\©Ù‡\Þˈ\<¸ ‰\)è Œ\5O�\¬nŽ\O�\Ð�\’¯
‘\¢%’\T¾ “\Eû •\£ž–\u©
—\¸l˜\»¥
™\‘Zš\Ž�›\øœ\Sb Ÿ\š \Iµ¡\íì¤\›Ù¥\]e
¦\
§\÷J¨\ºÂ©\x=ª\N¨«\6´
®\€—¯\½Ý°\_ ±\·£²\jT³\yR´\”°
µ\ɶ\Hî·\¹º¸\Ì »\¿› ¼\…½\_
¾\î³ ¿\£¡Â\ÝÃ\G^Ä\Û—Å\“ÙÆ\®ý É\‰
Ê\áË\£ßÌ\ƒÔ Í\¶õÎ\ÂÏ\LHÐ\<6
Ñ\E Ò\ÁÏÓ\“-Ô\-
Õ\„âÖ\ºn×\*
Ø\:„Ù\K*Ú\Û\oÜ\‚Ý\1#Þ\*Wß\Ljà\ª�ã\¡& ä\ å\N æ\¡µ ç\;è\êGë\‰rì\ní\Øwî\ïï\’eð\²ñ\gÏ
ò\¬‚ó\Ÿ¸
ô\‹ý
õ\X<ö\'4÷\„x ø\&ù\–ýú\J:û\åêü\o] ÿ\ÌŠ€]3C�]þ…‚],g ƒ]¶‡„]§…]è؆]Ÿû‡]¼ ˆ]›‰]ìÖŠ][E‹]Œ�Œ]-® �]vEŽ]ÿ* �]ç�]ó  “]*` ”]¯ó •]}F –]Ãa —]¶F˜]¼^
™]”š]êu›]±�œ]r�]çGž]‘ Ÿ]êÆ ]$n ¡]h ¢]´!
£]У¤]«–­]ñ®]®Ï¯]qÙ°]Åw±]ôü
²]#³]û´]®µ]‹%¶]¢@·]_!¸]×_¹]iNº]ÅŠ»]£Æ¼]CŽ]¼†¾]… ¿]öeÀ]€)
Á]åÔ Ä]Å]�äÆ]CÕ Ç]ÉXÈ]S É]’ Ê]c’Ë]BÙÌ]2Í]1ÌÎ]C
Ï]aIÐ]¤ÚÑ]˜ÂÒ]„]Ó]®Ô]“Õ]Ö]¼×]§îØ]PçÛ]Ü� Ü]Èk Ý]æýÞ]€fß]šà]Má]Y€â]¨–ã]rä]Ö±å]4Þæ]tÕ ç]Î è]h¡é]Á
ê]Ïë]™zì]ã³í]:!
î]Þë ï]5‰ò]ùG ó]ˆô]©à ö]vÏ ÷]‡Ðø]Nù]Àú]P
ü]ð$ ý]½ñþ]1}ÿ]c
€^Ô΂^kJ ƒ^™ô „^ñ: …^øy†^:: ˆ^_ ‰^î_Š^"¦‹^±µŒ^›K�^QÔ �^ê„�^äÈ‘^Â.’^A “^Þû”^Ì–^ãÙ —^ͼ˜^Ü
™^8¤š^Âäœ^SO�^EÊž^µ>Ÿ^;
 ^H¾¡^ǹ¢^|ÿ£^èv¤^D¥^០¦^Rj§^~ã ¨^'©^$* ª^`… «^¨ ¬^8]­^&°^Й±^»
²^0P ³^� ´^WÚµ^>R¶^¬m·^Ó–¸^‘3 ¹^UѺ^š
»^(ÿ¼^ž�
½^ª ¾^«'Á^?ÝÂ^æ® Ã^Ó•
Æ^š… Ç^p”
È^ß%Ë^·:Ì^)Í^)
Ð^öò Ñ^½ø
Ò^1ˆÓ^ô3Ô^LùÝ^^é
Þ^ð�ß^ÙQà^ùÊá^_—
â^® å^î æ^ª¾ç^ã è^øé^>& ê^Ô ë^ÉWì^ãRí^m6î^ÖÚ ï^±ð^ŸŽñ^üÍò^˜ó^~÷ô^™?õ^p˜ö^ï
ø^Ÿù^¦&ú^^
û^MÁü^Áuý^H°þ^¤Lÿ^ð˜
€_�_a‚_ÌZƒ_Çs„_™€…_k †_‰m‡_�4 ˆ_JL‰_æBŒ_n �_)¬ Ž_ËB �_"�_´¹ ‘_ ’_R“_|
”_•_¥�–_Ì[
—_ª�˜_»™_ª
š_1«›_û† œ_Nù
�_ìqŸ_‚ð _C6 ¡_â;¢_±… £_=~ ¤_M‹
¥_ùm¦_M� §_vM ¨_CY©_ ª_° «_Êz¬_‰V ­_ & ®_' ¯_4ð°_uå³_u
´_'ë
µ_<V¶_ï·_Ž¸_ó¹_Nº_I½»_Àë¼_îø
½_Ɉ¾_O= ¿_v’À_i_Á_5õÂ_æd
Ã_ÛÄ_jæÇ_üNÈ_AxÉ_,… Ê_WË_ôBÌ_ˆ Ï_ð‡Ð_QéÑ_…™Ò_úÓ_ÇMÔ_gLÕ_ ® Ö_€×_â¡Ø_,œÙ_‹ Ú_Û_ÂÜ_¶pÝ_êÞ_j ß_¶ì
à_k â_ÍŸã_\ä_qÈå_ÆL æ_'q
ç_d2è_
�é_¯´ê_ÏŒë_Òì_gO í_¤‰î_–
ï_./ð_å ñ_
®ò_^=ó_é4 ö_‚y÷_c ø_°ù_tH ú_
û_ pü_"¼ý_eV
þ_E;ÿ_Eg
€` ó �`c‚`–³ƒ`éþ„`•(…`1G†`¿L‡`ò‡‰`î# Š`¤…‹`;? Œ` ½�`TÏŽ`Q �`&�`=‘`–· ’`Cá “`ìY”`s|•`Kk–`�¨—`±�˜`‰¡™`³A š`ÒS�`ž\ž`Õ Ÿ`Å `�~¡`¶$¢`þs £`J·¤`ƒÛ¥`. ¦`ãÜ
§`³ ¨`#©` öª`*׫`8¿¬`KÒ
­`"„®`±`†¨²`¿p ³`,e´`D
µ`¸¶`‹w ¹`§¿º`÷0
»`` ¼`ÖX½`x¾`{¿`‚
À`…ºÁ`;ú
Â`ûÖ Ã`UÜ
Ä`ryÅ`ZÈÆ`ü­Ç`­È`ù"É`ÓÉÊ`ÑKÌ`º¥ Í`ÿ€ Î`’á Ï`
‘Ð`ÕúÑ`¦;Ò`ø6Ó`ÌòÔ`ûÕ`QN
Ö` ×`ì(Ø`B,Ù`OÄ
Ú`XeÛ`CÔÜ`�Ý` É
à`»†
á`ùVâ`@lã`Y ä`)Àå`µ»æ`Áç`B è`d é`÷Éê`Üo ë`@ì`Ï&í`ñî`: ï`ó‹ð`Þ_ñ`é ó`rÂô`14 õ`*
ö`p7÷`ɨ
ø`j�ù`üú`£õ
û`o ü`7 ý`Su
þ`lÿ`‚t €a2Q�aÄi‚aÐâ
ƒa ±„a•ì‡aU
ˆaW#‰a¨›Ša: ‹aàbŒaY��ahçŽaâ>�a®D�a÷j‘aà™
’aÆE
“a/}”a/i •a¥I –aR—aC ˜aM›aØ÷£aæ
¤a5a¥a`«¦a埧a¸Ñ¨a˜°©a¿ ªa}¶
«aͬa
­aœ5 ®amy¯aô�°a.� ±a¦ê²að…³aOã
´a½t µa‚- ¶aËÄ·að¸a®W ¹aNþºaØA»aú“¼a" ½a%
¾aí¿aT”Àa–Áa]T
Âa0ÆÃa´ÛÄa Åaf-Æa¯?ÇaÙÈa¤ÉatƒÊaã¹
Ëaç‰ ÌaIÍa} ÎaÙÏaȆÐatˆÑaõsÒa’pÓaÉ
ÔakaÕa4ºÖaq ×a&ÞØañŠ
ÙaÌÚaôÛaA ÜaŽêÝa¹‹Þa!º ßa—Õàa÷êáa‹=âaŸ
ãa$‡äaÉ� åaqVæa~¢ça’uèa�Œ éa�æêa…¡ëaÝÓ ìa£4ía[dîaIØïaÅ«ðaœ1ña{ òaEQóaŒÒôaÞÚõa(öa[Ž÷aÔ1øaE$
ùaâzúa0u ûavGþa�øÿa`S €bä‚
�b$‚b̓b³}„b?‹ …buQ †bô?‡bŒˆb}â ‰b_ôŠbÀ/‹bÜzŒbÏ‹�böiŽb*7�bBp�bÔÏ‘btþ
’b$“bG”b@c•bQ–b•ö —bbû
˜b�”™b¹i
šbüJ›blý œbH¥�b ¿žbs�ŸbØô b‘w
¡bP ¢bͶ £bjA¤bõK¥b*¯
¦b�§bÀ„ ¨bØí©bãªb»] «bøÀ¬bÈe ­b°»®bǯbã”°b?}
±bQ ²bI?³b}®´blÅ µb@U¶bØñ
·bA
¸b‘Ž
¹bÐëºbÊ
»b€Ê ¼b3 ½bÓ3 Àb5 Áb¯ôÂbMÃb_&Äbrî
Åb×Æb;¡ Çb«zÈboó ÉbÃÊbÑß
Ëb ‰Ìb¯* ÍbƒÎÎbF3
Ïb7; Ðb¥þ
Ñbë– ÒbZüÓb¢ÔbÚc
ÕbfÓ Öb?ž ×bãX ØbÛ5Ùb˜éÚbæ. Ûb�€Üb×ÝbªÞbDÎßb.} àbE
ábæ#âbÀ(ãbÜ‘ äb‘Øåb$-
æb ÷çbË�èbQô éb<üêbt:ëbf·ìb8kíb>¡îbè<ïbÚ½ ðbOíñb°c òbà* óbõ·
ôbZtõb)ë öb†,÷bHB øbÛ ùbZúb#ûb³€übUDýbæñþb.lÿbÇ”€czX�c¿Ê‚c“ ƒc /„cbö…c†cúg‡c˜pˆc{‰cœœŠc) ‹cé Œc�cíÀ
ŽcüŠ �c¼j�c.û‘c·1’cÛ'•cr¾ –c�»™cjU šc½Œ›cPÅœcÊ �cyÅžcŠÈ¡ccÕ¢cÒé
£c‹  ¤c�å ¥cðB¦cÜ
©cîEªc[2
«cž­
¬cï¼ ­c±®có¯cÉ1°cœ±cÑ ²c‘> ³cnð´ciµcDF¶cù 
·cÚXºc¯X»cÏ'¼cì.½cƒD¾c ¿csL Àc²» ÁcºÂc¦EÃc‰}ÄcµÈÅc, ÆcÿþÇc‡Ž ÈcŽ Éc­þÊc›[
ËcÚÿ ÌcÆ
ÍcˆÙÎc*
Ïcl†Ðc�Ñc
c
Òc0JÓc^í
Ôc�NÕc°Öc¤=×c\Øc!O
Ùc:y
Úc: ÛcTQÜc1xÝc)«
Þcßc,¿àc¦ ácÌ�âcèáãc™ÆäcŸ©åc&fæc0‘çcU‰ ècûš éc2Iêcò�ëc3í ìcè¤
ícߪîcÓ» ïc›ž
ðc+‡ñc?_òcZ×óc­.ôc~ õc3Aöc5‹ ÷cêHøc£FùcaFúcì�ûc<s üc ýc7þcˆ
ÿc¾I €dõu �d¨�‚d–CƒdJ¿„dÊ/
…dl†dÒ‡dK¸ˆd*p ‰d+pŠd´{‹d›°ŒdúË�dªÁŽd3Ò�dšÒ�dMŒ‘d“| ’d¼“dZ½–dì*
—d矘d/Á™dŠšdý´›d¸{ œdÞ0�d]�žd´
Ÿd"ò
 dX‹ ¡dJ&
¢d˜
£d;¤dÝä ¥dØI ¦d–>§d”�¨d°Ï©djœ ªdjÇ«dkt¬d¬ˆ
­dãt ®d& ¯dÿA°dA< ±dut
²dù³d•º´d謵d!`¶dÔÀ·dæk ¸dJ ¹d
ºdZ:»d€ ¼dÙD
½dê¾dpƒ¿d3­Àd“¯Ád–Âd%&Åd–ðÆd $ÇdYÊd#8Ëd÷5ÌdÍçÏd@˜
ÐdŽÑdX
Òdž
Ód_D ÔdŠÕdÏ~Ýd¸PÞd¨ßdAmàdß–
ádTâda} ãdnP ädŽØåd§wæd�*çd•3èd­j
ëdŸìdÕ`íd&úõdåéödûF÷d^÷ødJª
ùd:úd=uûdÇ% üdšÕýd(þdàÿ€e”Š�eŠ‚e¿6 …eC2†eé.‡ec~ˆe`ô‰eùïŠeVX‹eEŒeã‰�e<>Že»Ø�eÛÁ‘ed‚’eS“elÞ”e^‘ •e$C—e‚X˜e1™eÎDœe«
�e‡žeÁ ¦e²Ó §e@¼ ¨eaà©e@bªeû «eŠ ®eT¡¯eÚƒ °e<8±e¦²e™S³eN´em�µeå ¶eO×·eÃŒ¸eë‹ ¹e<=ºe¸Ò»eç÷¼eô¿eWÀeFÁeK=Âe½UÃe§#
Äe«_ ÅeÙDÆeìÇe|âÈeD†Ée¿£ÊeRáËe/Ìeè©Íe’ÀÎeòž Ïe,ìÐe—CÑebÒeúÎÓeÔª ÖeÁ™×eëØeLÙe#�Úe•[Ûeƒ«Üez ÝeÜ(
ÞeÄ1 ße’ä àenáe3Iâeè6ãeÿd äe}Ãåeï æe³uçeè!êe2¿ ëe8 ìevtïe/·ðeŒê ñe1ôeŒ9õe£˜
öew;÷eÄøew&ùeƒ2úeÖ(ûeHüe:jÿeì €fŽ
�f«Œ‚f«
ƒf'f „f�þ…fìj†f"É ‡fÖ‡ŽftF�fû&‘fä’’fmŽ “fè² ”f,•fº­ –fÍ¿—fÀ šf°Ü ›fÄÃœf×6�fvA
žf�©ŸfÈk f»‘ ¡fš†¢f)ˆ £f̳
¤fuc¦f$§fl ¨fA÷
©f-.ªfO
«f/U ¬fj{ ­fŸL ®f!
°f¬ ±fþ²fè³f9Y´f:
µfþ�¶fùy·f*<¸f¤ˆ¹f” ºfUq
»fJɼfq{½f.¥¾f
é Àf,Áfš¦Âf�=Ãfã„ÄfNFÅffÆfÐœÇf�ÈfŸÊfõ
Ëf—›Ìf`ÍfJ Ïf2
Ðf]³
Ñf¹< Òf2ÄÓf&,Õf®MÖfv(
ØfሠÙfÂVÚfvMÛf‚Üfîñ ÝfjO Þf¼ßf|æáfÚcâf¾�ãf6Käfÿåfø
æfº9çf¸bèf3�éfÅí
êfÁ. íf!
ïf¶\ ðfCvñfL¥òf« ófŸCôf&Ìöf øfÓ_ùf¨Eúf˜ê ûf™U üf' ýfÇXþf½€g‚# �g¦ ‚gÞƒgÅf „g•û
…g߃†g x ‰gÑÍ‘g2Š’gÄß“gÕÏ”g5 •g¸ž–gÅÖ—gÒ”˜g;‚ ™gçšgõ®›g’­œgd¨�gî=žgtq ŸgBœ gìm¡gùI¢g®ø£g™
¤g‰
¥gãa
¦ggò§gŒÎ¨g¦j «g‹ ¬gšD
­g¯z ®g�> ¯gØ< °gÑ�²g£Ã ³gѨ´geîµg-r¶gáñ·gÕعghκgº/»g­¼gAV½gÆÇ ¿g¦ÀgýÁgXHÄg†IÅg¢ÆgX%Çgþ¶ Èg�jÉg$ Êg ³
Ëg¥BÌg ÉÍg�Ë
Îg�
Ïg–Ð ÐgUýÑg)
ÒgëkÓg“îÔgHUÕg~lÖgß×gyc
ØgŒÜ Ùg‰<ÚgPjÛg¯ÖÜg ÝgØöÞgo{ágâTâgMãg,‘ägÊ1
åg±�æg»·çg¦èg‹Ú
ég»@êgÉÆ ëgfu
ìgësôgæí÷g–ûgDC þg›N‚hž
…h
‰h UŒh��h£
”h^á—h1K›hö žhgx¡h¢Ô£h·^¦h]�©hFë¬hú¿¯h�u
²hÆ µh&OÅhç£ÇhôÍhs¢ Õh™ZØhû°ÛhýßhÉ" âh��åh® èh9hëh>� íhTg îhón ðh]¯
ñh-xóh³ø ôh
j
öh?¤ ÷hqúh®Òýh–Ü
€i,Sƒiœ
†ivÑ ‰i ß�iÛ˜‘iay •i/š˜iÄ
ži8ê¡i ¤iÖ¬§iRªiq&¯iqã´i\Y·i}x½i6òÁi#ÑÅi¶£ ÉiF$ÌiZ¾ÏiµSÒi˜"ØiÏ"Þi9Œäisl
êi3E€jMp �j9R“j­±—jÜ‹›jõ_Ÿj£jtÀ¦j˜‘«j] ¯jÓ<³j®f·jƒì»jU»¿j[m ÃjR[
ÇjQ Ëj¥*Ñj$Öj�¿Ùjf` Ýjùàjö‚ |æŒMŽ˜Ê �Ø(’Æ ”S]–|'˜qFœ”Ò¥$.®ú5·FÀt»ÉWÚÑfV"t#gÓ$zð%Â<
&M«'ÕX 5j§6÷< 7pÒ8a 9HÖ:…µ;¯8<N=í>åÓ?@me AΖB¡ü C�JD[„E FÀG&bH|sI|ëJû
KjULRÛM� NôVO¼ÜPŸÑ Q¯kRêú S�PTœ% U9f
V€œW…¿XUY]ZH[åC\Ë>^U)_·�
`M aI©b"d
cQ%dbÌ{nw„;’…³©†+}‡ÏɈ«ð ‰��Š—j ‹*êŒ%è‘
åp†ôK9 öeC�Úò‚ÅÝ
ŒĆ�‹<Žiü�ï/�4Œ‘Hƒ’Z(““”ñ´iñµÑ›
æ·Gd ¸‰Ÿ¹Ôº·â»¶m¼X}½® ¾R ¿LÌÀEA
Á²0Ã?qÄŽT Åï� ÆÁ2ÇÆpÈHÉ'¨ ÊrË„Ì € Íæ ÎÃÚ
σÿ Йš ѳ ÒÈTÓgMÔ!i Õ�Ö¹+׺…ØåÆ ÙbîÚæðÛÃÅ
ÜSOÝäßvá~âÃ%
ã}0äñÓåÝæ[çVÆ è~ü é{±ê5½ ëL·ì
í0
î$3ïkð¸èñv;òpóZçôu©õ­¡
ö4à ÷-Ìøß@ùÔÆúc]ûÌØüÜÑý2” þ]•ÿÄ;€J�§u‚¬Øƒý’„[Ç…5T †–„‡¼° ˆŒŸ
‰ðe ŠUü‹³ýŒ½¸�ŬŽiù“åS ”lã ׎]
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ø HÙ„„ÚÞÛïÚ Ü5”ÝÃäÞ ãßð2Šñ/Où0ú"€
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
œÙ�¶V
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
žÐ{¢Ù^ £¡n
¤¤õ
¥ær µ1ðÝèñûÐòh
ó)k ôp½õß— ö… ÷ðø/ú‡§ûß,ü
òýO[þ‰ ÿ΀Šl�Í/ ™P*š+Á
Reference in new issue Copy Permalink