pima/Trinity-DevPCB-V1.0
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
5e3dd3128b544c5df5f3e5b62e12fd71d522a38e
Trinity-DevPCB-V1.0/Debug/USB_Device/Target/usbd_conf.o
T

2409 lines
1.3 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(|{˛ł´µ·¸ąş»Ľ˝ľżŔÁÂĂÄĹĆÇČÉĘËĚÍÎĎĐŃŇÓÔŐÖ×ŘŮÚŰÜÝŢßŕáâăäĺćçčéęëěíîďđńňóôőö÷řůúűüýţ˙ 
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopq€´…°Żx`Ođ°CÚlOđ°A{hCËdOđ°CÚl{h@ű`űhż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`ń\"`Z`š`Ú`ań P"!F˙÷ţ˙{hh#J“B>ŃOô€sű`#;aOô3{aOđs»aOđSűaOđ€s;bOđ€c;dń F˙÷ţ˙F+Đ˙÷ţ˙ ˙÷ţ˙OôŔSűe#;f#{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ń\FOđ�@˙÷ţ˙Ođ€`˙÷ţ˙"! ˙÷ţ˙ ˙÷ţ˙żp7˝F€˝żh@€µ‚°Żx`{hh J“B ŃOđ€`˙÷ţ˙OôŔQOđ�@˙÷ţ˙ ˙÷ţ˙ż7˝F€˝h@€µ‚°Żx`{hÓřŘ"{hő&sFF˙÷ţ˙ż7˝F€˝€µ‚°Żx` Fűp{hÓřŘúxyhF›DŰ Dő˛shűxF˙÷ţ˙ż7˝F€˝€µ‚°Żx` Fűp{hÓřŘúxyhF›DŰ D$3hűxF˙÷ţ˙ż7˝F€˝€µ‚°Żx`{hÓřŘ2F˙÷ţ˙ż7˝F€˝€µ„°Żx`#űs{h[y+Đ˙÷ţ˙{hÓřŘ2ú{FF˙÷ţ˙{hÓřŘ2F˙÷ţ˙ż7˝F€˝€µ‚°Żx`{hÓřŘ2F˙÷ţ˙{h[z+ĐKiJCđaż7˝F€˝íŕ€µ‚°Żx`{h[z+ĐKiJ#đa˙÷ţ˙{hÓřŘ2F˙÷ţ˙ż7˝F€˝íŕ€µ‚°Żx` Fűp{hÓřŘ2úxFF˙÷ţ˙ż7˝F€˝€µ‚°Żx` Fűp{hÓřŘ2úxFF˙÷ţ˙ż7˝F€˝€µ‚°Żx`{hÓřŘ2F˙÷ţ˙ż7˝F€˝€µ‚°Żx`{hÓřŘ2F˙÷ţ˙ż7˝F€˝€µ‚°Żx`,J{hÂřŘ2{h*JĂřČ"˙÷ţ˙'K(J`&K"q$K"Zq#K"Úq!K"r K"ZrK"šrK"ÚrH˙÷ţ˙F+Đ˙÷ţ˙{hÓřČ#"!˙÷ţ˙{hÓřČX#"€!˙÷ţ˙{hÓřČŔ#"�!˙÷ţ˙{hÓřČOô�s"!˙÷ţ˙{hÓřČOô€s"‚!˙÷ţ˙#F7˝F€˝żh@€µ„°Żx`#űs#»s{hÓřČ2F˙÷ţ˙Fűsű{F˙÷ţ˙F»s»{F7˝F€˝€µ„°Żx`#űs#»s{hÓřČ2F˙÷ţ˙Fűsű{F˙÷ţ˙F»s»{F7˝F€˝€µ„°Żx`#űs#»s{hÓřČ2F˙÷ţ˙Fűsű{F˙÷ţ˙F»s»{F7˝F€˝€µ„°Żx`FFFFűp F»pF;€#űs#»s{hÓřČ»x:�ůx˙÷ţ˙Fűsű{F˙÷ţ˙F»s»{F7˝F€˝€µ„°Żx` Fűp#űs#»s{hÓřČ2úxFF˙÷ţ˙Fűsű{F˙÷ţ˙F»s»{F7˝F€˝€µ„°Żx` Fűp#űs#»s{hÓřČ2úxFF˙÷ţ˙Fűsű{F˙÷ţ˙F»s»{F7˝F€˝€µ„°Żx` Fűp#űs#»s{hÓřČ2úxFF˙÷ţ˙Fűsű{F˙÷ţ˙F»s»{F7˝F€˝€µ„°Żx` Fűp#űs#»s{hÓřČ2úxFF˙÷ţ˙Fűsű{F˙÷ţ˙F»s»{F7˝F€˝€´…°Żx` Fűp{hÓřČ2ű`—ů0+ ÚűxđůhF›DŰ D3x ŕűxđůhF›DŰ Dő©sxF7˝F]ř{pG€µ„°Żx` Fűp#űs#»s{hÓřČ2úxFF˙÷ţ˙Fűsű{F˙÷ţ˙F»s»{F7˝F€˝€µ†°Żř`z`;` Fűr#űu#»uűhÓřČůz;hzh˙÷ţ˙Fűuű}F˙÷ţ˙F»u»}F7˝F€˝€µ†°Żř`z`;` Fűr#űu#»uűhÓřČůz;hzh˙÷ţ˙Fűuű}F˙÷ţ˙F»u»}F7˝F€˝€µ‚°Żx` Fűp{hÓřČ2úxFF˙÷ţ˙FF7˝F€˝€µ‚°Żx` Fűpűx+Đ+Đ#ŕ{h[z+Đ˙÷ţ˙KiJ#đa{hÓřŘ2F˙÷ţ˙ŕ{hÓřŘ2F˙÷ţ˙{h[z+ĐKiJCđażż7˝F€˝íŕ€µ‚°Żx`xh˙÷ţ˙ż7˝F€˝€´�°Żx`KF 7˝F]ř{pGż€´�°Żx`ż 7˝F]ř{pG€µŻ˙÷ţ˙ż€˝€´…°ŻFűq#űsűy+آRř#đż-39?#űs ŕ#űsŕ#űsŕ#űsŕ#űsżű{F7˝F]ř{pG &÷~
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
,ëaI çDçŔŕ rťć s8 tIB u“} v%{÷&|Qâ~ó  hŮ (•
‚XR‹)” 
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
íą¦M ‚ľ
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
ą“nbµ@Ťô ˝¶ ę±
›bĘŘ Žá˘ťč
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
Ď[!ý—"u=#¨v $Y{ %ë˛&Żt'¸' (k@ )üÝ*o+Ô,,bă-.ű /00éL1ç'2ĎŮ3ĘÝ
4”Ł5®D6ě·7°´
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
8‚J 9Ľ:˘Ş;�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
<ĐN=›ö>´©
$˛ “*ß-+\+ Ş!"č9 DŁ
ú ą5 O:—’Ç©
’ 'int˘Ë ę•
ú]Ľß$n ł
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
0.‹Ś¸ĹŞş�S›»‹TzĽ‹Ů:˝‹
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
SCRľ‹
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
CCRż‹
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
SHPŔŐă¶Á‹$3! ‹(÷Ă‹,U×Ä‹0Ś*
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ĺ‹4ňŰĆ‹8WÂÇ‹<
PFRČď@
DFR�H
ADRĘ�L—Ë PvęĚ#`§˛
Í(tT΋� iŐ V Ĺ �ę VÚę � Vô � V 8 VďvĎ• T V,Kę‘M‹˛D N‹Ą O‹(_
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
IDRQ‹
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ODRR‹Ä7S‹|3
T‹
AFRUú
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
BRRV‹( ‹ú VęyWT(�ľ b
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
CRŔ‹MNÁ‹ŽÇ‹™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
Ă‹ J¸Ä‹§˛
Ĺ-Ć‹v3Ç‹(Č‹ ˛şÉ‹$› Ę‹(ňˇË‹,!AĚ‹0±˛
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
ă΋8ăĎ‹<;Đ‹@X˙
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ń‹Df%Ň‹HÖŇÓ‹L�rÔ‹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
ŐTăxÖ‹Xěx׋\˝ Ř‹`ńšŮdJĄÚ‹hĐN
Ű‹l¨@Ü‹p+›Ýtć�Ţ‹xń�ß‹|ż ŕ‹€ł
á„”aâ‹�ł
㌏úä‹�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
CSRĺ‹”ĺć‹�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
č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
ęD á4 ë‹HS
ě‹L5
í‹P9ł
îT<0ď‹XG0đ‹\D‰ń‹`Ŕ(ň‹d©Ďó‹h@r ô‹l
oő‹pĺďöt�r÷‹xĄrř‹|đIů‹€‰ď
ú‹„ r VM°ű \ě,
ă?îz§˛
ďzFđz±˛
ńzxMňz»˛
óz
“Sôz ńšőz]öz+›÷z$eřzł
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ůz¦múzł
űzźuü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
ý<
´—
ţz@/ł
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
˙zBŞ€zD9ł
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
zF
FNRzH–ł
zJ“ózL ł
zN/~zP’žzRzTŇł
 zV›
zXÜł
 zZ z<
V,
ús  ~xf
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
ĹÓˇ •~†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
,m
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
]áŚEÔ5ž
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
) / Pin 1 �e 4 Ăx 7 R} :  Éś =  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• ©
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
< ]č<
@ ]w´
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
E ]1
G ]
I ]Wh
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
K ]‡Ů
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
Ol num
Q
]
C
T
] =
W
]Öa
Z
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
]
]•~
a
nŮĹ
d
nö
g
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
‡N
j
] ‡
n
Ş 
q ú­
s
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
u
|Q
w
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
 rs
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
zˇ  1Ł ·é
MŁ� ę�řF _µ 7x Ł  ;Ů �!�(�/�2ˇ @´  Cţ 9ŤM^GS Fĺ ô-
WA
¸ň X• ÇJ Yl *Ü b ď
C– eď
©g f
:; gi o hô
K>iô
P&«
j·
�̶ kŻ ‘÷ó l‹”ću m�#ˇ
nŮ ČŮloĚ˙ó r Đb*u ÔXĂwĂ
Ř
"
 V  V × Ś.
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
 u  ;  @  E   …ĺ  MŹ %P %k{˙ ' Ü +u8Ó 0 Jă
4 }„ 8  Úó < $â @ (É C ,.Ó G 0«© L 4 P 8˘Ě T <¬ W @U Z D9#
^ 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
a L9ú e�8č M
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
Ç
]l‰
Č
]Ý
É
nt_
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ę
nŐż
Ë
n™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
Ě~ É8ő˘©g
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
ř
Yću
ú
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
wŚ°
ű
‹ F8
ü
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
‹A7
ţ
YA
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
SOF
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
Y$GÎ
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ľ{
¤4]] »+,‹
Ü
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
iY
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
id
k]ăŞ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
lG
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
n fŁ
oÓ°
p&'P
q&TcÇ
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
s�Ý
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
tiś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
uiťM{
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
v]ž5˙
w]ź\
x] ĽL
y¤żW
z]¨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
}6´
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
ĽçĹ
€PŔŁL
�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
Ě}+
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
†Ř ˘]rr Ě ^]‹ | źź n ��Ô
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ř!Óçß
;m.C
/1
µ!N˙ô(¶Ă ŞÇé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
%ť 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
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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Ú°
4 mY
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
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
6 ‡
7 n Ąî
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
8 ](
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
:  ¦k
;® 6 V ˘ KK V © Ă
` VNň
Ť»,o0 +"1
?
­ąj�˘G Vłł] Ă… N’
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÝÝ]  âw 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
Ý] Şp
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
"Ý]iŠ
Q’
=Ý]Ňť P’
XÝ]Ú R’
sÝ]ž“ M’
ŽÝ]€Á
L’
łÝ]n]đ^ 2’
ÉÝĂ˝ 1’
ßÝ
+^ Ý’
őÝ
ŠĆ 2’
Ýnn
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Ý-)w k
ů· zOO `
#ŻyjO
gév…O]
E%w O]
ÉsO
"RrĚO
üâpâO
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
B qý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
Đ[uO
2 n3O]
+ mSO]
ŤlnO §o�î…ź !™™ ˙gĽ±îK Îî
ä ć™ć  "·Z,ă� .’
 k.Ŕ±"XśIĄq
":’
‘oµř$‘w/©3
ś0x ś�#p Ă
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
Ă
śż2&#‘t1memż Ď V‡ńcöśőíX
ö‘t˘aŇlś*ó1Ň0Ý‘t#msgŇIţ ‘s@`Ä
&śeâĹÄ4O‘tbÄB]‘sP
˛BśŕâŲ?O‘lb˛M]‘kb/ ˛_ ‘d2&˛n‘`Ąq
´’
‘wµřµ‘v“˙žBś[âĹž9O‘lbžG]‘kb/ žY ‘d2&žh‘`Ąq
 ’
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‘wµřˇ‘vVáŠ>ś¶âĹŠ>O‘lh
ŠL]‘kĄ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
‘wµřŤ‘v$Cť
v ]XśâĹv/O‘lbv=]‘kó1xÝ‘t1d>ś\âĹd=O‘lbdK]‘kĄq
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
‘wµřg‘vv/R>ś·âĹR8O‘lbRF]‘kĄq
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
T’
‘wµřU‘vŹĺ @>śâĹ@8O‘lb@F]‘kĄq
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
‘wµřC‘v8;.>śmâĹ.8O‘lb.F]‘kĄq
0’
‘wµř1‘vŰa LśčâĹ7O‘lbE]‘k«ŘV]‘jÎ)hn‘hĄ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µř‘vý6ś3âĹ5O‘lĄq

’
‘wµř ‘v‹> ÷6ś~âĹ÷6O‘lĄq
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ů’
‘wµřú‘v{Ůć6śÉâĹć7O‘lĄ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
‘wµřé‘vTĆŁÄśôâĹŁ5O‘të-Šśó1Š4Ý‘t3É vś@ó1v1Ý‘t®ď
b$śvó1b9Ý‘tŔíbG]‘s)|M$ś¬ó1M:Ý‘tŔíMH]‘s¨�.8śŇó1.0Ý‘tDĚ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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śřó11Ý‘tćâń<ś)ó1ń/Ý‘lß| ÷Ó‘wĐsÝśLó1Ý-Ý‘tQ
É4ś}ó1É5Ý‘tŔíÉC]‘sIĺ´6ś®ó1´6Ý‘tŔí´D]‘sÜź$śŃó1ź4Ý‘tÜs }8śô�Ů}+Ý‘tµ IĽś5 �ŮI)Ý‘Ś8WL ‘dB‚Mk‘”%G
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
&ś[ ýw 9‘t%ă‚«2ś‘ ýw «8‘lJô­‹‘t2Ĺ×
2śýw 8‘lJô‹‘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
: ;9 I8 ( I: ;9 I
: ; 9 I8 
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
: ;9 I84: ;9 I: ; 9 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
: ;9 I8 I !I/
.?: ; 9 'I<.?:!;9 'I@|: ;9!I.?: ;9!'I<$ > 5I
:! ; 9 I8(
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
:!; 9 I.?:!;9!'@|> !I: ; 9! : ;9! .?:!; 9!'@|&I.?: ;9 '<'I : ; 9! 4:!; 9 I
: ; 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 !>! !I:!
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
;9!".?:!; 9 '<#:!;9 I$.?:!;9 'I@z%.:!;9!'@z&% Uy'$ > ( : ;9 ) * : ; 9 + : ;9 ,4: ; 9 I?-.?: ;9 '<..: ;9 'I@z/.: ;9 '@|0.?: ;9 '@z14: ;9 I2.: ;9 '@z422&Ľ8$64<48$$Ä666L>>>>X>BB&l Xă22&Ľ8$64<48$$Ä666L>>>>X>BB&l XĽţP ĚkîŠqX� ŕ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
8Ą


?˘JE6Ł€Ź-™€Ř !"†#á$Řä%č&“'ě ’(đ)ô*Đ+ř,Ś 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
“ć”-yx . /şś0kU1˛ s92¤3Ä4´5ţ6±L¸7Ţ8Ů:·9 :u;p<ëŰ=>e / 9!1"?#$.%@&A'B(C)DE!Fbő "GŚ
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
IP
J K=L M ±c
I!N+I@/!O!P
÷#QÎR!S
TüK
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
˝UV$!'ň(WUXYšŐ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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!Z´˘[ W
D˘\a 
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
]î' ^±ŃL´¶_Žô ]“NŽ _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
·Ŕ¨k
B)… ´¬jĚ Ýżl )cb¬ú
r“yTQ™Ô�á
{�iIÚ ©¨@ßś™„(Ě;?ľ
>•
Ż
{8bň
Z6ś
wOxpúň
şceVF¨Ó
Ź.ţ•N ŃŤ
Ż·éőŹŐ
ż™›$ZZ‹řvÝë?‰°’E{ ZsŹY*
‹%Ţ {' [ĺbĽ\
ŕ´ y‡ Ů‹A Śî
 ` ĐĹ 7§x^ÔÝ
w„ 1ö P, ř I‘RŢEKŹk 7�
O°[;
GÉ®ůOđdĆ ť
?Ó
«±�ţ
–C‰ľ tk‹7 ˙uŘß•*
 Ͳ :?ĘW-so 8‘Ç‘ + jTł<hŹŹlW�ágÉü‚ľ%ž\
ŐX
d:
ďü\
ę$ÜKU  ¨ ďT  ‹ a
JNIZ.¦můk® ”ú’¶ ˘ąmŃë6ÍĚ ¤v*^p¶î3 ĐiO÷ qÉŘźa »ŇäWZ©´V3× łŠÚ}
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
Ż€J[¤ŘŇż­
.(ŃČ źäKż2ĹŠ‰Ģň ëR GbZĎ
óěq%Ň„ů˙Ăó†Á•^“8v¨…®[
ňI$Ă=Ą˙
LJ©­^ą.ů ÚN
.Ăm ď¨;J`K
ĺH0a
M3­â˙ü
ç_αýCGě M
M~ŻÜ×R©+ß’{"2 C·Šk<Ĺ2=,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
© wW>
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ů¦,> ˙®ÔĽH 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
»Í ,C𵠢Ώ ß
÷w
P0]˝Ě ů^`‡
Ăü 
b˝ô4x µęiúÁ »oŠísŤćqí6g )KhiŞóă{ ű ĘŔ
(Ďb� @ćb´ţW&ŕËĆ©za@C lwěx„"
jVS»Ă«vŃŐx ˛şVFT¤‰â#@gŐ
‚Š|¬ä×
ýp �í bť ŇŔMé
nůÁĚő ml)\
´ŐĘ%—‰ëîņ­î´ pmsŻ†UcpEĽ +Á»ś´}�—â¸ŕK(đé2Ť^:,s ÄZÓKĺ» •Ńô· ŕŘŚ �Y.Ô${
)8˛ś ŕÄż4� Yoż
罪
ęZ˛ré)»ßЬ㇠BÇńÜÚ)
‘?«®îňĐ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
 �
�A
+C/ăÚQ
f–U  E} ®‚_¤Ž;á
�˅
cŐ
ýęPW•Ńesî ŘŇf/
Ż =Ö © ⍧V»GŠĐŇhüI¶‚Ůť Đw…Ĺćq‹?u á’ë ůH ŰîQőĆÂwđżŽâ2f4´ł^ n%‘füÎ
˝ň݉HP=bZ0Hď70� Vˇ]n *J§ĚW $˛)0k* ĺ+PI0
4› 8˘Ä
9+�
>ë4 ?­ë@ß! AăşBĂěCoa D) Fě® GxHä{ IHĘ
JŰ{
KłĺL FMăž
NÚnO$ŇPmŔQę~
Rz~ Si6TÍ
UVňVYW‡ß XZÂY˝b6´f6¬nĚ,wDÁ~ťŹ †Fc�
�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�w»ś'•ĄŘ°S±\đ˛áhł&´ktµÇt Ĺq
&đU 4MëFLG™ÉHđ`IÓJJIň $fW0ől1*42ym3ĚB4…¤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
 oŃ!0ş(´[’Ž“cő—€ű�—ń ™ĽšV¸­_ ®ś&Źt•ç>ť�qĄa)
°¦ö´@‹
şQÓ
Ě�ÜboîňH¬—ůŻ!źł/ÜŁ=ĽĐS¤“m«ÖŚo„
¦s¬ĽXÎUôVď 
o„! +5ü,Ź -8č.ůa
/int0/ 1¶s 2M 3Ú
4™Ă 5|e6Sč
7�d8Ww9Jg :€pCÝmJqČ RŐ�]DŔh*(
q×ýxţI�ň�ŹÝ “Ţi
—%ۢpÓ­«|
j¸5üąŹ ş8č»ůa
Ľint˝M Â/ ös 
0J>n%a
!9ě %µé'ľß-!
1“ł3ô°
9]â=!ö?zű
Dĺ IRÉN~Č SöQ
·‹á3#Ń� )rB 5ŮB?ĆđI§Sě€,3�‚
‚đ�ëż™Ţóšž˙˘�˛ ŁÝô¤‚´®1‚
ŻĽ0 °F¸"§ąýžşHÄßęĹ„ Ć
FÔ¸8ŐÚÖ#BćO©ç§ č(XöoB÷ő řÆ0 ‡ Ĺ�DŚ
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
—ćÄ�ä¦gŇ §U¨If$" ·˝]¸8ĆíŹ
Ç�JĎUNׯ¨Ý
ě ެ
âşć+$ëˇdöi�€Í…ŚËŚYŮ Ťc}
�Ď ™W¤cÜĄ‘±F ˛|}Á$e
Âh
 O„#ş$ö%PÚBíDCkć DIGö¤g0ČZ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
)«‚ , /Ą< 2)5R¨8+P; >tă
A§dDË� Lq T„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
\”K
dDl´[o0€rű’ uQ]
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¦[›
ŞY®4ä˛T;
V­ţŠM˙a€u°‡]}ŤT•™4ś6O ŹÎď
Ô yTä \™‡răŽŃř
äîcç&s® �ŰńZÝĺ* ŢŻ: á÷Y â’Žăś�”5K•2š
—Ww �ăjšPΛ}ť3ž#ß
 tĽˇŰŕŁ4_¤Nóµ©× gSŃëĄ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ŇgP Ô¤~ŐA˙×OŻ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ř)ťÚ ŰĆZ ÝűúŢ7¨ ŕéłá.ă’Łä)ÍćQűçsX éÖĐęą‘ě1h ílL €vę�Ľb�§„ď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
©}ŇVńÓ9ŐŁÜÖ—ćŘŚÁ ŮcżŰ|Üu»ŢÍzßäôâ´B
ăßÉĺ|¨ć@´čä8
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ég ëËf ě&}îs ďîýńęŕ ň¨âôtő"„÷ˇ†ř÷f ú­µűY[ýáţ&±�Ă"
‚V…qĆ�F‘ ‰ŇË‹Ć‹ŚÂÚŽqŤŹ€Ö‘›@ ’¶  ”˝ü•:—ś �z·›#śßx žż&źŤŕ ˇ� ˘*Ą±¦Úň¨éĹ ©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
¬Ľp®X{Ż¬2 ±…˛ß ´Š@µQś
¸@pąőm»�őĽ›
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ľrŮ żă(ÁjšÂÂŔÄPĹĽ9ÇĎČe†ĘßęËż-
Í›VÎŇśĐć|ŃůÓŻ Ôk“Ök3×SzٶM
Ú “ÜNâÝ, ß ŕľă Üä’ßćô
çÉ`é›: ę íâĘîR�đŰß ńzeóK{ôöÓ» ÷Ó ůéŃúßPü×» ýÓ €Ź�Ě�w¶„v3†3‡®‰ĐG ŠŠ_Ś‡XŤA
Ź1Ľ� {’N,
“ř4–$—ů ™�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
ť8 źE *Ž˘›cŁ˙“Ą?j¦ąŢ ©aŞ+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
Ż
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ď°ŕł"§ ´2Ň \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
ą†Ť ş3�Ľ ˝ĚŽżɉŔVČ ×“‡ŘĄŐ Ű;–Ü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
�ÔK�Śś„t‘†Â‡űď
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‰üČ ŠíhŤn4Ž¦z‘ż~’JO•µ}
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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웎žś”
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Í,ŕÎXÍŃ„ţŇV¤ ÔŐá
Ő'×c˙Ř�D Úf@Űo
ÝŽ ŢoŕţcáňT ă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
ä'ţć%)çöP
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
饴ęôíWú
î“đ#ń˛ óÔ5
ôŤą źâ±  á!˘ťZ Łí ĄΫ¦»=¨[Ó©¤ś« ¬2ő®@bŻř± ‡ ˛Äű
´ůîµ+a ·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
ľHŔăNÁ(ÉĂ�Ä™�ĆĆnÇ{mÉŔíĘĂq̶f
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
ĐAŇš^ Ó÷© Öܱ ×ŕźÚËT۱żŢ++ß
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ű âŢçăľhć¤ęçĽ ę}Zëä‡
îm_ďÎ#ń"µ
ň–Ü ôw=ő&b÷czř§„úÄ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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đý^ţäd€({�ľ�MQ„!?†lď ‡•î łÇ”´Ľ—·UH ¸ĺ »1e ĽB¸
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ľ6Qż¶ŮÁö8
 UÄv—ĹaiČ­+ Éťôˢ˝Ěa˙ĎäĐ„– Ó[Ô€3
Ö›á
ׂ& Ů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
Úî#Üe8ÝŹÚ ß­ŕP9ârf
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ă-! ĺR\
ćÓWéŢ€ęŠŃě$eí`_đxŻń*îóąôWřö3=÷şŠ
ůJú,śüä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
ýˇˇ ˙ˇ˛€ ˘‚ iŁ� N† í‡ sľ‰ ôŠ żNŤ ‚óŽ –Ű‘ Ö’ = ” ¦
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
• �[— Ë� 3Řš Ţ  › q ť A+ ž F   +R
ˇ ­Č¤ Á"Ą Ý>§ ëę¨ ]*Ç T Ę ů§Ë 5µÍ »~ Î °ąĐ 7ţ Ń r Ô $…Ő �× §%Ř Ů3Ú zPŰ éáŢ UDß Ŕjâ Ą‡ă éEĺ ›ˇć ˘Fč ©» é ž…ě Ľ•í Q© ď �3đ
ň ßAó O ő źřö ë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
ů íý ű hśü d> ţ 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
…
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
ž Ą
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
[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
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
�®
Úô°
@±
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
w ł
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
N9ş
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
`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
/ŰÄ
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
îÓ Ç
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
VtČ
�ĐĘ
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
}Ł Î
ď6Ń
60Ň
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
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
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
ÉÔ Ý
†ÇŢ
»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
fmă
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
xTä
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
í
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
đ
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
Ű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
�Ç ‘ [W ’ ÷ß
” –• C-
— í™� kš FĎ› Żiť 7Ńž Nd  9ˇ Fg Ł Hť¤ �!¦ ú
§ K © Ux Ş ’+ ¬ 
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
˛ ×üł 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
· pą ~oş Ęý˝ Ú_ ľ íŔ 9«Á Ă IŽ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ä *ŃĆ +
Ç [˛ É –í
Ę Ť–Ě ¬€Í b Ď 'éĐ Ň-Ň �ů
Ó ˇ}Ő ˝F Ö ŰüŘ ÝťŮ k¬ Ű dĽÜ <Ĺ Ţ S�ß 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
á Ńs
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
â ëKô @ü jʉ î Š =v
‹ Ż‰Ś –Ę Ť Ňö
Ž ţ{
Ź I� •W ’ Í»“ ó©” Ü• úŕ– Í — @
� ů-™ U¶ś 8Âť #  ú÷ ˇ JńĂ ĽőÄ ľˇĹ � Ć «ĽÇ Ť;Č ˝(É 9’Ę gńË çŻĚ „Ŕ
Í ą�Î pŁ× zĆ Ř đ”Ű �nß Ŕvŕ Ö“á Fâ 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
# $‹;%&i¨'Ž6 (}m )Â!*Đ+Vű,y›
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
- Ź.^‘ /ąĹ0˛Ĺ 1x�2^ű34OX5ńŚ 6€7˙( 80č 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
:YU;ÎN<¶! =ňŮ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
?�Á
@•A†žBĄ' Cî�DÚ¸Ki´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ž2 {8š…g…�ů( ťP˘b3
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
§úŠ¬Â±ď‰ –%Í—87�„Uť¬ž:e
źťS  I˘? Łúł¤śu§í¨đW©ŞŐH­68 ® Ä Ż€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
±_¦˛®ł1Q´Áe·NŞ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¸kXą÷! ş¸
» :
ĽB0 ˝«>Ŕ‘× Á”/
Ăü«
Ä28ĹÔ
Će…Ç{· ČhüÉÓ›Ęç÷ Ë'Ě  ÍĂuĐń‹Ń Ň,iÓ)/Ô(ťŐY(ÖŐ� ×3]ŘřŮ%
ÚĺYŰ®hŢN
ßrů ŕ)ôáŮ âzęäJ7ĺk»ć{î ç×Í č, éx?ę9Đě©˝í.† î“őďćđťŇ ńÝM
ň
’ ô�Ś őĐ‘öbŔ ÷ŕ� řy˛ ů°CúëűU/ü`ý`˙ţq˙0:€Ż �fň�ĺ" „Y …�‘†ýž��˘
‰ŚµX Ť?�ŽXh
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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’i•”ů†•G— dš2›żž ś€ťšAž·Ú ź" Y͡WŹ˘ŇűĄ˙·©pŞĘ:­Čź ®ł÷ Ż?
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
°dx»ŰŤĽâ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
˝ľs
żţcŔ݉Á>
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÂÖTĂ®±ÄŢ€ĹSg
ĆĽ€
ÇÁ Ęň
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
Ěl9Íş™ÎXűĎĄ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
Ó’ÁÔŐĂ—ÖŞŞŮ.' Ú• ŰúÔ
Üx
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ý“M ާŤß‡Ńŕ±â(ă-šä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
ć Q çO� č€-
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
éŇl ëĺa ě}1í/¨îcďÎ
đÓ: ń�ňňöójô�ő4”
öÓ÷ř‰řK�ůŃFűT"ü0Ü
ýÚ@ţjú
€ Ţ� }
� 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
Š "‹  Ś wŽ ńŹ ň‘ M4 ” üŢ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
• 1 – „— Í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
� ŠZ™ ŰD š NA› ĺ*ś Űwť ź‡
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ž \őź cg˘ %c
¤ Ú"
° \=Ĺ ě:
Č ±|É ©Ę gB
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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«
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ď ÷´
Đ D
Ń ĽŇ z<Ó <Ů Ô (s Ő güÖ 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
iŘ ˛¸
Ů É|Ú ŮŃŰ —ľÜ @ Ý Ć-Ţ źß Žúŕ ű{á ö!â šě ă N ä Đ0ĺ °Đć rMç q
č .x
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ë <Ně ađ
í ‹· î cC
ď )Fđ Ą�
ń ;Áň ýpó Y€ô Ďő …]ö GŚ÷ ‰; ř bů ú ’ţű śŽ
ü ý 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
 ‚
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
:ˇ
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
ˇŢ‹
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
djŹ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
V'�
Ť3‘
9H ’
çÁ“
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
gG•
ˇă
–
é<
—
ÇÍ�
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
8_›
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
äî ť
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Źž
jŕź
!´ 
-�ˇ
R˘
ýŁ
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
żď ¨
kp©
ěfŞ
´
«
ŘC®
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
˛
Š—ł
”
µ
ćđ
ł¤·
cś¸
?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
÷ĘĽ
!S˝
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
Ŕ×Â
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ů Ă
4U Ä
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
(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
˝Č
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
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
ÚŐĎ
€ZĐ
f2Ń
͵ Ň
‹ĎÓ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
24Ô
K Ő
éh×
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
âŮ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
VýŰ
ty Ü
N5 Ý
ß/Ţ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
Vx
ŕ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
9L â
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
®Ŕ ć
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
Mčč
€D é
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
HUę
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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î
čňď
Ľ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
8
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ň
äó
ÇÂő
Cs
ö
đÁ÷
ź‰ř
9»ů
µ˙ú
W­ű
,Ÿ
‚Dţ
¸K˙
Â〠ʤ� Ë®„ J1… ź,‡ ër � �_‰ łç‹ ~MŚ ¶ŻŤ Í
Ž O/Ź ŢÂ� Ńč’ cî “ ';” ’ď• Su
– ĐŞ — &ů� ĘŇš NÝ› ó…
ś Ažž
Íź Ń  }
Ł ĽŰ¤ \G
Ą ¸4¦ Ą§ 1§
¨ ĽźŞ ”Ź « ̬ ĘŤ­ €•® ¶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µ �Ţ H̸ î*ą Ľ ş dŤ » \UĽ �č˝ 7 ż E�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ŕ »Á _ ‰wĂ š÷Ä şś Ć �$Ç óYČ šřÉ o‰ Ę »Ë R!Í M<Î �Š Ď ‰~Đ (Ń Ń ßÉ Ň )Ô K"Ő }wÖ Ř
× y`Ř Şí Ů ŤßŰ Đ�Ü Â(Ý “éŢ iŇß @fŕ přâ J ă 1 ä Ďtĺ Úôć wqç Ľ ę ľIë _žě ”˙ í 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
ď Łđń ‡6ň @ ó Ő
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ô vˇő 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
ö !; ř …W ů TŇú ´ű űŔü ËJý ¬2
˙ «ŕ€ Í.� Č‚ e � Üë„ Wц l©
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‡ &ó� `i‰ ?
Š µ‘
‹ ëyŤ ňűŽ ŤOŹ )/� : ‘ cŃ’ ­ ” w• îá– öş— ĐJ � Ź×™ ­Ă› 4Äś ]Đť Kn
ž ‹—ź E{  YZ˘ AöŁ Ő¤ 5 Ą l–¦ V! § Ď Ş pi« �p¬ ›­ Ľ® SµŻ J®° IH
± 
˛ 6đ
ł tÍ´ · µ ý^ ę · ¸ ěRş  » |‰ Ľ ›Ë ˝ ćw
ľ vŽż ĚůŔ áÁ BŽÂ 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
Ă ˘Ä ŔÉĹ LcĆ ¨‚Ç MČ %= Ë [* Ě 8ÇÍ s Î .ŠĎ řĐ źÔ Ń ±cŇ Ó Y&Ô w¤Ő ¤$×  6Ř $WŮ .Ú ‚ý
Ű Z Ü ŰÝ eľŢ ‰ ß 9ŕ ⥠á |żä =Ňĺ ]â ć Š§ç č őé ôŮę ‡të e'ě ěë í Ú˝
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
î ĂŃ đ ŮËń î$ň ţ´ó –Ěô žő |ĺö Mu
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
÷ ŻĎ ř QHů Ŕú ĎÇý ú’
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ţ … ˙ 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
hv�
hG‚
ń�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
»P…
±‘ †
j9‡
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
Î\‰
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
!gŠ
ę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
˛Ţ Ś
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č’
\Ě
“
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
Ö� •
/ś—
Tf�
_}™
%?
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
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
3k 
f2 ˇ
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
gWŁ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ë4 ¤
3¶Ą
>T ¦
‘ě§
ˇ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
j«
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
łý¬
_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
®¦®
mŢŻ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ôl °
 ±
˝ ł
áő ´
WŁ
µ
‚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
U·
ß^¸
ďćą
Ž©ş
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
[ľ
zg
ż
!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
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
’oČ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
8k
É
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
Î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
0˛Ě
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
ÚĎ
PĐ
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
Ň
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
tŔ Ó
#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
ißŐ
Šč Ř
E,
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
e3Ý
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
¨Hß
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
4i
á
$Ů
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
5>ä
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
©’ç
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
�f
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
ą&î
=ď
:źđ
Ě
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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ó
´ďô
v7 ő
´˘ ö
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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 ř
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
đEü
˘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
ć'˙
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
�5e ‰%Š`ş ‹ ŚK!Ť€™ŹŰ �î*‘˙Z
’r_“ôÍ”Č •0–ďb™ëšCo ›~Ďś5·ťIžCĘźşş
 b
ˇúŐ˘FŻŁÇ¤3©Ą; ¦QÖ§=g¨h’©ÖnŞ «™ ®4ŻĆČ°şÄ ±%¤˛ďb´C µoŮ
Ćă ·Ő$¸ô} ąĚY ş˙Ľ :
˝µ6ľŢ
ż–ŔlY“Ž Ăg
Ä!ĹkĺĆÁbÇ›˘ČśyÉřËh˙ĚĺÍ}ř Îá�Ďňz
ĐA˝ŃVÍŇ©ÔęnŐ(ŹÖŰ+
× ţŘ92
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
ŢĹ%ßaŕ=Ăáš´â©î ăŻÎä ;çßKč� éɨę/Ć ëJěb$í
.îí×ď$´
đË
ńdLň±ó˝°ô�KőRÁ÷x§ř/ô
ůLÜ únvű6mü®ýgtţ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
†ä‡ćx �Lo‰Ćq
Šů;‹�`Ś|ÉŤífŽ­ÉŹ/!�@â‘
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
’
Ň
“[o•¤ë –“ń—™ó�of™Ĺš±D›H#śY3 ž?6źP; Ť) Łű ¤ŰÜĄŔw
¦A§ôĚ ¨jT ©ÎN ŞHN «+B¬Š-
­Ç„
®Ö;
ŻźŐ°őž±ÔDł< ´˙"µ€˝°|
·’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
¸ń ąŐ÷şB_Ľ«‹˝Ě~ľvFÁ7ÇÂ'nĂJR Äş¦
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ŢíĆÇ÷ Č“ É“ ĘÜJËÂÎ
ĚjôÍ…™Î
ÚĎ€ ŃrÄŇŕ Ób Ôza
Ő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
ď׌Řn3Ú¶•
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ű-¦ÜbßN# ŕ# ፠âł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
ćáçJĺčŘý
éŐ ę]ë,?ěV>í΄îj‚ď¦_ đŞ–ń3Ţ
ôvő?�ö ą
÷ëÜ řX@ůĆú·Ö űßüÜt ýÜÚţÂ˙Ţŕ€;¸ �żÝ ‚9« �9™„�)
…ë †?K‰”eŠ{Ü‹3Ś‹ŤÜŽÝťŹ`Á�Ű
‘ Ą ’„˛“ä0”S•C – ›—��I™đCše�›ÁÓ
žI\ź
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
X  �ˇH7˘SźŁ„
¤ �
Ąť0¦¤)§–&¨Ěő
©GâŞ`ś «¸ą¬őš ­č®Đc Żš °ńMłhQ´Ŕłµ®Ś
qF·#&¸zýą5h ş‰»ę ĽC潊ľSź ż“dŔ°S Áyd B Ă^– Ä»µĹ�«Ć - Çäč
ČÓľ Ëż_ Ěś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
ĎߡĐ­ ŃżíŇD™Óď#Ô,6 ŐŢÖŢĹ×`)بŮŃ
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
Ű5sÜ~° ÝťŁŢH}ßĚ“ŕ�hăh]ä& ĺj”ćâ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
çU†
čMéé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|ë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
ďdţđŚů
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ń4áňŻĆó\Šô×Ôő&Ŕö[%÷Čř •űřČü?CýÚţw´˙Ý�€+�˛ž
‚#�ó
„2 †Ű‡r*�;
‰‚| ŠÁF‹ă Ś�/ŤŐ Žc:ŹŻ*“ Ů”Śz•ż”
– — Ţ�Ć™š šř  śÎL
ťŞăžî,źâó Š9ˇc› ˘"’
¤xĄÖ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©Ď Şş:«Ă’¬�ô®±¤ŻC°&#±xV˛Ţ´§-µ © Ŕ+·�⸝͹> şK‹Ľ¶©˝ŮľŰV ż�§ Ŕ\~ÁŘ_
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÂyđĂSÄ�îÇňČ/ ÉýsĘĚ×ËG> Ě»µÔ;s Őd/Öp
×ß1Ř Ů ÚAYŰ×0Üúß ÝĎޢ5ßpŕżěá\|â2G ă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
ë«1ě6Ă í3żîÚł ď5Ó đŐ)ńŁG ňĘó\ ô›őžKöő` ÷”^řঠůµ4
úSôűww ü5üýČţ"g˙€Đv �"D‚�e �jr„0w…•%†Ɔ ‡ćĺ�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�}Ó ‘×9’m •b
–:©
— šĚ‚
›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
ź‘¦ d8
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ˇxv ˘Mű ŁBť¤,‘Ą>ަÔͧčÁ¨ÉÓ©y±¬b%­g¶®}ç±(ś ˛ŮBł:»ô˝Ľö4 ˝2řľýżWĹŔťpÁ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
Ä@@ĹMú ƧÇ]Ó ČúĄ
Ę{LËI-ĚÓv ͢Îo˝Ď�óŃ=Ą Ň(qÓ®dÔŮ ŐűŮÖtď×�Á؟ٕKÚćWŰ©Ü>ŠÝnN Ţ@ęß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
ćłFçBč”Ięó5ëăěťeîď
ďR#đ+Ě ńM7
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ňeĄ ó“ňô'÷LĽ řxşůżíú{  űîüä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
€)Ó�q‡‚´c …ŞŽ †˛ň‡ú\Š9‹úzŚPŹ�—�6‘`V”;#•‘–^™¶ĂšŠÎ›gd žbź8đ >qŁ�˙¤*´Ąů ¨Ys ©z Şuä­ą8®éA
Ż¨3˛FŇłĽ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
´†•·As¸ó김dĽt˝žFľ…jÁѪ±ĂCD
ĆIÇżeČ­ĽË:RĚâ8Í:mĐĽÓŃąxŇĺL
Ő”ĄÖů·×ŢÖÚ� ŰTÜVß=űŕ8
ámtäÎď
ĺ ^ ćźéűőęäë`d
îIď đ¬żů�úy† űq(üôý3á
ţ�J˙Óć
€5Ł�:5 ‚®
�.5
„Y+…m߆ʙ
‡3@ �„ś ‰|ÖŠŽ‹$ÚŚ;ŽŤ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
�ˇÍ ‘¬˝’N“vŰ”_! •›j– Z —¨v�¶W ™]„šÍĘ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
›rĎśľ‡ ťmhž.* ź¸Ä ëˇ–
˘q4
Łű¤¤¤v Ą‰q¦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¨g/ ©fđŞm,«±� ¬ŻŠ­ i®‹jŻ#Ó°e
±µ˛ç&łîÁ
´÷ݵW~hń·Ô۸ íąňcş[�»çŻĽŃ�˝ś€ ľ÷ó
żHfŔŁÁĂ�Âö
ĂWĵĘĹej
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ĆťŘǦŘČž Év¬ ĘĽ& ËbĚ–dĎCĐ÷~ŃM=
Ň!XÓy„ÔcŐáBÖ6r×˵ŘWiŮęKÚ‰µŰ‡Ő܉}ÝĂŢccß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
âŕŇăäô-ĺ%ć˝÷çřßč¨Ďéoę)řë|C
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ě4­íČkîĂ”ď«jđ/…ńVľ ňóWŃ ôI„ ő2 ö§• ÷×úř|b ů[
ú™* ű•üśŻýi:ţcô
˙2ţ €Ó4�‚‹ô�çĹ„¬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
†^‡˙ě�ŕ‰súŠ[
‹vh Śě Ť�’Ž:fŹe!�5Ă ‘ĹP’/· “ÉČ ”<ş•D[–·T—Áň�Ž>
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€źoh ™ĺˇZ°˘Ś Ą$ˇ ¦.¦ §_ ¨eç©ÇGŞ%
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
«ľO¬9í­ML®Ľű ŻŐH°>^±ö˛e‘ łÍY ´
Ž µŢÓ·V ¸Lką?„şÇĂ »�g ĽÖ ľ†0żřšŔ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
Ć’Ţ ÇŢ•ČíĘyk˵=
Ěŕ
ÍEÎÎćĐL:щŇ"Ő#M Ö‰7×ÇÚš}Ű— Ü
Ţ ß�\ŕaá<é‰>ę˛H ë*§ ě©żí/‡îíĐď˙đë› ńXWň—óKŮôú ő‹ë
ö+÷đ†řř¦ ů‡ÓúűźT ü Ń
ýĚmţaÍ˙Ő1€>Ő�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�ŕ„EÄ …Q9 †/z
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
‰>~ ŠSJ‹ Ą
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ŚI
Ť
1Ž#~Źž‰’�¸“‹”ťţ•fă –8í—ą¦ �™üšж›0±śN ťëaž FźWP  tˇQŕ˘. Ł�¤rĄ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
§k$¨ô ©ĎYŞ|µ «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
­°` ®p
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ż˛°Ä±ó˛>Őł‹— ´ňmµ·§8Ż·ĺö ¸é‡ą§č
ş8ą
»ęň ľa  ż LŔ· Á37
ÂuĂN„ ÄáĹ ŐĆžDÇę€ČđťÉč"Ę6 Ë~˝ĚÍ79 ÎĎs ĐĐ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
×!Řs�Ů& ÚôŰŹ÷
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÜEiÝşbŢ�ß1˛ŕ0° á:ő â›Éă bäŃĺčńć!—çŔ<ęÓ/ëVąěĂ/ í’Ćîh>ď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
ń›ż ňvőó+ôÓŢő�IöŮí ÷Ď
ř)Ä ůŃúŁ� ű@üü†`
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ýţ.<˙«( €S �ý«‚Ó=�Çč„TQ‡‘Š� +‰TA
Šr‹+– Ś4׍őµŽ¤PŹň�cQ‘cĽ ’‘•
–…g —“�!Ő™oú š ›Đr ś×A ťöžÉéźG7 K� ©›Şá «;¬‚­Ě}®č9ŻNö°·Ď±•s
˛•ÂłĐ‹ ´ĘRµ
c
á;· Ú¸Ó
ą”ŹşMa »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
ĽED ˝đľ©>żXóŔÍĎÁ—4Â|QĂ�ÄŕoĹŰ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ća ÇăČr±É`Ęw“ Ë˙¦Ě HÍÎf�ĎUO Љď ŃĹŇOÓ}Ôč(
Ő} Öô?×ř‹ŘeŮ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
ŰŇŞ Ü…‘Ýe«ŢQ˝ßáâ ŕĚ áýfâQÝă«Ďä+Ĺĺu±
欫çć»č€EéÜěęĹľëµ ěP
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ím
îŃKďŕ đpzóË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
ö”ż÷÷%řŻü
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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úë}ű]Űü„ýaÝ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ţc˙}™ €§ä�wę ‚C �¦7 „IË…Ú †çť‡»S�|‰9šŠΔ‹NnŚŽó ŤŔŽ^ Źqą�ş‡‘ˇ’č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
”49•ŕD –Çy—Sů� ™ůŽšłµ ›ďh śOF
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ť*ĺž<+źżĚ i ˇ“‹ ˘ÝtŁť'¤ÚîĄ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
¦ňn§(
¨Ü-©ă* Ş«ëç ¬tT­˛x
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
®E鯦† °3±š
˛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
¸¤ ąňŁşŞ ˝Z¬ľZFż¶YŔPfÁÉBÂł{ĂčřÄźaĹIđ ơĄÇ8! Č͸Éí? Ęáä Ë®�Ě5z
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
Ň=Ó›ś Ô 
ŐTÖ\ ×#nŘA´Ů#
ÚCßۦęÜŃî
Ý•µŢd ßÉĂŕžt á%› âuoă¤Räąr ĺFć_=çščMVéoĚ ęˇ»
ë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
ďĐ‹đŠń„ ň%ó5
ô , őâ›
ö8Y÷.�řô˝ůň…ús ű#eü ]ýIaţľn
˙ňÝ €â¤�ŤK ‚,Ę
�Bß
„’ś ‡ěŁ�ů
‰ę«Š¶6‹Ö¤Ś>ťŤ( Ž�폓Í�ôi‘=– ’ć “éV”ĺš•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
–’đ—x-�–Ă ™׊šv›˛@śÔť žľźZÉ HˇŠ^˘ád Ł˛¤łśĄĄ ¦¸˙§Ůh ¨Ľ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
©2˙ŞË«ăެăí ­ú:®
Ż�ő°hĆ ±8˛čąłY´:^µtr
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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 Ľ-F
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
˝Ž ľM/ż»&ŔzňÁť 
¡±Ă�Ó Ä]5
Ĺ<: ĆbÇ/SČ`X ÉÄ'
Ęc’ËÂč
ĚÜÎÍN… ÎMŰŃë‚ Ň>1 ÓÓ‚Ô*ŽŐO=Öš¦×ë¸Ř+ŮaI
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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ۺܺóß.
ŕ=Náž­âף㼠ä>UĺńoććňçbÍ
čé‘h
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ęRV퟊î×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
ďşĚđ7óńŘ&ňţ_ó“!ô6,őŘúöúź÷wřŢňűěĐüŹ� ýăĚţá-˙:€ŐŰ�Ć€‚YF�ď�
„Çş…Iµ †l‰† Šö ‹ˇRŚ'¦Ť•ű Ž_ÇŹwP�Đű‘š’íó“üŹ”*ă
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
•}Š
–G7 —Ă �Č( ™&†
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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›eÄ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ś…ťpžOȟРšµˇ\˘/ľ Łę´¤o•ĄH¦+Ç §k2¨8 ©cóŞ « «Š¬NR­´§ ®áy ŻéÖ °¨e± >˛סłť! ´ ݵfCiN·,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
ľΊż3uŔ[ů
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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ČÇFÉę¸ ĘDKËcë ĚŢĂÍPÉÎ’2ĎyĐ~] Ń0aŇĚn Ó7ÔŽŤŐő€ÖBµ×/ľŘkÓŮÖ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
č
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ă™·äK ĺ ÓčÍźé‹O ęý8 ëłŰěŞYí´5
îůď_
đ»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
óô�ńőř¸ öńŮ÷đř§ůU±
ú �
ű ®ü5Eý®, ţ–X ˙,Ľ€l`�z]‚¤ĺ�Ě„đ…›&†óa‡Ń<�đ‰tĹ Šs‹ŕ�Ś�ŤMŽý
ŹT& �P÷ ‘Ë
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
’µQ“$˝”ôx•p% –^Y—yb�E™™;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
ť±Rž’ ź'~  3ß ˇIň
˘´­ Ł´ľ¤ü Ą×¦§‡
§'g¨5 ©Ki¬%�­đ
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˛§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
µůŢ|Ô·¸É
ą şkŤ»ŇÄ Ľęś ˝v ľËż­Ç Ŕ—5 Áj
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Â9üĂÖÂ
Ä�řĹľT ĆŁ˘ÇwŐ
ȸÎÉŠ0Ę%ů˹̆ł Íű"Λ
Ďç—ĐxJ
Ń; ŇÓů Ô¦Ó
ŐkŘ;ŮZL
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ú9AŰÄj
Ü)| ÝkhŢAoßV'ŕ×Z
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ăçŁäř‹ĺ^¬ćhńç #čŰés‡ę’ ëěˇíGîS˙ď&łđ¸ ń6˝ ň Đóâhô:şő™— ösŘ ÷‘w řWA ůňŚú7uűŘ üMű ýyÇ
ţë˙I¬€Eî�9m‚¸ �`u „§Ř…Wî
†)P‡#�¸ ‰ (ŠŢÄ‹>Ř ŚŘť
ŤeŽĆ” Ź?m
�Q‹
‘ű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
—Ô&�—€™ˇš¨q›ëxś0ť6-žŇ» ź�÷  _ôˇŤŚ˘Ö/ Łť ¤í‰Ą­H¦kÎ §/¨2©[ź
Şčx «·˘¬(n ­qC®©†Ż$Š °Ď±§ń ˛<K ł‡â´_`µ–
ae·/§¸Óq ąZŰşšĘ»ó߼®i˝KB ľŃ2żĘŐ Âôu
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ă’a
ÄÎűĆÝĺÇ7ČČŽ¸É¤ZĘs Ëö̢ÍW|Î ŚĎu Đz*ŃŇ4$Ó•<Ôá·Ő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
ŘTEŮî,ÚSű۵ Üb?ÝßF ŢgßAÜ ŕ„á)Ö âhĘăę$äźqĺ‰_ćÎ@ç�4 č—Ě éXięťů ëźěH; íąĆ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
î¦ůďß­đKÇ ń€×ňɇ
óZ± ôĽRőH=ö�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
÷¤ÝřĆů8ú¬´ű`Ô
üż.ýS4ţ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
N˙;B€.Ę �Ř
‚“�Ţ“ †?‡3Ö�/‰öľŠDĄ‹6 Ś*Ě
ŤlOŽŹ6Ź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
“Ş1”˛j•ß–5ô—Ž0�<‡ ™Ĺ šÝ×›
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
VśëŚ
ťVG
ž™ź�Ő
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
ˇ�˘§uŁOä¤ú3Ąť¦µ§‹Y ¨HW©Ëű
ŞĘ�«-¬J­źĚ®đ˙Żl2˛—€ łí ´Ćźµ±H‡ô
·ńy ¸üąą‹ şEĂRŃÄͶĹ4
Ć7 ÇőŻČHÉ›R ĘĂŽËl�Ě®7ÍR™Îş©ĎůSĐcý
Ń›ňŇܸÓ.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
Ö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
×đěŘ·ß
Ů>t
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Úţ†ÝnŢ–ňßBTŕźÍáëDâɉăyń äV«ĺéô ć»VçÔ†č{'ël.ěĺ íî0ű ďfw đÎńÔô
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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^ýş÷€şß�  ‚—�N„1ť…ç±�ŮىšnŠ2ý‹)�ŚPş ŹA�8ő ‘}’ÉP “†ç”îę •H“–Ťt
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
—ŞMšEç›Sś™ ť�žÂń źű3 ˇj@ ¤éP Ą=Ô¦'˙§®ý ¨°l©Ş­pŤ
°ň'±ň; ˛ŕ€
ł†=´5µJÍ·ŽP¸lśą.”ş|˝QľëżĂŔkAÁg­Ä ±ĹĂpĆ=ĎÇĎSČ˝-ÉpÝĘćcËĹçĚk%
ÍÎ¦Ř ĎĹ
Đ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
Ř ÁŮo=
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÚébŰ”N ܱ ßqŇâöŁăx§ ä™yĺyčĎÓë ěiîízcđ>ůó–űôbŽőirř~HűĘKüžýý
I€–�¸v„š…Ią �ŢŠ ‹ŮŰ Ś—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
‘Ű^”@R •č9–,Ë™šŇś˝»
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ť‰Nž)n ź‰m ˘ŐÄĄŐJ¦ §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
«ëŐ®ĽzŻ�+
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
°€±Ţ
´´›ĽÉ ˝ĐQľ˛Bżě
Ŕ‰µÁ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
Â~2Ă—ÄI. Ĺó(ĆE—Ç’úČß�É|ëĘöŹË.ăĚű
Í�—ÎČäĎ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
†Đd‘ Ń\Ĺ ŇGÇÓůŇÔÚ- ŐvŹÖŹŕŘNx
Ů9żÚÝ” ŰÉłŢ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
ß]7 ŕ–A áPČâŘŠ ăŽ?ä7®ĺŹĄ ćVóç&�čÔż éŕę™gëO ě†í íš&îm!ďŔ{ đ Ńń{ňĘę óhJôÚőMäö=÷L; řýÄ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ůÔúŇ
űÔq
ü+Ś
ý×íţÇE ˙ő±€ §ď� UÔ‚ �ž� ŁF„ 2O… Q † ¸4 ‡ ŇO � <ü‰ VŠ agŤ !dŽ ľžŹ …P� E‘ đ’ ×c “ �l ” ě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
• a
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
– ďx— ·Ö� yŔ™ †íš ĹĂ› ňś Čź ť kLž řź ‡-   gŠˇ E¢ 5ęŁ H|¤ 4Č Ą ,¦ ¤ż§ Z\¨ , © N¤Ş Č“« q¬ 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
Ż ý° \O
± žJ˛ Çł ó¶ eŃ· sz¸ A5 ą  ”ş ňź
» á
Ľ ˝ »÷ľ "ż ĆŔ +Á Űl }h Ă é‘Ä ŢŇĹ ĘôĆ ¦RÇ fČ \ É WłĘ ýÍ ×_Î łĎ A
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Đ „Ń 0,Ň t¨ Ó ‡hÔ sÉŐ )ŚÖ ÄĄ × :zŘ 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
Ů ć Ú ţéŰ B.Ü RMÝ đEŢ ˛ß Xŕ ć á 1Ă
â �îă +€ ä ¤ń
ĺ G@ć ›Ö ç §č ú6é ź¤ę ­ťë uÝě Í›í ŞMî ›Šď ś đ Âŕ ń –Ľ ň Şó –Ë ô j0
ő đůö Â#÷ 4š ř Š\ů Íú wű %
ü 
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ý ÚČţ JŚ˙ öC€!AJ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
‚!ö…!L&†!ai
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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Š!ŚĆ‹!@t
Ś!Ó+Ť!ĽřŽ!Zˇ Ź! ‹’!ńÄ
“!)“”!SU•!F{–!Ű>
—!j…š!űŮ ›!őúś!;Ů
ť!už!ďwź!˙w˘!CŞ
Ł!±z¤!.§!ĂŠ¨!hđ©!›ř
¬!1Ő­!Ł©®!Ŕ6 ±!„u˛!‘ł!)´!m”µ!F¶!Éç ·!θ!ř\ą!™óĽ!š˝!\Fľ!ŐŔ!őZÁ!ć™Â!zĂ!ëNÄ!\ÂĹ!ŚF Ç!JŕČ!C<É!�Ô Ę!sąË!ímĚ!ŘäÍ!AÎ! Ľ
Ď!nŇ!
Ó!ëŕÔ!žĄŐ!”
Ö!`’×!iŘ!–ý Ů!h Ú!m�Ű!ÄÜ!nÝ!BJŕ!Ô)á!g?
â!lşă!zä!Qqĺ!$ć!J$ç!Uič!é!m
ę!î ë!
‡ě!4÷ í!đ)î!ĺď!şđđ!ŻŹń!šăň!Róó!uô!óÝő!oâ
ö!hĎ÷!ŰÍř!�’ů!=ú!Óžű!›s ü!Ěý! ţ!ú
˙!±€"úŤ�"ŠĹ‚" �"bP„"�ę
…"�đ †"„ ‰"ťŠ"<´ ‹"×UŚ"†dŤ"P[Ž"^EŹ"ŁU�"ŕÍ‘"ąÍ’"X“"Ss”"4Z•"(µ –"ť¶—"ç
�"w
™"ż-š"¤? ›"žv ś"ŽŚť"QÄ
ž"mź"%ź "jǡ"͢"ťE
Ł"™Ý «"¬{¬"ďC­"©9 ®"7÷Ż"Ś‡ °"±"†˛"”˘ł"[•´"쌵"$¶"Ěη"‰i¸"5?
ą"Ćľş"Š°»"×íĽ"‹I˝" ‘ľ"liż"G’ Ŕ"—¨Á"߸
Â"-‡Ă"Ý Ä"Î˙Ĺ"o“Ć"”Š
Ç"é�Č"đn
É"6(Ę"€lË"<YĚ"3Ě
Í"rGÎ"ÚZĎ" Đ"^} Ń"qŇ"5ńÓ"\…
Ô"]o Ő"ežÖ"· ×"„’ Ř"¦Ů"ÂëÚ"® Ű"ñÜ"ˇ“Ý"ÂŢ"ˇŁß"»‚ŕ"ZŁá"â")
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ă"Ú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
ä"ňfĺ"oďć"ŢÄç""7č"·Ů é"1ň
ę"&Čë"o
ě"­
í"‡! î"mÇ ď"#­đ"Ńń"‘+ ň"µ ó"G§ô"5+ő"źö">ţ÷" _ř"U ů"… ú"Ç™
ý"›ť ţ"‹n
˙"·^€#ţ>�#M‚#kÁ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�#?Ţ „#Ç‘
…#0»†#Ş€‡#<�#nr ‰#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
‹# uŚ#żŤ#ѲŽ#@, Ź#¤�#Ö
‘#‹)’#ú:“#L�”#)Í •#ö‰–# ř
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
™#6Ůš#‹* ›#7ś#kť#÷ůž#ż_ź#JD #Öס#[1 ˘##bŁ#OS¤#!¤Ą#ű+¦# Ë §#}
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¨#Ńë©#řŽŞ#V¤«#+Z ¬#PÖŻ#>™°#ě’±#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 ł#¨Ń´#'@ µ#©>¶#r]·#çě¸#  ą#®Bş#»#ˇ¤ Ľ#w6˝#X»
ľ#_Ôż#�?
Ŕ#^Ă Á#áČÂ#KW Ă##
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ä#şÝĹ#$ Ć#HÇ#qśČ#4É#‘�Ę#ą Ë#‡»Ě#^EÍ#‚ŁÎ#×ě Ď#Ú× Đ#ąaŃ#U�Ň#ŁAÓ#w[Ô#`Q Ő#hGÖ#é×#®w
Ř#‘>Ů#7r Ú#§TŰ#6ËÜ#�.Ý#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
ß#Mŕ#CĐá#�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
â#řÂă#…ľä#Äűĺ#µÜć#“ ç#@Ľ
č#Řé#ŰAę#Źë#Ád ě#[í#&wî#mOď#¶™đ#‚ań#Ôđň#öřó#Î.ô#ľ¦ő#‰‘ ö#iI ÷#ď˛ ř#ÇŻ ů#XQ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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Ŕý#Ah ţ#čý �$^L
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‚$u^�$÷Ú „$h …$Çî†$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Š$Ń“
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‹$żÎ Ś$ß…Ť$Ź!Ž$ŁŹ$ë
�$üĚ‘$Â� ’$­î“$#M ”$}1•$JZ–$Hä —$ďĘ�$nő ™$Č|š$^ ›$•ôś$?ô ť$-ôž$¶# ź$V‡ $XHˇ$b ˘$Ň'Ł$,¤$ę
Ą$�ľ¦$ĄĆ§$Đ ¨$ë©$îHŞ$>Ť«$9¦¬$H}
­$"®$č
Ż$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
°$Ü(±$ý}˛$’¬ ł$Âu
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
´$ĄJµ$ÄŻ¶$ůˇ ·$ę¸$�� ą$#Ýş$î�»$yjĽ$6í
˝$芾$i#ż$GŘŔ$fÁ$_ Â$úOĂ$}ÔÄ$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
Ć$†ćÇ$–
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Č$•čÉ$ěŢĘ$sË$5aĚ$[„Í$Ś˝Î$ĆĆĎ$ŔĐ$Ň
Ó$Ác Ô$]ÎŐ$éÖ$>ě×$`ŕ Ř$•µ Ů$ľ†Ú$
 Ű$›á Ü$śÝ$/őŢ$é
ß$ ąŕ$Ô+á$şUâ$]^ă$í<ä$-iĺ$ ź
ć$NGç$˝| č$á< é$N ę$Ăłë$fŢ
ě$Đ1 í$ î$âŰď$ş?
đ$»˝ ń$PÜň$`[
ó$lÍô$Ö
ő$Šęö$Ť÷÷$A3ř$î“ů$+ú$`ű$ş<
ü$ňbý$<� ţ$ű˙$�;
€%Ň«�%­Ű‚%ćt
…%Ý”†%ě3‡%Ěi�%;â‰%÷ Š%uE ‹%µŚ%{$Ť%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
# Ź%n:�%Őş ‘%żş ’%­@“%p„”%ĹY•%ŘU–%:ó—%›Ě�%˝Ř™%©Ż š%ůé›%“
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ś%` ť%V„ž%pN
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ź%y4 %,ˇ%iˢ% Ł%9
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¤%<ć Ą%;•¦%¶¸§%„ç¨%ŞÓ©%šňŞ%�y«%r
¬%u­ ­%¬Ä ®%ę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
±%Ł
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
˛%t ł%ín´%˛l ·%ś÷ ¸%Ł"ą%Ć™ş%:ŕ»%}¸Ľ%¨Č˝%-Í ľ%)bż%Ŕ%Ë>Á%űÂ%´KĂ%™ĐÄ%4¤Ĺ%Z Ć%UlÇ%¬J Č%|I É%9ýĘ%ŘđË%JrĚ%@JÍ%9˙Î%zÎĎ%ăĐ%Ţ, Ń%†öŇ%$†
Ó%ËŇ Ô%n
Ő%ťŇÖ%ŇG×%ö Ř%§
Ů%<ěÚ%źUŰ%L9Ü%˛ź Ý%-/Ţ%ÄĆß% gŕ%
ąá%`‡ â%öĄă%JA
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
ć%$#ç%Jč%b>é%‡'ę%éî ë%7Ţě%§í%3î%,1 ď%ü< đ%I?ń%É+ň%jó%.žô%~Éő%ě;ö%Ť|÷%ylř%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
€&IM�&˘¶ ‚&jq�&ěő„&6ń…&Ľ]†&ë� ‡&Ą� �&¬Ü‰& Š&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
Ź&¸V�&$w
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‘&ť’&ęÄ “&e”&Ş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
•&śĎ–&ŃÚ™&Ą|š&’ú ›&42
ś&oť&‡ž&Š&ź&‡  &ó!ˇ&&áŁ&sŘ ¤&� Ą&Ź8¦&Ƨ&­
¨&$‡©&ÇŰŞ&Ňä«&}(
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¬&¶Ť ­&9o®&őË Ż&Ň?°&ëű ±&„d
˛&>•ł&âÜ´&�gµ&4ç¶&őP·&Š ¸&QŹą&ň
ş&4»&Aţ
Ľ&`$˝&µľ&Y°ż&Ô Ŕ&€„
Á&-Â&@ŐĂ&©ˇÄ&E€Ĺ&Ä‚
Ć&z
Ç&ËIČ&:)É&OńĘ&_¶Ë& 
Î&î:Ď&�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
Ń&C°Ň&Uß Ó&ř» Ô&’Ő&QĺÖ&ýô×&9†Ř&YÝŮ&náÚ&ăg
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ű&RłÜ&Ż|Ý&ú·Ţ&móß&ą—
ŕ&Qá&˛gâ&ď_ă&ÝDä&Ź�ĺ&Ďć&Ž<ç&½č&E¤é&K ę&të&Łě&A>
í&[5î&ła ď&(L
đ&ń&čA ň&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
ô&x€ő&‚`ö&'ö
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
÷&¶9ř&t ů&C9ú&�ă ű&b( ü&5ůý&˘ëţ&ä˙&řť €'ů�'Ż­‚'ý0�'E „'§7…'Ňŕ�':k ‰'Îő Š'ď4‹'!Ű Ś'˛LŤ'óAŽ'.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
‘'R’'Ţ“'Ňů ”'Hę•'\č
–'
ó—'
�'gw
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
™' [ š'Be›'Úś'Üúť'�gž'Řź'nU  'Căˇ'î·˘'’ťŁ'O÷¤'Ó•Ą')$¦'a1§'Ŕ¨'B ©'IçŞ'ĎT
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
«'n¬'V­'E›®'˝
Ż'#°'z˝±'>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
´')­ µ'ż$¶'}|·'­Y¸'p˛ą'<
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ş'„G »';‰Ľ'}˝'ÉĐ ľ'ĂÁ ż'ł Â'.Ă'¦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É'ľ}Ę't«
Ë'» Ě'›–
Í'¶şÎ'őĎ'5Ę
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Đ'ű+Ń'D Ň'%ĎÓ'«ç Ô'ż2Ő'ü×Ö'ďU×'ľâŘ'MčŮ'ylÚ''yŰ'?Ü'B� Ý'Ý Ţ'|» ß'ŕ¦ŕ'ž¸á'bâ'<ă'˛čä'Y–ĺ'xDć'˛F ç'šBč'?€é'¦8 ę'¶ć ë'©]
ě'Łhí'á„î'TŹ
ď'6 đ'Ěń'd9ů'X­ú'
Łű'QŚü'P˝ý'‰ţ'p×
˙'˝˙
€(ć�(Óä„(de
…(Ă´
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
†(Î ‡(iq �(F˛ ‰(°Š(;U‹(mĎ
Ś(ËöŹ(It�(Ú‘(¬’(1f“( Ą”(wR •(–(ôś—(^[�(Öľ™(
`š(} ›(u0ś(Fżť(<ž(p™ ź(E� (ałˇ(‹v ˘(áŁ(1g
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¤(• Ą(ŰŚ¦(F§(¨ł ¨(O ©(;ż Ş(p_«(ɬ(»­(©†®(˛
Ż(ş °(Ł ±(×
˛(,§ł(¬Ú´(>µ(˛Ű¶(©·(OŸ($Ną(Ď9 ş(Äa
»(Ęż
Ľ(ĚR˝() ľ(c; ż(7+Ŕ(zhÁ(<Â(¨¬Ă(<(Ä(z˘Ĺ(ÖŮĆ(|ďÇ(¸ÓČ(…Ą
É(€«Ę(q
Ë(ŠŐ Ě(üÝ Í(–¨ Î(qęĎ(-› Đ(öóŃ(:%Ň(f
Ó(CNÔ(OŐ(-Ö(]1×(ˇ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
Ű({xÜ(ĹdÝ(d˝Ţ(r1ß(5%ŕ(0—
á(;űâ(«ă(úä(‚ ĺ(Żmć(8Bç(ăŮč(Ĺî
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
é(ąoę(M¦
ë(ţŮě(´A í(yt î(‰­ń(/ň(áó(;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
ő(&F
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ö(iR
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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ů(\$ ú(Ćůű(źh
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ü(7Ăý(2�ţ(Ś$˙(G €)ÇA�)ůŠ
‚)Ž�)Ń „)”F…)Ť¸ †)Č ‡)¬
�)$2‰)Č-Š)&‹)/׌)ĆŤ)Ąz Ž)”_ Ź)Ů4�)§ ‘)3’)¸˙ “)|ć”)»< •)|)–)­Ş—)G �)V ™)ýnš)‰Î›)oś)î
ť)}đž)·ź)}M )"ˇ)�t ˘)—
Ł)wň
¤)řöĄ)îҦ)wW§)üĎ ¨)÷ť©)kfŞ)ó«)¨Ŕ¬)ó­)E ®)–Ż);— °)I±±)Á»˛)}"ł)pn ´)Č µ)Ă)¶)�™·)X;¸)Ő­ą)�Č ş)—]»)iŚĽ)ZÝ˝)ëľ)Á÷ ż)Ő%Ŕ)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
Ă)]
Ä)Ł‰Ĺ)îËĆ)wuÇ)×fČ)< É)«ŇĘ)1Ý Ë)=_ Ě)«´ Í)öq
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Î)×Ď)ľ{
Đ)BÓ)Č!Ô)öv Ő)ÍĐÖ)8˝×)˙%Ř)osŮ)âPÚ)ä“ Ű)°Ü)ý$Ý)CFŢ)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
v
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
â)5Ę ă){hä)>oĺ)zy ć)v× ç)¤( č)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
é)C*ę)Ť(ë)xě)r• í)@Üî):oď)ëďđ)Ňşń) ěň)Ë�ó)<
ô)Ľ ő)
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ö)Úz
÷)Z0ř)Rhů)�\ ú)=uű)ţ&ü)P) ý)Ë1 ţ)3ŕ˙)š€*ÂĽ�*¬‚*®r�*sŚ „*Ě…*„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
Š*Qd‹*/�Ś*«Ť*p.Ž*çMŹ*p* �*ýµ‘*“ň’*ě5“*ęl”*>e
•*‰( –*ä4—*2
�*kž™*Ąôš*ď˙›*aQś*ĺť*đž*Vśź*Zß *)°ˇ*é%˘**˝ ¤*K÷
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ą*|_¦*ɉ §*Ö¨*Ü ©*fJŞ*YD
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
°*/–±*×G˛*K> µ*†˛¶*\
·*µš
¸*�ü ą*˛ý ş*m»*˛˘ Ľ*éE ˝*&dľ*¸9
ż*1Ů Ŕ*Óé Á*“BÂ*´Ă*QĘÄ*cŐĹ*®ÇĆ*_¤Ç*ă&Č*�YÉ*ZžĘ*”Ë*7Ě*˙ŚÍ*$RÎ*ĹJĎ*ŽűĐ*ÖHŃ*"đŇ*Ż\Ó*/Ş Ô*Ú’Ő*7ŔÖ*ŹŞ×*íťŘ*ł~Ů*EÚ*A]Ű*•uÜ*O Ý*üţ Ţ*
ß*,ŕ*8 á*�ßâ*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
ĺ*ísć*âXç*Âë č*˘0é*ycę*#^ë*ŮĎě**zí*Sî*ľţď*ö-đ*<Kń*;˙
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ň*[ó*WÝ ô* ů ő*ŰSö*yI÷*mř*Ľů*¶�ú*yKű*ü*E?ý*6oţ*NÓ˙*�–€+7›�+$‚+;
�+ů<„+ą‰ …+Y˘ †+ä‡+ɵ�+·´ ‰+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
Ś+¦?Ť+böŽ+�Ź+ëh�+ý
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‘+ – ’+’”“+{0 ”+-¤ —+~-�+ŚÎ ™+H.š+Kż›+Í€ś+ Ăť+\hž+Sí ź+ő� +cˇ+­ź˘+# Ł+sM ¤+Ş Ą++ę ¦+ă §+FŔ¨+`Ľ ©+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
®+Ô†Ż+ř°+—Ú±+÷˲+ó¨ł+ŁĄ´+X9µ+P¶+>"
·+h ¸+
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
–ą+ę
ş+úâ »+ŠłĽ+á´ ˝+¬Ş ľ+ˇż+us Ŕ+«rÁ+ˇ
Â+ůĄĂ+z·Ä+N#Ĺ+®^
Ć+AÓÇ+fČ+Ý"É+Ą= Ę+„Ë+ÔMĚ+#
Í+2®Î+ oĎ+…ĎĐ+‚Ź Ń+×*Ň+Ů®Ó+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
Ö+ĺ
×+ů« Ř+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
Ú+mË Ű+X‡Ü+Ś&Ý+ ›
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ţ+.Qß+fNŕ+(i á++â+č ă+Ó ä+…� ĺ+�–ć+Ńě ç+i č+“é+i
ę+4Űë+ú‡ě+�×
í+ĘU î+“ď+;Eđ+KŤń+žFň+şó+č ô+pő+űÚö+‰‰ů+}‰ú+€ű+,ü+Lý+7ţ+!ä˙+'É€,Đď�,ŢŹ ‚,N© �,™X„,—A…, †,~‡,ç�,ź ‰,b{Š,ç}
‹,©Ś,Y$Ť,÷›Ž,5Ź,�,ĽL‘,ëz’,ţV“, ?”,� •,đ%–,Bü —,2�,Ű× ™,ô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
›,!< ś,ůîť,"ž,Tľ
ź,‡B
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
 ,k/ ˇ,%Ś˘,

Ł,>F¤,´ýĄ,Ćަ,Ť§,"i¨,L±©,ĄŞ,¬1«,\Ź¬,Đ­,jU®,Ĺű Ż,W¤ °,\±,�˝˛,×˝ł, Ý´,.+µ,RR
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
»,0B Ľ,1‰ ˝,wu
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ľ,Vqż,ÇO
Ŕ,HéÁ,Ýť Â,"Ă,Á®Ä,ď¶Ĺ,Đ9Ć,&‡Ç,—šČ,1eÉ,0ý Ę,QË,“!Ě,*Ä Í,Ŕ?Î,C)Ď,ýĐ, Ń,‡«Ň,KmÓ,î9 Ô,dĂ Ő,Ö,SŻ×,tŘ,:tŰ,ÄÜ,µÁÝ,8nŢ,śÁß,Fŕ,ißá,â\ â,¨ŕă,ą” ä, ĺ,�ć,†–ç,ę– č,ç˙é,xA
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ę,0;ë,tě,ěí,†0î,§ď,‘“ đ,"Ěń,Ţzň,jˇó,$˝ô,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
ő,ÖOö,Xö÷,¸�ř,Ż`ů,�ú,µű,6đü,2Ź ý,Ëm ţ,Ř˙,v€-ţ‰�-3ő‚-™K�-aC„-´…-¤
†-Xb‡-rŢ
�-%܉-¸)Š-ZŞ‹-{,Ś-ŽěŤ-ŮuŽ-ž~Ź-ł�-ĎJ‘-ϱ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
’-¤u“- Ŕ ”-ŞŘ•-Ú”–-GŚ —-J �-ş` ™-Ţš-#-›-M'
ś-Në ť-B ž-yJ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ź-Zp -uˇ-˘-pA Ł-uS¤-<>Ą-3¦-Jv§-)ţ¨-MÍ ©-tŞ-•ń«-ąS¬-Í
­-ß®-|Ä
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
ł-×h´-˵-‹L¶-Ň7 ·-ĺů¸-‚pą-�źş-ŇÖ˝-““ľ-ż˙ ż-ój Ŕ-8Î Á-UF Â-ăĂ-Z} Ä-Ćč
Ĺ-µ×Ć-
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ç-u† Č-%äÉ-ˇĘ-8ĚË-ŕAĚ-�©Í-ÍnÎ-ŘĎ-CĐ-ŽŻŃ-�Ň-čÝÓ-OPÔ-©Ť
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
Ö-ľ÷×-^Ř-J!Ů-·<Ú-2WŰ- Ü-—iÝ-ł'Ţ-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
ß-Ž
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ŕ-Ż‹á-Sřâ-sË
ă-•x ä-­'ĺ-=× ć-­�ç-oě č-ü„
é-žŹę-Ěvë-P‰ě-ë—
í-´D î-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
đ-|\ń-Ý<ň-Ĺţ
ó-Ģô-Rő-„Xö-LĽ÷-±Źř->_ů-žä ú-&-ű-.Ś ü--ý-ÇĎţ-,ń
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
˙-Ĺá €.qć�.˛K‚.YV�.óö„.#M….Ĺó†.M˛‡.Ń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
‰.·S
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Š.ÔV‹.uߌ.E Ť.FV Ž.u¶ Ź.ß
�.rş
‘.‚Ě’.ó»“.©ľ ”.}•.bÄ–.7)
—.�“�.ś:™.źF š.qS ›.t¤
ś.žŤ ź.+«  .ý0ˇ.vR˘.Ş>
Ł.ÜN¤.Ś Ą.&É ¦.@%§.×aŞ.‰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
´.k: µ.­‚¶.ý* ·.ŕř¸.­Q
ą.˝: ş.±Ű».â+Ľ.†ž˝.ˇxľ.Ę™ ż.Ŕ.‡ž Á.
ăÂ.IDĂ.:HÄ.ýĹ.ÜŞĆ.ĚŰÇ.sňČ.±ĚÉ.1Ę.ř«Ë.ÔĚ.ŤF Í.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
Î.Łď Ď.ŮyĐ.ş6
Ń.\Ň.†Ó.’Č Ô.ű\ Ő.NŃÖ.(ę×.� Ř.rŮ.>ěÚ.Î3Ű.Ů7Ü.%ÄÝ.S3Ţ.ď˝ß.Wěŕ."Zá.ÔŃâ.šIă.kjä.eÜ ĺ.Śęć.ţBç.+ č.¨Ťé.©Sę.Ő2ë.żĎ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ě.śí.<¸î.Éëď.7đ.&W ń.«Śň./Ś ő.{ůö.ří÷.ďçř.Ëń ů.Łú.U^ű.‡ü._^ý.Ńmţ.·“
˙.Ţ€/X�/Z5 ‚/
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
‡/”( �//a‰/·\Š/ť‚‹/d
Ś/Á>Ť/RćŽ/ł·Ź/$‘ �/Č‘/ü’/©“/Ć’”/á •/8’ �/úm™/Ö)š/nN›/1ü
ś/ˇ�ť/-€ ž/évź/ť×
 /k Ł/Ě5¤/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
Ą/W‹¦/ h§/óA¨/ę:©/7JŞ/)«/ł¬/v
­/2Ř®/u, Ż/ç
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
<˛/Bł/ÇW´/*}µ/]˘¶/ó·/X ¸/Ř›ą/ ­ ş/Ä »/óźĽ/‚]˝/¤”ľ/řż/ďM
Ŕ/*;
Á/·Z Ä/)?Ĺ/ľl Ć/$FÇ/•‹Č/(ˇÉ/łcĘ/ł‘Ë/ť/ Ě/q> Í/ŃyÎ/޶Ď/×\Đ/4EŃ/ N
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ň/´Ő/­LÖ/Ť×/Ž2Ř/ŚgŮ/Ą€Ú/hŽŰ/o
Ü/?Ý/d•
Ţ/ß/ş7 ŕ/Şśá/”Ńâ/´ză/éć/�Yç/5č/^é/Ž¬ę/¬Ú ë/×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
ň/»ó/‡Ůô/a
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ő/u‰ö/!÷/0Éř/wăů/ő®ú/uŕű/on
ü/Żh ý/[ţ/­˙/$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
€0Č �0µp‚0îu�0ş
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
„0 f
…0łŕ†0mµ‡0|�0�Á‰0hŃŠ0hŕ‹0ŻŚ0=Ť0”«Ž0«&
Ź0_ř�0ąF‘0ő± ’0˘?“0Fő”0›ę
•0b|–0śd
—0@Î�0Žc›0¤0 ś0Âť0ż„ž0šź0$¶  0.çˇ0Ő ˘0|ĎŁ08ň¤0SÎ Ą0‹Ó¦0v §0ă8¨0Şß ©0^şŞ0Y«0˙1¬0És­0¶6®0LG Ż0„"°0ýA ±0Ľ‹˛0é˙ł0Ŕ° ´0q‰µ0m�¸0C� ą0ŕÉ ş0 ˝0˙Kľ0Ő]ż07_
Â0ŕWĂ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ÔiĚ0XÍ0(1Î0"Ń0„Ň0oâÓ0nÔ0&!
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ő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
Ů0UŘÚ0ýŤŰ0šŢ0�Ą ß0čgŕ0č(á0O˝â0¤¬ă0'Đä0]“ĺ0:Şć0#� é0^»ę0¦Šë0őó0r‡
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ö0�¬÷0?cř0·rů0é�ú0+ťű0™Ń ý0íR
ţ0:˙0dŠ�1>÷ ‚1R�1—š …1‘đ†1ŤŤ‡1…‰1yŠ1"á ‹1Ţ<
Ś1ÚżŤ1{� Ź1SŚ�1×�‘1“Í”1Üc•1ăF–1Ý“
�1ô¬ ™1čaš1@O
›1Ë»ś1`�ť11€
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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ÂP
 1{ęˇ1š˘1pŁ1÷r¤1Fă Ą1z[¦1”ă
§1-O©1©Ş1ËŽ«1öĄ®1ĚčŻ1rr°1ź‚±1ś$˛17¸ ł1[2´1�е1»”¶1pŞ·1n ¸1ʡą1|�ş1Ű »1śöĽ1iĽ ˝1©Ş ľ1ż>
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ż1ĄçÁ1V‡ Â1˙$Ă1Ż1Ĺ1ý�Ć1©ŘÇ1%ŠÉ1şźĘ1µoË1dZÍ1ň Î1IDĎ1IR
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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ĹĘ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ó1Ť} Ô1<”Ő1s­
Ö1µ;×1tRŘ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
Ű1ĎńÜ1ćÂß1Ď' ŕ1X¶á10
â1,ž ă1yŻ ä1„)
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ĺ1o-ć1á]ç1! č1Kßé1/Fę1k»ë1Ásě1Z¬
í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ł ď1đĎ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
đ1đň15Đ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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‚¦
ő11�ö15/ ÷1ů1ś9
ú1Ěu ű1×Ň
ţ1 8˙1B €2÷�2
č‚2ąB �2âĐ„2Š
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
…2đS
†2
_
‡2T( �2 Đ‰2Ó
Š2ĎĂ
‹2yŘŚ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 éŹ2k0‘2Ö˛ ’2ď“2â•2»‹ –2u—2çß™2Yzš2Ţ5›2ŮYś2]\ ť2‘úž2ŘÔ 2­ˇ2
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
˘2eÁŁ2ë6
¤2�2Ą2x ¦2Íĺ
§2Řť ¨2ř
Ş2ŃX «2ˇ¬2ôu®2˱ Ż2ň°2lŐ ł2“ ´2Úüµ2Ł¶2Źh ·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
¸2FH ş2oK»2nŻĽ2,ň˝2řŐ ľ2 ż2c¤Á2É
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Â2ďš Ă2ěá Ä2ĂŚĹ2`V Ć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÷UĘ2OË2çŚĚ2a’Í2f‰ Î2
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
Ď2gĘĐ2k—Ó2[ĆÔ2,^ Ő2ež
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ö2%×2të Ř2#–Ů2°Ú2ĆďŰ2ÖÜ2‰Ą Ý2+�Ţ2�¤ ß2˛O ŕ2 Ěá2çÎ â2éç ă2?o ä2Ł’ć2Zç2ŤŽ č2� ę2µë2¬°ě2úî2ęÓď2`Ž đ2¦Ďń2hvň2Dó2ä
ő2Ätö2Z ÷2ß9ř2Îýů2Ěžú2a©ű2˙ü2}Í ý2•<˙2ú|€3�ś�3.|„3$%…3Ü †3ž)‡3Ę? �3L^‰3ĆY Š3¸î Ś3¦ôŤ3…ĂŽ3ő6Ź3é�3č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
‘3ﵓ3ť4”3ě•30Η3Ť6�3Ke™3ŞQś3Ľöť3ďž3yź3ÄŚ 3a
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ˇ37ń ˘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
¤3Ú&
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ą39€
¦3·§3zY¨3 ©3ŻEŞ3B�«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
­3´Ç®3O`Ż3E°3Ňź
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
±3—O ˛3}Đł3vÖ
´3v€µ3kÚ¶3J–·3äs¸3-. ą3>2ş3aň»3ŮrĽ3—C˝3ěľ3ő˛ż3ĎćŔ3@4Á3äÂ3­Ă36PÄ3KćĹ3»2Ć3IJ Ç3VTČ3ţ›Ë3fZĚ3ZŚÍ33g
Î3‰4Ď3p‚Đ3l›Ń3ěĐŇ3ČÓ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
Ő3ŞBÖ3Ţ ×3tüŘ39vŮ3�ĺ
Ú3ă©Ű3Ü3ç Ý3fB Ţ3°­ß3SNŕ3ŰŽ á3‚Dâ3 să3Q&
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ä3‡űĺ3Z·ć3 1ç3ČŹč3_—é3–Šę3BÓë3;ŕ
ě3«Ćí3•† î3@"ď3ß™đ3�Üń3k«ň3Mŕ ó3ITô3çS ÷3v) ř3=čů3ěu ú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
ű3˝…ü3OSý3¶e ţ3Î×
˙3s‚€4÷Á �4˛z‚4Śż�4ű „4+\…4ű�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
†4=‡4‹�4Ď
‰4OŐŠ4Ôd ‹4˙Ś4µiŤ4ňhŽ4v*Ź4Î�4¬ú‘4€m’4öŞ “4Wž”4ąË•4 Î –4lÉ —4#Ž �4kś ™4ňš4łj›4dµś4Ů
ť4Zĺž4Kď
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ź4qŤ 4A}
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ˇ4ř˘4®ËŁ4k¤4‡>Ą4¸8 ¦4Ĺß©4ŘŞ4RĄ «4j¬4îs ­4ý«®4yŻ4z °4<±4«Ţ
˛4± ł4îă´4ą µ4+G¶4Ź+·4Ĺk¸4‚ŕą4ÁÁş4˙Ż»4ťzĽ4şl˝4±�ľ4˙Ľż4f´ Ŕ4í Á4ÔaÂ4JłĂ4OďÄ4â/ Ĺ4ę7Ć4®Ç4ŠFČ4ÍŽ
É4±ĆĘ4܇Ë4†�Ě49[ Í4RĄÎ4nîĎ4ô4Đ4˝ĐŃ4ZLŇ4*ýÓ4(UÔ4NOŐ4.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
Ř4ÉŮ4‘Ú4÷ŰŰ4f`Ü4�§Ý4ÔŢ4Ďňß4Nŕ4ýę á44â4L™ ă4Đ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ä4ÂŰ ĺ4Lć4÷Tç4¨Ď
č4Ĺ.é4Ď„ę4Ł
ë4ĹÓě4‡űí4Í&î4đ ď4Éžđ4Â3ń4Ěň4…z ó4h&
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ô43´ő4roö4‰÷4BË
ř48ˇ ů4#‘ú4štű4O
ü4»d ý4Ź' ţ4Ę’˙4C|€5u‹�5Ű
‚5ŇĄ�5ç*„5éý…5ÂÖ†5lá ‡5PvŠ5k‹5Ś5’*
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ť5Ç' Ž5 SŹ5gŮ�5t6‘5c]’5<”“56<”5 ÷•5ĄÂ–5ŰŮ
—5P± �5™56… š54ë ›5�ś5*+ ť5Těž5úą ź5;  59€ˇ5{ć˘5{aŁ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
Ą5Žö¦5źb§5ŞR¨5r#©5ĹŹŞ52…«5Cř ¬5)ę ­5�
®5 Ż5‰ó°5 ±50K˛5­Qł5łŰ´5¬nµ5Ľ¦
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¶5›Â·5đ. ¸5=z ą5™ę Ľ5, ˝5Đ ľ5‰â ż5ɧ Ŕ5c¦Á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}IĂ5Á`Ä5sNĹ5H<Ć5$Ç5]Č5×É5�R Ę5ĂąË5SqĚ5«PÍ5”
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Î5a±Ď5MęĐ5HČ
Ń5î Ň5X¬
Ó5@Ô5Á• Ő5ÁÝÖ5Żh×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
Ů5aě
Ú5ţ0Ű5�˘ Ü5X·Ý5;YŢ5 ß5îĺ ŕ5Ě* á5ĺĺ
â5dÇă5p� ä5ĹŤĺ5Ś:ć5Nw
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ç5PA č5ŰŐ
ë5)­ ě5}�í5ęŤî5/Z ď5{Ôđ5-Ľń5Wń ň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ö5 Ř
÷5¬/ ř5ę´ů5ę
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ú5Żű5�_ ü5§Aý5�·ţ5dď˙5wf€6v• �6˙9‚6Ť@�6)’ „6`ĺ …6ż-†6›ľ‡6
ě�6–‰6ęŠ6
 ‹6µ» Ś6hŔ Ť6fXŽ6źŹ6Ö�6á‘6ä%’63“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�z•69–6Y—6Ťš6Ćť›6PEś6Á—ť65ž6�cź60v 6‘ŕˇ66
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
˘6¨±Ł6™z ¤6ŞĄ6ŽŚ
¦6‘ §6Jɨ6Ä5 «6ńO¬6ůW­6űL®62çŻ6ç°6ÂŃ
±6u…˛6Ě’ ł6] ´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´
¸6Q˝ą6Ő_Ľ6 0˝6ĘĄľ6cČż6u˝Ŕ6/:Á6ÇŁÂ6ŰXĂ6y�
Ä6\ł
Ç6É Č6€ŞÉ6ż�Ę6]jË6eU Ě6hř
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Í6ęŰ
Î6ŃŚĎ6vVŇ6‰’Ó6=%Ô6]Ő6Ó#Ö6ůh ×6•ťŮ6W”Ú6‰Ű6GŠ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ý6xÜ Ţ6�>ß6ˇ7á6Zę â6Zkă6d¸ĺ6»Uć6×ç6j–ę6u,ë67Ëě6Oní6Óí
î6?_ď6#qđ6ű ń6ęň6ĺ*
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ó6ëĄô6ߣ ő6·%ö6tF
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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Ŕä ů6ŕé ú6:ßű6ĺý6ę]ţ6I˙6hm€7iź �7E(‚7~ů„7râ …7۸†7So�77d‰7§iŠ7ëŤ7˙L
Ž7¨ą Ź7‚š
�7îî‘7.J ’7Ų
“79ź”7#ď
•7—7 %�72
™7aš7ŕ­›7^ęś7żť7“Óž73†ź7î6  77š7ř� ˘7´…¤7\
Ą7ë ¦7žś¨7±m©7ęł Ş7ęi«7µ¬7>‰­7Z-µ7‡˝ ¶7l·7p¤
¸7
§
ą7˙„
ş7Ĺ»7ńĂ Ľ7s˝7Öąľ7#^ż7u
Ŕ7°
Á7˝ Â7u˛Ă7ľÄ7&!Ĺ7UXĆ7±ĺ
Ç7—RČ728É7®O Ę7ŤË7l¬Ě7ÄňÍ7ú\Î7|`Ď79âĐ7FŃ7Ý
Ň7ş˘Ó71áÔ7e·Ő7'‹Ö7‚ť
×7LzŘ7Â Ů7_)Ú7*AŰ75>
Ü7îN
Ý7Ëň Ţ7éá7aŔâ7�ă7ŇÎ
ä7’ ĺ7Óć7›5ç7üJč7XŮ é7Rc
ę7Î~
ë7ĚXě7×*
ď7ł…
đ7ń7VZň7ˇ:ó7˛?ô7Ôő7ĐĎö7łE÷7Mâř7č
ů7Hlú7ŢÄű7$d ü7Źíý7Öšţ79}˙7Ĺó€88ö�8쯂8Ó�8Đ4†8!
‡8ę9 �8˝‰8Š7 Š8‰@‹8Í
Ś8ţ Ť8lŽ8eô Ź8s˙
�8Dç ‘8q
”8YA•8¦_–8 Ł™8®Ôš8f<›8ÁBś8€Ěť8]żž8ćjź8  8Ű`ˇ8Ĺ›
˘8>Ł8)ؤ8µ�
Ą8a¦8żú§8k
¨8‘— ©8ëí
Ş8ⶫ8ř·
¬81L­8Óö®8ixŻ8|č°8Ű| ±8ib˛8y�
ł8¸Î´8RHµ8úB¶8Hä
·8Óø8ž™ą8ĺTş80W»8`Z Ľ8˝8ţľ8.Áż8€şŔ8;m
Á8xÂ8–—Ă8ůÄ8%ŮĹ8ŹşĆ8d¨Ç8ćżĘ8XŔ Ë8ă Ě8„ÍĎ8€Đ8ă˙Ń8un Ô8�ŤŐ8Ő`Ö8�˙
Ů8„-Ú8~T Ű8[z Ţ8Ź—ß8ć;ŕ8›ô ă8Oä8x)ĺ8?ö
č8gĐé8ÓĆę8Fšô8iő8Źúö8Ż÷8˝ěř8 v ű8b¦ü8ý8MÓţ8.-˙8}Í€9´9�9ř‚9ÉŢ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�9ć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
†9b‡9{+�9=�
‰9pxŠ9dŐ‹9^�
Ś9Ť9Ň@Ž9úŐŹ9Ýq�9_“ ‘9)Ë
’9¶W“9Q° ”9˙u–9‰Ô —9ÇĚ �9÷™9!š9µf›9ͱś9€µť9ls ž9$ěź9Ęj 95D ˇ9¸4
˘9ëî
Ł9Ä�¤9´Ô¦9Ť5§9ţ#¨9._
©9�S Ş9 u«9Ž.¬9µ­9Ď\
®9—ŔŻ9âŇ°9Ąz±9řÖł9Ţ' ´9e:µ9‹ ¶9˘Ľ·9N‰
¸9Ď ş9?»9€ÜĽ9Á–˝91‚ľ9_&ż9}Y
Ă9gľÄ9”8
Ĺ9fËĆ9˛Ŕ Ç9ťů Č98ŰÉ9GĆ Ę9fÔË9Éń
Ě9*Í9µaĐ9÷ Ń9¦‹Ň9e;Ó9ŰĽ Ô9OŐ9“kÖ97y×9ôŘ9$ŰŮ9ÚŻ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ú9Žü Ý9BnŢ9ů•ß9iŕ9 á9¬’â9tă9×ä9ý€ ĺ9Űöć9Ňç9‹ę9'o ë9iŞ
ě9¬† í9cŢî9ZŞď9÷đ9rń9^Óň9>Ďó9g‚÷9Ť°ř9-†ů9­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ł\ű9{ţ9)Ľ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
˙9 ő €: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
�:Ge‚:oŘ…:Pn†:»n‡:ńÎ�:űƉ: ň Š:řw ‹:÷‹Ž:?wŹ:0
�:8Ď
‘:›s’:8#“:Aě –:ľÝ—: c �:jŞ™:šš:ő5›:†©
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»­:üt®:Ţ«Ż:‰�˛:8Ał:w´:ôÝ
µ:: ¶:Č-·:ço¸:čž »:fü Ľ:ą
˝:xŤ ľ:Óż:Až Ŕ:ŹĂ:éďÄ:Ń^
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ĺ:÷öĆ:€UÇ:Ň´É:u÷
Ę:ĺçË:ÔÇĚ:6dÍ:$î Î:�Ę Đ:¸ŠŃ:ë–Ň:XŹÓ:†‰ Ô:8¬ Ő:�»Ö:×:x‹Ř:3ËŮ:f{ Ű:˙Y Ü:¬TÝ:¤#Ţ::×ß:5Aŕ:ă
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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 í:Děî: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
ň:ßNó:#¦
ô: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
ő:y+ö:?'÷:¸Ťř:mpů:Éü:ŘŁý:ž˝ ţ:&˙:ű7 €;Ů �;É‚;�;ż„;ş…;Z| ‡;g{�;XŢ ‰;§®Š;ôa‹;»Ś;>·Ť;ç
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ž;ŚÍŹ;|�;F5‘;ŚJ“;Đc”;Ű%•; ·–;2- —;&�;K2™;5ó
š;ĺy›;Jşť;ľž;’Ť ź;Ú!  ;ž] ˇ;Ië˘;ÖOŁ;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
Ą;�X¨;U* ©;\‡Ş;Ńr«;Í ¬;<s­;¦Ä®;1(Ż;xX°;†Ô±;�&
˛;źôł;Ç4´;đž
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
µ;´đ ¶;í·;]G¸;FÄ ą;›Cş;u
»;~Ľ;XĐ ˝;®!ľ;Ălż; őŔ;•(
Á;]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
Ă;(m Ä;H“Ĺ;Wđ É;ŇŁĘ;ß:Ë;muĚ;( Í;,Î;´0 Ď;^TĐ;†Ń;"Ň;3gÓ;ĄÔ;ř(Ő;t� Ö;–>×;Śź Ř;ŕźŮ;ŕóÚ;ü�Ű;tĆÜ;h€Ý;’o Ţ;D
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
â;9 ă;Lä;ŤQĺ;ˇ’ć;;sç;-Š č;şÄ
é;í�ě;�Eí;íoî;M2ď;ś…đ;wÚń;Cň;‡P ó;ł*ô;MXő;>»
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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~ř;â5ů;‡ű ú;6‡ű;Ţ=
ü;l»
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ý;ťtţ;…˙;/¬€<đá
�<Wô‚<J�<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
„<Ť…<c†<'>‡<7“�<"˛ ‰<Ý‘Š<§ ‹</ZŚ<OíŹ<íJ �<¸‘<!Ĺ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
’<¤“<°c•<[y–<I…—<Ž�<U™<HĎ›<ńë ś<s1ť<#Łž<T.ź<í…˘<gĎŁ<Ö¤<¦Ą<2%
¦<C�§<· ¨<šµ©<ŠŞ<ĽĎ «<©»¬<߬­<!®<ĎŹ
Ż<ýW°<O' ł<8V´<;̵<ĎO¶<KB·<±§¸<>ą<ţť
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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˝<1xľ<Ůż<ľă Ŕ<üŔ Á<ě)Â<X´Ă<ÚľÄ<=— Ĺ<"%Ć<ĎâÇ<Ă‚Č<ťgÉ<eíĘ<†—
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Í<ŐÜÎ<í Ď<n?Đ<6Ń<ÔšŇ<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
Ô<™.Ő<Ľ¸ Ö<Ć×<ÎaŘ<â>Ů<ďľÚ<€}Ű<®¸Ü<âÝ<cí
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ţ<‚ ß<Çŕ<Ą6
á<ů.ä<O ĺ<zÁ ć<E…ç<żEč<I\é<çŃę<Şë<×&ě<źŁ í<Ăă
î<'ď<Żż đ<Ď
ń<řŘň<,} ó< ô<˙ĺ ő<ôö<{÷<"&ř<{ů<…iú<33ű<H ţ<qó˙<Šâ
€=Źd�=ż
‚=Oŕ�=Ăž †=B͇=Źv�=o҉=q&
Š=…â
‹=Ý}Ś=1üŤ=ú Ž=Á› Ź=: �=Nô ‘=˘} ’=Ć;“=90”=ä •=č–=·—=Ef š=ËŢ
›=<Ü ś=Ó«ź=źP =nŚˇ=o* ˘=§…Ł=° ¤=üą Ą=Š¦=�R§=�
¨=LG©=Ú” Ş=‰č«=›®
¬=Úy ­=ű°=#‹ ±=Żň ˛=S^ł=#´=Ây
µ=_ë
¶=5¨·=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
¸=Mcą=şA ş=ćŢ »=qpĽ=m¤˝=ńţľ=ŻŽ ż=µŔŔ=ăśÁ=.+ Â=Ť»Ă=˙úÄ=jăĹ=ăź Ć=¦ÉÇ=aĘ=Ŕx Ë=ËżĚ=ß=Í=0ŮÎ=A€Ď=#Đ=§ŚŃ=ĽŃ Ň==Ó=†µÔ=Ť Ő=L‡Ö=č„×=<s Ř=±Ů=÷™
Ú=ű› Ű=#ű Ü= ÖÝ=¨@Ţ=Š=á=9
â=1éă=% ä=2vĺ=çić=Č&ç=Ç č=¸@ é=7ę=?ąë=o>
ě=(dí=V¨ î=­ď=¶Ňđ=ÝŘ ń=ż6ň=ő%ó=·Ë ô=;ő=.ö=öć÷=(] ř=Ú8ů=
m ú=Š¶ű=Ćü=Ćčý=;Ŕ
ţ=X�>á1‚>�>¸_ „>S‡
…>i@†>D‰>!ËŠ>1‹>šŚ>\`Ť>Ů{Ž>Ł±Ź>Ń�>ść‘>É°’>Ś�
“>”Ď ”>śk•>*–>pá —>Fx�>§ű™>;Ľš>qöť>qK ž>Čź>g  >2ġ>đ
˘>[L Ł>Î�¤>ĹgĄ>·�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¦>Sͧ>Ű: ¨>$©>‹rŞ>ą«>c ¬>k4­>»{ ®>źĐ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
¶>ů—·>�v¸>"Ą ą>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
ż>Ě8Ŕ>¶ Á>l™Â>Š|Ă>.… Ä>đÝĹ>·—Ć>Ź± Ç>-± Č>ZżË>łOĚ>«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
Đ>
ĂŃ>($Ň>Y…Ó>
Ô>Đ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ő>ĺd
Ö>Ł`×>9IŘ>/ÔŮ>[[ Ú>î¶
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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ŕ>żá>Ć5â>¬Ź ă>U>ä>żP ĺ>őďć>¸ěç>A�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
č>ßÉé>’:ę>,Áë>ú( ě>2oí>ńbî>¨¬
ď>łĄđ>ŧń>Ľ_
ň>“‚ó>-Qô>§© ő>E0
ö>ý÷>@6ř>Ĺ ů>T~ú>ô ű>%:
ü>�=˙>?a �?ľ\ ‚?D©�?]8
„?ń‡?±ˇ�?G�‰?˙űŠ?úX‹?—‹Ś?źxŤ?= Ž?Ô Ź?b§ �?.9‘?´‰’? ü“?äw”? f•?ýÜ –?kË—?EC �?źx›?ł…
ś?ߏť?é!ž?»’ ź?g€ˇ?~Z˘?n Ł?A•¤?C1Ą?'±§?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
¨?Ĺ©?\;Ş?ţ7«?«‘ ­?F•®?Ř‹Ż?’Ý°?ËB
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
±?Ěďł?4M´?Aëµ?Ź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
ż?�ŐŔ?ë Á?PŻÂ?­
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ă?˝Ĺ?d_Ć?MöÇ?|9Č?JąÉ?׊Ë?ÎbĚ?NĘ Í?„�Î?*Ď?§đ Ń?śě Ň?ä´Ó?ŞNÔ?µÁŐ?Ł¦Ř?âá Ů?áC
Ú?,‰
Ű?iĽÜ?Ř>Ý?VcŢ?çĹß?é@ŕ?Šáâ?…Ó ă?l�
ä?R¨ĺ?őřć?-zč?bé?ÂŽ ę? ´ë?{*
ě?tżí?»ď?Ąđ?řń?´ľň?€ ó?Ź  ő?yťö?^,÷?Iîů?t–ú?Ôgű?ää ý?é=ţ?‘ ˙?HW€@™˘�@‰_‚@Ç
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
…@{Ą†@:µ‡@) �@‹ă‰@kDŠ@¦f‹@@
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ś@NŤ@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
Ź@m¸ �@¶8‘@Đś ’@ł(
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
“@/ ”@čR•@ťů–@ý}—@®�@ß’
™@9U š@ŐL›@‡eś@éĺť@ý
ž@&*ź@ŘŐ @ö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
¤@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
W§@ : ¨@Ë6©@� Ş@“s«@)¬@“­@””®@ŞŠŻ@6Ő°@€@±@ k ˛@Ćč ł@ć´@ŰÖµ@ĺ�¶@‰ý·@ş9ş@"Ö»@{Ô
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ľ@h˝@Â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
ľ@p ż@Ś‚Ŕ@ă¨
Á@—vÂ@’ö Ă@˙ÝÄ@X]
Ĺ@‚'
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
Ç@/ěČ@’É@]µ
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§Ô@ĽĹÖ@am×@„Ř@]‹ Ů@ę+Ú@¸ Ű@TAÜ@ŕ:Ý@X©
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ţ@â!
ß@KÖŕ@qé á@uôă@˛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
ä@§Gĺ@;˛ć@Ď%ç@·č@}Ä é@>-ę@ăąë@.­ě@˝í@˝kî@Tď@Gxđ@8
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ń@^ň@Qxó@ç) ô@.ő@*Š
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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ű@»¤ü@C
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ý@Xîţ@‰�˙@ €A:í‚A”’�AŔ„AZ�…A�4†A4”‡A‹;�A´& ŠA?»‹Aő_ŚAőpŤAí)ŽAłšŹA„
�A í
‘A±U’A#n
•Aa–Aęč—Aů˛�AŹY™Aǡ
šA1›AĚ–śAâg
ťA"TžAJ źA j A˛ ˇAjb
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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ŤG
ŁA7~ ¤AÇö ĄAő¦Aßű©Aş4ŞAJN«Aý€¬A*@­Aač®A<ĆŻA&Ô°A¶–±Az˛Am
łAf6 ´A%}µAË[¶Aއ ·Ańp¸A6ląAÔÇşA˙ »A…HĽA)˝A2´ľAÖżAD™ŔAĆu
ĂADcÄA•J ĹA'Ť
ĆA;`
ÇAl9 ČAĄWÉA�ŤĘA<
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ËAË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
ĚAn(ÍAł?ÎAY«ĎA'ĐAŁ�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ŃAT>ŇAÖ�ÓA‚WÔAş•
×AYcŘAX}ŮA>ÚAŘM ŰA»— ÜA,žÝA‹·ŢA-TßA»ŕA,öáA¨iâA+yăAýŐäAŮ
ĺA„ćA,ŽçAsKčA  éAP ęA— ëAµľěA5–
íA€îAąÎ ďA]đAťÉ ńAŔ ôA�‰őA˛öA ‰÷A”×řACg ů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“ ýA¨3ţAţ= ˙AS±€By6�BďÍ ‚BçŢ
�B®
„Bx±…B“Ą†B~Ő‡B •�B R
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‰B|sŠBŚ‹B�%ŚBř=
ŤB�*�BŤ€‘BŰÚ’B†Ů“BčC ”B••B˙c�BĘd ™B¦šB:›BbśBaÉťBýfžB–VźBř—  BÄüˇBç ˘BÄtŁB�H¤BjLĄB¬î¦B j§B”•
¨BWI©B>o
¬B}ź­B6‰®BŻBô°BHj±BXó˛B<–łB=í ´B5pµB;a¶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čĎąBťşBćą»Bś6ĽBSă ˝B—ŮľBóCżBz2ŔB&Á
ÁB–oÂB(¤ĂB˝] ĆB´}ÇBU˝ ČBľ ÉBuâĘB!LËBóş ĚB�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÍB�ÎBŻ* ĎBfa ĐBQŤŃBÇŠŇBÄ�ÓBÔBňy×BŁŻ ŘB9+
ŮBm< ÚBś" ŰB)
ÜBk ÝBŤö ŢBQ°ßBI{ŕB;řáBm›âB; ăB} äB¤ĺBFćB
$çB} čB5uéBaqęBuëB§ěBW*íB/[îB6ŻďB“ąđBŔžńB×]ôB>Ť őB[Ń öBłZ÷BĂž řB�
ůBµ üBĚ
ýB4†ţB%Ú
˙B�®€Cí �C6�‚C �Cfů „CąC…C­¤
†CéD‡C¤�C˘;‰Cĺ­ ŠCti ‹C�?ŚC ó ŤCş�C4®
‘C-ą
’CEť“Că”CÉÝ•CłXťCnžC  źCG  CġCő˘CÚ ŁC˙đ¤C…™
ĄCÚ%
¨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
©CM§ŞCÉ«C·
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¬CĽe­CGţ
®Cž¤ŻCôk°C$p±C‚‘˛C.nłC~�´CÚB µCs�¶C–Ą ŔCÁVÁ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ÄC{†ĹCëFĆC* ÉCÁ/ĘC‘
ËC�Ň ĚC’üÍCĘ ÎC¦çĎC0—
ĐCßŔŃC| ŇCč[
ÓCjüÔC¬0ŐCdk
ÖC43×CÓRŘCÇŞŮC%�ÚC%ô ŰCAĘÜCšÎÝCň&ŢC’É ßCHŕCLňáCKš âCăC˝äCř‚ ĺC©gćC÷ďçC,ŁčC� éC$ËęCŠôëCóWěCŞíCpR îC6ďCůˇđCX—ńCިôC ÜőCAköCď­ ÷C%řC;LůCŤĺ úCYűCqb
üCxäýCÝŻţCŮÜ ˙CDĎ€D*ú �D}e ‚D ¬ �DBU„D™Q …D”߆D™> ‡Dvť �DOg‰Dß ŠDZ
‹D›K ŚDpŔŤDú ŽDĄŹDÖ�Dşz‘D�– ’D3ô“D6P”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
ÜšDü”›DśDSŹ ťD_$ D¨9 ˇDtń˘D®:ŁD�ޤDŠŮĄDŇ·¦D„“§DUÓ ¨Dr” ©DAŠ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ŞDö«D+/¬DV¸­D 
®DaăŻD썰Dev±DBŲDő÷łDp0´D�mµD] ¶DE�
·D Ř ¸DçÔ ąDR´şDŃÇ »DŠĽD�#˝D˝ľD�żDƦŔDWâ
ÁDÂDŇ3 ĂDuŚÄDż�ĹDĆDđ<ÇD´ČD;H ÉDG@Ę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 ÎDńČĎDMŢĐDç2ŃD„]ŇDnOÓDç´ÔD±ŽŐD¸r ÖD/ő×Dű+
ŘDalŮDĎ ÚD@ŰD8nÜD–:ÝDNŢDu3ßD+ř ŕDĚN áDj,âDňŔăDDÍ ćDd±çDCčD<éD7]
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ęDtëDbŃ
ěDOŔ íDGˇ îD€ŢďD©(đDiăńDŤż ňDť–óD•w ôD-˝őD&1 öD‹l÷DÚBřDú{ ůD»AúDżűDĆrüDV¬ýDĹţD9˙DUč€Eß�Eś…
‚EŞA�E,Í„EľĚ…E†*†En‡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Ź‰EbJ ŠEF‚
‹E�< ŚE™HŤEŕ’ŽEŮeŹEFS�EĘÚ‘Ety’EŹ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
“EÁ ”Eďz•EöM –EBL—E˝á�E(¸™E.¬ šEyë›E#ižEżXźEÄ” E?ˇEŻ ˘EKjŁEަEńo§Es� ¨Em7«Eáł ¬E–M­Ef®Eßż ŻEc°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
˛Ew¨łE´D´E_LµEvx ¶E y ·E|‘¸Eč
ąEşEĂ!»E‰§ĽEw˝EkšľE—żEčJŔEů
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÁE‹ÂEeĂEŹ™ÄE`Ú ĹEą> ĆEţéÇE– ČEžW ÉE±6ĘEmËEÝĚE•ÍE�žÎE“ýĎEěhĐE,ŃE—2ŇEÉÓE†ZÔE_mŐEk´ ÖE¦Ľ×ENµ ŘEš§ ŮE¶ě ÚEDů ŰEąĚÜEłt ÝE(ŢEë’ßEŃ ŕE ráE� âE ÝăENÓ äEŤ•ĺE¨ ćE@
çEgŚčEq' éEBµ ęEQö ëEĘ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
íEHĎ îEMńEIKňEýĆ óERmôEŐőEO’
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
öEcÎ÷E�[řE0—ůEĘÓúEÇ’űEEą üE‡ýE¬ć ţE±˙Eąl€FŻ{�Fż3
‚FÚ†
�Főo „F‰n…FŹ“ †FÝZ‡F± �Fgî ‰FwÝ Š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„]
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ŽFűł ŹFÉ�Fa˙
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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ÉG’F`u“F¨ă”Fk •FŢ –F†¦ —F ľ�F¦ú™FđÚ šFýn ›FRš śF^ ťF‡
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ž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Ě3 ˇF@ ˘F^Á ŁFÂ)¤F_ ĄFCĹ ¦F9§F=¶
¨FĎ_©F ŞFţ' «FîĆ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¬FŠP­FĎ› ®Fkš
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ŻFne°FŐ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
±FÜ{˛F-˘ łFÉ—´FU’·FĽ¸FPb ąF—JĽFc˝F7QľF|×ÁF]PÂFĂFôÄF_ÎĹF<ĆF,
ÉFU) ĘFćš ËF! ĚFPÍFĎtÎFúś
ĎFk#ĐF”“ŃFÔĚŇ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«fÖFĆN
×F4$ ŘF>ŮF®Ę ÚFYóŰFÁ[ ÜF�Â
ÝF ŢFNßF‘ÄŕF.9áFJ‘âFťŁăFŮăäF’Ď ĺF^ţćFkŰçF J čF{éFéžęF¦„ëFŇěFGˇíFľîFľ6ďFHËđF
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¨ńF�b
ôF=Ź
őFYŘöFQ~÷F µřF1‹ůFĆÎ úF¬ĽűFĎüFˇçýF”zţF«n˙F�; €GM3�G9C‚GĹI�GLż„GoĚ…Gă †Gőű‡G¤×�Gčs‰GĹoŠG)‹GrEŚG¤žŤG(ÖŽGt´ŹGě…’GČk“G_”G9C—GBN
�G%™GyăšGPŇ›G 
śGďqťGH žG'¬źGy¤ Gg° ˇGöO ˘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”d
ĄG/ΦG­2§G8¨GQ®©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ŤńŻG5O°G7ę
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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ăp łG`´GĎhµGô- ¶Gp´·Gż=¸G.Đ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ąGę[şGĚc»G埼GU}˝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
ÁGb˘Â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ďŽÇGn%ČGŤĹ ÉGClĘGKG ËG~o
Ě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ĂĐGIkŃGćĚ ŇGŤČÓG¬; ÔGmAŐGź ÖGKP
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
×GšŘGŽřŮGşT ÚGědŰG÷RÜG¸QÝGŚ”ŢGxÚßG‡­ŕGš
áGX'âGşď ăGŔ äGžĺG
ćG'O çG+đ čGúĎ
éGł– ęGQÇ ëGŠěG[Ď íG îG0ŰďG|đG?ą ńG&žňGpóGĆt öG_=÷GšEřGŐłůGsś
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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;űGH«üG‡˙ ýG'—ţGA¶˙GPQ‚H+t�H p „H‡Z…HťŞ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
†H%o ‡HĆk �H)‰HĐďŠH¤‹H 'ŽH ŹHś»�HŠW‘HśĹ’H 
“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
–H­D—HÝr�Hă_›HÂs
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
śHa6ťH!í HÁšˇH9t˘HÉLĄHĆP ¦H&?§He9ŞH¦S«Hú¬H‰0ŻHJ´°H­× ±H-'´He^µHy© ¶H©ąHňşHPr
»Hl]ľHÍ żHA’ŔHUg
ĂHměÄHKj
ĹHäLČH)Ľ ÉHŞśĘHEÍH‚üÎHZWĎHlĄŇH÷4ÓH˙ ÔH 4×HľFŘH"‹ŮH»g ÜHŽÝHőžŢH áHVZ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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“óăHž8 ćH�]çHý čHô¶ëH¶űěH�ÎíH7ö đHÇÚńHΠ
ňH"sőH2šöH»,÷H÷ÍúHďŃ‚Iâ‹�I:„I¶
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
…I®7†I"/‡Iůü �IeT ‰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
ŤIfLŽI®őŹIčX�Iqä‘IiŮ“Iˇ ”IŇ›•I )
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
–IŰš —IŚ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
™IÜšIÜ›I#śI�DťIč?žIg
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
źIFY I˛U ˇI
˘IpâŁIjź¤ITĎĄI�ů¦IÖ�§Ié=¨I’¦©I[íŞI´Ç«IŞ'¬I…W­Iđ®IĂŻIâv°IÓ`łIőB´II]µI”�¶I}’
·Ióe ¸Iy ąI5ßşI†O»I¶I ĽISŁ˝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Ö6ŔI6
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
ÂI_
ĂI
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
/ÄI?…ĹIĽgĆI"±ÇI=BČI\9ÉIë5
ĘIŐËIřR ĚIťÍI­·ÎI]8ĎI}ń
ĐIŁOŃI)ŇI9ÓIęÔIȤŐI±F
ÖI>„
×IM: ŘIńşŮIZ
ÚIÍ
ÝIp™ŢIĺ ßIŕI‡ŠáI��âIµOăIáäI…H ĺIŔęćI;;çIč�čI éIţÖęIE}ëI ěI„íI<‘îIfD ďIhČ
đIýGńIöůňIŚóIłôI`RőI�ŠöIxŻ ÷IjfřI†«ůIe1úIşPűIŢo ţIÇ ˙I§˘€Jqq�JĐß„J’ë
…JÔ �J`‰JnôŠJQ=ŤJ K ŽJOŹJ/ —J»L �J›’™JËšJŚŞ›JZ śJűŘ ť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ŚĚ ˇJ�U˘J¤™ŁJ®¤JşĹĄJŽ2
§J��¨J�Ľ©JÄŞJÎÄ«JZ ¬JŮć®J–ő
ŻJďM°J?ç±Jď ˛Jz łJąí µJF
¶J%h·J=¸J† ąJúň
şJ}‹ĽJÖ[˝JC{ ľJţŽ
żJz ŔJt
ÁJăZÂJąąĂJl­ ÄJÂŃĹJµĆ ÇJ/& ČJ0MÉJ¬oĘJ·9ËJdVĚJJÍJüµ ĎJZN
ĐJ
ŃJ•F
ŇJ"¦
ÓJŰÄ ÔJ˛ą ŐJř�ŘJŮJ’ÂÚJäEŰJŤeÜJN’
ÝJT ŕJAöáJQ= âJóăJÚoäJB
ĺJ4EčJcKéJŕť
ęJ"ęëJ ěJý íJő đJśşńJźńňJąóJVn ôJ™¶őJŔ7öJ
 ÷JzřJTůJŔŞ úJ]6űJ-ÄüJć¬ýJk-ţJRŤ ˙JĹA€KsÓ�K¦Y ‚KđU�KŻ¬„K‚…KM‚†Kه‡K�ů�K:( ‰K„ĚŠKŔ‹KµĂ
ŚKÓĺ ŤK÷çŽKk
ŹK‰ť�KEQ ‘K
’K–Ö
“K"ż ”K •Kno –K^ţ—KßP
�KN4
™K¦šKxň›KśKú5ťKč žKŠ.źKBG K¨é ˇKŃ˝˘K~ZŁK ˛
¤Kr„ĄKĎĐ
¦K~/§K&
¨K@›
©Kő
ŞKAŠ«KĎj¬K+2 ­Kµ´®KˇyŻK‡¤°K¦ż±Kt?˛Kz}
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
łKÉ´KÁµK†Ą¶K1W·Kű7¸KçąKaňş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(ËľKŕ
żKźĐ ŔK­ßÁK¤ZÂK’ˇ
ĂK¨ĆK·'ÇKâď
ČKĆÉK¤µĘK+3
ËK¸ĚKąO ÍK„ŇÎK? ĎKÜó
ĐK�ŽŃK^%ŇKC°ÓK
}
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÔKŽŚ ŐK›ŹÖK ; ×K®wŘKÓ$ŮKlcÚKĹý ŰKT»ÜKKÝKYŰŢ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
ßKç^ ŕKˇ¤áKŕ
âKޤăKű�äKÍÎĺKGo
ćK5
çK[öčK;‰éK;÷ęKŃßëKËé
ěKá• íK
îKYŽďKůKđK/"ńK¤ŃňKXÜ
óKÖhôKŽkőK¸° öK§÷KzřKĄ.ůK©†úKh
űK0üKˇ ýK?łţKž˙KŕŔ €Lˇú�LáT‚L¦Ű �Lzc„LńF…L»h†Lɢ‡L' �Lň™‰Lš?ŠL~‹LZMŚLŇëŤLĘ’
ŽL­•ŹLí�L ‘LťŇ’L˛‡“Lîŕ”L‘ •L…Đ–L>Ô—LÉ�L´z™L ¸ śLĐů ťLB žLçźLo LơLP˘LÍźŁLŕ% ¤L—-ĄLK4¦Lň§LN¨LćÚ©LĘŹŞL8Á «LG
¬Lȵ­Lß„ ®L+…ŻLµl°L»ä ±Lčµ
˛LŻ4łL´L¤´µLĘѶLŕ6·LmJ¸L´‘ąL|şL�X»L5­ĽLÇŢ˝LZŢľL<pżL×î ŔLÄŔÁLÂLÄĂL“ ÄLBáĹLQŇ
ĆL·ÇLޢČL=śÉLůä
ĘL.ËL;gĚL2ÍLe ÎL)gĎLPLĐL•ËŃL%W ŇLâsÓLxő ÔLřÂ
ŐL˘F ÖLŤ· ×LbuŘLŘľŮL•WÚLͧ ŰL[ęÜLg�ÝLťpŢLĹŔ ßL0:ŕLÂŘáL4âL5ăLişäLpĺL;žćLNĆçLůOčL/ĽéLî˘ęL…sëLľěLđ íLZ îL??ďL
ÖňLV¶óLĐ ôLµ÷
őLpĂöLoč÷L_Ă
řLď�ůLJäúL:�űL‚…üL3ČýLîZţLYË
˙L™\€Mýe�M°c ‚MŘŰ�MÉC„Mţ…MŔř†M˝^‡MCZ
�MMz@ ŠM •‹MÔÇŚM÷< ŤM^?ŽMš' ŹMm �MśĎ‘MÔI ’MÝΓMő”M«
•M$®–Mkć—M—Ŕ�Mş™Mk šMĘ“›MZ•śM�JťM{™žM¦ źM`r M%SˇMç̢Mń±ŁMĄî¤Mĺ× ĄM„ ¦M–8§M}U¨M]š©MÔŘŞMÍ«MĐÔ
¬Mz’­M±ü®Mý ŻMz*°Mŕ±M¦˛MőţłM–z
´M6NµMÎŶMÓ·MÔq¸M‰ąM˘şMr°»MM
ĽMűę˝MŁľMőI
żM%ďŔMĺ* ÁMÉ ÂMZĚĂM'ÇÄM�Ü ĹMęć
ČM|«
ÉMŢ ĘM8aËM×ÍĚM•č ÍM\wÎMÓŁ
ĎMy!ĐMqö ŃMź'ŇM/ ÓMJüÔMUOŐMUůÖMÚˇ ×MI
ŘMŮĺ
ŮMß‹ÚMëźŰM1%ÜMF‘
ÝM®t ŢM�ŰßMĂ3ŕMđáMµ9
âM)4ăMÉ
äM#"ĺM,4
ćMj+ çMĽ
čMT/éM
ü ęMJVëMM*ěMçíMÖŘ îM*Ľ ďMč%đMÎ$ńMI»ôM¦h őMîQ
öMĐ
˙Mµy
€NŔD�N¤e‚N€ű �NýĐ „N§.†N·3 ‡NOŐ�Ni ‰NŮ) ŠN_- ‹NAŤN1Â
ŽNźd ŹN–Ŕ �N¬ź‘Nřg “Nź�
”N2— •N^Ü–NĹ}—NOŤ�Nő† ›N śNwťN÷ žNľá
źN� Nü�ˇNC˘N.
ŁN�ŃĄNô¦NĘI
§N2R¨NţD ©NkŞNP^ ¬NŃ}
­Nsf®NšQŻN·L °N+˝ ±N�÷łN­‹
´N|nµN�0
¶NÓî·NBń¸N‚§
şNři»Nl4ĽNĽt˝N��ľN"żNŁ� ÁNđÂNxGĂNĄ<ÄNĆíĹNó
ÇN€bČN×ÉNl·ĘNŠd ËNKţ ĚNĄ ĎNŤŁĐN˘řŃN’/
ŇNˇ ÓN�\
ÔNÖ; ŐN¶FÖN€®×Nűö ŘN
 ŮNµÚN\‹ŰN*‡
ÜNuÓÝN,ź ŢN#Q
ßNŔsŕNýŤăN�? äNéĺNTŘ ćNŻű çNźw čN ëN­ű
ěNt˘
íN7ţőNIöN7Ł ÷NX)řN«‡ůN„şűN´ĘüN7źýN@ÝţN˛˙NR‘‚O‰u�OMo„OŚ‡…OÉ` †OŹ �OѤ
‰Oş™ŠONo‹OÇĘŚO*eŽOÖţŹOĎ�O8-
‘OŠn’O}§“O�•Ox
–O‹#—Ou%�O{ ™OWJšOzĎśO?ŘťO.őžOŮ$źO¨n OJ5
˘OvjŁOP¤Ov•
ĄOq˘ ¦OX§OŃ~¨Oü©O’ąŞOÚą «O�°
¬Oă­OÁ–®O˘¤ŻOBf°Oy@ ˛O4Ű łOž]´OÔ µOŻł¶O&ž·Oö¸O“ŚąO¤ěşOnxĽOĘô˝O›ŠľO»E ŔOÇ� ÁO4´ÂO
ĹOWµĆOš„
ÇO
ČOŃxÉOćĘOw7ĚOĺÍO%h
ÎOH]ĎOD ĐO·ŽŃO îŇO;9ÓOÉ ÔOó„ŐOC–ÖO8~×OŹwÚOŘnŰOä
ÜOJfÝOQ´
ŢOľ/
ßOĎŕO 
áOŞâO‚OäO«Č
ĺOdű ćOfçO» čOđ éO;5ęO:„
ëOÓKďO_ŰđO˛đ
ńOźfňOęňóO
ôO#ůőOŞÔöO 5÷O{3řO\ůOŞ<űOYÄüO3 ýOĹţOˇt˙O_…€P¨<�PĆÍ‚P‘Đ�P�Ä„Püq†PÂ(‡P±î �P�·‰Pé ŠP ţ‹P´ť ŚPŰ—ŤPô ŽP{‘PĐš’P©=“P…Ś”Pů˘•P…x
–PťK—Pđ•�Pď.šP™›P™1 śP4cťPrÄžPń
 P6 ˇPҢP§ ŁPîŕ ¤Pq‰ĄPÓá¦PNv¨P<ű©PçRŞPíÝ
­PG®PÎÉŻPłĽ °P‡±Pö‹ ˛Pľ łP6Ö´PâĺµP«¶PÝ€·Pąá ¸PÝ°ąP9h şP=Ö»P§ÄĽP:’˝PaŇ
ľP釿Pyß
ŔPÁP
GÄP<ÚĹPÓ ĆP%=ÇP´,ČPľÎÉPçqĘPXËP{GĚP>‡
ÍP˙
ÎP©ĎPśş
ĐP¤7 ŃP'µŇPą1
ÓPńC ÔPšTŐPţ§
ÖP ×PŽTŘP;šÚPP…ŰPüJÜPyO ÝPöÜŢP|ęßPXâP ăP8cäP÷é
ĺP+ZćPŚĘçP™čPO3éPSęP‰
ëPzd
ěP˛ďíP(;îPGďPŇPđP˝ÜńP=s ňPkµóPn°
ôP‹6őPö»öPázůP®J
úPjśűPš“ţPŻ ˙Pű €Qmđ‚Q'
�QÔ† „QÚ¦…Q,†Q _ �Qg ‰QĄŇŠQwc‹Q ˇŚQĎ@
ŤQ«Á ŽQ3'
ŹQ_ń�Qrľ‘Qóá’QzŔ
“Q{ –Q;'—Q̧�QZ×™Q»…šQőĚ›QľŔťQŤĎžQTY źQ€  Q2Ď
ˇQS˘Q0¤Q�\
ĄQdŠ¦Q‚,
§QZn¨QĂ ©Q�,«QôÓ¬Q«‘­QF‘
®Qťá ŻQĘg°Qę& ˛Q7ĐłQ ´Qť%µQPX¶Q™ź·Qú“ąQű± şQx »Q߼QčĎ˝Q"tľQ´
ŔQa
ÁQ´4ÂQzĚĂQŤÄQŕ‘ ĹQa
ÇQ 0ČQ&jÉQ°iĘQrł ËQÚĚQ^ú ÔQ•}
ŐQ¶˛ÖQ@ľ×QŞńŘQĚEŮQkÜQ¦ÝQ61ŢQúŽßQÇô ŕQ€EáQ«ĐâQ¤ÂăQ�úäQôĺQÁ ćQyçQjZ
čQ«éQ’]ęQS¬ëQ jěQřŚíQe
îQ·´ďQä®đQFńQ\` ňQ÷»óQž*ôQ,őQú‡öQŚ÷QëřQP ůQi"úQ űQ## üQ÷˙QÓg€Rá˛�R5›‚R�
�R’ü„R“…R¸†Rnż‡R·��R;щR˙ ŠRô°ŹR×í�Rv‹‘Rçe’RsH “R·¶”R2 ™Rv šRt*›RÇśRmŽťRT,žR{ÝŁR�¤R`ŠĄRď…¦R�{§R Ú¬R›˝­Rˇ>®R빯R%G°RŻ±R˘Đ ´R§ÓµR·¶R‡o·R2n¸RN ąRUíşRÜo»RÄůĽR÷g˝R”?ľRíŁżRs†ÄRTĄĹR@ýĆRŕa
ÇRtCČR|`ÍRĐÜ
ÎR�1ĎRlgĐRüń
ŐRo^
ÖRŤR
×R˝—ŘRg>
ÝR˛†
ŢR�TßR
 ŕRPăRaĆäR‰ă ĺR|VćRG çR1ŚčRtjéR­�ęR¤čëRü ěREíRÁ]îRLóR_Í
ôR {őR;ÎöRűrűRNüRc÷ýR?ţRôÄ�S„SŚ& …S†S© ‹S‘r ŚSGE
ŤSŞł
ŽSŐÍ‘Sfĺ’S¶“Sąô ”SX­•SŃ?–SOq
—SŰ2�S�ä ™Sţ{šS„ş›SĽö śS éˇS&V˘SçLŁS­÷¤Sřú ©SčsŞS]v «Sć}¬SS±Su ˛SµZłS­&´S¶ÖąSg!şS»ž
»SăĽS7“ żSo+ŔSQU ÁSÜ� ÂSPłĂSýQÄSAîĹSëüĆSäĘÇS©rĘS©ţËS‘ĚS$ŔÍSî­
ÎS—
ĎSCĐSŞJŃSţ ŇSĺW ÓSRË ÔSĐE
ŐS‚"ÖS@É×Sš ŘSQŰStÍÜSU”ÝSObŢS}<ßSÓ9
ŕSˇŁáSůŃâS:M ăSÍf äS~ĺSLň ćS˝qçSŽ čSKéS)ęS�·
ëS‹üěSÝ&íS·R îS'µďSL đS~ö
ńS[ČňS9ŃóSÚŚôS^zőSď/ öSŹ(÷S,řSY? ůS»rúSbŇ űS°ŁüSČŠýSźţS®
˙Sđ»€T”_�T°o‚T&‹ �TH˙ „TW…T×˙†TM—‡TZ`
�TŢ
‰TÔŠT ‹T°˙ŚTu
ŤTĂ
ŽTŚ+ŹTO°�T‰‘TŘP
’Tđ“T3Ű”Taw•Tőf–T©T—T
ť�TÍ· ™TwšT•{›TÚů śTľ ťTsúžT“źTă TZ$ˇTVě˘T3µŁTţő
¤T
ĄTpŃ ¦TJp§TíŞ¨Tjý ©T­B
ŞT†K«T5d¬Tm­T‡Š
®TÁŻT×ú°T%‡ ±T�9˛TŻ· łTda ´TƵTµí
¶TČë·T‰m¸TőąT )şTŻ¨ ˝T"׾Txp
żT8ŁÂT�1ĂT„n
ÄT´`ĹT~ÂĆTŕ
ÇTY×
ČTZWÉT§8ĘT’6ËTďĚTőŚ ÍT
ÎT¤"ĎTHĐT'‡
ŃT>W ŇTθÓT�HÔTWi ŐT ÖTĘĎ×T ŘT+śŮTć4
ÚT
ŰT׺ ÜT˛Š ÝTô¬ ŢT`lßTŢüŕTy áT4 âT·ĘăT¬ŹäT«ŕ
ĺTż> ćTylçTa.
čT.°éT÷ëęT…łëTw€ěT¨íT�˙ îTůó ďT[ĺ
đT�—ńT„aňT·`óTKÔôTW/őTÝ2
öTŁo ÷T7:řT~|ůT1śúT űTM üTńÜ
ýT%e ţTé˙Tv€UF0�U-ß
‚UIŮ�U$Đ„U/ű…UX †Un ‡U',
�UHđ‰UEćŠUßW‹Uë,ŚUÉ]
ŤUa�ŽU€ąŹUĺÉ�U›L
‘UĽg’UZ�“UDĹ ”UÁK•UÉ
–U�ą—UŢS�UV`™UIéšUaű›UËÖ
śU�őťUT žU%•źU*ę UěˇUŘy¤U±.ĄUł5¦U%°§U7 ¨Ui©UMvŞUď¦
«Uë߬U˙Ş ­U9
®UÔŻU×P°U솱UÉ/˛U.JłUö5 ´UŞůµUro
¶UăÉ·U¸UöéąUE& şUlu»U\čĽU­ő
˝UBbľUP=żU†îŔUXÁU üÂU`9
ĂU#u ÄUÚYĹUYv ĆUL2 ÇU‘ČU…ÁÉU`SĘUTÚËU¬ĚUŐúÍU�CĐUâŃU»-
ŇU�äÓUŽű
ÔUNŘŐUCtÖU€�×Uʬ
ŘUő)
ŰUĽťÜUŐŞ
ÝUT8 ßU¬&ŕUáĽáU=ő
âU2ăUůŚ äU� ĺUŞ<ćU1… çUw7
čU( éUKęUélëUóâěUöwíUÁîUĄu
ďU˛đUŞŚ
ńUŘ%ňUż�óUÉ�
ôUŁŻőUřeöU2’÷U¨řUˇó
ůUiťúUtCűU‹`üUô=ýU%€ţU ű ˙U@0€Vs&�VD¨ ‚VŐm�V¤Á„Vă…VŚË†VÇ3
‡VÚń�VâɉV–üŠVߍ
‹VéŚVŤźŤVŔ%ŽVÚ~ŹV@�VżÁ‘V”j
’Vŕß “V…”V*ż•VcŤ–V,® —VČ
�Vűc
™V0^ šVą-›V\# śV⸝VsŚžVłVźVă Vź� ˇVUE˘VgnŁV¤ ¤VŇ ĄV–•¦Vh§V­Ţ¨V X©VŽx ¬Ví­VČŤ ®Vaw ŻV �
°VÔä±V/ȲVpŠłV9×´Vô´ µV?¶VŔZ·VËú¸Vś ąVúmşV€D»VňĽVRË˝V;‰ ľVĂú
żVÇ·ŔV
ŐÁVwŐÂVy¶
ĂV ĽÄVőąĹVŕ–ĆV©ÇV8kČV&q ÉVcń ĘV™{ ËV;ĚV§—ÍV‚#ÎVUĎVz„ ĐV¬i ŃVj�ŇV†ĹÓV<kÔV˝ŐV9ÖVo!×VŃ ŘV-|
ŮVy
ÚVmRŰV�żÜVAd
ÝVhFŢV9ßVübŕV?áVmâVév ăVÓQäVŔ:
ĺV¨{ćVÍ çVžÓ ęV¶äëVen ěV@íVx€îVn ďVVđVŐEńVgš ňVh_óVP%
ôVĐ%
őVîĂ ýVm& ţVË!˙V)) €Wę– �W–ŕ
‚W—X�Wm„WŠa…W$V†Wň]‡W×; �Wę÷ ‰Wĺ3ŠW Ž ‹Wˇ ŤWçĹ ŽWď ŹWĘ�W˝‘W_<“WIë
”W{•WĽz
—Wťl �W­w™W¸
šWa?›Wd
ťWţÁžWŽQ źW™
˘W‡tŁWw“¤Wâů
ĄW§Đ¦WŃ §W(Y¨Wéž ©WD ŞWÄ·¬W!Ů­W` ®WÔ•ŻWŢź
°WR2±WI
łWşď´W2" µW¶W“­·W’W¸WßąWŹ şWĎ#»WvĽW0Ć ˝W7 ľW(<żWŽ”ŔWĆţÁWľ˙ ÂWŁďĂWŻ@ ÄWH ĹWĂ"ĆWŘă ÇW7ĐČWU‚ÉWúP
ĘWĺËW±$ĚWźÍÍW0w
ÎWc’ĎWj
ĐWĺŇWg˝ÓWyzÔWÉMŐW«� ÖW® ×WˇJŘW§�ŰWŔOÜWő§ÝW—X ŢWßWÔdŕW7íáW}1ăWuM äWWĺWŢ çWÝ
čWŔ‘éW׉ęW´ëWT-
ěWz íWśź îW†Ĺ đW’3ńWśłňWŢôWtôőW½öWy‘÷WH*řW™ŽůWČ~ úW7üW8Č ýWËţW™Ţ ˙WŠ
€X‹‚Xí§�X¸ç„X[č …Xîô†Xâm
‡X¤ăŠX•
‹XŚ{ŚX
Ě ŤXü¶ŽXnłŹXAŤ�XŞë‘X®„ ’XŐ&“Xň~ ”Xb•X@g–Xo—X
ű�XÚŞ ™XŮ+ šX¬M
›XyÉśXÂgťXĂžXĹZźXT… X%ˇXK¨˘Xß� ŁX�„¤X¬ĄX0}
¦X“
§Xú¨XŐÁ
©X*ŞXDX«XË´¬Xyv­XĄ§®XZúŻX‹
°X~/±X–"
˛X¦úłXşK
´X‚ťµXYU¶XW ąX7�şXŢ…»Xá…
ĽXFz˝Xô
ľXPOżX}!ŔXěÁX¶PÂXÁş ĂXŮ_ÄXžiĹXĚXĆXŐěÇX^nČXką ÉXp ĘXÂŔËXllĚXéś ÍXLü
ÎX‚žĎX‡lĐX"¸ŃXąpŇXÜ@ ÓX´őÔX.™ŐXďl
ÖXOJ×Xäč ŘX
+ŮXŻY ÚXEhŰX%­ ÜX,ŻÝX�ŢXŤ7 ßXX5ŕXŕéáXkâX7ĐăXÚýäXÚ{ĺX·ćX?óçXçčXĎ? ěX¸íX‚>îXa ďXţđX´^ ńX–,ňXĂóXa‡ôX
 őXTöXF¦÷X÷řXĆ$ ůX˙ĘúX±@
űXRđüXsÜýX[IţXtţ
˙XWK
€YőW�Yţ‚Y >�Yźy„YB‹…Y8
†YžźŠY2˙‹Y0  ŚYŁ›
ŤY;ߎY1ž�Y
V‘YĹÂ’Y9“Y,ą ”YĘf•Y*n—Y ť�Y!i™Y(Ł šYxg›Y�‡ śY›ŽťYÓŇ
źY>8 Y
čˇYŢ„ ŁYˇ1
¤YDŕĄY�¦Y¤y§Y°Â©Y—úŞYŔ‚«Yކ ¬Y˙­YŕB®Ysq
°Y¨`±YĽŽ ˛YŚˇłYVű´YdѵYžÓ¶Y|Ť¸Y먹Yˇ şYUź˝YˇPľYňQ żYPçŔY]˝
ÁYV—ĂYWúÄY~žĹY<EĆYz<ÇY®ř ČYŕLÉYc�ËY‹mĚYHÍY@%ÎY] ĎYwÄ
ŃYŻ¤ŇYe6 ÓYľé ÔYř×ŐYmÖYF×YFÚY%BŰYŘŤÜYčŘÝYdŁŢY3N
ŕYx+ áY%âYX`ăYý5äY0Ç ĺYÓöçYY•čYßËéY‰ýęYtD
ëY¨$ěY
íYŢ_ďY`Z đYJ|ńYbĹ óYc~ ôY˝uőYżŚöYUJ÷Y5ň ůYďtúYťN
űYůÄüY
ýY‹žţY‘L€ZČČ�Z ‚ZÔ•
�Zý„Z`…ZE¨ †Z/V �Z¤‰Zźi ŠZ]
ŤZ6ŢŽZ@­ ŹZqz�ZOg‘Z •
“ZŮ:”ZŤÜ •Z¤8
–Z9S—ZĆ
�ZŹ
™Z!`›Zb śZĹň
ťZÁőžZçäźZ”nˇZ�ş˘ZĂ(ŁZ6.¤Z źĄZáL ¦ZŔý§Zćô ŞZW� «Z_Ţ ¬Z­ř
­Zç� ®ZŚ”
ŻZ
â ±Z[h˛ZO\ łZ]ç´Z޵Zľ°¶Z
S
·Z�› ąZĘşZ6¶»Z˝4 ˝Z%QľZ·$żZ¤RŔZŇÁZ2ÂZ3 ÄZ#ö ĹZIŠ ĆZ™ŕÇZ�É
ČZó§ ÉZ‹śĘZńĚZCĄÍZŤŰ
ÎZą ŃZŇZnŘÓZ‘JÔZ%hŐZ xÖZ,z×Z¤‹ŘZ’ZŮZřDÚZň ŰZ¤ěÜZŕ`
ÝZúBŢZę©ßZ=˝
ŕZ‰© áZSŁâZ!ě ăZ25
äZŮMĺZj*
ćZ|Ź çZ¬T čZŁĂéZÍ ęZC” ëZe‘ěZÍĘíZW� îZßůďZš
đZ~ß ńZ| ňZę,óZ‚ôZőZ–ČöZpË÷Z řZdżůZlúZ—űZ·Ĺ üZNtýZ¬aţZőÎ˙ZTŻ€[/F�[|Á‚[™�[Ë„[Ţ…[� †[ߨ‡[?
�[äz ‰[‡ŘŚ[.FŤ[Ke Ž[`» Ź[J’�[&E ‘[~ˇ”[şć•[ĺx
–[”C ™[‚š[Ä›[qą ž[Ä— ź[“ç [*‘
Ł[O
¤[ŁHĄ[dq¨[N;©[îŞ[N­[đ®[˙ű
Ż[7m˛[÷°ł[‘!´[3ó ·[
O
¸[f
ą[%}ş[ń;»[&ěĽ[ä
˝[ĹMľ[Äžż[ťíŔ[/ĚÁ[ęů Â[.LĹ[ C
Ć[=Ç[¬qĘ[‡ŇË[ †Ě[ť Í[čĘÎ[®ŃĎ[(§Đ[%=Ń[mŚ Ň[!G Ó[§Ä Ô[I¤
Ö[jä ×[N�Ř[_6
Ů[nĚÚ[ăóÜ[ß’Ý[ŠB Ţ[¶Tß[ĽÚŕ[”á[‘� â[’†ă[zTä[�fĺ[Πć[* ç[m
č[ŕÁé[’
ę[B ë[U
ě[»G í[®ď[â‘đ[*Öń[jC ň[Š5ó[+t ô[o ö[p·
÷[��ř[= ů[9U ú[‰ ű[z ý[ćţ[qě˙[“á€\ Á�\_˛‚\÷§„\ú
…\ =†\™Ţ‡\Ń�\ÝĽ ‰\Űó Ś\ŠPŤ\öqŽ\v Ź\Ű�\'˛
‘\r&’\žĆ “\ 
•\o§–\„´
—\m�\±°
™\őcš\\Vś\ćf ź\Ý \™´ˇ\î¤\ÄĺĄ\
o
¦\; §\J¨\ůÇ©\ŹGŞ\H§«\ ˝
®\ß�Ż\Ĺâ°\B±\±­˛\%Xł\_[´\)ł
µ\ź�¶\ú·\Mľ¸\Ť »\+¨ Ľ\­Ť˝\I
ľ\„Ľ ż\¤¤Â\Ă\7kÄ\Ă�Ĺ\ĘÝĆ\#
É\ÇĘ\6Ë\«äĚ\Eŕ Í\•ôÎ\ÍĎ\$UĐ\A
Ń\"� Ň\6ŃÓ\[:Ô\ď)
Ő\ťçÖ\Ć{×\ç3
Ř\>…Ů\ 7Ú\gŰ\ pÜ\•Ý\.Ţ\x[ß\•ŕ\I›ă\ç- ä\) ĺ\O ć\� ç\�č\oSë\đuě\9í\Wxî\ěď\‰jđ\{ľń\…Ř
ň\¶…ó\’»
ô\F ő\ą<ö\Ç2÷\
� ř\!ů\9 ú\2Gű\ۨ ü\éf ˙\ŻŹ€]”C�],…‚]bm �]”„](ł…]ĺ†]oú‡]J �]‰]„áŠ]čP‹]Ű›Ś]ř¶ Ť]NRŽ]o1 Ź] �]Ď© “]÷b”]T˙ •]%J –]=k —];R�]Äh
™]—š]g~›]t»ś]Ěť]żTž]Ć ź]ZŃ ] w ˇ]ť ˘]™+
Ł]÷Ż¤]đ•­]ţ ®]{ÜŻ]ˇ°]ö€±]ő˛]m-ł]�´]°Żµ] /¶]vM·]*"¸]ű_ą]^[ş]¸“»]ĽóĽ]­Ď˝]®�ľ]^‰ ż]ĎoŔ]‚Ú
Á]zŰ Ä]. Ĺ]űăĆ]á Ç]ďaČ]‘Y É]
Ę]›Ë]2ŢĚ]b<Í]ŹÖÎ]
Ď]ŁIĐ]DÚŃ]ĆŇ]É]Ó]„łÔ]¶ťŐ]DÖ]ĚŔ×]
óŘ]řóŰ]Ť• Ü]ît Ý]>ţŢ]Űfß]Ѣŕ]Xá]/‰â]Ңă]Wä]s´ĺ]¨ęć]!ß ç]Ţ č] ˇé]vę]®ë]ȇě]_ľí]+
î]Dń ď]+Śň]ŻP ó]‹ô]�ć ö]|Ü ÷]ďĎř]ů]BĹú]]Z
ü]6, ý]ţţ] ~˙]z€^âÚ‚^DN �^Dý „^ö= …^$‡†^?= �^ ‰^™iŠ^ѧ‹^ÄľŚ^ŐTŤ^ŕ Ź^Ń‘�^ăÔ‘^Ë8’^Đ “^(”^"Ř–^Ză —^˘j�^Kß
™^‘Pš^0äś^óZť^ýÍž^ZFź^
 ^Zȡ^ŞĹ˘^…Ł^}¤^Z
Ą^r¤ ¦^­j§^Śě ¨^Y©^Ľ, Ş^©‰ «^ŕ° ¬^—f­^‡ó°^Űś±^2Ä
˛^U ł^­Ă ´^~޵^Ţ]¶^4o·^–¸^46 ą^…Đş^xť
»^Ľ^n‘
˝^q
ľ^|.Á^fáÂ^�» Ă^‡™
Ć^ůŽ Ç^ź
Č^%Ë^!
Ě^ĺ/Í^t
Đ^\ř Ń^gŇ^5‰Ó^>Ô^Ż˙Ý^Yě
Ţ^÷’ß^Qŕ^řÖá^ ˘
â^Ĺĺ^Ç% ć^Ńżç^·� č^xé^„- ę^Ý ë^ĺcě^P\í^ÂAî^Má ď^�»đ^¦“ń^?Íň^é�ó^nřô^™Lő^š¤ö^wř
ř^–ů^ä&ú^–c
ű^áŔü^"�ý^rĽţ^:X˙^ Ł
€_ �_�‚_+d�_Nu„_ľ……_H� †_†w‡_C7 �_űP‰_¤CŚ_Ł Ť_ç° Ž_µK Ź_Ö.�_\ ‘_ů’_F)“_Ž
”_Ε_抖_Ba
—_CŠ�_Ľ™_ľ¬
š_P®›_D‹ ś_ńű
ť_ssź_\ö _é8 ˇ_C<˘_Ź Ł_I‚ ¤_ň•
Ą_�5¦_ą© §_ęS ¨_§b©_E Ş_q «_ů‡¬_] ­_Q- ®_p) Ż_“ď°_(ňł_§
´_ěí
µ_Xb¶_ä'·_«¸_‡üą_pOş_lĆ»_ëĽ_‘ű
˝_’ľ_D ż_›—Ŕ_ _Á_
Â_on
Ă_ľÄ_ŐđÇ_$NČ_8�É_Ž Ę_‰� Ë_{DĚ_OŚ Ď_°‰Đ_őŃ_ŻžŇ_ŐÓ_ NÔ_ýWŐ_޲ Ö_Ú�×_ţ¦Ř_T›Ů_‰
Ú_KŰ_ÎÜ_-uÝ_Ţ_ân ß_{ď
ŕ_úo â_ ă_´_ä_<Őĺ_˙U ć_#x
ç_1č_ŕ‰é_˙łę_ŹŽë_ô'ě_‚X í_1”î_š
ď_..đ_¦ę ń_ň°ň_4Gó_Í< ö_Bĺ
÷_x
ř_/˝ů_BL ú_j
ű_Łxü_ćŔý_`
ţ_Š@˙_Ém
€`qř �`äd‚`Úö�`Y
„`‰'…`íE†`M‡`’‰`q* Š`¨†‹`F Ś`ŹľŤ`]ÎŽ`É Ź`D"�`r‘`>Ŕ ’`*ç “`wY”`�…•`Ţt–`{§—`�ť�`Š¤™`ťJ š`Ä\ť`,fž`śŰ ź`é `އˇ`�%˘`nz Ł`)¸¤`CčĄ`m5 ¦`ŕ
§`Ŕ· ¨`"©`ĎüŞ`ĘÖ«`)»¬`qŰ
­`L‘®`7±`´˛`»y ł`$n´`‹‰
µ`¸¶`d€ ą`0Íş`č:
»`  Ľ`‘\˝`˛ľ`ąż`hŚ
Ŕ`şÁ`Â` ă Ă`‘ß
Ä`Ź‚Ĺ`ČĆ`ɶÇ`°Č`G-É`ŇŐĘ`LĚ`Ś® Í` … Î`yç Ď`–Đ`Ń`ÂXŇ`Y7Ó`źóÔ`ĺůŐ`QT
Ö` " ×`é-Ř`ý2Ů`†Í
Ú`ŽnŰ`gÓÜ`ź‘Ý`CŇ
ŕ`h‘
á`„Vâ`›lă` ä`PÁĺ`yŔć`JŔç`%č`Tj é`ŻÍę`7v ë`űIě` -í`Týî`vĄď`Ú�đ`Fiń`’ ó`tÎô`Ě; ő`x
ö`�A÷`A«
ř`Ź†ů`ú`Ö ű`p
ü`ř ý`€
ţ`‚
˙`} €atQ�aln‚a;ě
�a+°„a—ř‡a Z
�a
O‰a©žŠaŹ" ‹a˘bŚaL–ŤaąóŽaC?ŹasN�a u‘a�¤
’aÜK
“a@†”a?!•aU%–aŚV—aYD �a�V›aŁaýč
¤aýdĄaµ«¦a^ˇ§a-Ó¨a‹ą©a'á
Şapą
«aÎЬaÝ
­aÝ®aýxŻaę�°a•™ ±aůî˛a‹łasć
´a,y µaň3 ¶a�Č·açő¸aa ąaHýşa–K»aÝ–ĽaË ˝a!0
ľaůża~ Ŕa™Áa–^
Âa9ÇĂaÝÄay Ĺa.:ĆaTGÇać ČaţÉaž�Ęa
˝
ËaF“ Ěa”TÍaľÄÎaAĎa†Đaě5ŃarxŇaAqÓa Ě
ÔaňmŐařľÖao
×a‹ÝŘa–•
Ůa„ÍÚaB)ŰaV
Üa6÷Ýa˝ŚŢa"Ç ßa·áŕaáaŕ>âaF ăaK�äaŐ… ĺażZća›Ąçaó‚čaC• éaüëęa˘x ëaěÜ ěa˝9ía¶dîaáâďażŞđae<ńa< ňaÎQóaÝôaCÚőa4Î öa˝Ť÷aĎ0řaA.
ůa�úa ~ űaNTţaoů˙a@X €b҉
�b1 ‚b�Î�bĆ„bň“ …bńW †b×I‡bó”�bdč ‰b,˙ŠbŐ:‹b¶{Śb¶�Ťb®rŽb…8ŹbŃp�bcÜ‘b/ ’bÖ.“b§”b›c•b„'–b
ü —bńý
�bśž™b_p
šbdK›b; śb1¤ťb·ÉžbV“źbČő bŞ~
ˇb ˘bÝĂ ŁbűH¤bŰTĄb1¸
¦bĚ §bśŤ ¨b‘ů©b4ŞbĘc «bú̬bţk ­bĂÄ®b‰ŃŻb¨ť°bf„
±bZ ˛b,Iłbw­´bYË µb\a¶bĽô
·bs
¸b6™
ąbŔ÷şbÓ
»b…Đ Ľbľ9 ˝by: Ŕb»7 ÁbôÂb‰Ăb¤ ÄbŰ÷
Ĺb¨ÖĆbŞ Çb…{Čbçř ÉbůĂĘb<é
ËbËŠĚbG- Íb;ŇÎb>
Ďb-C Đb` Ńbm  ŇbüÓb“ŁÔbbi
ŐbuÜ ÖbxŞ ×bIb ŘbĹ<Ůb€ęÚbD6 Űb�…ÜbÝbĽ«Ţb¬Íßb:� ŕb3K
áb±(âb *ăbŤ– äb nĺbö7
ćbâ çb«�čbö˙ éb6 ębÉ;ëbE¸ěbLuíb�­îb˙FďbŰĘ đbjîńb*m ňb>2 óbčş
ôb uőb“ö öb-÷b2K řbn ůb«úbë-űbŘ…übNýbąňţb¶m˙bÓˇ€c-ˇ�cţĎ‚cŠś �c#4„cR÷…cQs†cÁp‡c,r�cZ ‰c졊c±+ ‹c¤ Śc( Ťc«ĎŽcEŹ Źcn�c#ú‘c„8’c«(•csË –cá­™cĎ^ šc ™›cAÎścB ťc¸Ęžcëǡc–٢c[ó
Łcg© ¤c4ë Ąc¬A¦c�
©cOFŞcL<
«c3°
¬cLÂ ­cÖµ®cÝŻc’<°c—±c
˛c{G łcAń´c«mµcĄF¶cÉ«
·cödşc:X»c .Ľcő8˝c
FľcN$żc¬U ŔcłČ Ácł˝ÂcbDĂcŽ‡ÄcÓĹc‰2 ĆcÇcî— Čc�ŞÉc»ĂĘca
Ëc8
Ěc¦
ÍcłŘÎc&
Ďc^�Đc´ŃcŻl
ŇcťKÓcÇö
ÔcŢWŐcÖc?×c)`ŘcçŹ ŮcY€
ÚcB Űc(^Üc°xÝcU¶
Ţc˙ßcOČŕcÔ
ácAŞâcOăăcQĘäcMŁĺcsoćc7–çc´’ čcmź écČRęc‘�ëcĚ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ěc`§
íc4µîc{Ä ďc˙Ôđcy†ńccňcľŘóc�Ąôc'! őcůSöc”” ÷câRřc.Oůc†KúcÓśűctücP ýcóçţc ˙cŚM €d{~ �d2™‚d»H�dqŔ„dś:
…dŁ†dN ‡d‘·�d…v ‰dżqŠdŃ„‹d˝ŻŚdĹŘŤdćŔŽdmŰŹděŃ�dו‘d¬€ ’d�§ “dlÇ–dÝ5
—d �d1Í™d(šd›dt„ śdŰ1ťd˝€ždv)
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
 d ” ˇdF0
˘df›
Łd»¤dëí Ąd±M ¦d)H§döŚ¨dÖÔ©d Ą ŞdiÓ«dµw¬dtŹ
­dRy ®dW2 Żd`B°dńB ±dq{
˛d0łd)ľ´d­µd¨l¶dÖĚ·d2r ¸dAąd,
Reference in New Issue Copy Permalink