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/Core/Src/app_entry.o
T

2440 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
  
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€�‚ƒ„…†‡ˆ‰Š‹Œ�Ž��‘’“”•–—˜™š›œ�€´ƒ°¯x`KÓø€0#ðI{hCÁø€0¿ 7½F]ø{pGX€´ƒ°¯x`KÓø� I{hCÁø�0¿ 7½F]ø{pGX€´ƒ°¯x`Oð°C
JÃøœ Oð°CÓøœ0#ô|R{hOð°ACÁøœ0¿ 7½F]ø{pGþÊþÊ€´ƒ°¯x`Oð°C›h#ôBOð°A{hC‹`¿ 7½F]ø{pG€´¯KhÃó F½F]ø{pG¿ à€´¯Kh ›²F½F]ø{pG¿ à€´¯KiJ#ða¿½F]ø{pG¿íà€´ƒ°¯x`{hÿ"Zb¿ 7½F]ø{pG€´ƒ°¯x`{hÊ"Zb{hS"Zb¿ 7½F]ø{pG€´ƒ°¯x`9`{h›h#ð;hC{hš`¿ 7½F]ø{pGSHCI_USER_EVT_PROCESS
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
€µ¯KOôBaÿ÷þÿÿ÷þÿ¿€½@X€µ¯ÿ÷þÿÿ÷þÿI ÿ÷þÿÿ÷þÿ¿€½€´¯¿½F]ø{pG€µ¯P ÿ÷þÿ¿€½€´¯¿½F]ø{pG€µ‚°¯ ÿ÷þÿx`{h+Ð{h›yFÿ÷þÿ¿¿7½F€½€µ¯ÿ÷þÿÿ÷þÿÿ÷þÿ¿€½€µ¯Hÿ÷þÿ!Hÿ÷þÿHÿ÷þÿ¿€½(@€µ¯Oô@ÿ÷þÿÿ÷þÿ ÿ÷þÿ¿€½€µˆ°¯ÿ÷þÿ ÿ÷þÿFJ`"! ÿ÷þÿFJ`J!Hÿ÷þÿFJ`K;`K{`;FFHÿ÷þÿK»`Kû`K;a@ò<S{añFÿ÷þÿÿ÷þÿ¿ 7½F€½<TH€´¯¿½F]ø{pG€µ‚°¯Fûqû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
à KhOðÿ1Fÿ÷þÿàKhFÿ÷þÿ¿¿7½F€½¿€µˆ°¯x`{h[h 3ûaûiˆ›²£õC+Ø¢Rø#ðEW______ñ Fÿ÷þÿxhÿ÷þÿàxhÿ÷þÿà¿¿ 7½F€½€´…°¯x`{h[h 3û`ûh3»`¿7½F]ø{pG€µŠ°¯x`ñ"`Z`š`Ú`#{b#;b{h[h 3ûaûi3»a»ix+Ñÿ÷þÿ#;r#»rÿ÷þÿxb{j›²»‚ÿ÷þÿ8b;j›²û‚ñFÿ÷þÿÿ÷þÿ! ÿ÷þÿà»ix+Ñ{h"p¿¿(7½F€½€µ‚°¯x`Oðÿ2! ÿ÷þÿÿ÷þÿ¿õ瀵„°¯x`ÿ÷þÿ¸`{hû`ûh³ñÿ?
Ðÿ÷þÿFFûhDû`àÿ÷þÿ0¿ÿ÷þÿF»hÓúhšBôØ¿¿7½F€½€µ‚°¯x`Kh!Fÿ÷þÿ¿7½F€½€µ‚°¯x`KhFÿ÷þÿ¿7½F€½¿€µ‚°¯x`KhOðÿ1Fÿ÷þÿ¿7½F€½¿i(3!‰ó{¡ M^+=à³ ;QeÔ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
9W|* ô
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
üª Oq6±1 Ñ
)int£E
U8 1”4 $K£9 0e±½õý*ô'Ð ×½ñ�áŒ
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
ºÂÙÐ
»½{}
¼½¢ã
½½ SCR
¾½CCR
¿½SHP
À7þ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Á½$×
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
½(©W
ý,¯"
Ľ0GÆ
Ž4å&
ƽ8žð
ǽ<PFR
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÈQ@DFR
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÉÂHADR
ÊÂL†µ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ËkPL@
Ì…`xV
ÍŠt©»
νˆ 7� 'ÂL�<LÂf�Vf€�p€±š�˜ª
Ïö±·�±Ç�±×�±ç� T ò e0À ô½CR õ½‚V ö e"i ÷½<ôà ø½@ˆ&
ù½Dÿà ú½Hu û½L\# ü½P±u� ®é ýçˆ - ÌACR /½ o 0½ùã 1½§  2½ SR 3½CR 4½uR 5½‚V 6 ± 7½ º¬ 8½$Ç 9½(Ç :½,õŽ ;½0t© <½4,Á =½8³j >½<ŒV ? Ì@ÐÓ @½\ôˆ
A½`�
B½d¥ C ·hSFR D½€š% E½„±Ü�pá F�½ù�éŒ Š gCR1 Œ½CR2 �½CR3 Ž½CR4 �½ SR1 �½SR2 ‘½SCR ’½CR5 “½Ò¦ ”½ qº •½$é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
–½(wº —½,ò¦ ˜½0}º ™½4 5
š½8ƒº ›½<"§ œ½@‰º �½DxV ž×HL§ Ÿ½Xøº  ½\‚V ¡Ç`›³ ¢½€ñb £½„§& ¤½ˆ¥ ¥þ+ˆ ¾ § CR À½Tµ Á½Ž8 ½.±
ý Oï ĽxV ű" ƽ”4 ǽ, Ƚ æÀ ɽ$n* ʽ(÷´ ˽,Í� ̽0‚V ͱ4› ν8¥ Ͻ<æ‡ Ð½@?‡ ѽDõ1 Ò½Hž Ó½LøÀ Ô½PŒV Õ±Tç{ Ö½Xð{ ×½\>Œ ؽ`¥ Ù±d¯ô Ú½hÁì
Û½l*€ ܽpA½ ݱt � Þ½x� ß½|ÁO ཀ:
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
᱄±• ⽈
W 㱌… ä½�CSR å½”¬ 潘p 罜W è§  
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
[é½
!Wê§ 
Ë ë½H
™Õ
ì½L
æ 
í½P
+Wî±T
WTï½X
bTð½\
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
]椫`
œvò½d
Rðó½h
tæ ô½l
ïõ½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ö±t
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
Ë�ø½|
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
#¢ù½€
d—ú½„±· �„ ût   û TR ½DR ½CR ½ISR ½ 4¯ ½< ½ 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
±Ç ½�Ï ½ WPR
½$SSR ½(? ½,01 ½0´± ½4= ½8æ0 ½<¨
½@üs ½D¤Þ ½HOR ½L@ ½PG ½T)N ½XÂV ½\È\ ½`Âø ½dop ½hAw ½l¨� ½p»‹ !½tz "½x† #½|ಠ$½€– %½„Õœ &½ˆÜ­ '½Œ«ï (½�X¶ )½”¿ *½˜ÎÅ +½œõ¿ ,Ä ½ � Ø 3 j
û¦ 5½?µ 6½ 7½PR1 8½ ‚V 9 ×E :½ Eµ ;½$·æ
<½(PR2 =½,ŒV > 0¥ ?ñ@A½ @ñ`~
A½€Ÿ� B½„:
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Cùˆ ~
D½�¤� E½”!W Fz
˜?~ G½À\› H½Ä+W IùÈF~ J½Ðc› K½Ô½z
� j
Xd L = 2§
µlý5¯F 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
1å
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
H‡ IFüòC=á¿C$
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
> ± 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
A ±‹¶
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
G ± Be
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
M ±0g
P ± 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
­[BN
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¯§
XG
±ñ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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=,ݳ d2“
sg9 1=_~ íŸ õbé,=š,ºn Æ?
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
”<� A `‘&
C
`�ÚD
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
` ±àÏ E<”�� b ¥ÿ¶ d
¥ê:e
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
qŽ f� k âQ—m
”s=n
Ӑ: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
q) p± r Ö t
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
”evtu
â½Evî
€ B� ‚eX°ƒߎ„Š~¥Œ¥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
~”Ž�þÛ�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
”cmd”
Ž^É •š —ì� ™eìUš½Ý–›É ® Pmy°
³
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
'ǵ ±L� ø B†h­ wq4
µ4 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
:› Qx `x
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
oxÚ›2¥)¯ „î ›î ²î 7° ï q° ~�.d@dRdddvdˆdšd�º _0!v0"�0#¤0$»0%Ò0&é0'�Y(©
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
)¹
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
*É
+Ù
,é
-ù
. 
/¯Ï 02Š 1FŠ 2ZŠ 3nŠ 4‚Š 5‹Ü6¬Š 7ÑÀ8Ìk
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
"~{V
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ža™6¡Å Ê#ÕΆÆhà Ået
~¨î }ëé|ß–{
z"‰¨HÏÕ%9
ÓÎß›ÜÎb" ßÎóY ë± $ð Î^ñ!Ü!Ï ò±ÖåóÎ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
õ΋ ö±}÷÷­KnøCÏ¢
ù± d`úOÎ
 "^!Ü!Ï ±ÖåÎk¢±  Øß" w^!Ü!Ï ±ÖåÎk¢± Š²4w=¤³0
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
±‚  '° F û)H!¤p8
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
I\Î�J× 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 ³
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
“…O 6#6Ë +³ Pm�
*±=0n>ìø� õƒ3S=#¡Í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
æÈ ¬Ó(z=2Ô>ó• }Ü~?^
ÈƤ7­W@.¿š’V#’ {’`ç ’7ˆ’£¹’G£
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
’v|’‚Ë’ Q E�î
R¡^ S.=¥�àœàÏ(é
$‡L“
B›Ÿ ’Óû ÿJŸ®Q`
–da”· b”.§c”qd”ƒ�e±·ëf±'·g¥ ph¥Å.iœ 9« ”ôŽ  ”õÛ ”{+   ”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
 ”h<  ”&<  ”}I 
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
 ”Ð  ”ã  ” +< ”
sŒ ” òR ” ù¥ ”
a‡ ”9æ ”Ñ $  LÛç",¥4#”id$” F%-Ö)ª”u$�;¤&<5d¶´=<ì<”¨$� )>5—H¡½?5—TÇBF
+²½G7¸yH}ð
JÚ\2m *7±±> r A7G°É
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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Ý%m:k
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
±µ›Ù
±ž±±±½ ’µGn3N„�ÌÌ ô.:Þ-�ðð …N  +•† I (+±&É.sä RBB Pü
§^Åδqs¹Î Ú6b7¥±±¥ „¿>
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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Üu/õì
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
ë”B‡ ª¼(i$œ- £>i"±‘t9
b œS ïŒb%±‘t¦E[ œy ;†[#Αtk>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
>±‘l
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
A ±‘t{%œã —1%&Αtý£ØˆœT ­ÞØ/ΑT
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ØrÚT‘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
ÛY‘h
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
'·Þ ±‘t
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
pß ±‘p ¥ Eæ* Â
"œ¤ ­ÞÂ%Αl
ØrÄT‘t
áæ Ť‘p Ô�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
Ør…T‘t
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
o9†‘dL\h@œ )h3Ë‘w0Ø\ d
œ4x FœœZ
5ÖHP‘`
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
MI;‘X £
0œ ø œ ú–œa:(œ²
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Xo²‘t L1ò‘»
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
œ!Rn
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ªœ2Τ˜œ!÷× œ!Á8kœ&Ÿ o &œC ˜$o :¥‘t Ò'o I±‘pÝXÿ œk ˜$ÿA¥‘t‘{ôœ“ ˜$ô@¥‘t3¾¡7 œ'\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
鱜ÈÊ
- (œø ß[- >±‘t!O<œ  ïHO=±‘t¿Ö‡(œH ¯Ü‡6±‘t4lª,œ tÈ6±‘t
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
: ;9 I8 ( 
: ; 9 I8 : ; 9 II
: ;9 I8 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
:! ;9!I8 : ;9 I  : ; 9 
4:!;9 I> I: ; 9 $ > 5I.?: ;9 'I<: ;9 I : ;9 (&I(
.: ;9 '@z.:!;9!
'@|
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
: ; 9 I8 4:!; 9 Iˆ!4:!; 9 I?.?:!;9!'@| :!; 9! .?: ; 9 '<.?: ; 9 '< .:!;9!
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
'@|!.?:!; 9!'@|"(!ÿÿÿÿ#'$!I/%.?:!;9 'I<&.?:!;9!'<'.:!;9!'I@z(% Uy)$ > * + : ;9 ,> I: ;9 -4: ; 9 I?<..?: ;9 '</.?: ; 9 'I<0.?: ;9 '@z1.: ; 9 '@z2.?: ; 9 '@z3.: ;9 '@z4.: ;9 '@z,(<(  & ( œ@h"ˆJ $¿,(<(  & ( œ@h"ˆJ  $o? 
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
K8Åû
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
k„
 !{� " # æ{
$%+ÉÎ/$&$'A¤ #(Î)$*c¤ +×½,-$$'Õ(.U/0ƒé
"$1o¨2 ."b3üâ4Û55Œ 6X ˜
 WÞ?7¢8)�69£:€Õ™;»×ØàÛ <Ì= ÷ ØÛ6>$?ÍÔ@áAØBäCèD“EìF’GðHôIÐJøKŒL9O M“NÌ;”O]í  ºPœQVDR²SkT¤
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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þWÀN¸XÞYÙ& !"Z#R$%&['\(])^_âŠ!``r
"`aûT b%³c"d9efghKßi×Çj» efkgšlmqn›Do[4 pû›!qß\"r%^(s#^$f%g&s'e*t+u­ƒ,v-wªä.xýL/y 0zÛq1{x62|ï%3}›¥
4~h56€!a
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
7�8‚—ƒ/8!dú9„»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
:…‹R<†&õ– >‡J›„
ˆ 0Á-A$”Ú
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
4s—O
‰ Z¸Š!¿û‹0пŽ¦¬¾6ÇÙVö‘ßÚ Œ6‘„ „OvgŸ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
€ } Zú¢ŸÚ®“nBÌÅ1ž
ñÍwê~q
x �UG0Ç'�ï`¯dò …®

á ¢ A%" ~QMŽ}šœ� ¾î�6X P<¦å¤³ù‹Øî/[Z ™_º¨á¿z_6%§ÝÙ@B‹<5•éH¨
2¼“ Õž ;&ˆ£Uà
€=ý ë©PÍ ¥u eí }]
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
·ð”Ý„P Zs
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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ýïøßá?Yz¥èئœSøN  Ã�Ì4f4õ„¨
\9iàE| ÙY!þú€ü —¾3+
‘À F“ºÁxš¡»‹æ6¯øæ
''§kÛ
º
�—•à
H1’2dî ¦=
:î ö
7¯
‘iq CÕ„Pô'
Š/G Í¿¹%…že
á7 Ƥ¼"© ‡�
Þ' 1ÌÕ NE Á¥ àöŠšQ
˨Î ™Å
¯ØM~ŒÓ]Ú5 Â/÷Ø<Αo#'Ø•µ9n
=j�ë ꢊvw>¦˜‡ ‰4®ÅeÜ wuʃ<xÍšÔú
þº¥|gX€‡ $¼¿J1 Sv
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
l‹4â 7®�±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
'îZ…¬AKÜ2Lˆáó»„
ë
Ù¨ù1 »ÁOÿ"ÓZÈ øÖ¾ˆ–4—c³Óë}%î` ‚Åús \9 ò¯¾
Ú¬ŒQ ½Íº‘mlÌTQ|G
Uj0Õ�ý(5�$@d ÷û
’Ø›µ¾^ Ô
/*‘ r± ¾Béì ós¼}Y
w@83ŸÀW ÃMÎ
[Ȫ–/ÞþY
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
T·ç
f1´ëqþJÐ嘦Oð· ¬ÎÐäŸ
tXøÚ�!e= C � *«¦¯h
ŽT- f3Z 궜U¼9^š
¿i
Ã, (¬ -p =RtÔʼn X3Þ}Aß
‹¸Hxµ0JÒ˘M÷¥LBÖºŠÖ
—=ì£ÂFóZ8têÊÄ lÛT 0îŒÆ?û«�_äÿ ð`9v0”ˆ ü%eN
Óùj³t§ìÛl¨�ì<;·¬Þó0‰…
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‘q†� ´tMm]Ø�¢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
J¸
š •Å
"rÿ÷€"Œ.!¢]X
4Ú1¡ê á–'3åI
ñÞ
aDtpÔ
Q2‘Ê ïwY™ €ÆcÜ_У
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
v…
s¢þ ˆ|y åç BåC�ó« §±Ë
À(
«4·!
Êû
âWv÷sB—À/¢J†ò
ç¡ 6 62;�Ã
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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íƒ
ë•ë
'†±æk«“¯´c�€3
ù÷ ý1øÏ,vëgë›4„¤o‚wI1ê
ÜÌ[´ëú „9+­½
I^X· Þž
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
 Ý/!¨(7^’@»“•h —ÊR˜¾m
™Dš[ï­ÆÐ ® �ïZ•&¦�^t¥§
°œ´w ºkzÌßÜ�±î ¡TçRÂ!4/8= S²mu÷ŒÄ&¦ɾ¼$µÎLûôÒ‡

(ÓÛ� +c,,Œ -ô'.�å
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
/int0°� 1è 2Qæ 3“_ 4Ó=
5Uh6z�7`˜8Z¡9â
:)C§¯J
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Z Rך]—îh�¥
qà8xÄK�vRˆ!q “Å —â¢æ ­©Cl¸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
¼int½Qæ °� Ãè 
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
µ¢„t»}¬š
!¦€ %
'5-õ©1«¹3ùS9û÷=)?È£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
IšøNœB
S½ï
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
;(
A #å
)×`
5w�?I IžðS 6€‹A�j ‚�%˜ôö™ôšUs ¢§H
£@¤l$ ®† ¯%Ç °Zc¸¥Ý¹þæº�7ÄüJÅß” Æ›ëÔ…uÕJ:ÖÏŽæ~®çê› èrtö¹©÷r
øᾆX ‡FüˆF/–¿8—ô˜ý¦{d §Z¨¨+i9™ ·ž¸áŸÆ6 Ç
£ÏP¦×" Ýz€ Þ#=â¿Iæs0ë„�ö +€†+…¯� Œ£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
�W ˜'y™«f¤«:¥¥Å±üô ²£€Á¸Âþ‡ �h *º°2ÖÚ5ìêEííÙóc ö÷3ùQ³þÆ‹� šÔ¿¤öŸMO\[bä1c­
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‹aÀŽ¦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
à>kæš
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
ü¥Ï ƒçé‰ç` –Œ±¢÷u F` ÿñ
!d%2Y+¸@ Ey
IW
J>s'¨ˆ (ш*÷&“æ‘”úÊ •m –".—fE ˜‹™Ooš+×
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
›oœ@­9ðÈe ÉF3ÊìË~ÜÌ%t ÍÞο¾Ïz Є¦Ñ‚ÄÒúÓ� ÔÃq ÕR( Ö××Q•Ø– ßÐ ü—ºš¨v ›?/œ*~ �†»ž{. Ÿý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
¡׸
¢Œ¦£Wõ¤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
£MÑ©³÷®aO¯í´mz 1t2ö?3È’6­È 9]D :GV<ôŠ=‘ >žy ?e3Bð
CèìDMI ^È>_‰·k�ÃlÿfpêŠqx‘s Æuð`x]-y€êzX“}5­‚"a
„*ü …ƒÀ‡ËŠw
‹ØŒ`g Žg7
�î‘,Œ“Fœ¤Bõ¥2ó¦q_§ÿD ¨?G ªîë«ß~¬Ð
Ùú¤ æè ç‚´èÝk銹êcLëGì³AïC¬ð¹ÓöKèÒÕ*äºuêô ë²
ò'øÉþÿè•
†°Ü ‡]$Ž�ÿ”jÈ
¥ À²ØÔ¸¡ÕÏJÜ�±Ý 0à—)êSàë¿_õ©‚
‹+£
�™U�ƒ���Þ’Téœô  ¢î¤Œ §­«w‰­Ö§ ÐÂOÔ°–
ØM›Ü1àe� äϦ
è ì^ëó#ª ôÒõ¦¤ ö]©÷Ã
Œâð �»ŸÛV ¥·•
¨µö ªÚÍ®Ï@°ÉÈ
´{Q·ÊM
¹Ó½v¬ ¿0V
ÁAw
År8
Ö³5×ò¹Øï�Ü<ÞÝRâµ
æU–êdîWïûð)
ŒØ×Åâ�­9ðü—ºì�<ñ?
ø¯7 ž�
£MÑ©³÷®aO¯í½’Ùì ”,Œ ³^�»+²À7®É¨
*/M÷
#Q%âé 'Ël *`a,÷
.ñ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
0�Ž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
4 æ 6 w8i;½ã=ú«Nš¾ a†u ’£c
«Âa¬Þp­®8â
¯
˜ °�s±À›
½öž¾9¿î*ÊZ7Ëë=ÌEÍiùÎËv¬iN
ÆHÝ ßÅwi ¯-(wÏA}Ù\â_EæÒë|­
öÝT ù…ÿ'v‚z¨ ˆº¡ Š=½ ¡÷]¤á4 §Õ¨}ˆ©A¥ªlz «Í¬Ñ0 ­�I®`¶
¯e¢ °³±È²‡¿³ÃŒ´Ä<µäj òI·¬ß ¸n:¹I¢º Ö»…C¼µ™À-^Š— ‹‚¢Œn"�-¯Ži;�ÃÏ ��Ü‘ž’áG “抔Ÿÿ–g2¡„ §ì[´0�·åy ¹rEšÐï×ÅH> ­9ðü—ºì�<ž�
£MÑ©³÷®aO¯í±ÆW
´1­ ·ˆÕº s†e!!×Å"H> "�R'sm/FÞ C9gM$Rç€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
ƒƒGW±¢XóYžZy \ŒÒ]`'^¾!_Gz``¼aV™
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
bxc¶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ðÃeÔ×iül˜µ m÷b xÎÒy®Ÿz+x |¿°�‡:ø�á“Ðß —’· žt¬¡«b ¤×L
¦²r§®¿¨÷Ë ªm²
«Á³¬´è ´˜Ü ïã¡ð �’8
¯,~
Ó|ÞÔç€Õ›Öøƒ¼¡„¡†Š²ï’¬œ
×Åõ H> Û1
ªæ¢68ùü<ø=ú?ƒä C¨¨¡ü1³ Å�"�R2”7 4Ñ„ 5¼8š:Îm
m.gpí&vƒÉ y[y Ð 7õ :ËÈ;‘T = –>Ù>?¢Ú
@�fA@™
Bh#C‚ˆ D¨BElF¢† GøCH°IË
JáKH
L‚MŠ
N­çOñXPPÈ Q°}U9 Y€øZ 4]g^Ù4 _D'` àc‘°dæ
eÌÒf` gªx
h‰þkU†l\w m“»nÔooP
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
p®ªqsr@"
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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çÚtòª
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
u}0vã?w$5}ù?„Š�ý �š¬”cO—’š œµ– ¡æ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
¢om¥û *Œ 7ÁDê9
LTzUÒ)X” [Gw^ø aŒæ
dú7mŠ
t@ |¡ Œ1Q™wzŸÀ
¤R¨
¥á&
§/1¨9Q&ëÊ 4IKF«)G—HDIÄLJëŠ
$½¯0\»1ÔÜ2©3D4@ 5¿Ú Ú•#Š$L%|8B¼wCQ~
DšPGÛgî=^Ý
)' ,š© /È 2ž*5☠8„;ƒ>µh Aê²Dï Lò� Tûí
\†é
d^œlí©o«rº
uñà
¦>ªP˜®†9²Ü4^þ™OÿÆ€µÏ‡„€�Ì«•„eœ
è �©—Ô }pä 8ô‡ÈëŽC€ ä·fçú¦®· Ûþ‚ÝE³ Þ}¯ áó âÿÕã]à”ff• —3ì ˜J¹š››�q ž;† Ü¡î裬­¤¦SµHj « Ñ“IÒ@Ü Ôe©ÕŸ ×URØ«»Úê§ Û¿ÔÝ:ÞðàÏÅá&ãóòä*æ•FçÍä é•ñê°:ì=õ í= € �†Œƒ‡%„”Ćt‚‡Îõ¨éª
©.€ÒëFÓ°jÕ²'Ö]<ØY
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
æÖýè9Ö
éHô ëŠèìM€îñnïVIñ…Z
òT ô=õ’Ç÷űø�
úÅ»ûfƒýŽþÃ�Ó½
‚q•…G¿†ªÍˆË
‰{*‹KÚŒî8ŽVº�Ì!‘{µ ’”0 ”Âp •U—^F˜/×›žYœÃí žWAŸ(Z
¡¯ ¢o§¥—¶¦]H¨–]
©üÜ«:–
¬§�®V™¯§ ±¼–²zÖ´ €µ@" ¸¶…¹óo»g ¼È=¾ÏS
¿­�ÁõÏÂ; Äq]Å�†ÇÈë‰Ê[ÝËÊ
Í€¤Î‰äÐMŽÑ´&Óä£ ÔzÈÖ=d×êäÙÏ
ÚMÚÜ¢-Ýà#ßH<
àÒãÒ˜ ä¶ÿæ'‚
ç,Šé-Æ ê§ª íTúîxŒðšs ñ>¦óâåô,ö+L ÷±” ù%D úŠxü4S
ýí €:;�jê ƒ’„º†a‚‡Ý‰³à Š4|Œ!±�¹À
�!Î�±É’fª
“’›–€`—¡´ ™þ š£hœh�F­ Ÿá Mè¢m¤£;É¥s‡¦rv
©¬¯ªðÀ¬s­
¯¡Ö°³™
´Fd ç!·Q^ ¹'
º¢¼(<½€“¿·ÍÀòY ×sËØ4h ÛÆðÜ0óÞGjß¾·áØÆâCÙ ä•
å
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ç è¶Ç
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
€Qº
�ãMƒYÌ
„Á¢†NN‡Ö—‰C
Šq�CŽp‘$‚’áj•Ó–Š9 ˜6v™ôô›ŠÌœ”µ
Í5Î8 Ñg9ÒR:
ÔºHÕKJ×u`ØGÐ ÚI�Ûè“
ÝsYÞ„½à¼áÊ ã{�
äƒq æ‹LçdÓ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
é§êªýíÛ¹îZíð%Fñ’+
ó¡µ
ô:3
Ÿ]+
 3.¢$ç £¦…
¥Lõ¦qŠ¨N©†Ê«&±¬Ì/®”¯(±ªü ²¤´àµXÕ ·5(¸3‘ ºñÉ»TU½‚L¾•ÀFjÁßÐÃ8“Ä1 Æ«Çê®É§Êẹ̌ÍãžÏÛ0 Ðm0ÒÝë Ó×"
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ö¢É×ùçÚŽ|Û>ßÞ0gßbU
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
â-ðãlÒæÁJç^\êû²ë³*î|ï#ñWYò±üôXõC–÷î­øp¢úbJ ûu ý¹®þž €›Ò�IЃ�„íd†ªƒ ‡Ó‚ ³;ï´Gò·½ ¸hZ
»…ò ¼”> ¾‹ò¿rÁff
ÂÇVÄçņ·Èj¢ ÉÃ?˽ÌÏ ÏlÐZ
Ó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
ÖËf ן� Ù˜d ÚGÜ®RÝ°m ß¾àõ:â_ãÕ¶ å«ú
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
æ\ZéðÄêIòì©K íhoðÑÁñóÙ.ôW(ö×W÷æ ùnvú•ëü^ý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
ÿ–¸€ µ‚ ø¨ƒ 1‚† xÕ‡ ì‰  Š è‚� IŽ Oð‘ o!’ ­:” [- • �ƒ— 'Ę 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
� ų ž ¦™   òï
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¡ Ф 1p¥ _~§  5¨ ÃMÇ É Ê l Ë ªÍ +s Î 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
Ñ Œ Ô ´ÝÕ ²F× ÓUØ ŒpÚ
xÛ òÞ Ö�ß 2žâ 0ã 3­å ýæ ¼yè &5
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
é ¤—ì "Ëí ‹>
ï Xð d$ ò Jtó €cõ ¶Oö !Ñø ÿ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
±?‚
P „
«
…
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
>
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‡
”׈
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Cq¤
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
O7
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
Ó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
™ì®
Î °
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
+´
•Q

h7·
©$¹
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
¯ß½
P¨À
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
4N
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
Í
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
29
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
uË Ô
Û Õ
…à×
\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
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
Q|ä
¢Z æ
šç
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
�ê
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
i´ë
[Sí
žî
_ ð
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
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
Nìù
z_
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‘ Òã ’ ÿ†” !D• “É
— O¸˜ 쵚 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
§ ש © 
ª Á ¬ {’
­ õ¯ Y—° óe² ³ —¤ Àð· N�¹ ¶qº A½ Ô ¾ utÀ áÉÁ ÃTà ’ Ä v%Æ àÆ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ç “B É ¯t Ê …¨Ì $WÍ « Ï ¨HÐ µyÒ ¬¡Ó -¨Õ ‚Ò Ö ŽØ ‹ÓÙ õA
Û ïÂÜ ¤V Þ 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
á Æâ Ùñô :Bü :ê‰ g‚ Š gú
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‹ ÷Œ Yb
� »} Ž Áÿ
� Zp� ñ ’ rÛ“ ‘Ø” æð•
é– 1× Ƈ
˜ ¥/™ 1œ Aù� yp  ‘
¡ (!à ž@Ä Ã´Å Òø Æ ÆÇ z=È 6É ï–Ê E!Ë ßÌ gÍ öÎ i¶× V^
Ø >Û éÅß é¹à û<á ǵâ n;ã  ðä ¼1 Å»"ía #ž¨ $®`%3f&ýº'òÁ (Û
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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É*Wê+ R,#>-ËÝ.Ÿ /@6 0›?
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
1•2À…3;4,¦5Ý%
6´7T¾ 8W€
9¶ž:gû;ɦ<¹˜ =P_ ?rG @AUAúBçµ
C×ÙDí¾KUXHR gĺ {/À …O—�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
§ ¬(ù±Ìÿ –xà—ÇŽ˜ž¬ � :žÁè
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ŸƒU Y¢ã£:Ó¤ŸŸ§�'¨yZ©
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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­(Ï ®E>
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¯÷ì
± Ų⠳,ž´šh·š1 ¸À¹ ™ º¨�»¼¹
¼�¸ ½a‹ÀøQ
ÁF0Â?Ì
ÃOÄù´Å:{ƸÇN.Èq7ÉS®Ê2Œ Ër‹Ì'ˆ ÍƟиùÑðUÒ@†Ó�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
ËÕüŒÖ¼2
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
׉�؆wÙ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
ÚcvÛSÞWÏ
ß]’
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
à[·ánS
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
â×IäÜßåÇÁæ÷†
ç˜G
èYéG¹ê�ì(ü
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
íÏû î-0ï.9ðÄ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
õ£ö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
ù�›úÓJû»kü³?ý¾ þ’]ÿ’€Ë(
�7ƒš „på …â¾†®ÔˆÀ) ‰h5Œ=ò �Ó†ŽÏì
�}ô�š¦‘“„’¸³”àß•]f—›
š+[›
œÆ�tž U
ŸÔQ ží¡
®¢ˆo ¥©Ÿ8ª�‡­é8
®Ü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
¯o£ °�Ï»šÜ¼u½r<¾$¢
¿O
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÀAŽÁ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
Ì?†Í×BÎ’+Ïï¬ÐDÑöÒ} ÓÈÔ“qÕÌ™ Ö Ùˆž Ú7$ Û¸Y ÜŠ
Ý7Ã Þ�ûßõ/à{hâ
£
ãJCäi}å«
æýê çy' è né5á ëbû ìÊ}í$×îC%ï†uðƒÆ ññ òàAóæ
ôŒ”õ•6öØ÷•ØøLªù°žûkEüUa ýygþã� € ê_� 曃 Þ4„ èq‡ ¥Åˆ <‰ Ìq Š Y^‹ —ÇŒ 2} Ž „L� ç‘ WÊ ” !d • pÇ – ”•— � ˜ Ïš™ I3š $B› %Eœ ò¡� ò ž \KŸ 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
È òÓÉ ÊˆÊ Và
Ë )2Ì , Í Å!
Î ˆ2 Ï ,YÐ õÃ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ñ ©[Ò Æ{Ó ÿk Ô bç Õ –]Ö † × 2·Ø &_Ù æçÚ ˜òÛ  Ü ÿ Ý ñiÞ üß È*à ‹Óá
Eâ � ã –Š ä �må ;æ �Oç ²è ë OPì Y˜í 81
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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ïò ÒŽó A«ô Øõ ö Ûª÷ (Ç ø •<ù w}ú Uû 1ü Ýfý &/þ ¡#ÿ o‘
€
±K�
r§ ‚
xJƒ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
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
:ˆ

‰
˜
Š
Åþ‹
ãê Ž
–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
Sp‘
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
Ž””
y'•
â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
N¼
—
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ș
F' ™
Cš
Üa›
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
k
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
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
gT£
ã¤
ë¥
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
佪
Y�
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
«
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Y�®
ø¯
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
•Ð°
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
]±
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
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
ñ;À
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
AD Á
˜Â
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
pá Ä
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
)¨ Å
—>Ç
ãÈ
é2É
ÿúÊ
O° Ë
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ºÍ
ÕÎ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
-H Ï
 ŽÐ
›@Ñ
,Ò
ÿÓ
ךÔ
ÈûÕ
·‚×
ª›Ø
Ï@Ù
…^Û
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
·ä
7ûå
iQ æ
Ÿ™ç
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
,Z è
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
)¹ é
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
­ê
’jë
. ì
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
dW í
”;î
Üï
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
Û…
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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Áù

ú
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
׉ü
«kþ
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—… Ô‡ %ç ˆ ®‰ ‰ç‹ 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
� gþ’ ߆
“ ü’” +• H– ; — &)˜ ãæš ïN › k(œ &±ž æ> Ÿ Âñ  ’ £ ¯&¤ :Ç
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¥ £e¦ �Û§ …. ¨ wͪ ˜ « Ž
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¬ )’­ Oš® J¯ ¥ô± SX² ,ê³ …8´ lµ Cæ ñ*¸ z�¹ =Ž º 
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
» ´”¼ ÷½ z ¿ í À òÌÁ •À leà @2Ä �¯Æ ÍˆÇ ß§È š(É Lÿ Ê pË ~!Í ?‰Î í"
Ï ×éÐ tc Ñ �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Ô »oÕ ‹•Ö ‰¡
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
× ÍØ ‚ Ù Û íAÜ T�Ý ò Þ ‚æß /�à ‡Oâ ͯ ã 9
ä "Ìå æ b‚ç È… ê Fïë Ü ì 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
ï w
ñ Fsò £nó ß³ô ®éõ _Nö ÝÒ ø FÌ ù ÙÙú û# û ?Çü Qrý ³Ï
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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„ Ï † ÏL‡ )üˆ %Á‰ ®&Š e ‹ yä� VGŽ Ó¶� ×� rè‘ ÞØ’ U¶ ” • *÷– É
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
— š¿ ˜ g™ 0Ö› Zûœ Ë.� Rž òŸ ÕÒ   z£ é¤ ¦§¥ ß´¦ k© § Ëx ª z« W¬ 1×­ ¹® E¯ Í° ?È
± µ.² .˜³ T!´ v µ \Ÿ ö„ · à·¸ ¤zº +Ž » © ¼ ‡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
½ ·¾ š»¿ ôDÀ QvÁ j7 ¥E à ÿÐÄ ¾Å Æ Æ aÑÇ Á‹È ó± Ë ¡ Ì ›ÙÍ •
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Î F¨Ï ík Ð £l
Ñ 
Ò “ Ó ÇbÔ ÜóÕ E?× _sØ Ë¾Ù a<Ú ¯¥Û µ” Ü ÇïÝ òÝÞ ¦;ß Ÿ à Ù
á õ ä =å #z
æ ý ç Ù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
í Jdî ÁK
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ð bÓñ Uò ’$ ó íÓô Æ>õ !W ö wù
÷ b ø xXù �ßú !t
ý  5þ k ÿ Ú
€
k �
ªì‚
‹Fƒ
§„…
+
†
â‡
�H ˆ
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
°
‹
Vr Œ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
Ö �
T›‘
Ë’
€s“
Ï”
©ù •
iE—
ÄϘ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
,S™
1Ý
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
9§ ¡
Ǭ ¢
¿£
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
½ ¤
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Bå¥
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
«
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
¬}­
Ï ®
,¯
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
Áb
ÈV·
¾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
©X ¹
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
§º
Í‘¼
„- ½
4�¾
Éë
¿
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
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
W Ã
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
0ÒÅ
Q7Æ
­¥
Ç
¿±È
€ É
ÜÁ Ê
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
péÌ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
1ÝÎ
6%Ï
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
�BÑ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Q Ò
‰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ùÔ
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
h7Ú
É~
Û
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
.³Ü
MÝ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
`çÞ
ܯß
«í
á
‚^ â
ÈÌ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ã
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
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

ê
uë
#ì
Ñ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
Îî
´Yï
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
Mô
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
²²õ
n
ö
7§÷
š� ø
NG
ù
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
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
m›þ
JÏÿ
àØ€KÅ �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
ƒE
†N¡‡L„
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ˆÍþ ‰ƒaŠgQ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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�Há�˜r
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�É,‘¼´’ÊÇ“uÕ”<Y •S|–;Ì™Õ@šÑû ›w#œ{½�CAžúÑŸA  �¡Ƶ ¢ó£ºþ¤¦ ¥ì¯ ¦™@ §?¨¨±©°3ªj«@±®.A¯Æ9 °?\
±k²ٰ´ç² µÍ^ N]
·"}¸³ ¹»Î º‡¼ép½ 8¾=c ¿3!ÀÈÿÂÊ'
ÃÞÄ7-ÅÁíÆ
ÌÇ5òÈ=!ÉöËK:̈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
Р, ÑÍ+Ò6ÔQ½Õ•ÖÖó©
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
×9Ø)Ï
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÙÅØ Ú+ÛC]ÝGNÞEÍßu¹à[!Ჺâ%‡
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ã°äÔ¢ç5´ èðxéžÇê—W ë¤5ìÞ`í’“îs[ï§: ð\~ ñ™òSóàô ‹õ|ï÷ûÝø²›ù«o ú—¹û€Šü™3ýu’þ«š€ 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
�Xñ‚¹…o¡
† ­‡¤
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ˆ³½‰YŠa‹gŒ;Ü�硫õø�W-�œê‘ÿ°
’y“ªÆ•„
–MÆ
—I˜Qi™ê~ šF›#>œZ¨ žÛ‚Ÿs` n  £9”
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¤%2¥‘¦„P§õF
¨}É ©¢ç ª$Ä «aC¬ÚÉ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
­ú ®/»
¯
4°Œú±Ú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
¸d¹ÉNº¡Ÿ¼�½¶²¾�yÁoÎÂîÃÒë Ä. Å1ƸBÇDt
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
È£<ÉÐ
Êa£ËwËÌ/Íç·Î¸áÏÀŠ Ñ3ËÒÐs Ój
ÔüÕÁüÖ¦×üuØëÛÚj ÛTöÜvcßkš à�² á‡
âèÆ ã-Øä°Ëå„„ æª?çïV è¦é_g êÂlëD—ìØ}í‡Óî3 ïó&ðfÄñK…ô-AõTŸöV¥
÷Jp øìrùç\ú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
ûüõ ý•ïþ’ûÿç€è1
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
…÷… †³Š‰ª™ŠÅ1‹–ŒŽ(
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�_ŽV �ÕÇ�ÔZ‘]5 ’Ôá“
”K •šÛ – ®—=®˜›Ä™kš­�›OX žžœŸüÌ  ã¡¡ „¢õ
£; ¤ï*¥O1¦ð6§ôs¨¿| ©´S ªÿ5
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
«0¬z¬­v"®0Ø ¯Z” °8i³z÷´¬µ°/˜V·Œ'¸áT¹
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ºŸ×»V² ¼üû½ê:¾›
¿k˜Àkí Á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
Ä—ÿʼnÚÆòµ ÇG�ÈtrËìÓ ÌÌ`
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Í!bÎñ} ÏÆÐЮ$ÑNÒ «ÓK|ÔÛÌ Õ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
Ý=ÿÞ%ß²ày㶄 ää
åÐÉæ ‰ç± èâ#é‘` ê�°ëÓ8 ìÓŒíÔî44ïÒð³Úñ$ òZ7 óùØôAG õ$€ ö5�÷óYøï™û[ühjý*þ
þÿDö€íe�¼$ ‚ÖRƒ š„Ó¦ †)0‡ƒˆ™’
‰=
Šì‹µv Œ^I�YO
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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“5K ”#å•s –Œï—0þ˜x ™ù3
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
šÊØœff�ü8žª:Ÿ×Ñ  ‚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
¢È4¤i¥?Ç ¦Ÿe¨R3©ua ª²I«º;¬%®Kª¯r7°–p±•®²G´Ã\µ€"
6ӷ˸âí¹¹É º¯�¼) ½ù.¾lð ¿ú
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
À.ÎÁÝþ
ÂJÃsÄò(ÇR4Ș  Éÿ‘Ê®,Ë'³ ÌnÇÔóÿ ÕN=Ö×±bØo¥ Ù�„ÚÍ(ÛòTÜ©w
Ýù"Þ¤Oßîjà³áç#âåß ã‚äÌôåí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
æüðçµ è^qéüêRg ëØ—ì¹Z
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
íÀÞîD ï\k
ðÁŽñVà òN
óèè ô‘¹õÐöQî ÷'Ÿø�
ù‚´
úÖIûú ü>7ý#°þ$¨ÿ%^€šZ�£�‚ÿ ƒßÀ„Ùª…ao†

‡EˆnZ�¼e ‘ek’"Ô •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
Ÿ& ¹Õ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¡‘ ¢¥� £Ð ¤Dà¥Ù¦R,§]Ȩ‡Û©! ¬PH­È® O ±‰+ ²ßR³žT»¼-ª ½IO¾ÄT¿‡åÀ­³Á#v
ÂRM Ä
éÅ9“
ƞdžM
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
È¢IÊ­€Ëe\̈ë ÍÎ0ÎÎ, Ïî>Ñ�5 ÒJ¥Óh Ôêk Õ« Öxƒ ×Ô1 ØaeÙ sÚ˜¿ÛUTÜÛØÝOç Þõ4ßòaàÈkáËâÊGä
åˆã
æ’žçCèïê1�ë:yì
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ïî¬
ï®{ð,^ ñ¢Ô
òY;
ó>ôvt÷ 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
ø½Àùu8úY0 û�Mü Î
ý~Êþ ÷ÿÛ�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
€Ÿ �tô‚Ø …á'
†µû‡_·Š’…‹ø˜ŒÓõ�ÙÌ�‰‚‘}®”º_•k_–Çm™Üúš-›õØ ž0–Ÿ§P åš£¯/¤$ ¥¡¶ ¨Ì©ï ªÇ9­Æ]®‰Á
¯%ܲó³O’ ´³Ü·¸Ý¸Bó¹Ig¼Éx½à­¾·¸Á¾ÂÂÃãá
Æ"¡Ç/ÏÈkóË5ŸÌb…ÍÔ Ðm(Ñ‘¿
Òáê
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÕÜÖ}×××+Ú¨ ÛÿUÜ~­ßGà»
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
áw ä!w åcë æ¿.éÒ êV ëçç
îà‚ïmxð,$ù°>ú” ûµKüF$ý;ˆþrÿÁ�€°(
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
�žÀ ‚,qƒû´
„üå…“/
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
†W<‡/Ø ˆå+ ‰F÷Šª’‹K/ŒÙŸ�çz Žjh �”…�@&‘EÝ’‚“g”ý•͸–“ó —ѹ˜¥Ì ™”,š×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
£—î¤Yë ¥Š›¦”¡§ø¶¨”¥ ©ÕPª˜h«ë ¬LÙ­�®"¯°eµ
±(»²4γ7H ´Ï(µŽÕÀ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
ϼÀÛ½Æ
¾A{ ¿À�AÁØdÂ)�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÃDÄŸÝņ
Æ·ìÇkùÈù” Éã%
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ʯ ËÝ‹Ì_gÏIDЬÂÑ9Û
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ò—°Óÿ‡Ô�\Õ
jÖ!ƒ×&% ØUÞÙeÎÚ¡»Ûä3܇›Ý½AÞ]fߨ6à¾Vá~p âsE ãpäy“åæXXç±çè&.éC£êÄXë:Ã
ì£öíüˆîg¦ïBÂðS°ñÅN òó£c ô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
õ8È öï$ ÷®[øü ù�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ú?
ûË¿üÃÞýV<þÏòÿh’ €|Y�û/‚̃æÌ„™…LÀ
†Ãz‡àú ˆ‰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
�⎪Ï�À…�Ÿ?‘Rx’Ü0
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
“z`
”HÀ•Ç]–ì“—8e ˜šÜ
™!± šÒý›<íœØð�X žYžŸ}© �l¡½ ¢õ¡ ¥Qk¦¥
§8ˆ ¨X2©¼Ÿªæ}
«yk¬‹M­W\®y
¯Æ{°¼¶±æ ²Ñ*
³'æ ´ µ&'÷ç·@â ¸¼¬¹v,ºL[
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
»
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¼³� ¾ª“¿~ÐÀzÁuò ÂBHÄB¸Å¤ÖÆ6r Ç ?È.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
Ík„Δ<ÐZwÑ.·Ò¶MÕ8Ù ÖOŸ×ÌFÚáŽÛH& ÜÙW
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ßtà¼iá)é ~ê•á ë|7 ìf팻î9%ï FðnÄñ¯ýò‚ó1.ôKw
õP%ö
O÷}Õøo
ù çú‰|û²É ü�U ýÅþúÿ“‰€ö�mE ‚:sƒs5„Ê[
…^Ð † ‡šÝ ˆòn ‰ô Š‡~‹À, ŒÉ
�ìC Ž:²�·µ’•ï“àœ” •û?
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
–5_ —0
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
˜Ç·™FšƒÈ›¯¶œZ… �ÃÊž4mŸWR ðv¡É¢ût£Rg¤Q”¥Õ¶¦He§´ˆ¨ q
©»§ªB/
«˜f ¬¯
­ î ®é”
¯EL°ä±qS²ù)³Ó& ´¹µ¬Ö˜ø·®�
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¸Œ¹
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�º§_»‡ ¾?0 ¿ª\À¤M
ÁˆÔ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Âa/Ãñù Ä-éÅjöÆ‘Çn„ÈâËÉÿEÊS;ËìÌèÍDÐ Îñ²Ï®ÿ Ðã£Ñ*~Ò‰Ó‚V ÔéJÕ•êÖØ ×Un؈ŸÙL» Ú¡IÛ ŸÜj·Ýü–Þ\Áß°·à"Üá8r
â¶: ã¥ÌäÏå¹æ©çdåê­ˆë4Ëìð¥ íëªî­MïEâ
ð)J ñ~9
òM ó¡Nôõ
qö4‚ ÷Dvø®[
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ù¾[ú ûÊGü+ä
ý Gþoaÿõ° €Æ~ �€ ‚–ƒ& „X…‡õŽˆ¥g‰ôÀ
Š46‹À/
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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ë�åŽ_��yd �.©‘ÀS
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
’ò •¥
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
–¢ô —s­ ˜~3™¶w
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
ç œ¦¶ �žÁL Ÿ7\ ' ©7ª¡Z
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
«¬æÅ­�®‡X ¯þ&°°#±Š²á2 ³� ´‚zµŸæ
RV·Ì8¸ا
¹¶éº¾ú »B¼ÒÜ ½äv ¾À§¿nÀpãÁ<NÂþ¸Ã#LÄ ¤Å š
Æ#FÇ}NÈÃàÉ[@ÊW
Ë©ÅÌSIÍ5=Î8¢Ï)è Ðǃ Ñ?åÒbƒÓMPÔ™¦
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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(Ù-ÑÚçy Û$
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
à,› á«Ðâ•ã6ÿä÷Ëå
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Uæ9ýçFèÒFék
ê>íë±x ì9Ñ
íµñ
î¿ñï©Xð¬˜ó ªô%cõD ö…ö÷åHøâ¤ùš£ú%éû( ü<být„þÌÿ>
€S�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
‚lÏ ƒ¹¬ „ë…�q
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
†G‡y«ˆ�#‰ÄÏŠû=‹8ŒNp
�7ÒŽ+-�œ¿�$0‘ìÖ’@•“T ”1^•¨¹ –Uä—0˜%™­“šy/
›gÝ œ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Ÿè, õ¨ ¡-
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¢žÃ£.u¤s¥»Ë
¦*q§UÃ
¨j©Æ¡ ª±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
®¯Á °‡W±K¡
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
³�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
´ —µ3u·â•¸² ¹8ºR?
½°¾¾ƒm¿Ö�ÀfšÁªÂ>#ÃDÄwÊŇ„ ÆfÇÈ— È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
Ín9 Î�zÏÀ
Ð| ÑÅéÒæÅÓü+ Ô& ÕO$Ö;õ ×tÅØ�ÓÙ¾
Ú»Û;%ܬ–ÝHÇÞÄ ßïúàé á›* â$™ãKâ äaÿ åÖ+æÚLçõ®èÚeép^ ê,bëÿ ìÔí}DîZŽïz¸ðò)ñ
òZ&óß´
ôŒ´ õÑ! ö8�÷v�øu- ùY¹úU û‚ü‘ýó}þÅÿsu
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
€Á·�\Á ‚6qƒZ†„Æ
‡sóˆE¡‰ÛÚŠÊE‹ÔŒ¢ø�” ŽâM�,�(‡‘…% ’ç$“vf”a •‘Ž–c—”\˜ÛT ™0¿š�à›4€œ&j�y³ žÒbŸ»' Ž(¡݆¢oÙ £Aé¤b¢¥&Ž ¦Ês §˜
¨ÉB ©D`ª¾Ò«¢¬ƒ†
­2z®¥
¯Ä°a@
±��²K) ³wÿ´nµ¡`·ýû ¸-J¹á+ ºªÞ»¨ì ¼IS½–
¾?׿ÿIÀÓ=ÁsCÂ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
ÃʺÄ*µ
ÅIÑ Æ5ÇUÈOÍ É)¥
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ê�ÙË%�ÌpÖͼ
Ε9Ñ‘ Òþ¾ÓŒÑÔüÕ~•ÖÁö×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
ÚBgÛê ÜÐß…�
àæ]á\ÌâwÿãµYäÓ¢åeræD>ç†tèéxê
íF·î ï»ðÅ-ñpAòV‰óÑ]ôGPõÅ5ö«Õ÷•øáûûœAübù ýh+þ�/ÿ
<€  �ÆØ‚ÿ’ƒ¾+„AŽ …æE †¯•‰ Š,s
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‹âøŒ·ï�Ì”
Žšþ�r¨�p‘<Z’õ “7×”Š•© –o¬ — ž ˜¾ ™ž(š…²›~kœ±¢�,³ž»ÏŸö_ ÚÔ¡ªx¢ê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
£³=¤ÕÊ¥ ¸¦fX §
v¨-ü©Úe ªZ@
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
«iN¬À¹­þ7 ®Þî ¯On
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
°�h±™?²n§³ ˜ ´dµ9›ð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
ºæÿ» ¾¼zݽ®# ¾2�¿4ÀÍ€ ÁfA ÂøRǼĮÅ8Æ—Çù{ÈðmÉLI ÊufËæ¯ ÌaÖͳÎ_)
Ï~¨ÐÁê ÑÚ}Ò5
ÓáEÔ’ËÕ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ŸÖÿ×¼ÝØ‹1Ù´Æ
Ú"ˆÛÂúÜ°ýÝè·Þõ–ßCµ
àõôáµ&â8n ã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í�µ
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
ð=Ãñ5õòòN óî%ô�úõœO
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ö î÷Pb øÖ7ùêTúR û
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ü‘„ýN þðä ÿ‹+ €Ù¸�ý_‚Ê0ƒÖÓ„ …ßI†ß~‡å£ˆ¦*‰˜�Š=‹PÇŒ©�çÒŽ¢Ž
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�q� �yt
‘‰
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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
á™Âvš"�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
›' œ.Z�oªž*;Ÿæ  ×r ¡…y ¢='
£÷Ф`³ ¥ ,¦v*§ô
¨xË ©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
®¿ ¯>�°ñ—
±H߲볽c ´ο
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
µY=o·®%¸ž
¹– ºŽç» V ¼K, ½ù® ¾…< ¿ºÀÚª Á°î
ƒSÃ}iÄo3Å î ÆŠÑÇœ|È6-É|9Ê-ZË�̪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
Ï8ÍЯÊ
ј?ÒFwÓ…¨ ÔÜzÕ¼=ØÎPÙäÌ
ÚêÛ Üä Ý©¶ÞyqßîAàmÝ
ãö¶ä©Úå˱æwúç`èÈL é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
ëÌ´ì¦Iíi3îÅJï¼üðuN
ñ“T
ò$ó#ªô?ñõÀ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ö½o
÷ ø Í ùðÐú,Ÿûvo
ü„”
ý.M þèÿÇõ€£ë�~‚µ1
ƒäé „¿#…pu †äŽ‡)ºˆXH ‰¡BŠªË‹Ýj Œ‘@�ë�Ž[.
�Ùñ
�ˆ ‘Rý’±•“0ù
”ÞQ •e6–L&—ù˜P’™Ž[šnt›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
œü=�ò:ž„5
ٻt
 S ¡>Û¢¸ £ɇ ¤¨¥Jˆ¦&H
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
§4¨¨é©e% ª” «Wþ¬¶ú ­»ª®�߯Q °Ä?±¦²~ä ³%ø´í®µT
 ·­¸S¹¤0º„Ý»s>¼àk½%· ¾Â3¿Yh Âú
Ã(å
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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Ê>ç ËKJÌÄ3;�Α:Ï' ÐÕ�Ñ:®ÒáSÓL>Ô§Õu Ö‰×fÀ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ø#xÙdÔÚ o Û³E Ü.eÝ¤Ò Þ›ßÌs
àª^á¸h â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
¨çî© è˜^ él†ê«v
ëíÌìçÆ í§L îÎDïÃäð†X ñJøò˜*óqA ôýøõÊ|ö”Ñ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
÷–
ø˜ ù=©úüëû%Y ük0ýøMþÈŒÿš€ñ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"‚jƒ¾
†VN‡†H ˆöU‰o Š#¸‹b‡ ŒFs�óvŽå7�MØ �$®‘@º’¶ˆ“|b”pÔ•âæ–Ï.—Mm˜ƒ
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Šœí/�Hå
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ž¥èŸµ| œ�
¡�`¢é£¡9¤�B¥¿¢¦#ä§zÎ ¨Åf©tƒ ªM´«b8¬W” ­ ®t!¯¹~²‘ ³nŽ ´]ûµœ•‘{ ·Ç ¸ñ¹ëœ ºɬÃæÄ–
Å%Ñ
Æà– Ç,ÈY?ÉØÇ Ê‚ÝË;•Ì@àÍšžÎÓÏ/úÐ … Ñ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
ÔsÕ1ôÖo¶
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ן4Øßd Ùhø
ÚôÝ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
e ß|à!á=Fâá§ãw… äÔôå∠æ×HçÚ˜è%€ë0ìÒx í?]îg”
ïBì ðmáñWœòó¯öNUùèK ú&’ý
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
€sç�W
‚Íăo„°…8áˆ8‰I˜ŠèH‹þàŒý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
�1‰ ‘²8’Æ “µ”O•Àâ–‚—1ušþü›àœ0"�Wžôm
Ÿï3 wi¡šÌ ¤Fê ¥0¦• §
{
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¨®©cªe­§ °(5±À° ²P#³?´‹ŒµíB3í·Y ¸NʹúÁº?5½¿x¾ë@¿“AÀïPÁûþÄ]àÅñÚÆ8A ÇcÈ°QÉ:þ
ʾ—ˤY Ì¥À
ÍÈÎð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
ÏÈK Ðf× Ó·Ölý×K„ Ø„ Ù[Û
ÚãeÛhç Ü1A ßé
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
â± ã5þä�|åW¼èÂëèìÉNíêsðFZó6ôó’õTƒøo{ûƒ˜ü§8ýÿ•€#Zƒ,ᄢDž»I ˆJ#
‹.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
Œ/
�{Ž*´
‘S­”}Ç •hT–Ó™ö0œHb�²‚ž‡
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ÿúá ¢å¥°—¦î˜ §uª¨± «œ®-¯yÇ
° ±´»
´kã¼5C
½Ëž¾²\¿u“À˜äÁA*³@øµÄT¤ Å…�ÆíæǺEÈ'ÉNÊêËÌR�
Í1ÅÎfúϹÉÐé
Ñú\
ÒªÓçÔ,¶ ÕB8Ö˜Ø(Ù²íÚ
$ ÛëÞwi ߾ àßÍ á³âÅ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ãÓNäš åƒ;
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
æZ
ç;Ÿè·9
é^ê�„ë×ç ìá� í\3îÿÈïFð›ØñºvòÆ~ óîqô+îõx/öbo÷° øFK ù\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
ü/ýfþŒÑ ÿŠ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
€ *� ¿F ‚ ^½ƒ I“„ 9Q… UÆ † Þ¼ ‡ ¦è ˆ j‰ «eŠ h›� ŽŽ £±� t�� JH‘ þ�’ ñ “ æ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
” Ó • i– ò — "˜ £î™ �àš lò› Uœ ¦/ � u\ž ÑŸ Ùµ   UΡ ‰ ¢ £ tç¤ ÐY ¥ /[¦ ê§ Ū¨ Ÿ © ª @ã« [³¬ Ç
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
­ ?š ® ǯ L° î
± ò±² x³ †-¶ ù· þ!¸ „ª ¹ lº ŸB» †�
¼ çO½ Lk ¾ ’v¿ »À ™ƒÁ ,Ä ‰õ à à:Ä ¦Å ^þÆ úaÇ Ò È ˆ‡ É &# Ê ”ƒÍ 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
Ð ÊXÑ œ‘Ò !
Ó ‘’Ô CéÕ µ�Ö ¸;
× v˜Ø ÏcÙ S§ Ú Ô?Û Ö“Ü aOÝ BGÞ €·ß ˜gà Üy á zI â Šã % ä '™å *�æ *i ç }¹è \é Z ê CÒë b(ì Oºí ¹Oî Q3ï ƒR ð ]Z
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ñ óS
ò ‰Oó úÿô ÿ¯
õ ZQö ÙF÷ ‡ø byù ƒüú ½(û ç³
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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�€!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
�! k ‚!µ …!nI†!H ‡!¡€Š!é‹!5Œ!Øg�!¼(Ž!
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�!½Ù’!
l“!Ø ”!Ò¼•!bŒ–!y¾
—!Éš!PT
›!#œ!™^ �!ïžž!݈Ÿ!×¢!yã£!2m ¤!aÕ§!ÍΨ!Ø*©!Ï ¬!›G ­!cÈ®!Ô« ±!‡Ÿ²!�6³!Ìv´!9µ!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
·!•,¸!é¹!"T¼!»½!;ž¾!Û¹À!SÁ!ò Â!œ3Ã!rvÄ!£ðÅ!ß Ç!¨5È!ÓmÉ!®f Ê!xðË!·¯Ì!„Í![¨Î!SB Ï!i$Ò!JbÓ!'öÔ!}¸Õ! Ö!­£×!†Ø!æ‘ Ù!í„Ú!UþÛ!6~Ü!l¼Ý!4—à!�Ðá!ÚAâ!dã! ‹ä!å!‡Sæ!’0ç!‡kè!î)é!r§
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
í!‚‚î!Ãgï!c ð!áƒ
ñ!…ò!à-ó!›aô!žåõ!{‰ö!ð÷!»!ø!T—ù!E•ú!„Ôû!üç ü!›Óý!•  þ!y� ÿ! €"�œ�"ºå‚"ǵ ƒ";l„"Hq …"#‰
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
†"V‰"Ã^Š"tD ‹"ìqŒ"¦¼�"÷wŽ"‡l�"a­�"á‘"™!’"4“"ÊÝ”"9•"ÓK
–"PÈ—"kK˜"æ™"zš" × ›"M
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
œ"Nž�"šJ ž"$/Ÿ"Ô¤ "cç¡"—Ô¢"`Å
£"+q «"<Ó¬";^­"ÕÄ ®"‡¯"� °"nS±"A&²"6 ³"Óä´"æǵ"’$¶"Tþ·"骸"Ó¾
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¹"·õº"±ß»"©¼"Îc½" :¾"Ó¿"Â+
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
À"IßÁ"S_Â"Q²Ã"N¦ Ä"haÅ"αÆ"À Ç"BÈ"Nó
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
É"¶WÊ"L}Ë"¹±Ì"ÞP Í"‡Î"8Ï"˜ZÐ"]
Ñ"ø¼Ò"€c Ó"� Ô"öã Õ"J±Ö"3N
×"ÿ+
Ø"9öÙ"ÞKÚ"L¡ Û"X
Ü"î¤Ý"$ Þ"\ ß"ŸÚà"ºëá"13â"̦
ã"ÊÍ
ä"á�å"ºa æ""#ç"\Qè" l é"´™ê"&9 ë"-0
ì"_ž
í"œ© î" B
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ï"A@ð"²ñ"N¢ ò"Ý.
ó"Çðô"€Zõ"ëö"÷"…Ÿø"glù"¥ú ú"œ ý"´
þ"’ÿ"/­€#€~�#ðg‚#hƒ#øu
„#m4…#T†#†(‡#õˆˆ#×
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‰#Š…Š#·T‹#½¨Œ#~1�#ëéŽ#ô �# Ú�#¤}‘#ñL’#͇“#ÀÖ”#*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
•#]÷–#�Ÿ—#ú¤˜#o©
™#`K š#n¡ ›#œžœ#i¹�#Ež#i|Ÿ#)œ #¤G¡#«¹ ¢#Rº£#…ù¤#$Ú¥#g‘¦#Ú\ §#æ¨#Î] ©#àüª#›: «#³ó ¬#;ê¯#ô°#› ±#ZW²#W» ³#
´#WÌ µ#ëp¶#c·#9M¸#Œ± ¹#äCº#»#�:
¼#¥�½#¢A ¾#î¿#)¿
À#áZ
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
Ä#(Å#qÔ Æ#éKÇ# È#¨êÉ#’ªÊ#�I Ë#:êÌ#=�Í#…ÙÎ#>� Ï#yj Ð#¥~Ñ#ÒÒ#˜BÓ#°©Ô#Ý Õ#oFÖ#/Y×#Øû
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ø#BdÙ#ßþ Ú#�VÛ#¹úÜ#�‡Ý#ð6Þ#i ß#2à#2á#Ï*â#úã#Ëä#
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
å#^ æ#>€ ç#ŠB è#ìé#Òhê#º­ë#OÙ ì#§í#Oˆî#_ï#JÇð#Žqñ#,Qò#ö(ó#‹Hô#åöõ#Ê ö#Qâ ÷#I
ø#‚E
ù#ÆÓ
ú#9-û#C
ü#>ý#Mõ þ#D{
�$Rê
‚$e’ƒ$rr
„$ƒ
…$ÐD†$®’‡$S0ˆ$Ž
‰$�vŠ$ë ‹$Í` Œ$e‰�$¸yŽ$>ë�$‡á�$}Ô‘$²
’$§“$à ”$¶U•$jŽ–$Ç%—$˜Ò˜$
8™$ Ôš$W÷ ›$|Jœ$8ˆ �$! ž$ ¬ Ÿ$Yô $�o¡$®u ¢$cu£$
.¤$;¥$ÅĦ$ª§$J
¨$¸Q©$}Jª$þž«$ãĬ$f­$}h®$¨• ¯$ò†
°$x*±$ œ²$Ü< ³$”´$*£µ$A ¶$³
·$喝$ë
¹$(º$}Å»$«l¼$16½$
Ͼ$è_¿$ÐÚÀ$ajÁ$KÓ Â$£_Ã$ Ä$=Š Å$ë
Æ$¬1Ç$Y/È$*#É$÷3Ê$E Ë$´¡Ì$ÈÍ$þ9Î$‚æÏ$‡
Ð$"˜
Ó$ ñ Ô$Û,Õ$�Ö$ù×$ûY
Ø$[/
Ù$â±Ú$³– Û$)VÜ$•PÝ$pÞ$��ß$ê à$üEá$a½â$<Æã$“nä$7“å$% æ$”ç$¼
è$ÅÔ é$Uˆ ê$’# ë$~…ì$ º í$î$Ûãï$ÆÝ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ð$`N ñ$bò$�ù
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ó$mô$€iõ$ƒ²ö$�N÷$òŠø$fãù$`Zú$Yû$¼
ü$bsý$òø þ$ö$ÿ$fÙ
€%ÃÚ�%ôû‚%ù
…%
܆%0€‡%þ·ˆ%A‰%¤ Š%=º ‹%Úñ Œ%éË�%�Ž%B« �%îT�%ÿQ
‘%^­’%ÿf“%¢ð”%þì•%m£–%P—%Œ_˜%×ì™%dE
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
š%†
›%Ñ œ%¸x�%õ·ž%aì
Ÿ%N %@b¡%Ó¢%j› £%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©%�ûª%Ǽ«%°¬%â&
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
®%ox
¯%˜°%*±%ú�
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
¸%䆹%Ò º%²»%à' ¼%‰½%Ke
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¾%5r¿%¸(À%Y@Á%í5Â%¥MÃ%'äÄ%ï Å%Ʊ Æ%ð•Ç%ãã È%F¾ É%B8Ê%žË%”Ì%Å¢Í%:Î%AÏ%rT Ð%£ Ñ%|Ò%W
Ó%ò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
Õ%/'Ö%í×%0=
Ø%¶¦
Ù%ž&Ú%�rÛ%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
Ý%ª_Þ%çà ß%‚jà%p( á%ý â%†ïã%9ß
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ä%Ëßå%oç
æ%;Fç%}<è%dé%cBê%'ƒ ë%@3ì%Ï­í%Pî%|¹ ï%—È ð%cèñ%{ð ò%ßÓó%üåô%Æøõ%Á“ö%$÷%ÊÃø%œ¥ù%\ú%p×û%Ãü%Ò?ý%éÇþ%I
ÿ%Ù} €&?��&O0
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
‚&Œ¥ƒ&uV„&ex …&­†&ÿ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‡&¨ ˆ&ô:‰&¶‹ Š&˜u‹&$#Œ&q�&‹)Ž&8^ �&�¤�&Nû
‘&¿¯’&sV “&èg”&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
œ&û�&�ßž&ó'Ÿ&A. &z¡&UË¢&÷×£&1k ¤&‰– ¥&…¦&b§&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
­&mÆ®&µ] ¯&Ïe°&C� ±&²&Û ³&yò´&jjµ&°ê
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¶&ð�·&³¸&Þ¹&ò´
º&¦š»&Ÿ¦¼&þ$½&Âƾ&�¿&.f À&³ Á&Ð.Â&ÆÃ&Ý×Ä&JØÅ&î Æ&ïÇ&‘KÈ& LÉ&§QÊ&nåË&l´Î&Ã’Ï&bcÐ&7? Ñ&ƒÏÒ&ùr Ó&ª5
Ô&®ªÕ&§íÖ&—/×&ßØ&åÙ&—éÚ&¼§Û&¤êÜ&òJÝ&ÀÞ&û-ß&‡ à&÷ á&¶„â&€Èã&nêä&HÒå&Öâæ&2åç&!- è&ßóé&'™ ê&ë&šòì&MÜ
í&Zî&0û ï&²Ì
ð&ñ&1Î ò&8Æó&~ˆ
ô&}Øõ&·pö&ª�÷&wø& ù&É ú&ƒ{
û&¬° ü&:4ý& þ&«U ÿ&¶- €'él �'ŸÜ‚'¯1ƒ'Û¹ „'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
‰'÷r
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Š'�‹'Bn Œ'k™�'^tŽ'¹
�'‡Ÿ�'ûH ‘'¶ ’'Æå“'w
”'¥I•'ƒ�–'�H—':œ
˜'8™'­ô š'Óu›'¤œ'†n �'ˆ›ž'Àߟ'iÊ  'ˆ¡'à
¢'@Ó£'õ1¤'9Ë¥'Ç$¦'[n§'Á¨'Å® ©'…!ª'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
¯'Ù=°'¼
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
±'u²'Ϫ³'h¦´'s= µ'ÖG¶'ž ·'™¸'ü¹'ëŸ
º'`Ó »'â¼'è½'ð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
¿'*  Â'0^Ã'ßÄ'¶ô Å'‚
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Æ'Ÿ¦Ç'CÆÈ'…ÃÉ'øèÊ'�NË'j} Ì'O Í'4* Î'~Ï'!O Ð'OÑ'’Ü Ò'¹ÖÓ'Ò
Ô'WLÕ'ÂøÖ'ä­×'ëØ'À"Ù'Þ‰Ú'E—Û'k]Ü'è Ý'í<Þ'-…ß'cÝà'ýÍá'à â')jã'ˆ>ä'ÎËå'Gwæ'?ß ç'ä©è'ø‘é'›­ ê'‚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
ì'­’í'�–î'� ï'ÃÌ ð'“Vñ'a^ù'Çöú'­þû'û¸ü'Ôëý'›þ'€~ÿ'ÅP€(4E�(fV „(ø…(øX†(` ‡(îý ˆ(Á+
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‰(EÏŠ(º¼‹(�vŒ(&j �(J�(I8‘(jË’(âv“(�«”(´Ç •(•"–(� —(ûj˜(Ñ™(Xpš(©l›(À|œ(Ç. �(]ž(W3
Ÿ(Д (M¡(@ë ¢(S £(¤( ¡ ¥(†«¦(÷§(ÌI
¨( z ©(ˆ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«(ØÛ¬(¥ò­(bÕ®(áU¯(§J °(Ë ±(&~²(M ³(tL ´(µ(IM ¶(E'·(̸(ki¹(ûÄ º(Zå
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
»(2f¼(l‘½(¶•¾(Ç ¿(”ÒÀ(p…Á(—gÂ(°Ã(€KÄ(ÔÅ(ðíÆ(vÇ(ÑçÈ(¥, É(dâÊ(m±
Ë(h Ì(Žq Í(-!
Î(&5Ï(ø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
Ð((Ñ(¨ÌÒ(îÓ(ÊuÔ(Y¶Õ(ˆÔÖ(N2×(¯“Ø(ýyÙ() Ú(÷" Û({Ü(7îÝ(UôÞ(‘?ß(±aà(›9á(zâ(»Éã(qä(p å(¼æ(¼Qç(x�è(ûu é(Æê(¡- ë(%/ì(ýÍ í(v î(,™ñ(ÖÖò(Só(ô( õ(éÅ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ö(Y©÷(ïkø($ù(‘¹ ú(Ë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
ü(@úý(Úçþ(£Gÿ(A
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
€)3©�)% ‚)Oªƒ)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
„)½m…)þN
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
†)Â
‡)'3 ˆ)äà‰)t/Š)^~‹)YI Œ)ç�){ Ž)îø �)AÐ�)Ï,‘)÷3’)]}
“)5ü”)ŸÔ •)üX–)mÉ—)º ˜)oï ™)¬˜š)Š›)i½œ)š¢
�)ìPž)`½Ÿ)¦� )°É¡)ÿè ¢):J£)Áy ¤)H¥)½¦)Bs§)Yb ¨)Gí©)×aª)5«)n¬)?­)�x®)¶?¯)"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
°)ȶ±)L²)¾†³)ã ´)îáµ)|w¶)Ç·)-“¸)Åܹ)Z º)Az»)õ�¼)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
Ä)‘ÍÅ)¡= Æ)žÌÇ)ÕƒÈ)–Ç É)…ÌÊ)£t
Ë)—ø Ì)
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
Î)S"Ï)FÐ)è™Ó)ð-Ô)k Õ):ØÖ)Ý×)öUØ)ÜÊÙ)΄Ú)# Û)BÇÜ)kÌÝ)]yÞ)r_ß)^”à)^G á)ßâ)D
ã)œœä):±å)P æ)j ç)ù½ è)7§
é)cfê)
Xë)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
í)ëM î)e£ï)Ñ:ð)¥
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ñ)Ûò)”¡ó)#¹
ô)kS
õ)r&ö)Ó÷)¥|ø)\’ù)Íõ ú)‘) û)~Vü)1  ý)ž¦ þ)0R ÿ)·é€*gÜ�*’õ‚*¯œƒ*@ „*…*—P†*|î‡*qåˆ*ÜL ‰* †Š*q¼‹*ïŒ*g�*”Ž*¢Œ�*S¡ �*¼‘*š ’**Þ“*¶}”*Ò•*Þ½ –*‰N—*£±
˜*Læ™*æš*PW›*0$œ*E9�*ùž*ÿ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ÿ*@? *¨µ¡*�@¢*\Ò£*mT
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¤*4~ ¥*ÛŸ¦*¦ÿ §*iL¨*'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
«*˜�¬*ZK­*¤®*/¯*j°*Ì ±*ôH²*!Ê µ*X¸¶*tú
·*¤ ¸*¹y
¹*’ º*i»»*+3 ¼*®Ñ ½* �¾*0×
¿*˜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
Á*ÉCÂ*ÆÃÃ*ƒ; Ä*|éÅ*î%Æ*zÚÇ*cVÈ*„§É* ¤Ê*”;Ë*7;Ì*šúÍ*²ðÎ*÷~Ï*ØRÐ*
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
°Ñ*óÒ*ç/Ó*ê
Ô*zÀÕ*õÖ*·û×*Ò°Ø*t©Ù*pFÚ*Ä_Û*¾¸Ü*lv Ý*I˜
Þ*2< ß*üOà*Ë’ á*bQ â*¤ê ã*
+
ä*Tp å*ü¶æ*"!ç*6„
è*taé*¼±ê*¦`ë*W.ì*µ­í*önî*ˆï*éQð*nñ*"‡ ò*'Ãó*É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
ô*F� õ*p¡ö*?K÷*ˆ®ø*ÿCù*&Çú*bñû*'?ü*Öqý*hÙþ*gçÿ* Þ€+¹¹�+®/‚+ûØ
ƒ+ô…
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
„+N"
…+
†+”‡+rˆ+ E ‰+ì^Š+%¶ ‹+NVŒ+´
�+ë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
’+Დ+˸ ”+‹4 —+qQ˜+š` ™+ô/š+Ä ›+·´œ+ò�+·¿ž+®� Ÿ+v“ +d ¡+^Õ¢+¾²£+´Ù ¤+s¤ ¥+'~ ¦+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÷¨+46
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°+qŽ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
±+P²+¥ß³+3ï´+ØSµ+ÛC¶+žŸ
·+b‹ ¸+7?¹+Îp º+Àz
»+Y# ¼+JE ½+§#
¾+ìÏ¿+
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
À+ ÁÁ+4’ Â+ÕÃ+:'Ä+Í_Å+5ý
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Æ+ÛÇ+x¬È+KÊÉ+dÕ Ê+ÜË+ãOÌ+΀ Í+`ÀÎ+DqÏ+†Ð+à
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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Ò+—ÍÓ+Á< Ô+Øf Õ+e–Ö+±´×+=%
Ø+’@ Ù+H¥Ú+nE
Û+-àÜ+ìŠÝ+ú Þ+2…ß+­ià+ö á+j8â+u ã+¢ ä+l2
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
å+ýËæ+q…
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ç+$è+8<é+x¥
ê+I0ë+g§
ì+ ~í+ÅÊ î+Ù(ï+�Fð+ª‘ñ+X� ò+Önó+â ô+Å7õ+'9ö+ðöù+Ö½ú+:hû+´tü+žiý+©ßþ+2ÿ+ˆ'€,ÙE�,<
‚,å!
ƒ, ÿ„,ã[…,—� †,Hh‡,úX ˆ,=8
‰,í"Š,` ‹,ˆLŒ,pG�,a÷Ž,ßC�,Ø�,{ò‘,(¥’,U¯“,î‹”,EF•,Y'–,y•
—,á˜,Ao
™,þ†š,>/›,ÝÓ œ,E�,N1ž,ÄdŸ,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
 ,›Å ¡,O5¢,²�
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
£,¿’¤,"¥,í|
¦,�‘§,§y¨,�à©,–øª,]K«,'”¬,Åð­,q®,� ¯,§Ï °,C6±,
²,P³,´ ´,yµ,èÔ
¶,£ˆ ·,°I¸,ô‹¹,€] º,nH»,
· ¼,Æ!
½,¡ù
¾,9›¿,Lî
À,ÉHÁ,›- Â,X¿Ã,ÖåÄ,ÛÅ,vâÆ,R™Ç,´CÈ,
hÉ,g–
Ê,Ã}Ë,»-Ì,K¯
Í,_ZÎ,ÀýÏ,è2Ð,Õ Ñ,/ÊÒ,ì–Ó,ûÐ Ô,ž=
Õ,®Ö,Úø×,ä�Ø,I·Û,`'Ü,*ÈÝ,ˆ‹Þ,�ß,�à,áá,lÑ â,»èã,é# ä,ˆ å,�«
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
æ,BÄç,Ñ0
è,E
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
é,Á
ê,þãë,}Ëì,~ í,p>î,oï,q
ð,Eìñ,uåò,o´ó,?ô,¶1 õ,·ö,FA÷,Ï ø,ƒcù,74ú,º©û,u¼ü,•(
ý,|þ,þ ÿ,YQ€-bŽ�-' ‚-ŠMƒ-gS„-5¶…-k� †-dr‡-—c ˆ-ÐM ‰-ÉCŠ-G‹-Å9Œ-
�-ˆ©Ž-MÂ�-Gâ�-ÃZ‘-dU’-S©“-ùW
”-Û6•-@Ê–-º—-Fy ˜-+ú ™-òbš-2Q›-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è
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ÿ- -C¸¡-Y(¢-¹Í £-«ù¤-Ê?¥-Œr¦-¾à§-W¨-Щ-`ª-íQ«-²o¬-¾Q ­-bô®-•k¯-u%°-?a±-7 ²-¢¶
³-¥´-âµ-Jò¶-3à ·-å)¸-°Ú¹-;¾º-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
¿-kß À-óG
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Á-âÞ Â-d.Ã-M Ä-¦o Å-ÏëÆ-‡¬
Ç-ü È-P/É-–Ê-> Ë-L©Ì-E¼Í-ÆÎ-ÝIÏ-:jÐ-iÑ-‰Ò-,Ó-
�Ô-à Õ- ;Ö-¾'×-x¬Ø-¥…Ù-hbÚ-ÍrÛ-PÖÜ-ˆÝ-)Þ-âß-Y à-Á©á-jOâ-}rã-S
ä-Ã4å-Üi æ-J×ç-Lh
è-/ é-†ýê-Ï ë-·öì-¹ í-AÝ î-¨—ï-x1
ð-çªñ-)|ò-ø¦ó-¨ô-åyõ-)ûö-«+ ÷-æø-u‡ù-ñ]
ú-®…û-%
ü->>ý-Ðþ-Ö˜ÿ-¦y
€.H�.œ[‚.>¤ƒ.Ê
„.ªt….É
†.¸‡.eˆˆ.<  ‰.rñ
Š.+¯‹.™ÿŒ.ˆ› �.Ë Ž.G �.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† ‘.ƒ’.R+ “.V
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
”.Ø®•.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
Ÿ.u;  .¼m¡.qŸ¢.§â
£.›ô¤.ÿ~ ¥.*7¦.lU§.ºª.—“«.>¬. (´.9¯ µ.’î¶.à¡ ·.à(¸.8Ô
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¹.‹¯ º.ù9».½-¼.gæ½.A¬¾.‹
¿.îMÀ.e. Á.¨øÂ.“«Ã.+{Ä.EÅ.ÀáÆ.ÅãÇ.ËRÈ.ÎßÉ.Î�Ê.N¾Ë.2XÌ.RÒ Í.êJÎ.რÏ.d­Ð..Ô
Ñ.NœÒ.ºÓ.°B
Ô.…Ñ Õ.
òÖ.µ
×.¡
Ø.¦Ù.BÚ.BXÛ.h�Ü.®4 Ý.D4Þ.|Ýß.Ó à.BŽá.YÙâ.´¡ã.Âä.ðs
å.A5æ.Hªç.ï•è.�ºé.C»ê.mLë.5T ì.e¡í.¼î.Yúï.(ð.�ã ñ.Îæò.ü õ.ƒZö.JN÷.Y�ø.mŠ
ù.©ú.èžû.Ieü.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
ƒ/‰M„/ö­…/l †/Ç
‡/Þ° ˆ/•¹‰/Ù„Š/f ‹/žŒ/ºç�/x1Ž/ù½�/©
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�/ð>‘/0’/ˆM“/‹Ç”/M° •/®! ˜/ä~™/"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
œ/,•�/d
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
£/D‚¤/”÷
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¥/�4¦/‘x§/u�¨/×<©/Qeª/$B«/¾" ¬/©€
­/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
®/ñÁ ¯/0Ž°/12 ±/ÆQ
²/’Q³/¤¥´/¶§µ/£À¶/ÒM·/*¨ ¸/^ѹ/“B
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
º/ ™ »/bï¼/îw½/ÑÛ¾/]¿/>Ï
À/bB Á/>ç Ä/·@Å/
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Æ/MmÇ/§©È/äTÉ/#tÊ/£Ë/Ü· Ì/´Ê Í/½Î/ÅÏ/‹lÐ/~¬Ñ/ÒsÒ/Ú^Õ/­hÖ/Ç;×/ݘØ/�¾Ù/·ÄÚ/ÕÕÛ/_³
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ü/HqÝ/ Þ/91ß/¬Î à/Q¯á/Ùâ/Y®ã/Öæ/X�ç/Ä�è/=Oé/ä¾ê/'r
ë/>»ì/%í/ÄLî/Tr
ï/_ð/ÿY ñ/çE ò/àoó/Cô/Äûõ/�§ö/·Ý÷/“ø/¼ù/q´ú/~û/Íò
ü/»õ ý/iwþ/“þÿ/ºÖ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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ê9�0„‚0bàƒ0*"„0�…0¼†0…»‡0¢`ˆ0Ká‰0'òŠ0·‹0vÁŒ0�1�0!ýŽ0¤
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�063�0Î`‘05B ’0AZ“0FK”0bq •0`š–00—0 "˜0q€›0
Ç œ0X �0k–ž0aUŸ0Ñ/
 0MF¡0®— ¢0wA £0÷¾¤0H
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¥07¦¦0þ[§0âu¨0Cs ©0cñª0w?«04@¬0¨§­0us®0ó» ¯0ôo°0uÚ ±0ƒù²0ƒa³0ÚŽ ´0×�µ0ŠA¸0*2
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¹0£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
º001€¾0Æ¿0¾ý
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Â0¹sÃ0>ü Ä0lÌ0ƒgÍ0?Î0ìÑ0ïÛÒ0¢Ó0ú~Ô0Ež
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Õ0ÇAÖ0ПÙ0J Ú0åûÛ0�?Þ0Ó5 ß0ù¾à0hXá0
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ôâ0ú¾ã00ä0ŠÚå0ë¼æ0êý é0¾ê0Üãë0/Có0Å ö0—Û÷0¡Ìø0'ù0
¯ú0âäû0—K
ý0ƒÕ
þ0ÿ^ÿ0̶�1‰‹ ‚1Ì©ƒ1S4
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
…11ù†1°ç‡1­ñ‰1¡¬Š1¼t ‹1ì!Œ1Ò�1Â
�1ß��1tב1ý”1¾�•1ÑV–1>6˜1~B
™1²‹š1ëí
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
›1*+ œ1‚ê�1Y Ÿ10Ó
 1Q@¡1¦Ï¢1N£1˦¤1 {
¥1žÃ¦1wŠ§1(§©1h1ª1i «1ö®1a#¯18u°1í±1)r²1¨N
³1á°´1þ.µ1X ¶10É·1sâ ¸1TÀ¹11º11L»1Ïi ¼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ËÜ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¿1„Y Á1�
Â1}?Ã1èUÅ1Y«Æ1IÇ1"ãÉ1
ïÊ1à£Ë1„ŽÍ1ú– Î1wÏ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
Ñ1Q™Ò1±O Ó1€ Ô1´ãÕ1zPÖ1Ø`×1†øØ1¹‰Ú1�\ Û1q!Ü1-ñß1#° à1òÕá1�¯
â1ê- ã1Ñ? ä1þÄ
å1Ò
æ17žç1¹¶ è1çé1‹…ê1êë1£‘ì1vOí1ò- î1Õ9ï1fT ð1H`ò1‚wó1¡"ô1Ö- õ1CÅö1g¥ ÷1�n ù1r¹
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ú1{
û1eW þ19ÿ1�Ú €2jX�2éY ‚2 Ï ƒ2±„2% …2«ñ
†2‰â
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
‡2©½ ˆ2
؉2~
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Š2±j‹2>ùŒ2oJ�2ïÎŽ2µ#�2­Ø‘2ú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
’2o“2ü•2Š$
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
–2-“—2_™2€}š247›2^iœ2»Ð �2}[ž2g 2o@¡2n—
¢2+£2_Ô
¤2Û@¥2J£ ¦2 Œ§2 7
¨2# ª2ÀÍ «2û4¬2ø†®2F+
¯20=°2àg ³2´,
´2ÌSµ2à¶2Ý ·2ùÊ
¸2:Ô º2(˜»2õø¼2�d ½2¸m
¾2œ¯ ¿2 Á2­ž
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Â2* Ã2‚u Ä2ƒžÅ2×â Æ2«»
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
È2v?
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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 rÊ2Á^Ë2‚úÌ2%—Í2û!
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Î2œk Ï2­(Ð2öñÓ2”ÍÔ2r÷ Õ2†—Ö2×2› Ø2ÐÃÙ2xÚ2føÛ2¥ÝÜ2€
Ý2µÞ2}:
ß2‹Û à2â= á2ØH
â2€
ã2¨
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ä2š;æ2(Žç2ë
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
è2x)
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ê2Öë2ìÏì2üî2yï2—'
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ð2:×ñ2Žyò29¤ó2;�
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
õ2…Ãö2Ç� ÷2\¡ø2�ù2­æú2Ô û2æü2~_ ý2Fbÿ2;Ô€3ë÷�3gÛ„3q}…3-†30‚‡3Æ× ˆ3öz‰3Nó Š3ö‚ Œ3Øg �3«úŽ3‡ß�3_ �3÷
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‘3J% “3GÝ”3¶h•3÷—3éÞ˜3I‚™3®…œ3²�3¨÷ž3Y&Ÿ3o« 3Ž
¡3Ù‰
¢3-'£3êY¤3?¤
¥3©"¦3ÉÖ§3÷±¨3Äk©30’ª3Ÿ¼«3�
¬3�$ ­37Ú®3`”¯3«ê°3B±3kè ²3L³3T[ ´3R(µ3b/¶3ç ·33 ¹38oº3·B»3¾u¼3᪽3‡6¾3‹ü¿39_
À3<5Á3U9Â3¨ËÃ3|·Ä3n4Å3˜ŠÆ3‡Ö Ç3ŒúÈ3~®Ë3ä²Ì3„5Í3‚ë
Î32CÏ3”­Ð3HöÑ3«ñÒ3@&Ó3lÔ3ÇãÕ3.RÖ3u"×3þGØ3_yÙ3æcÚ3”Û3‹6Ü3^  Ý3@· Þ3àß3Zµà3ì á3� â3y¶ã3‹Á
ä3µå3×æ3‘2ç3�Äè3|@é33Ùê3¦E ë3ce ì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ÿQï3Q ð3šñ3î ò3 t ó3/Vô3úÈ ÷3W  ø3œù3¡ê ú31R û3vÔü3
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
«ý3Nÿ þ3å\ ÿ3k¶€41<
�4="‚4Áу4R¶„4wª…4€;†4¿b‡4§nˆ4ŸS ‰4ä
Š41ò ‹4$`Œ4Ä·�4$kŽ4–f�4›€�4æ*‘4ÊŠ’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
“4Áù”4ÇÚ•4[H
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
–4/a
—44 ˜4Ì+ ™4“Kš4{›4@ÿœ4Þ�4…0ž4&—Ÿ4Б 45 ¡4p|¢4¯£4@m¤4=Y¥4òà ¦4=©4‚6ª4¤5 «4IN¬4=è ­4n±®4e¯4¶Ÿ °4¤m±4Ã…²4G
³4ÄB´4í— µ4RW¶4Ð8·482¸4ѹ4Êøº4%Ï»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
®¼4xÖ½4}9¾4Ì¿4ÈJ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
À4nS Á4¬ÊÂ4^ÅÃ4ša Ä4Æ Å4°ŸÆ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
Ç40“È4=1É4)Ê4F0Ë4ÆÌ4ãç Í4 Î4¹` Ï4½CÐ4wñÑ4òÒ4z-Ó4]”Ô41ƒÕ4Ä
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ø4ÑèÙ4ŠÚ4 Û4w”Ü4}ÖÝ4s Þ4->ß4_à4þ‚
á4Àšâ4v( ã4 ™
ä4V
å4Ræ4µ¬ç4ü è4 _é4n¸ê4
ë4 2ì41„í4j(î4˜µ ï4£èð4upñ4ò*ò4[ ó4¢Á
ô4…ëõ4Ÿ±ö4B�÷4Lrø4ä
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ù4°¯ú4N¨û4l:ü4ò ý4õž þ4y ÿ4è¿€5Ÿ4�5œ¹
‚5Ü ƒ5: „5W…505†5[
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‡5õ©Š5âY‹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ýê�5‚�‘5m’5°î“5(‰”5Æ1•5®ù–59_ —5VG
˜5™5Ùú š55ƒ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
›5× œ5®³ �5Hž5lJ Ÿ5¾Y
 5KÄ¡5 X ¢5Ï£5‚¢¤5´Z¥5G1¦5™e§5bz¨5‰F©5çéª5ÞÈ«5ŽŒ ¬5*‚
­5Ø�
®5øX¯5Ÿ°5È ±5¸ð²5/¹³5~ ´5õص5dJ¶5¤É·5"¥ ¸5(
¹5š‚
¼5ì“ ½5tb ¾5Oz
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¿5d=
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
À5óïÁ5(‘
Â5ïÃ5Ä5n¦Å5EKÆ5PsÇ5á"È5Ü÷É5ì Ê5¡ËË5u¥Ì5T`Í5u6Î5MÏ5â$Ð5‚M Ñ58j
Ò5y3 Ó5ì]Ô5 % Õ5óÖ5¥…×5Þ~Ø5>¿
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ù5Á“Ú5—Û5=
Ü5DÝ5¹uÞ5*òß5ºy à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ç5ôµ è5§Z ë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
ì5NÅí5
èî5‰æ ï5åF ð5óñ5ù‰
ò5¡º
ó5áô5R?õ5N9ö5Ç÷5Ù¥ ø5Æþù5}’ ú5©Bû5½Ó ü5©ý5Áîþ5øÿ5;§€6™Z�6Ò†‚6ßfƒ6è
„6!_
…6Û\†6. ‡6âAˆ6Ãå‰6œ
Š6è” ‹6S
Œ6#Q �6°tŽ6³½�6Š!�6‘6<~’6ض“6µœ
”6B •6† –61—6Üžš6tÓ›6Ø
œ6iç�6>�ž6Y—Ÿ6Õ© 6+?¡6s­
¢6—ã6–ï ¤6÷W¥6�/¦6c¨ §6J: ¨6ºF «6�w¬6¿q­6]®6n!¯6 2°6Îx±6.Ô²6‹
³6?‹ ´6<2µ6÷‹¶6ž¡·6E~ ¸6Œú¹6T ¼6é0½6ßÔ¾6L÷¿6#hÀ6,_Á6ÕüÂ6u±Ã6£ Ä6ß9 Ç6À`
È6mÉ6Ž•Ê6ïË6¡á Ì6{ Í6ð‚Î6{ÁÏ6ª•Ò6Ü¿Ó6Š}Ô6²wÕ6R`Ö6¸
×6–¼Ù6ô Ú6,µÛ6X Ý6×o Þ6À¥ß6!tá6[‚
â6ƒÏã6ª¾å6P£æ6Q.ç6 ê6‘[ë6àÒì6¶¼í6ìt î6ÜÑï6Š¿ð6bñ6«ò6¼Æ
ó6  ô6X4 õ6ýaö67Æ
÷6Êø6Ax ù6ú} ú6X-û6²ý6ÉÅþ6ó{ÿ6[×€7u8
�7©Ï‚7¦D„7
\
…7`†7…Ùˆ7W¼‰7BzŠ7��7ûê
Ž7U3
�7=�7¤9‘7ø¾ ’7–V“7Û
”7Yv •7ÕÖ—7í}˜7ôÎ
™7±1š7\³›70œ7ô8�7]ôž7ÚòŸ7¬  7Þó¡7h!
¢7[ò¤7'ß
¥7×f
¦7 Ò¨7}~©7e-
ª7¸«7®$ ¬7@›­7MQµ7B7
¶7›Ã·7H¸7a. ¹7T'º7¦@»7+>
¼7Üœ½7Ûð¾7¶ž¿7¨�
À7;7 Á7µM Â7" Ã7JEÄ7Î\Å7€Æ7Ck Ç7UªÈ7
ÚÉ7‚è Ê7c¹Ë7ËÌ7¸Í7r«Î7PcÏ7EÐ7h­Ñ7‰Ò7\ Ó7ÛÔ7ŽîÕ7‹�Ö7;@×7‰¤Ø7šY
Ù7ñ�Ú7Ö�Û7Þ½
Ü7=Ð
Ý7o
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Þ7Ì3á7â7gRã7vä7¾† å72çæ7Nrç7‡rè7l é7ëæ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ê7Â ë7Qhì7ƨ
ï7æ ð7ÑAñ7[Âò7Gãó7Crô7Ï@õ7yðö7…÷7_ø7û©
ù7“Œú7…óû7lñ ü7vý7\Ðþ78èÿ7HI€8ñ0�8i ‚8`Zƒ8j›†8ñ»
‡8Å ˆ8pô‰8ë Š8Sé‹8
­
Œ8Ч �8×ÕŽ8^ˆ �8x§�8;{ ‘8šõ
”8øg•8–“–8öØ™8ø2š8X‰›8”šœ8‚ß�8Nöž8mŸ8Ó- 8¹¡8�>¢8Ÿ}£8;W ¤8<3¥8hŠ¦8in §8Â�
¨8²\©8¬•ª8*æ«8l^¬8@N­8É®8w–¯8R>°8Ú
±8«–²8Ü ³8kï´8l µ8]¶8+‹·8Õã¸8»B¹8Žð º8‡ý»8»„¼8P½8Ë€¾8ô¿8…ñÀ8
Á8Ø9Â8} Ã8ûÄ8 .Å8mÌÆ89ÇÇ8£Ê8ÝW
Ë8)ž Ì8(,Ï8,ÄÐ8UKÑ8Þ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ô8L¬Õ8ò”Ö8\‡ Ù8Ú8Éí Û81 Þ87çß8}äà8™q
ã8Qä8‰Cå8Nõè8¾é8Kê8"õô8ÞÀõ8|5ö8×Í÷8º^ ø8Áê û8åÜü8{êý8m1þ8¶Fÿ8µà€9±^�9V3‚9îc ƒ9Ò¶†9çʇ9V-ˆ9­#‰9s Š9ê‹9 Œ9Tt�9T€Ž9Äö�9£t�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
‘9P ’9h¿“9©@ ”9<(–9dl
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
—9È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
˜9Ox™9´Lš9‚
›9
Ñœ9Ðì�9¶ç ž9öŸ91¹ 9³n¡9×¢9!v £9ðã¤9C¦96Z§9F0¨9Øâ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
©9Sí ª9¤†«9Ð^¬9PÔ­9hà
®9¥Ò¯9t'°9Kɱ9‰Þ³93½ ´9:’µ9j‰ ¶9°Î·9}
¸9øH
º9œ@»9) ¼9̽9Ú¾9½s¿9Ü
Ã9«ÄÄ9éÕ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Å9¿Æ9Å:
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ç9ˆ’
È9ñïÉ9 ^
Ê9$ÜË9y Ì9®"Í9‹Ð9)t
Ñ9Ð4Ò9R=Ó98T
Ô9�vÕ9.•Ö9!×9±Ø9ìL Ù97 Ú9é� Ý9 °Þ9– ß96‚à9=á9p—â9£7ã9™ä9÷ å9vWæ9äç9)Ïê9µû ë9¦Mì9Mü í9æî9‚ûï9 bð9útñ9é…ò9¼-ó97¡÷9
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ø9«¹ù9 ò
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ú9’Äû9îþ9´bÿ9‰ €:Ôn �:]™‚:…:Np†:"½‡:¸ˆ:‰:tn
Š:§ ‹:SåŽ:³á�:fb�:hv‘:^_’:¡‡“:h
–:iå—:Êü ˜:nÙ™: š:âr›:éLž:Ài Ÿ:åj :³5£:„F¤:'¥:L ¨:!+©:COª:YÍ­:Õž®:†Ê¯:¯Œ²:w¨³:¡´:c µ:M¯ ¶:PG·:£¸:Æ. »:�•
¼:Íó ½: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
¾:—·¿:. À:FÄÃ:4b Ä:Pâ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Å:÷LÆ:ŠWÇ:"ìÉ:ŸÊ:A"Ë:Ô8 Ì:ŽÍ:‚ Î:_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
Ð:„6Ñ:ã¨Ò:#ùÓ:"
Ô:—A
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
ˆÞ:”"ß:¹Pà:Û‰á:ìýâ:tzã:H+ ä:w?å:Î
ç:{µ è: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
ì:Cæ í:î:]�ï:¨á
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ñ:¥N ò:ˆ^ó:w- ô: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
õ:å�ö:Ÿ‹÷:Ûçø:R�ù:4ü:“ ý:Y7
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
þ:eŠÿ:íÎ €;¶� �;: ‚;C­ƒ;‰ „;ôB…;:ò ‡;ÎŒˆ;v
‰;eÍŠ;–‹;v&Œ;@�;ºŽ;��;˜¿�;ž6‘;R§“;¢¤”;Ib•;é1 –;r£ —;Š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
�;õž;– Ÿ;·  ;ËÑ ¡;˜ó¢;ѧ£;±
¤;$c¥;´—¨;Û¿ ©;éÕª;FÁ«; _ ¬;‘­;-5 ®;˜5¯;U¦°;‘ƒ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
±;; ²;9/³;ð€´;ú$ µ;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
·;Nz¸;ŠU ¹;�º;û»;š¨¼;h
½;Ào
¾;(Š¿;ÿ À;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
É;ÓÊ;¨ãË;–¸Ì;tŸ Í;–l Î;¹ Ï;7|Ð;«oÑ;X†Ò;» Ó;­^Ô;¦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
Ø;‘ÕÙ;!?Ú; ­Û;õÜ;zÄÝ;+ä Þ;÷Œ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ß;dIà;D­ á;Ë�â;Þ• ã;•‹ä;‘…å;ô¿æ;�ç;'
è;Óké;Øì;ô„í;œ™î;cï;À°ð;?L ñ;šyò;té ó;­Ñô;HŒõ;ˆA ö;j.÷;wœø;Z‚ù;Îx
ú;ÃÕû;(Hü;÷aý;‚wþ;£0ÿ;×Ê€<íÚ�<©"‚<¡ïƒ<²„<Þ=…< †<Ë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
‹<­vŒ<ù'�<× �<‚‘<+l’<n“<ˆ—•<{Š–<m°—<@7˜<Ù!™<A#›<^€ œ<$K�<ôµž<GRŸ<±¢<h£<u¤<¡@¥<lÀ
¦<à§<‘G ¨<vÿ©<„÷ª<­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
«<™Í¬<ç­<ãC®< ¯<¯¿°<©ž ³<Lü´<^ìµ<ŠŽ¶<÷Ž·<8ø¸<º6¹<·@º<5„»<p5¼<X½< ¾<úà¿<‹À<<ÞÁ<ÑÐÂ<M$ Ã<ÅÄ<d
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Å<±1Æ<møÇ<W†È<¤›É<ô
Ê<: Í<çÎ<³ˆ Ï<
ZÐ<2[Ñ<6¹Ò<¦ë Ó<bÔ<äzÕ<I Ö<×<�dØ<p@Ù<2ÑÚ<—±Û<ÚçÜ<VªÝ<$•Þ<>z ß<P"à<†¶
á<§)ä<l<å<R æ<þÓç<èlè<Ì^é<Oê<Aûë<÷bì<~xí<¦Šî<´(ï<üV
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ð< €
ñ<)7ò<áò ó<Iœ ô<å}
õ< 1ö<BU÷<€sø<¯ù< zú<wû<èà þ<ÉSÿ<–‰€=o��=rr ‚=‹õƒ=í7
†=g
‡=’ ˆ='‰=É£
Š=µg ‹=�Œ=Ñ�=8Ž=²
�=.�=�
‘=Ô
’=]ä“=J”= ]
•=Ý–=ë—=ÍÚ š=ã…›=‘V
œ=D±Ÿ=xl =Å¡=ï² ¢= Þ£=¾E
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
¥=I1¦=¶Ÿ§=I“¨=ž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
ª=þ«=ÇQ¬=¨
­=º°=
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
±=Ȇ ²=2n³=€Ê´=ƒý
µ=Fr ¶=ÿÞ·=Q ¸=�±¹=^¶ º=�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
»=�³¼=ª½=Mr ¾=À ¿=8À=GøÁ=ªÀ Â=}ÍÃ=iRÄ=P_
Å=Á/ Æ=]ÑÇ=0qÊ=¤í Ë=XîÌ=$MÍ=H$Î=+´Ï=­XÐ=¥ÐÑ=
d Ò=BªÓ=á$ Ô=&
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Õ=(‹Ö=rk×=Ì
Ø=œÙ=„<Ú=š5
Û={� Ü=1ÞÝ=Å…Þ=Wæá=U¹
â=‚Cã=Eº ä=¿å=f�æ=&tç=ž‚ è=ê±é=Õ8ê=áë=¾
ì=˜í=í
î={
ï=H'ð=®k ñ=Ü[ò=uÍó= Iô=Y1õ=cjö=F÷=kê ø=ZSù=~á ú=| û=UWü=¥Z ý=+F þ="g�>’K‚>Ž{ƒ>ù „>� …>ÀZ†>c«‰>Ê)Š>N‹>s¸Œ>„�>d#Ž>ãÐ�>±%�>!‘>¡’>ò:“>¢g
”>Ј•>Áw–>+y
—>Ϋ˜>Ï™>àÛš>_A�>³ä ž>‹4Ÿ>‰Û  >ÙÖ¡>¶Œ
¢>“Ø £>T‡¤>Jx¥>†+¦>3!§>©¯ ¨>æ5©>Áª>–«>24¬>Œ­>›ñ ®>ìw±>¿œ²>ñ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
´>¶3µ>8]¶>‰¶·>÷à¸>;
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¹>‘Ø º>ü*
»>' ¼>ºT½>Iu¾> ¿>Ù]À>öŠ Á>éÂ>ñ�Ã>c
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ä>nÞÅ>ÍÆ>ÆA Ç>¨*
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
È>�ÑË>®§Ì>®þ
Í>Ô/ Î>Ž… Ï>®a Ð>™Ñ>„|Ò>߈Ó>”†
Ô>EwÕ>yÖ>"¡×>ÿJØ>Ä Ù>+è Ú>
= Û>×ÇÜ>h
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ß>cvà> öá>ÈOâ>° ã>„–ä>†© å>•øæ>xõç>¤ è>¯éé>g’ê>¡Çë>¶Ÿ ì>á˜í>Tî>ÄOï>Úõð>8 ñ>fã
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ò>ˆSó>œ¸ô>ñ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
ö>¶H÷>–7ø>ì>
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ù>¹�ú>Ñ� û> Ø
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ü>9Šÿ>ö€?J• �?óõ ‚?lúƒ?>¸
„?‡?&ýˆ?#ó‰?ŸŠ?ƒ[‹?ÀŒ?­–�?·È Ž?Ò: �?.=
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
�?Ó:‘?·â’?pG“?
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
»”?ô´•?ot
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
–?‚ë—?¸ ˜?�‰›?+(œ?þ^
�?zQž?1" Ÿ?Ûë¡?j¢?O:£?§Ê¤?|U¥?ÿ§?¸/ ¨?§ó©?¨zª?Êt«?0
­?Úï®?_À¯?Ž °?ºà
±?�³?CO´?µ?M«¶?rµ·?â: ¹?kκ?Ñ™»?'ʼ?4Ñ ½?¨#¿?” À?kŸ Á?©ÁÂ?©¤
Ã?©ÜÅ?x¦Æ?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
äË?ÈeÌ?*D
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Í?nµÎ?7Ï?… Ñ?…
Ò?�ÆÓ?½PÔ?¦Õ?q¹Ø?Ãy
Ù?ÄÃ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ú?[
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Û?È+ Ü?»‹Ý?…»Þ?Dß?(¨à?4â?®M
ã?;+ä?½ñå?ÃYæ?½½è?—8é? 
ê?]ëë?j¨
ì?1í?šNï?tôð?×Nñ?5. ò?׳ ó?×
õ?ôæö?æ„÷?éöù?l¨ú?õ›û?…x ý?pþ?m™ ÿ?—‹€@T¨�@±‚@M …@àô†@Iä‡@š ˆ@Љ@ì�Š@hC‹@óÝ
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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�@2
�@º‡‘@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
“@Ö”@Zº•@Q–@š�—@ÂQ˜@…5™@4Ê š@ï\›@A œ@ŽW �@ ¦
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
¢@dæ£@¶£
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¤@n¸
¥@ˆ° ¦@±¾§@Ñ ¨@5 ©@`
ª@Ë«@hw¬@§­@ï®@�¯@2 °@c�±@þ
²@à| ³@ç´@j6µ@›´¶@¬-·@n;º@�4»@@Y ¼@…½@Iè
¾@K¦¿@ †À@/0 Á@$Â@Š Ã@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
Æ@'³
Ç@˜ôÈ@·–É@²YÊ@eƒ
Ë@ûƒ Î@C Ï@p—Ð@, Ò@µ+Ó@LÖÔ@côÖ@Ю×@KSØ@h Ù@r„Ú@!¡ Û@FêÜ@`UÝ@¤0 Þ@BŸ
ß@#à@òd
á@Þ¬ã@Üú
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ä@˜zå@‹áæ@-sç@W%è@:ðé@U0ê@ÁËë@„¿ì@�¸í@Oî@ï)ï@o¢ð@4±
ñ@†>ò@?‰ó@1² ô@p¾õ@; ö@dC
÷@ˆ‰ ú@½Aû@ÖÚü@¸
ý@0þ@lêÿ@‚¡ €ACC‚AÁÙƒA! „ADµ…A„5†AšÉ‡AšJˆAë» ŠAŸ‹At ŒA\¿�AþCŽA­�Ag&�Aa•‘A •’A*•Ak–AkH—AÜĘA阙A™( šAO0›Aý›œA1ì
�AXúžA3„ ŸA¤z A › ¡Aä¢AkÇ
£Ai
¤A��
¥A7h ¦Aó+©AcCªAs‚«AýجAÍr­A3®A ¯A�F °AAñ±AYO²Aê ³Az« ´A#›µA؃¶Aá ·AÜ�¸AÑ•¹AWÚºA_› »AÌI¼A„X½A^è¾Aþ+¿AØÆÀAðù
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÃA3—ÄAÀÖ ÅA^ ÆA°ÇA˜Ä ÈAZÉAIÜÊAä»
ËA¥ÌAîWÍA–ŒÎAÊÏA67ÐA ÑA
‹ÒAðÓAÑ‹ÔA%8×A­ ØAU> ÙADºÚA¹æ ÛA¢1
ÜA|íÝABÉÞAë«ßAí
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
àAWi áA'�âAaÐãA…ÝäAY  åAÉ¡æAP»çA][èAÞ/ éAD¤ êAÏèëAûìA 8íA™8îAtH
ïAåðA`a
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ñAÕ¨ ôAoÍõAöAï¦÷A®ëøA»Û ùAÒüA•,
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ýA BþAã² ÿA“ЀB�E�B
f
‚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
„Bd…Bºõ†B—é‡BƒäˆBÒï
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‰BZ�ŠB8ЋBÎ}ŒBr½
�B¤D�Bi(‘B±â’Bž$“BHÜ ”B¦•Bä˜Bbþ ™B% šB¸j›B)SœBÑ�BûƒžBÊ•ŸBß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
 BzH¡B/
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¢BÅ£B¢ ¤ByN¥B)¦B?‡§BH ¨BKY©Bœó
¬Bû­B�½®BÓ3¯BÑû°B{±B¶>²Bi?³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žŠ¶B0;
·BY{ ¸Bá#¹BaìºB¨Ù»B¹[¼Bóv ½BÈ7¾BùS¿Bk3ÀBG ÁBæŒÂB©ÃBêÑ ÆBq%ÇBúM ÈBS'ÉBÑêÊB·sËBPR
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÌB™:ÍB5ŒÎB’¡ ÏB®î ÐBÜÑBdÙÒB}ÒÓBAÔB}­×BU)
Ø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�Ä
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÜBBƒ ÝB¶s
ÞBªÂßBp~àB3áB$ãâBŠ’ ãB½ò äB³7åBâæB�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
èB^¸éB6�êBÂÃëBø=ìB1xíB�îBKæïBÜèðBb
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ñB‹môBß
õB‚i
öBÀ‚÷B¡. ø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Ü÷€CY� �C•‚Cp:ƒCÊ� „C¿S…Cå+ †C„v‡C¶¬ˆC9ä‰Cn'
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ŠCìÝ ‹C¦ŒC{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
�C�é�Cz5 ‘Cs? ’Cô¢“C¦5”Cíý•C¸À�C´XžCZ­ ŸC‘»  C_Ì ¡CK¢CqT
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
£CJc ¤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
¨Cù] ©CÐݪCΨ«Cf 
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¬Có³­C† ®Cáí¯C[º°Cé™±Cy:²Cì—³C?·´C´· µCX߶Cè5 ÀCõüÁC�›ÂCØ/ÃCßË
ÄCŒºÅCzÆC”® ÉCœIÊCª ËC¤d ÌCÁ]ÍCÌC
ÎCÙFÏCä ÐClàÑCðñ ÒCß
ÓC´SÔC²–ÕC¬ ÖCºW×C‘ªØC«áÙCìÄÚCˆ ÛC‡(ÜCz"ÝCPtÞCPC
ßCTíàCáCû
âC‡^ãC�äCL• åC³‘æCóçC]ÒèCïíéC&ÞêCUëCpgìCáíCøë îC�ïCUkðCP©ñCòôC7N õCÿÔöCyC
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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„ÌøC6¤ùCYy úC‰hûCæ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
üC‰ýC¸þCKt
ÿC÷ï€Dqw
�DÑò ‚DU< ƒDW„D«P…DMç†DpÖ ‡D×, ˆDG¾‰DÌ• ŠD˜‹Dù× ŒDñ�DムŽD–Â�D8�DQå‘Da0
’Dt“D1¨”Dš½•Dݳ–DŽ—Dࢠ˜D½3™D&�šDË™›DêQœD±
�Du: DµÐ ¡D:¢D�‡£Dôó¤D3ú¥DÔ¦D±Ú§D|k
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¨D¢# ©D-ªD¼«Dí<¬DÛ­D[~
®DŒ.¯DK’°DÙà±Drå²Dõ'³D;–´DÒĵD³ ¶Dš ·DrR
¸D2g ¹DjººD³_
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
»DμDñ‡½D\ ¾DÎs¿DƒBÀDD‰ÁDkyÂD�É ÃD&ÛÄD¨ÙÅD jÆD½åÇDÕÈD½ ÉD™fÊD›¨
ËD= ÌD­m ÍDŸÙ ÎDñ9 ÏDøåÐD+ÑDü«ÒD)ŽÓDÿºÔDO ÕDòæ ÖD¾%×Dª
ØDƉÙD&g
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÚD¡ ÛDŸ¼ÜD¦wÝDñfÞD;pßD3‘
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
àD¨Ä áD<.âDïãD‚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
æDã¶çDfªèD·YéD×à
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
êDüëD�
ìD
Q íDD1 îDÈ<ïD;�ðDTñDÚV
òDµóD¼c ôDëóõD�Ç öDIÖ÷Dú\øDMùD\úDQÑûDüD^ýDªUþD‰2ÿDÖG€E�EÏ ‚E,�ƒElà„E…E€Ñ†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
ˆEy³‰E Ö ŠE¶$‹E4)
ŒEÛí�E¥ÇŽE=‹�Em‡�EÛ%‘Eä’E¨1“E;
”E”®•E×æ –Eò—Eùö˜E-ï™Er%
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
šE•K›EH·žEY±ŸE“™ E™~¡Eðd¢E}¸£EjN¦E@Ú§EO ¨EüŽ«E÷I
¬E‘¥­Ezb®E,W
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
¯EO±°Eõ¬ ±Et.²E¾³EºT´EZ¤µEE ¶EÊ
·EÍë¸Eϸ
¹E‡)ºEo»Ec\ ¼EqA½Ew”¾Eœ@¿EçˆÀE`'ÁEß3ÂEd½ÃEÏÄE�m ÅEüÊ ÆEyIÇE§ ÈE�Ì ÉEß�ÊE/
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ËEd!ÌE=>ÍE-úÎE%q ÏE†ÐE�„ÑEUŠÒEzÓEr¨ÔE°ÄÕE£D ÖE‚Ú×E/
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ØE
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÙE“h
ÚE¨� ÛE’> ÜE7
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÝE§‹ÞE­¿ ßE[c àEÀáEj£ âEù'ãEe äEååE:ÈæEƆ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
çEûªèE¨¼ éEíK
êEÎëE”¾ ìEÐtíEvg
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
îE%´ñEÑðòEIA
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
óE~ôEã�õEõ4öEd÷E(xøEM@ùEYúEôÙûEò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¯ŠýE�`
þEõÂÿEën€Fu¯�FÐÐ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‚Fì
ƒFYä „FÙ‹…F¿" †F"›‡FzXˆFŽj
‰F q ŠF/?‹F`sŒF�.
�F$á
ŽF^J
�FºÂ�FI¹
‘F™”’F©“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˜Ý˜FPn ™Fn šFf
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
›F%4
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
œF<³�FÃ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
žF¯QŸFþc F© ¡F:Œ ¢Fá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
£FT‚¤F
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
’
¥Fá\
¦F¾§F\< ¨F<¸©F=<ªFTŸ «FÜL ¬FŠR­F¼Ï®Fø<¯FÞΰFN•
±Fl¿²Fç
³F2�´Fâá·Fœ%¸Fîû ¹Fð¼F
½F©¾F
ßÁFX¨ÂFX;Ã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±4
ËF¸ÎÌF˜wÍFÓ…ÎFÅ?ÏFÙÊÐFC ÑF-ÒF°»ÓF: 
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÔFÐ ÕF¼½ÖFÐ
×Fi¹ ØFpÙFqb
ÚFnüÛF‘è ÜFÑH ÝF�!ÞFVßFØäàF¿�áF—¢âF¨¶ãF+9äFƒI
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
åF¼æF$ðçFGÖ èFsÒéFÅÌêF_ÓëFq0ìFW×íF6ÄîFZƒïFJÞðFºÞñFôF† õF1àöFYœ÷F€øFgäùF¶f
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
úFQÜûFÌïüFn2ýFИþFu°ÿFLÓ €Gp�G?S‚Gà|ƒG¶`„GH> …Go© †Gö\‡G†,ˆG½‰G9rŠGÄ)‹GëŒG…æ�GêŽGÆë�G¥Ô’Gc•“GÓÖ”G×�—G3ì
˜GQ™GùšGæ›GºŸ
œGÅÖ�Gͼ žG}¾ŸGÐJ 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Êè ¢G1
£G�} ¤Gè
¥G­,¦G^o§G19¨G´ ©GC‡ªG½¶
«G–­®G^¯Gôô°Gq ±Gi" ²Gsý ³G”®´G®¸ µGF¶ ¶Gˆº·GM?¸G¤T ¹G÷ƒºG•f»G|û¼GS›½G¹¾G…¿GúÀGBž
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÁGüñÂG‰~ÃG6†ÄG¸›ÅG.Á
ÆG®ÝÇGšUÈG:]
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
ÉGªºÊGþß ËGaÌG¾ÍGtdÎGùÅ
ÏG!ãÐG{mÑGe
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÒG�9 ÓGhÓ ÔGbBÕGY.ÖGlÑ
×GÚáØG|CÙGÍÉ ÚGטÛGÝTÜG3† ÝG0¦ÞGÏ3ßGkäàG¡<áG¼ÎâGák
ãGd äGÔ åG¯‰
æGÛ çGÔVèG*wéGû% êGźëG+¨ìGLI
íGÔô îGQ—
ïG5ðGãO
ñG ±òG˜­óGBé öGc÷GìFøGí¹ùGr" úG7¢ûG,âüGç˜
ýG þGn¼ÿG6S‚H,ƒHr
„H”‚…Hn�†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›K‰Hb ŠHʃ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
‹H³ŽH¿Ç�HAÛ�H½–‘H#6 ’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|w—HK¶˜H”b›Hì÷
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
œH·7�HsM H#¹¡H ’¢HØN¥H$Ö ¦HkN§HP‘ªHéú«Hþ¬HËدHL°Ho
±H×´H�µHÃ9 ¶HP®¹H=ºHzö
»H䫾H8e
¿H ÀH2ÃHÏ&ÄHåî
ÅH�™ÈH†S
ÉHäEÊH{ÀÍHwYÎH�–ÏH€¦ ÒHªqÓH؈ ÔHIC×HHØH»øÙH3Ü ÜHùºÝH¤¤ÞHÊ
áHìÜ
âH!.ãH·Ã æH-zçH‚ðèHîëHSìH$ÖíH�
ðH}âñH¤CòH—ÁõHõöHC…÷HSáúH®ò‚I“ÚƒIûH„I=#…Io„†Im{‡I*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
ˆIMà ‰IÊr
ŠI“
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ŒIfH �IüsŽI… �Ifu�Iœ/‘I“K “I› ”I#¡•IÅ
–IYB—IËë˜I ¡™Iâ šI'›I5¬œIgw�I‹ržIfë
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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Ëh Iï ¡IH*¢Iø£I ¤IA¥Im¦Ia•§I¶æ¨I"ð©I8ªI´8 «IîJ¬I7¿­IÑ®I ʯI º°I§c³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šÚ ¸IRˆ ¹IüæºI�§»IôÕ ¼I⨽IX5¾IË¿IvÀI´†
ÁIEAÂ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ÇHÄIÏÝÅIÛÆI· ÇI¨tÈIðjÉI¸µ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÊI{G ËIÈ ÌI9ÍIdÉÎI*uÏIÜyÐI†ƒÑIOaÒIËSÓI³$ÔI<ÃÕI£ä
ÖI“&×IyÅ ØIéÙIö÷
ÚI>tÝIž·ÞIX ß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
áIT9âIpŽãIÀNäI§Ô åIU%æI^`çI¡ÒèIz4éIÈ÷êIŒŽëI";ìI&MíIɯîI¹ ïI!¬ðI&oñIÃm òIÙ�óIô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ܽùI7búI)¸ûIG
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
þISX ÿIßê€Jr›ƒJôÿ„J“…J¯¡ ˆJÿ“‰J{g ŠJõW�Jg× ŽJŒ�JÛk—JóØ ˜J`Ç™JŒúšJ�Ù›JAÍœJÌk �JÁÉžJ ŸJ‡' J�F
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
¡Jɉ¢J° £JJÀ¤JÈ¥J•Ï
§JJ(Ü©J’ÖªJU5 «J£m¬J?!®J¯Jvu°JY ±JX¡ ²Jæ± ³JY†
µ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& ¹JDz ºJÀ¼JT´½J ¾Jn1¿J«cÀJ «
ÁJ©ÂJéÃJöB
ÄJÄýÅJðW ÇJf» ÈJïòÉJ[™ÊJ4¡ËJªŠÌJ�¢ÍJ©/
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÏJKì
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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ÊIÓJÄ>
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
ÔJVP
ÕJã9ØJÔwÙJÌÚJ@…ÛJ|�ÜJþ ÝJ1É àJ/AáJ=² âJ üãJNräJé±åJxèJ&ñéJß# êJŸëJ|vìJHz
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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* ñJeòJé›óJÃâ ôJ3ÖõJÍ\öJ— ÷J¼¤øJIùJ¡2úJù‚ûJ³ üJŽËýJ–iþJ>&
ÿJ0t€KÝE �K•Î ‚K6ŠƒKö„KÔi…K6Ú†K®à‡K׈K�½ ‰K]> ŠK9‹K—jŒK¬_
�KFðŽKÉ’
�KUË�K¢ê ‘Kóº
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
’Kt[ “K9
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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> ›K©œKüO�K�žK60ŸKiW K)e
¡KТKäv£K:8 ¤K;¢¥K+x¦Kû_§Kí¨K/! ©Kœ
ªKá’«Kf¬K{º ­KjK
®K/ä¯K¢Ú°K
±Kö~²K˜³K`Ø´Kt¯ µKK¶Kˆ¯·K�à¸K2F¹K¿d ºK_ä
»K
,¼K(,
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
½K@® ¾K,e ¿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
ÀK’ãÁKÄŽÂKd( ÃKoñÆKHuÇK5w ÈKäÉKWÊKž²
ËKÔÉÌKÅ ÍKéD ÎKéÖ ÏK&{ ÐKΔÑK‰ÒK ÓKþ ÔKz%
ÕKQ®ÖK?Ç ×K¼•ØK€TÙKÎÌÚKü–
ÛKxÜKÕXÝK!M ÞKmò
ßKÓ àKôáK&£ âK™ ãKY¯äKÈ@ åK*æK1°
çK«èKØ×éK¼j êKÚëK—p ìK‹
íKN¢ îK|èïK�sðKŸoñK &òK^ƒóKkôKþ¬õK3*
öKô¬÷K³äøK9”ùK¯˜úK>»
ûK_8üKý0 ýKÕüþKþi ÿK›Q €LŽ5�L*H
‚LûU
ƒL©»„L ®…LÅ’†Lcò‡LPˆL†Ç‰LŠLs‹L,šŒL¤�Lz ŽLUå�L C�L0u ‘L"Ú’L¤� “Lf”L�
•LÜ–LüÛ—L)9˜Lñ¤™LM2
œL»’
�LLÎ žL^Y ŸL5 L«ß¡L�¢LñÏ£L» ¤LŠQ¥L6e¦Lû§LÖ¨L®L ©L–8ªL»X
«L; ¬Là»­Lø
®LäÓ¯L�}°L^
±LTZ²LTN³L=`´L£ãµL^¶LŽ·LቸLyƹL¨0ºL�À»Lä¼Lræ½Lió¾LL³¿LS‡
ÀLQàÁLYuÂLàªÃL‹" ÄLÜ?ÅLÇV ÆL²AÇL€ ÈL§÷ÉLÜ‹ÊLúyËLB›ÌL3ÍL%” ÎL®wÏLo³ÐLH= ÑLæË ÒLI ÓLq‰ ÔLŸiÕLgÒ ÖLVH×LÄØLY. ÙLìýÚL8 ÛLè
ÜLû†ÝLËÚÞL€Q ßL(IàLÚ#áLÁpâL/ãL+ÚäL–_åL7ÌæLõôçL¸õèLºÂéLœ¨êLüÝëL¨³ìLߤ íLÖnîLÁ~ïL`H òLå óL®CôLFŸõLûÕöL÷L¨I øLçµùLÝU úL\êûL¦°üLmÿýL�þLEP ÿL«€MÁ¦�Mqý ‚MoM ƒM^„M¥°…MŽY†MÙ‡M'ø
ˆMíÛ‰M·Ø ŠM8Ü‹M à
ŒMÛÔ �Mv—ŽMVl�Mà �M•#‘MÖ ’MÞ“Mê?”Mñ¢ •MâÌ–M‘1—M ÷˜M¶è™MýÇšMÉ›M)šœM×±�MÞžM˜ ŸMo� Mdb¡MÀ> ¢M1Ñ£M>¤MLR
¥M-q ¦M(á§M;­¨M7â©MtªM¬M«Mõ{¬MÎì­Mß®Mp‘ ¯MTx°M� ±MÇ]²MjV³Mp´MõóµM $¶Mj„·MdܸM‚ö¹Mý¯ºMï »M�—
¼M�%½MÁ0¾M,Ê
¿M”)ÀMÚ@ ÁM)œ ÂM\ßÃM,ÄMïo ÅM
ŽÈM�2 ÉM�u
ÊMؤËMpÌM¯| ÍMUzÎMkGÏM
QÐMÑ{ ÑMI€ÒM�› ÓMyÔMþ^ÕMU)ÖM×1 ×M|–
ØMkk ÙMÐÚMSÎÛM
HÜMÍ3ÝM« ÞM!xßMÕKàMýáM‹¹
âMÜpãM'’
äM:EåM=Ñ
æMî³ çMB†
èM=ˆéM`•
êM_rëM€7ìMAíM=S
îMþ5
ïMLŠðMÖñMüéôMÝ õM„Ô
öMž´
ÿM�€N�w�N“�‚N·”
ƒN$i
„Nh<†Në¨ ‡N¹G ˆNu„ ‰Nº  ŠN±µ ‹NK¼�NzH ŽN7þ �N©:
�N[¥‘Nõ “Nn+”Nz& •Nh–NÞÔ—N¼Ô˜N ›N*† œNŠá�Nã�
žNЈŸNK½ N"�¡Nú@¢Ny›
£N
¥N(¦NÊ
§N¤¹¨N‹Ý ©N×ÔªN“ë ¬Nd¸­Nß ®N€S¯Nùå °NÐM ±Nà³Nä ´NCµN°
¶NÍ·N·g¸NÖ. ºN*l»NݼNß½N…¾N­C¿N·
ÁN;ÂNizÃNñ{ÄNë_ ÅN0­
ÇNå#ÈNH[ÉN' ÊN"þ ËN�’ ÌNü:
ÏNH ÐNìÑN'¯
ÒNÒcÓNÜú
ÔN’Ó ÕNA†ÖNÙÀ×NF‹ ØNŒ ÙNõþÚNˆÏÛNœ)ÜNhÝNV8
ÞN‘Ó
ßN϶àNjÕãN³Ë äN¿åN»R
æN� çN{ì èND‡ ëNVƒ ìNbEíN—UõNüXöN°3 ÷NåÅøN€àùNüûN üNÍýNé þNïÃÿN=:‚O�†ƒO2„OO¥…O%î †ON ˆO , ‰O¸ŠOžŒ‹OÅŒOO4 �OÓ�OG«
‘Oi¢’OBK
“O”³•Oü
–O¢F—Oõ̘Of ™OÜ¢šOãœOHU�OÿžOGÌŸOàp OŸÒ
¢Oª‡£O®w¤Oè7¥Os|¦O‘Z§O†Â¨O¸o ©Op˪O~P
«OÆS¬O¯­O™ ®O½Ú¯Oy´°OYµ ²O¯r
³OšW´Oôk
µOD¶O�ù·O‘Q¸O'«¹O­BºO\‰¼O±J½O4ø¾OHÞ ÀOÊ ÁO\ãÂO¤
ÅOo»ÆOÍ ÇO`³ÈOï–ÉOÒûÊOÑsÌO²€ÍOtì
ÎOÀ«ÏO¨³ ÐO~ÃÑOÞÒO”vÓOëZ ÔO�ñÕOÃAÖOré×O’¡ÚOqÛOAi ÜOûvÝOkXÞOiÌ
ßOï-àO<š
áO¸¼âO=ŽäOÑM åO¼� æOŒÏçO‘K èO¶y éOäYêOm ëO€ïOPðOó¯ ñOµšòOY-óOµ
ôOKDõOG öO¾q÷O¥˜ øO�ùOÍ”ûOËüOº!ýOi*þO¯’ÿOïÝ€PLW�P"á‚PŠ$ƒPQË„Pä
†P-*‡PØj
ˆP‚
‰P"} ŠPy‹Pü6
ŒP‰Å�P © ŽPïê‘PíC’PJ·“P¨æ”P Ò•P_–P°£—P�ØP:{šP. ›Pé¹ œP¤s�Pù4 žP³³
 P}Á ¡P¢Ù¢P| £Pˆt ¤Ps›¥P�¦PÛ¨Pv+©P‡‘ªPö„­P7W®P1¯PT
°PÜX±P`
²P~N ³P£!´P1µP¸¶Phì·POu ¸PйP±Ü ºPÅÝ»PÍû¼PÇá½P�y¾P«Ë¿P‘†ÀPKÁPÚ“ÄPL ÅPNe ÆPÖbÇP5:ÈP…ÉPœÊP‡8ËPK”ÌP
*ÍP' ÎPÏPæ@ ÐPÃ ÑPgÔÒPN±
ÓP˸ ÔPDÕP�KÖP¬k×P#¢ØPâÚP—ÛP.ÜPMè ÝP:ÞP%ßPäDâP‘~ ãP–äPf‘åPvæPŠçPžGèP!déPŒºêPà+ëPè
ìP!PíP=îP4®ïP‘öðPÌ'ñPwç òPóPœSôP™�õP�ÂöPl"ùP è
úP!äûPÇÚþP©
ÿP±õ €Q
ù‚Qd™
ƒQuü „Qû …Q)F†QTì ˆQî!‰QtŠQI¤‹QÐŒQ¾Þ
�Q.Y
ŽQQÂ
�Qy<�Qcõ‘Qw©’QjF “Qõ –QÓA—Q`º˜Q<,™QÁ—šQö›Qèî�Q .žQCÎ ŸQý
 Q¿S ¡QÙª¢Q±l¤Qà
¥Q3¦Qšª
§Q£Ø¨Q…Z
©Q2 «QJ2¬Qì­QD‘®Q8[
¯Qk°Q!¼ ²Q¼¤³Q&¬ ´Q͵QÝg¶Q²ç·QÆÁ¹Qv+
ºQɬ »QjC¼Q‘ð½Q¾Qt• ÀQ”–
ÁQPŸÂQ�ìÃQæqÄQL+
ÅQU ÇQ;TÈQ¸ÉQuÁÊQí,
ËQ°¸ÌQÂŽ ÔQ³ÕQâÖQ1õ×Q{ØQ]ëÙQ¨ÂÜQ›ÝQçJÞQgÖßQÅq
àQ©láQ¦B âQ¦âãQªäQåQF…æQF�çQÝ
èQJÆéQFmêQ7ãëQj«ìQçíQ¢¬
îQ÷ÓïQAøðQñQ¸í òQKóQù�ôQ ½õQ½¥öQåù÷Q– øQm;ùQ».úQ€° ûQX« üQZÿQÕ¨€R�" �R
‚R„°
ƒR›7„R*ƒ…RˆP†R²Å‡RëˆR Ô‰R€Œ ŠR‰ �R¾�R¢Ï‘R´’RVá “Rý¼”Rž� ™R¢‡ šRO,›RiMœR•7�Rž9žRŸý£Rª¤Ró÷¥Rõ—¦Ræ§RVâ¬Rú, ­RæM®Rc¯RwH°ṞRÉh
´RC µRĶR²£·R0p¸R÷æ ¹R'ºRÒ²»R°Z¼R’½RwŒ¾RÓ¿R—±ÄR¹ôÅR #
ÆR‘˜ÇRõ�ÈRû ÍR£ƒÎRUbÏRn¨ÐR8y ÕRX—ÖR0ð
×RAßØRsÜ
ÝR$)ÞRÅ“ßR
àRðƒãR 7 äR]
åR£XæR½Ò çRhÐèRéRˆáêRTëRס ìRÏàíR9¬îR§zóR
R ôR–"õR—áöRpÁûR£uüRœ� ýRQ¬þR{5 ƒS™Z„Sû …SÊJ†S`« ‹S9ÿ ŒS
ã
�S×WŽS]ý‘Sã:’S¯“S²ˆ ”S®¿•SS–Sjõ
—S€™˜S‰B™Sõ¯šSW
›S©Š œSá>¡S0X¢S}t£S¡N¤S?x
©SU˪S 
«Sr¨¬SÇê±S ϲSúš³S´S¯+¹S�yºStA»SÈU¼SÌ,
¿SzEÀSÉî ÁSa
ÂSåÃShßÄSJDÅSô7ÆSæÝÇS ÝÊSr ËS²\ÌSYÒÍS45 ÎS“±
ÏSa]ÐSX™ ÑSaÒSÔÌ ÓSSE
ÔS³ã
ÕSðÉÖS¡'×S”Œ ØSTÛSO? ÜSz=ÝSQËÞS)nßSÎ×
àS¤ÙáSÈâSOÙ ãSe
äS>ÕåS n
æSrçSˆ‹ èSbéSb6êSÈ= ëSHìS!JíS?ì îSwìïSÔ[ðSžñSCèòS´ØóSšžôS‡‹õS¦ öSÓK÷SzÓøS‰Ë ùS uúS‰j
ûS?©üSaøýS:þSN5 ÿS•Û€T¸�Tݱ‚T1 ƒTD“ „T<Y…Tð:†Tíµ‡Tÿã
ˆT-…‰Tf2ŠT¨[‹TJaŒTq¯
�T+
ŽT—E�Tvß�T“¼‘TFÓ
’Tgb “Tð”T
«•T×i–Tîú—TÄä˜Tz1
™TŽšT #›T>Ž œT*² �T_[žTZŸTw8 Tû>¡TS^ ¢TÜÆ£Tñ| ¤T;«
¥T¼7¦T¨¤§TÞÙ¨Tƒß©Tœà
ªT¥²«T¥t¬TRÄ­TV-®Tf1 ¯T„Ê°TÆü ±Tc†²T\1
³T‘Õ ´T¦&µTÎt ¶T¡ó·T*—¸T8D¹T��ºTù8 ½TZq¾T´ô
¿T˜ëÂTt2ÃTâò
ÄT (ÅT‡ÉÆTÇT7\ ÈT%sÉT'…ÊT.ƒËTÌT ÍT#ÎTpÏTå�ÐTa ÑTµã ÒT¯ ÓT
ˆÔTÏÝ ÕTÙ— ÖT^××TÏ“ ØT­ºÙT³´
ÚTÚ�ÛT„4
ÜT#
ÝTa&
ÞT’nßT
^àTº áTK© âT‡êãTçÖäTÓe åT–Ö æT@çT‹Ê
èT‘ éTLêTqëTŒžìTÆ1íT“ îTò‡ ïTíj ðT(¶ñT4¶
òTÔ”óT¡2ôT2IõTäÏ
öT
÷TÝâøT|šùTÊúT# ûTÙ üTb ýTÌÙ þT�*ÿT4‡€Ua�URd ‚U*áƒU"x„U6…U{ä †UhŒ ‡UÈ
ˆUñ‰UŠUU°‹Us…ŒUh×�U“ŽUã( �U; �UpÍ
‘UÆ‘’UîÅ“U-?
”UಕU†;–Uù—UÄU˜U‹p™UÿšU¥F›U©[ œUV�U÷ß žURÜŸU+œ  U¾¡Uÿ|¤U9H¥UñݦULߧU¸� ¨U+f©Uér
ªUC. «U¬UI; ­Uæ¸
®UÀ/¯U’�°U˜Ê±U³=²UôK³U¥Ì ´U‡µUÐó
¶U¢Ü·U¸U°4¹U|» ºU®»U«ð¼U | ½U Œ¾Ulo¿UÀUUÁU,ÂU6¹
ÃU§é ÄUú�ÅUr ÆU„È ÇUÂEÈUKÉUFUÊU
ËU‘»ÌUïÍUä‚ÐU×ÑU«
ÒUÓUÜ£ÔUf#ÕU°ËÖUAà×UæOØU°Å
ÛUíÜU�Î ÝUmà ßU(àU[ÃáUG| âU'ãUš
äUe-åUœ‰æU9 çUÌÔ
èUk©éU³)êUX®ëUG.ìU>ÏíUÈîUwïU®oðUá ñUÆHòUĬóU&ôU"µõUšöU£÷U×øUëz ùU¼úUªDûUcÉüUªŠýUÑ×þUgx
ÿU –€V¡Í�VŽ8 ‚V<¼ƒVj„V†g…Vå†V”³
‡Vmñ ˆV*ù‰VýSŠVyª‹V9ŒV>Õ�V5+ŽV?‚�Vf�VL ‘V‡"
’V{Y
“V÷}”VST •V,¬–Vµ'
—VNˆ
˜V}™V]Ò šV/Õ›V±« œVÀÊ�VÁžV
¯ŸVs V-
¡V±„¢VŸp£V³¤VL
¥V3 ¦V&œ§V ô¨V“þ©Vrí ¬V¤7­Vg®V<ô ¯Vi °VD±V÷²VÔŽ³VÊÞ´VŸK
µV:@¶Vä·V5R¸Vä
¹VÙ¡ºV†T»VÒ&¼V= ½Vÿ ¾V<‚ ¿V~ÉÀVÔõÁVs ÂVÈZÃV†ÄVÀÅVˆæÆVÝÇV øÈVŸ×ÉVŠm
ÊVBñ ËViÌVUÅÍV]>ÎV¸ÏVj
ÐV$Þ ÑVãÒV”ÓV|ÔV"ƒÕV4#ÖV‰ ×VK
ØVÙVý
ÚV%zÛVßÜVÈç
ÝVºGÞV„SßVΣàV(èáVrGâV˜
ãV‘©äV»Ø
åV?ææV�” çVÇM
êVåëVóú ìV�íVb´îVŠâ ïVĽðV'GñV^îòVŸ‡óVŠÀ
ôVÕ¢
õV2U ýVŠ� þVÃDÿV~¾ €W2& �Wž‡‚WátƒWr©„WT‹…WjŠ†WE†‡W½�ˆWu
‰WàŠWi
‹WÍl�WOW ŽW–±�WàÜ�WE‘W\K“W0r ”W5Œ•W–—Wá ˜W±z™W‰^šW{è›W ç
�W‹ žWMÝ ŸWª ¢Wlw£Wœ<¤W[� ¥Wañ¦W€} §W­h¨W1
©W»  ªWðæ¬WKK ­W&‰ ®W�ïWî% °WC3±W� ³Wb ´Wg· µWô¶Wé¿·Ww¥¸W¦T¹W8– ºWª>»WC¹¼Wõ]
½W?– ¾W¿ä¿Wù·ÀW;VÁWº“ ÂWîa ÃWßÌ ÄWç¼ ÅW{ÆWxw ÇWÂÿÈWé…ÉWÁî
ÊWê¨ËWæˆÌW ÕÍWÎW·ìÏW
JÐW_DÒWëëÓW¯ÑÔW„ŒÕW’2
ÖW‘C
×W'rØWâ×ÛW·ÜWÄ­ÝWò ÞW+?ßWjuàWÆ
áWª—ãWVæ äW|oåW€\çW³®
èW¯½
éWðµêWºëWc«
ìWü
íWz/ îWo?
ðWedñWîêòW 5ôWýTõWÖöW¦Ø÷WÚ‚øWXÝùWÚMúWd8üWVB
ýWðpþWRv
ÿWä,€X+%‚XXñƒXô!„X‚€
…X h †X@ò
‡X*ŠXŠ7‹XÑ¥ŒXÍ] �X–ÖŽX�X
¬�XÆK‘Xž
’XGå“Xú
”X½g•X
–XlŒ—XI˜X@
™XUÁ šX¨ë
›Xy: œXpÑ�XMñžXݨŸXÉ Xí1¡Xߺ¢X ( £X5-¤X¹Ê¥X'¦X´5§X)8¨X·G ©XÝâ ªXŽt«XtƬX¢‡­Xt­®Xn ¯X†
°X¿G ±XöŸ
²X ³X7Ì
´XìøµX˜d¶Xã ¹XþºX…ò»X
¼Xh®½X®…
¾X Ž¿X‰]ÀXHLÁX¶RÂXn4
ÃXg®ÄXLÓÅX>ÿÆXT'ÇX%ÈXP
ÉXÜ° ÊXž0 ËX–ÌX16
ÍX¤ÎX1¤ÏXö­ÐX ÑXÛ¤ÒX%Í ÓXõÔXŠ«ÕX”·ÖXÉ×X �
ØXæ ÙX æ ÚX ¿ÛX¯B
ÜXêÍÝX¤ÞXÎ ßXlDàX�4áXöCâX2B ãXlq äX8¦åXæX#çXäèX¯´ ìXk' íX8‹îXL ïX†ðX÷ë ñXà9òX#;óXôüôXè“ õXpöX[Õ÷X–ÆøX­ ùXtúX Þ
ûXÂ*üX ñýX!KþXEBÿXÔË
€YÒ¥�Y&®‚Y;–ƒY*­„Yl4…Yâ·
†YîîŠYÿ‹Y0 ŒYn>�Y—ôŽYˆ �YX‘YÎù’Y
^“YÙ2
”YxЕY—Y�F˜YSk™Y 
šYg‘›YPý œY,“�YÍyŸY±Í
 Y½¡Y�ú £Y6±
¤YM¥Y:ê¦YᣧYô ©YRªY’Æ«Y%
¬Y ­YD®Yi°Yü±Yó'
²YsгY„´YåµY‘¶YéÔ¸Y^ ¹Yƒ‹ ºY:²½Y��¾Y±Ý ¿Yc¶ÀY–C ÁY§ÌÃY'ÄYDÔÅYelÆYWÇYõu
ÈYŸòÉY½ËY¡ÌY7 ÍYÏ1ÎY– ÏYÀJ ÑY#ÃÒYÍ ÓYØ} ÔYÐÕY×ÖYÙ<×YÁZÚY�tÛYvŸÜY$ÝY§Ð
ÞY‚Ï
àY5¢ áY¡râY× ãYEäY|A
åYÓLçYý¦èYàéY<êYâ
ëYÌìY³IíYΓïYçæ ðY±ˆñYK?
óY•
ôYàõYÛ5öY©±÷YN† ùY£¨úYŽì
ûYÅËüYìOýYp±þYÀ€Z©�Z¡9‚Zˆ ƒZm„Z:_…Zà=
†Z¦â ˆZGg‰Z^
ŠZ¿
�ZŽZ­&
�Z˜}�ZÔw‘ZÀ “Zü_”ZâV
•Z…¸
–Z} —Zù�
˜Zî ™Z²È›Z¸û œZHš�Z[0žZ�:ŸZy¡Z* ¢ZøB£Z_^¤Z­
¥Z#æ ¦Z(I§Zäq
ªZg
«Zr ¬Z€ ­Zƒ*
®Z ¯Z u ±Zü²Zé ³Z<Y ´Zî
µZ¸ç¶Z£Õ
·Z�
¹ZÑéºZ( »ZÇÊ ½ZÎ`¾ZU%¿ZºÀZ¿ÁZ©þÂZ¨ ÄZŠ ÅZC
ÆZèÇZtN ÈZ=8 ÉZ
»ÊZ»ÌZZÔÍZ#âÎZ*¦ ÑZë5ÒZˆìÓZ«eÔZªxÕZ£ ÖZi¤×Z¼¿ØZ³ÙZ‰êÚZ£Š
ÛZ#'ÜZ…ä
ÝZ#jÞZûßZvC àZZÔ áZVÙâZþg
ãZ‡Ò
äZ‚]åZ%Æ
æZ€ çZ”à èZJòéZIžêZs# ëZ©^ìZX«íZþ îZÀÜïZpº
ðZY
ñZÂ òZŸ.óZéÙôZk(õZÐÿöZrÞ÷Z¸| øZÝ ùZ¢úZžñûZd]
üZY…ýZ{dþZ‰ÖÿZ{Þ€[�G�[÷Ó‚[{΃[¿¼„[™u…[  †[Øù‡[»¾
ˆ[áï ‰[Ÿ#Œ[Hy�[Ÿò Ž[5
�[žì�[³Ý ‘[(• ”[à1•[ïü
–[À2™[ Yš[ÿ›[3
ž[î& Ÿ[âï [Ñ £[þì
¤[J¥[Ë¿¨[;=©[4sª[Õó­[Ù6®[M¤¯[ûÖ²[ϳ[än´[®±·[\Ð
¸[k¨
¹[*dº[%£»[¢ ¼[䊽[„ó¾[^±¿[S8À[Ø*Á[Õ’
Â[M³Å[ná
Æ[˜|Ç[üúÊ[ ÚË[âÞÌ[vˆ Í[AÎ[mòÏ[¯÷Ð[l¤Ñ[ê
Ò[âVÓ[õU Ô[�+ Ö[ä×[‰ÎØ[
Ù[ÇÚ[Õf Ü[£—Ý[ñã Þ[t¬ß[‡
à[�#á[Ë â[˜˜ã[`Vä[—šå[QZ
æ[PW
ç[¯0è[²é[Ðê[fv ë[™×
ì[—Ó í[ívï[¶ä ð[ôöñ[ÂÏ ò[cOó[¯
ô[Öã ö[°= ÷[Ùêø[Õ ù[R«ú[ û[í ý[TSþ[FBÿ[œ,€\Jï�\NÄ‚\ÇÆ„\ö±
…\«>†\X‡\• ˆ\‚M ‰\}Œ
Œ\cl�\÷›Ž\æ:�\÷"
�\U8 ‘\¶I’\Ê@
“\¡ 
•\ïð–\žX—\Eo˜\¶d ™\tÍš\§’›\˜Žœ\ô Ÿ\ \BÆ¡\—¤\ê0¥\í¦\Ǩ §\Z¨\3ÿ©\Ñìª\Þ¹«\«c®\;·¯\!w°\Vb±\. ²\è³\z›´\¬9 µ\a̶\íZ·\Ñì¸\  »\Æ=
¼\Õ½\I¶
¾\X6
¿\ÕÓÂ\œÃ\ž¹Ä\ žÅ\¼
Æ\Ø¢
É\RCÊ\¯Ë\1Ì\ôw
Í\)þÎ\îÏ\¹¢Ð\ß
Ñ\i
Ò\õñÓ\.‡Ô\Ù§
Õ\Ù!Ö\VÓ×\´³
Ø\ĈÙ\ÔƒÚ\ÀqÛ\uŽÜ\X4Ý\¨†Þ\®rß\ªïà\ƒDã\'¤ ä\—ü å\Øæ\Z
ç\ÓËè\-«ë\óŸì\Z^í\[{î\Ùï\û�ð\Iñ\¬ò\Ú°ó\ÜA ô\ˆ õ\p>ö\&A÷\4
ø\¸ƒù\Vú\”û\%9 ü\aÛ ÿ\vÄ€]òD�]Ø–‚]À
ƒ]yî„]½…]<0†]?‡]ç‹ ˆ]Ÿ(‰]�S Š]³¨‹]èöŒ]¥0
�]IŸŽ]§Ç �]ëS�]¯"
“]€”]´˜
•]cÖ –]µß —]ù©˜]«™]²Äš]›]Ûœ]8�]T¢ž]Rª Ÿ]„C  ]üë ¡] ± ¢]¿õ£]Z ¤]”§­] :®]Ã:¯]ÍP°]�ì±]P¯²]ãÔ³]J=´]Öε]â׶]Hš·]ä<¸]¬b¹]—©º]åÚ»]¬¼]¨A ½]¯î¾]‹ ¿]‹À]ï²
Á]Ùn Ä]©{
Å]QìÆ]Àx
Ç]n¢È]ó É]v� Ê]ßâË]ñÌ]åÍ]I Î]V™
Ï]iKÐ]•îÑ]¾ôÒ]L`Ó]ÖêÔ]ÕFÕ]û#Ö]Õ÷×]å"Ø]{IÛ]Õ$ Ü]ré Ý]¬Þ]½iß] ëà]Má]«=â]rþã] 4ä]Y¬å]~@æ]¼X
ç]†¶ è]7§é]è£
ê]«ë]UÖì]à- í]©
î]B… ï]Õ¸ò]þÅ ó]«·ô]\z ö]t
÷]’ãø]˜ù]hüú]Aø
ü]ó¢ ý]bUþ]2�ÿ]‚˜
€^÷/‚^zÚ ƒ^uz
„^‘É …^I†^ÚÈ ˆ^
ˆ ‰^Š^¡Æ‹^= Œ^û�^Âw
�^^á�^ž)‘^]á’^— “^P>”^Ï,–^õ\
—^4˜^pd ™^š^†ìœ^q³�^…ýž^úâŸ^°
 ^Z9 ¡^ç#¢^ß4£^_ä^&´¥^Ä4 ¦^ßl§^ih
¨^Á
©^&çª^Ö «^[*
¬^Kw­^b#°^½Ê±^Kk²^Lá ³^2[
´^…µ^\¶¶^„Œ·^^˜Á ¹^ò׺^w# »^¼^ ½^8� ¾^õjÁ^oÂ^àR
Ã^  Æ^W
Ç^²AÈ^‘1Ë^trÌ^KlÍ^f©
Ð^§Œ Ñ^ƒªÒ^[�Ó^D¥Ô^’:Ý^Hs Þ^¼Çß^ª`à^ñ+á^÷Dâ^ã½å^þº æ^^ßç^'!
è^?-é^Ä£ ê^}W
ë^¼ì^Aí^•™î^çt ï^÷* ð^µÈñ^’àò^1žó^dô^R™õ^Mö^« ø^ëwù^�(ú^ç
û^%Çü^ÛÑý^¢þ^Ô°ÿ^8G€_"I�_û‚_賈_\“„_¹…_�
†_@‡_¤Â ˆ_焉_ÍjŒ_ô­ �_Üð Ž_„Á �_!{�_–<
‘_Pz’_Ø�“_�
”_ü!•_ø–_Øä
—_1Θ_³Û™_ß3 š_@Ý›_O œ_šƒ �_U‘Ÿ_1 _#Ä ¡_ú=¢_n
£_¥ ¤_]8¥_Ëá¦_5` §_¥í ¨_óË©_–¬ ª_è  «_†Ö¬_Rö ­_‘£ ®_º± ¯_3ø°_€R³_
´_u µ_‡º¶_`Œ·_ ¸_µ¹_kº_<»_nó¼_:ƒ ½_æ ¾_¨Ü ¿_ìÌÀ_oÁ_t Â_vÃ_ÒaÄ_ c Ç_Í]È_NíÉ_è
Ê_�*Ë_Ç^Ì_ Ï_ȧÐ_'@Ñ_¨¢Ò_sÓ_i¹
Ô_s°Õ_C Ö_ºÌ×_�ÝØ_µ­Ù_   Ú_²(Û_ã!Ü_á¨Ý_´¶Þ_pû ß_±v à_Šü â_´¥ã_ë‡ä_™3å_y_ æ_-ü
ç_î>è_ÎÍé_›`ê_E­ë_‘€ì_qÍ í_V=î_?�
ï_ê;ð_¢~ ñ_Càò_O®ó_›± ö_Ôj ÷_¾¢ ø_üù_zØ ú_–ª
û_ç»ü_ï÷ý_Eõþ_sÿ_'ò
€`¼Œ �`Ç�‚`gƒ`…m„`ò…`V†`O‡`v;‰`À Š`.Š‹`”Þ Œ`Þ�`ñÕŽ`5� �`ÖÉ�`ý‘`:
’`öz “`üh”`Ðô•`1ß–`ëV—`÷ì˜`»Ó™`p�
š`þ´�`ö ž`ûn Ÿ`( `2õ¡`@¢`Y
£`­×¤`>¥`°ª ¦`Ge §`H ¨`h.©`Ø7ª`Í#
«`)I¬`b˜­`dà®`Ùv
±`�²`¸î ³``Z,µ`N¾¶`ö ¹`Ÿñº`tº
»`è‰ ¼`�„½`h¾`DD¿`j/À`"ÀÁ`ÇjÂ`æz
Ã`áÈ Ä`mîÅ`–ÚÆ`<ñÇ`.ßÈ`½ÔÉ`�*Ê`"NÌ`(
Í`ä Î`p{ Ï`
Ð`â^Ñ`ýˆÒ`¯8Ó`£
Ô`îÕ`çÖ
Ö`A· ×`^Ø`èM Ù`ªtÚ`×ØÛ`AÛÜ`>°Ý`Oyà`1á`fâ`Ínã`ñ� ä`ïàå`‚÷æ`Òç`FUè`
é`7ýê`æ
ë`ƒïì`Ëií`»Tî`×Ûï`ª,ð`ôÒñ`>ãó`T"ô`š° õ`6
ö`À¨÷`b2 ø` ºù`üú`R§û`ß&ü`¥Ñ ý`ƒ"þ`N´ÿ`
€aZS�aK¢‚ay
ƒa„„aY‡a6Ý
ˆaÌô‰a¥ÌŠa¤™ ‹aç„ŒaÈÝ�aBTŽaA�azµ�a ‘a ’aØ “aìÉ”ahy•aûè –ahF—a�â ˜a•ü›aÐO£aÝo ¤a¥a.P¦a迧a’A¨añã©aóA
ªa¶? «aY¬a-š
­al² ®a뉯aI¾°aV
±aó²aa¿³al ´aØ µa½É ¶a�÷·a�0¸a@Õ ¹avºa·†»a™Ä¼a�§ ½aøÌ
¾aV{¿a?PÀa°ÆÁaý
ÂaõæÃaeýÄa ‘ Åa‡ÆăÇa:Èa38ÉaÚæÊaCC Ëa
ÌaR¬Ía* Îa¸«Ïa˜ÐaøŒÑa¼ù ÒatÓaKQ ÔaCÅÕaéõÖaïŸ ×a¡©ØanãÙaÉíÚa ÐÛaœ¢ Üa!MÝaI‘Þaä
ßaÀ,àa§h áa–Yâaãa3þäa(Råaߎæa°Ôça¬ÑèaØ.
éa^&êa ëaõìa˜ía îaNT ïap½ðaÆG
ñaþòa±yóa¿N ôa– õa.+öa[Ÿ÷a¹>øa<¬
ùaãàúa
C ûaã¡þa¾ÿag¿ €b �bÒ„‚b4ïƒbpÊ„b‡-
…b¸¨ †b_ï‡b ܈b~| ‰bˆr Šbª’‹bÝ~ŒbÏ« �bûµŽbG*�b·s�b­1‘bàÖ
’b¿‡“bbu”bYV•bèΖb^ —b®… ˜b>
™b›ô
šbïr›b˜ œb@·�bÞWžb"ÁŸbŸ  bž ¡b!… ¢bb[
£b�ˆ¤b”¥b¥^¦bª”§b–&
¨bä„
©bÀDªb‹ý «bÚ ¬b\
­bš®b³C ¯b_å°b™ ±bîÎ ²bnî³bÍ¿´b(] µbݶbÆ{ ·bcg¸b»;¹b®Bºb5z»bÑb ¼bËÐ ½bˆ1Àbà ÁbRXÂb/ÛÃbùˆÄblŸÅbÛêÆbæ&Çb¬~Èb!ŠÉbûãÊbh´Ëbã¨Ìb™µ Íb9ÎbÜ
Ïb¸ Ðb*‰ Ñbµ
ÒbzjÓbÙÁÔbÙí
ÕbÊV
Öb³?
×b©Ö Øb|ÙbRÚbX« Ûbí¸Übbþ
ÝbdÊÞbáßbt àb°Ë
áb1Xâbé~
ãbÕ% äb½åbKÕ
æb.v çb[¾èb·* ébÅz êb:Vëbä×ìbMíbÈîb>ìïbÇb
ðbðEñb›á òb§ ób2A ôbîwõbÿtöb¸.÷bxÌøbH– ùb2(úbDô ûb?¹üb!µýbU þb„ÿb3ñ€c”��cU‚c£
ƒce„c)…cÌÁ†cѳ‡c
}ˆc?Y‰cØŠcnC‹c
� Œc~³�c¼.
ŽcI �cÄ—�c4m
‘cQu’cïK•c_c
–c^ ™cüÒ šcèó›cBœcÃŽ �cžcWÏ¡c?Ú¢cÞš£cþ!
¤c$ ¥c0Q¦cˆ²
©c¡Gªc‚«c_7 ¬cô(­c&í®cî¯c‘”°c„±cH²cE¼ ³c´cl¡µc÷G¶cåN·c½ºcN
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
»ck¼c«|½c]? ¾c¼Ë¿c§Ê Àcd`
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data to use in trinity visualizer. Bare minimum functionality works and is replicated from the first prototype.
2026-09-13 19:51:03 +02:00
Ác7ìÂchTÃc?}Äc¢ ÅcÁÈ Æcb4ÇcV
Ècû Éc½ãÊc§ä
Ëc4¥
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ì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
Îc¹Á
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
Ïc
¦Ðc·ÀÑcq ÒcÎfÓc‡žÔcøÕcÂÖc¯Y×c:”Øcg÷
Ùc� Úcݶ Ûc ¬Üc´{Ýc¤ZÞc%`ßc0àcˆ#ác.âcàãc™ùäc÷ûåc¥Ùæc¬Ëçcs
ècK/ éc:ºêc®Aëc¥‘
ìc´. ícÈ$ îcd>
ïc( ðc˜ñcÿŒòcƒùóc—‘ôc<© õcÚ\öc>
÷c,ù
øcé�ùc¸úc2ìûcÓ üc½¦ ýcIjþc·,ÿcÍÙ €dR* �d
‚d¬{ƒdþß„d—Ø
…d+†dñH‡d×½ˆd4
‰dw�Šdkñ‹dÂŒdö6�daÓŽd`&�dqÙ�dt ‘d¦ ’dÛ6 “dl8 –d2Ó
—dÎ¥˜d!™d"BšdCÕ›dú œdV�dv’žd'§
Ÿdù£ d -
¡dÛ¯
¢dU! £dK,¤dj
¥dçÙ ¦dY¯§d¶ž¨dk
©d—
ªd(«dÖ¬d½ ­d( ®d­~ ¯d–C°dvÛ ±dQÿ
²d“³d­ì´d€²µdùöd} ·d›
¸d–x¹d̉
ºd[�»d• ¼dÇí
½dn¼¾dJð ¿d1' ÀdráÁdUÂd>ZÅdäÆdúo
Çd7Êd~©ËdÃèÌdøIÏd’! ÐdÑ“Ñd‡,ÒdFLÓd7ä ÔdÒ@ÕdÌ�Ýd‰_ÞdEQßdøàdJDádV�âd§ ãdSð äd£Dåd[—æd°,çd®ièdÚõ
ëdÞyìdÍcída^õd“ñödân÷dTv ød4 ùd�údâxûdM£ üdAýd#LþdC5€eœ�e Ú‚eFÕ …e®3†e£ˆ‡eÚˆe�‰eÝm Še<v‹e
‚Œe �e«aŽe™ß�e
‘eú>’eÀ|“eK”eW% •edQ—e©³˜e�ƒ
™ešµœeŽZ�eê6že¹ ¦e#w
§ee· ¨eÞB©e×
ªeÄ«e
<®eÂó¯e¢%
°eF±e”²e휳ez´eÉöµeOj
¶e£.·e™ 
¸eô
¹e=„ºeê&»e÷,¼eô¿e]FÀeO=ÁeVYÂe�ÇÃe(Ë
Äe„ñ Åes`Æe“Çeñ8Èe¿¼ Ée¥µÊe%Ëe͈ÌeüåÍe÷üÎeá3 ÏeûÐe×QÑeÇÒeñáÓe!-
Öe€×eŒCØeáp ÙeÊ’Úe[ÎÛeÊËÜe ÝeÅ”ÞeFÏ ßeK~ àedáe$qâen\ãeQM
äe·Õåeæeþ…çex=êed
ëe/dìe²Àïe»
ðe0„ ñeŒ¢ôe9UõeëFöeë÷e;øeD‰ùeåZ úeà4ûe“ŠüeÞÿe÷¼€f;�fîÜ‚fÍLƒf±÷ „f&} …fØΆfZL
‡fëÿŽf@·�f[‘fZÍ’f1
“fH ”fàŽ•f20
Trinity Devboard PCB V1.0 Firmware. FreeRTOS is setup and the MCU reads IMU data over SPI fand Magnetometer data over I2C, each with a seperate task. Sensordata is then run though MadgwickAHRS and send over USB as serial packet data 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@ œfŽ8�fê
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
žf­ÛŸf f´% ¡fV¦¢f

£f€< ¤f¾�¦fLX§fµ
¨f^| ©föHªfû§
«fiæ ¬fÕù ­fÎì ®fî¨
°fõ@ ±f§²f ³f£´fð®
µf壶f”²·f­¸fÄعf/ºfù»fF ¼f(ñ½f‡Å¾f±‚ ÀfQÁfË Âf4¡ÃfA³ÄfUÅf…ÆfCØÇf ÈfWÚÊf(§Ëf>»ÌfÁÍÍf+È ÏfÅÚ
Ðf< Ñf7Ì ÒfÎöÓf‘aÕf{†Öf²
Øfÿ
Ùfõ±ÚfW¨ÛfõÝÜfŸ‹ Ýf2à Þf%&ßfVSáfzœâf˜øãf�gäfKxåfš¦ æf(qçfb�èfö¹éfäêf3« íf‘‘
ïfrü ðf Ûñfä òf@ óf†kôf¡ÞöfÀøf*~ùft¶úf,p
ûfç üfÔ± ýfqþf8 €g]¿ �gÇœ ‚gƒgOø „gá… …gú߆g„y‰gYJ ‘g*ª’g,6“g* ”gGo•gñ–gÃ
—gÉ´˜gƒ#
™gšgÔÏ›g¹ œg_�gùYžgmï Ÿgí gB~¡g—f¢g¦P£gç|¤g›p¥g!
¦gÔú§g‘/¨g!è «g0e¬g-Ë
­g>ù ®gÎ ¯g[º °g…÷²gBF
³gL" ´gZ"µgµ#¶g p ·gR—
¹gÕºg1»g‰g¼ghs½gm
¿g`ÆÀgT2Ág¦,Äg¢XÅgاÆgJIÇg“[
ÈgmÞÉg¢Ÿ ÊgžbËgþzÌgB4ÍgÎ{ÎgÛ¥
Ïgži Ðg«?Ñg ÒgîÏÓgRÔgÇÕg‘ÐÖg6×gxí
Øg„v ÙgøbÚguzÛgDS Üg™” Ýg8ÞgpágT�âgS>ãgÈøäg»
ågW•æg§Èçg•uègìb égašêgÜk
ëgB ìg8¡ôgÛ!÷g±uûg¸â þgê¿‚hK‰
…h?Z‰hj² Œh¥ß�hþP”hÂö—hMZ›h,›
žhÅ¡h-è£hIŒ¦h* ©h$B¬hC; ¯hÀ"²h.³ µhÞ‡Åh ÇhŒüÍh‰$
Õh †ØhÄâÛh±ßhÀ¾ âh�¯åhÒèh¢ ëhê íh—ä îhä ðhØ^ñh¼¥óhž
ôh¬öh~&
÷h©*úh>ýhúd €i€·ƒiä
†iÚT
‰i1[ �ißé‘iÑo •iÖ¹˜io žiÏ ¡i˜• ¤i3ͧiNªi…J¯i7ù´i%£·i±½i
Ái»2Åi÷E
Éi"%Ìi®²Ïi¯Òiš{ØiWÞidóäiêia€jZ �jµÃ“j¿í—je¬›jL~Ÿj"£jLƦjRâ«j‘ ¯j­–³jkž
·jKô»jbí¿j:
Ãj&a ÇjtºËjƒnÑjÈÕÖjÂÐÙjXÞ ÝjQàj¡$
|�¡ŒÐ…Žéb �ï�’!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
”ôl–)C˜TUœÓô¥7S®xQ·ëõÀÙÉí<ѱºBä $k)bm*œV +­} 0¤ˆ
Both sensors now run over interrupts in pulse mode. This still needs
2026-09-20 19:55:57 +02:00
4eŠ 8»k9U >Ë ?@¥A¥ÚB±Ç C¬) D»ÇF”MGà
HŸ IRqJžÿ
KîL&yMõN‰˜OãòPæ
QÞ RžþSÅÞT#�
U Vâ€WP¹XÉYb7µfßþn?ÒwÑ ~û
†@f�<ý
˜�= œ�Ê¥+J °Iù±p;²e³�¯´€•µà Åò€ Ë%#>Ú$Ÿ%%nå
&ý$ '²ø 59­6uÌ 7Ù8~ 9ÆA:�/ ;•©<C©=å>$ö?œ²@)ã A½¶B•+C
@D�àE>F?yG{eH�«IŸÁJo¿
Kk°LŠ2Mº:Nb�Oy P§j Q·ÏRò€
SR_TˆÁ UÉVÜîW]ÅXôQY@¸ZL*[±´\Ž¯^½Û_7 `äqaø®bįcø&dÝÞ{X�„=F…ù†>㇠܈{v
‰<ÁŠL
‹�½ŒŽ ‘…
åËU
ô÷× öLk�á_‚f Œ#ã�EÍ Žg�51�Àè‘v±’q�“¿”ÔÛ´Yo µ)J>·æõ ¸ö ¹Kº[ã »4¦¼½§¾s™ ¿I ÀÞé
Á™PÄ�Ä Ò ÅL
ÆçvÇžÈJÉt*
Êy‘Ë
‚ÌÙ ÍA£ ΋Ïݤ
Ð
Ñ#‹ Ò9rÓQ†ÔŽú Õ! Ö‚F×o¥ØÙ^ Ù[Ú‹TÛ<N ÜœQÝ tßí'ᵎâÎ
ã¥sä9P åSòæù1çJ^ èö– éÕêâëÅì}¼
íø–
îN’ï[{ð±ñ\¬òpóSô$¯õ]+ öÓE
÷M ø†\ùnÍúº{ûâT üýÍ
þTµÿŸ€f�.£‚»úƒ´˜„ó…ÎĆ ‰‡F ˆÖ( ‰„
ŠÕ‹lŒ–ô�YÿŽtQ“å ”<ÝעؕIÙâ²ÚãFÛu ÜåÎݲ;ÞVß*ðÇÙñEwù %ú8-œW0�ž×á¢ËÜ £Çù
¤› ¥] µ«tðÖñM%òÂ
ó®ü ôÕõ§9
ö©Ž ÷=%øúë ûËbüâký}¶þ7
ÿ´Ô€o�–º ™åÜštq›^ÝœLø�—�žú³Ÿân
 ÚÎ ±ÿ²!¿»�¼âÿ
½̦¾b“ÇB È=5
É„ Ên­ÌrÍ·kÎReÐS, ÑVü
Òæx
Ó̓ ×~ Øm3Ù~ö ß
Reference in New Issue Copy Permalink