Compare commits
700 Commits
Author | SHA1 | Date | |
---|---|---|---|
221d7b408a | |||
f413ed6f7d | |||
05bd1cc8c6 | |||
2f51f58c7e | |||
182b90ee6d | |||
606da48861 | |||
b8a4384c91 | |||
6faea8a33b | |||
e0e0554fea | |||
b8bd211d8e | |||
54fb646ea1 | |||
dae901a45e | |||
27f9c0223c | |||
f8942cd6c6 | |||
81915f1772 | |||
033bdb93ad | |||
57b815c8ee | |||
23e2c5ffc8 | |||
66ece6544e | |||
7f71ee82ec | |||
9e03f9babe | |||
be122038ed | |||
84367f8424 | |||
e1112f1903 | |||
684d9b8059 | |||
4a5ad4fb4d | |||
b279434ef0 | |||
daa3b0084a | |||
65961695de | |||
1c17aac544 | |||
165e6e829e | |||
0d1ff8585c | |||
d4dcd8c03f | |||
8e8fe3d0c9 | |||
8c2c402821 | |||
a2bc72a798 | |||
8e6d8a6fa8 | |||
ff35986a16 | |||
1684c28e0f | |||
54640147c1 | |||
042acc1a23 | |||
ba68c80d6b | |||
6b88c525b2 | |||
c88ed9616d | |||
f88674ed59 | |||
dfd817d27b | |||
e61dfc0401 | |||
e082f3973a | |||
da78e57dd3 | |||
dfaaae5512 | |||
55618e381c | |||
3a6c7e3183 | |||
00bd6e260a | |||
486fa9cae2 | |||
39f4ef6ccb | |||
cca0d5735e | |||
9010f58636 | |||
33ff05c558 | |||
e01f2a8947 | |||
3593f5ab8c | |||
9eb990b3a2 | |||
2419e9fcc6 | |||
5bf4e50849 | |||
3edf7572b6 | |||
768bb14842 | |||
e56532367f | |||
0b215bf7e0 | |||
9f60c82725 | |||
7ae2d7117e | |||
10e2600415 | |||
a067014116 | |||
c83020d2c1 | |||
fd85ab3122 | |||
2551e673d8 | |||
4ad3339331 | |||
b822ee77bc | |||
d5b22ca636 | |||
f5c1263dd3 | |||
ee53485d4e | |||
940115b588 | |||
9c625a5743 | |||
e58c375cb9 | |||
d27a57ab28 | |||
bf9f40aad3 | |||
9387fdce1c | |||
398277ca08 | |||
6c988ecf50 | |||
3f35dbfad8 | |||
b9e8346e82 | |||
7a97471ed9 | |||
27ee6bfffc | |||
f5c525699e | |||
7427d93c1d | |||
63ec6d3eae | |||
56a57fadc8 | |||
0f9690f6c2 | |||
7c1dcb5f11 | |||
8394f6226a | |||
9c7a203930 | |||
7d01aa463b | |||
b10bf2c68d | |||
23ba1a997d | |||
8498a84354 | |||
c37e7022d1 | |||
15bab6ae33 | |||
5bd613fb57 | |||
6a8c9e14e9 | |||
54e3b99708 | |||
52e420b0be | |||
4704e6deb8 | |||
29efde6cbb | |||
62531a710f | |||
57280167a2 | |||
bcac56a65c | |||
4ea8ff9876 | |||
090979e5a9 | |||
334ba6d4bf | |||
3400c538b3 | |||
91e0e9f233 | |||
b722b15b26 | |||
6ddd2e4759 | |||
208f417d17 | |||
3a6dcdc78e | |||
583ab285d8 | |||
88a9f8f8de | |||
e95647c572 | |||
7adff2c9a8 | |||
0f42790aa1 | |||
587e9451ea | |||
685b9cd1fb | |||
e3f36ddcfb | |||
b1973f77f7 | |||
1e40013210 | |||
f1249392cf | |||
3c17ba5cc7 | |||
c9e5fbc361 | |||
f9721eb1ae | |||
d9badee18f | |||
50cf01376f | |||
e59a98f11c | |||
00042af77c | |||
ac49f3f72b | |||
4d154b7cee | |||
07e68bd05b | |||
a65072b743 | |||
3035aea885 | |||
20f091d54e | |||
60d43246d4 | |||
7005314d4b | |||
0108a913e6 | |||
a3092e57e4 | |||
cfce44ca3a | |||
fb6b5b9e46 | |||
00eeeade3f | |||
acfd6bfd5e | |||
1fa0e3f9c2 | |||
90da51ed5a | |||
328a3b2d02 | |||
92eb403e35 | |||
c3e20d6a11 | |||
4823496b58 | |||
0c086f9f15 | |||
632b8c7355 | |||
470f0c05bf | |||
826cb13c3e | |||
191f3c3deb | |||
21593a4696 | |||
e222be0534 | |||
83d99a6662 | |||
68d56c4cd3 | |||
27e3e446e9 | |||
3c4033f83c | |||
814f6caa43 | |||
bb8ccd2842 | |||
abeb4cdbb1 | |||
b4d1046928 | |||
19c97546b6 | |||
e67bcd4e26 | |||
6543264691 | |||
c42b3f56c3 | |||
a56b80ec55 | |||
18d018b7d7 | |||
6781b6debe | |||
e1d506926f | |||
ec01edc535 | |||
b8011717f7 | |||
5aa800af6e | |||
4000c35299 | |||
39471d8261 | |||
2cdd192eeb | |||
339b8e8ecc | |||
9456dc1a00 | |||
3250a9f489 | |||
a77d5f3669 | |||
9bf3e46e3c | |||
e142408bb8 | |||
6440567585 | |||
344390da14 | |||
f47101c388 | |||
fea0b2bfe9 | |||
7d5b4325e2 | |||
988a5e6b31 | |||
0067cac94d | |||
89bbf98b4a | |||
dd822f9c44 | |||
d6e256a5d2 | |||
3bd5db2352 | |||
866450f1ae | |||
9d80e73925 | |||
0374262176 | |||
9cdc67ad6c | |||
9d5345c5de | |||
d91ceb6fa7 | |||
4edbbf223c | |||
4050521e5a | |||
bae1ea7c97 | |||
1651926efa | |||
c1726f897b | |||
ab4b397918 | |||
6043a827ed | |||
6be7cb4d0c | |||
e56c538518 | |||
239e1f9f9f | |||
3bd4c57b85 | |||
b1e716788a | |||
0a315f203b | |||
8ee3e18327 | |||
0b9b24ca08 | |||
9231f47641 | |||
ef48c8c6ad | |||
3207d25bd3 | |||
c6f7281bc4 | |||
521b47d9fc | |||
26d66d2a36 | |||
a9c93db790 | |||
b4505e5305 | |||
e8cd2207cf | |||
5c535784e9 | |||
bf73a2e442 | |||
9998b54f89 | |||
604424c7ed | |||
71ada855c7 | |||
49bbfb7b7d | |||
90b65d4d8a | |||
8ad2114d4b | |||
03707f2d6a | |||
102385a707 | |||
38a1b496e7 | |||
93e84fde29 | |||
7a57043df8 | |||
a07468f7b7 | |||
512d339803 | |||
a56224c339 | |||
34a4904738 | |||
745526ce8a | |||
b1667770fe | |||
ded92fdf7a | |||
7f4f241841 | |||
b3ca5ac6f2 | |||
c35c94f22b | |||
c9787f8e47 | |||
4913ffa6d4 | |||
262837bf0b | |||
68eb7c9271 | |||
c88371b37a | |||
328b9d95af | |||
1eb6017a9d | |||
79fac2adcb | |||
f948905aa2 | |||
947134bfd1 | |||
32236f9864 | |||
eb23dc1b0f | |||
5bd4f56bc6 | |||
dc6a2ffe56 | |||
a74ce78c6f | |||
df3b729baa | |||
a50f852b9d | |||
cf92707ee3 | |||
77d8f2fc54 | |||
f49e5fbd5f | |||
2f153fe23c | |||
4a20306a83 | |||
29b795252e | |||
bb2f5bbb03 | |||
bd7958f6c5 | |||
890d28fb7f | |||
0724215b6a | |||
3ab6494c28 | |||
50e17bc160 | |||
c1e04b286e | |||
2fe645375c | |||
d4bb5e3f18 | |||
c9fe3294ac | |||
5cc7331e90 | |||
76adea6bd5 | |||
0ed4691113 | |||
c32ca422fc | |||
a85800d86c | |||
d5a09dc280 | |||
fab259a2b5 | |||
1d6f999ab6 | |||
77c45c0de9 | |||
975b3cd294 | |||
870dd717e4 | |||
7138d29041 | |||
c657264832 | |||
ce6c9d4613 | |||
a9cd072acd | |||
643584e1c5 | |||
3a274e7a9b | |||
5a210e19e1 | |||
384122f811 | |||
71c5aa4df0 | |||
9438ba8dcc | |||
e6d8d24cd5 | |||
41ad4099e3 | |||
abfc120633 | |||
0d03f66e9d | |||
2207d06058 | |||
969251d9fa | |||
37ae508af5 | |||
952dfde5b7 | |||
858fd07c4a | |||
3b9959b8b3 | |||
70ab486081 | |||
2fa8de4103 | |||
1aa8befe50 | |||
9b0906c068 | |||
806280ee4a | |||
a706f6d9bd | |||
e73dc2f191 | |||
3421c6fcbf | |||
e1ddd19e31 | |||
a9824b71b7 | |||
d0807ed262 | |||
2323fd0506 | |||
9d48438fae | |||
64ac41d1fe | |||
d8ec051e13 | |||
1f5553b571 | |||
372dca87ad | |||
2e0d747a0d | |||
7201fdf152 | |||
1bed87bc20 | |||
470e834b80 | |||
17615a5a2d | |||
1f7ff062c1 | |||
f6a0fcbe0b | |||
09db06e8b2 | |||
24ee4cb7f5 | |||
7a28cba71b | |||
20f4baa84f | |||
7e0510115a | |||
b59abb55fe | |||
8b8a1554a5 | |||
3bbc7820c8 | |||
1aca0b4499 | |||
ac51ad7a4f | |||
29e7ac210a | |||
3833b7a875 | |||
e26ffb6afd | |||
8d160572c7 | |||
2ea75d2a05 | |||
14dec1d700 | |||
fa8cdb3241 | |||
8cddbf86d9 | |||
76f840f137 | |||
1331c9e7e9 | |||
cdddc76a59 | |||
27c011413a | |||
940c770b44 | |||
db82350d53 | |||
8a104c4af2 | |||
c31ae5073b | |||
72cc081098 | |||
38ad9f0da2 | |||
d12027126c | |||
433b218227 | |||
433947824a | |||
861d92f3c2 | |||
1b38d34951 | |||
421866b739 | |||
337a485fc1 | |||
bed70c6fb5 | |||
36d33711a7 | |||
636c1fdf26 | |||
e3841d180e | |||
8694a20c63 | |||
428d2562ac | |||
72c0503ac1 | |||
654e75fec8 | |||
3163995d06 | |||
2dd8fb4f45 | |||
79859090f8 | |||
ffa8a37b04 | |||
e442a8c968 | |||
2ed0bdf132 | |||
6346da658a | |||
4dee8658fd | |||
50154c944a | |||
1bd1e25629 | |||
64ab445f4e | |||
481756b014 | |||
a3b6c7e8c8 | |||
5a0563a7e8 | |||
9e6ad8807a | |||
5ae6a61ec0 | |||
774ffa8359 | |||
5067519b8a | |||
58074f9bfd | |||
717f2e21a0 | |||
74f52632f6 | |||
9983acf98b | |||
1f6dbd181c | |||
5fadb8f86d | |||
985ef0f6bc | |||
86581d81c9 | |||
9c42b861f4 | |||
af32941352 | |||
f9581f3100 | |||
1895d7c3db | |||
e64a3fb645 | |||
54e5fef8fd | |||
52d8ae5ffb | |||
11704ea908 | |||
99c450933e | |||
b691a1e75d | |||
58c40695ae | |||
fac6996a15 | |||
ed8399ef9a | |||
7cc0fc640f | |||
5c1c0dc515 | |||
a7ab2bb93a | |||
a2b9484db3 | |||
77f6ac57e9 | |||
8c649b3e70 | |||
d287aa80c1 | |||
8d284b3d2a | |||
667bbc918f | |||
ac3790b659 | |||
1affc1e1d3 | |||
077913400f | |||
b84bdcc0fc | |||
5ea129d252 | |||
eb0e9c2a41 | |||
8b97528afb | |||
007126feff | |||
0b7e8fa38b | |||
25b53d55ce | |||
5b412bf072 | |||
0f89282dae | |||
14ba11738b | |||
fa89da4438 | |||
be75332be7 | |||
1886c69e0b | |||
23d9f56308 | |||
1be7208f47 | |||
395fbb7704 | |||
b4479d6a7d | |||
34897aceae | |||
542aa994b7 | |||
345ccf5392 | |||
ec7568337c | |||
c2dbebe56b | |||
cb6db97fc1 | |||
15b2f9a13e | |||
283921cba1 | |||
dc0f435dbd | |||
63965e2f68 | |||
67ac4060d7 | |||
4a01ff3537 | |||
c1be4a1e83 | |||
9ec653075d | |||
a2d5f872ad | |||
8891cda1d4 | |||
9e9a19ebb0 | |||
0f3e9de2b0 | |||
f75e7b2002 | |||
08b369f667 | |||
6f85968f3c | |||
709661ff67 | |||
c7cd4afa01 | |||
3e2f4e7a10 | |||
9191d1ec33 | |||
556a3986c1 | |||
b71ac25a77 | |||
ca8e3f685a | |||
017e02e513 | |||
46dcc18ddb | |||
9ddea586ea | |||
f8d5546a03 | |||
b7cd192185 | |||
9f681275b4 | |||
dac3068437 | |||
c56fc09da7 | |||
0237a22ae9 | |||
ccb3a23602 | |||
30cf0c7aad | |||
dcdf0c9843 | |||
7c673d6e7f | |||
667a893d01 | |||
01e9ef64c9 | |||
5e42618dfd | |||
1bef032260 | |||
221012f790 | |||
8d10dcbe18 | |||
c51d9b437e | |||
c85a7d6b9c | |||
8a6b4a14bd | |||
2e0606ff0c | |||
f3f96e02a2 | |||
7d6022ab09 | |||
10f2a7a7b7 | |||
271d133053 | |||
65ed862c9b | |||
1f981e7a60 | |||
823decde5c | |||
2b609a413d | |||
5da2a45881 | |||
c5c7a895a4 | |||
18f7d3e3c9 | |||
bea4b7629b | |||
1463bcae52 | |||
a2a6bf1b45 | |||
448ca372a9 | |||
350e494930 | |||
47733a5648 | |||
7f70673625 | |||
7ae02d43a7 | |||
82b72e66ee | |||
3ca18a42ad | |||
55d31d0dc2 | |||
0499fd03da | |||
8e23be665b | |||
825682c36d | |||
f61d0e83f0 | |||
e4286d18d4 | |||
ababb5c062 | |||
74fa4835e2 | |||
cf04b83cdf | |||
c1fe5325ed | |||
5b6f091859 | |||
d903df55ce | |||
6a00fd3099 | |||
4db5944514 | |||
699ffd75df | |||
14dcd9eb5f | |||
e5d0dac65e | |||
8acb0c3c02 | |||
55a274a6e3 | |||
90bd6b1fc1 | |||
2fd4687108 | |||
3af5b8560d | |||
a5f9d0c0d5 | |||
7fd5b6b39e | |||
71bf98794d | |||
3e5ef61d5f | |||
3a606fdfc4 | |||
04d791824d | |||
5b26564058 | |||
8dd58ed4fe | |||
c0dde1a005 | |||
773627dc3d | |||
f0885fcb2e | |||
9fd4c477f0 | |||
b305924e11 | |||
11537f9988 | |||
863295cd31 | |||
5348f059b0 | |||
0e43969b63 | |||
ebb575d490 | |||
b1a91da844 | |||
d6164971df | |||
397e1433fd | |||
0e68dbd86c | |||
31c84d47fe | |||
8fc144b595 | |||
8693075061 | |||
b128455217 | |||
99c975d0cd | |||
d5205b59c1 | |||
26fbd81d39 | |||
0ccf062d51 | |||
aa71159a9a | |||
e56a30df06 | |||
c035a26051 | |||
7b7bd76703 | |||
d54e2276d6 | |||
ee878d9fe9 | |||
0b50d9aedf | |||
4131084973 | |||
b81ff7f8f5 | |||
1284d10257 | |||
af9a9b837a | |||
9a16544836 | |||
dbcf4f5d69 | |||
f9050ab185 | |||
d6e22e7d4d | |||
e1ae1c021a | |||
da45326150 | |||
28040f85cc | |||
652cfa0986 | |||
3a76ee366d | |||
09c602a830 | |||
1d8c4be47a | |||
e2c26efe4a | |||
c4ba578285 | |||
804afa5d96 | |||
26162f8e78 | |||
38903f647b | |||
cd92f4a611 | |||
8f1d521007 | |||
cf9ff87560 | |||
cbb7fdfa99 | |||
487b6fd5ca | |||
ddd8ff2180 | |||
87d00dbcee | |||
5cb6ab8416 | |||
4b5f22f013 | |||
48a8a52b1c | |||
8dcd2f0c95 | |||
2cb562cdee | |||
00bafd98fe | |||
536c0cb0fe | |||
0f57fc33c8 | |||
2aa76766af | |||
00711c148a | |||
d0cba24a37 | |||
adb0147ea9 | |||
086d076262 | |||
260082c425 | |||
ad052462c1 | |||
b8b6cd8872 | |||
799e90f617 | |||
8afc6dea11 | |||
8af3a91b5a | |||
bdd5a7dd21 | |||
2630d7fae7 | |||
df5b0a19de | |||
c7d0a9551e | |||
26fa568d72 | |||
39acc24535 | |||
d29b86a0bd | |||
8e6a2a1f02 | |||
43fe7e0aa0 | |||
ca79f370b0 | |||
10f5933c1e | |||
3354f2a696 | |||
c67a7ef1d8 | |||
63ec5d6338 | |||
a66a76609f | |||
9f389fb920 | |||
9dff2e1479 | |||
299136f1a5 | |||
2c65849bc6 | |||
0343372910 | |||
366c475b05 | |||
46e3956bca | |||
6409c596f7 | |||
5779f511cf | |||
63c7903f9b | |||
87495fd3af | |||
38c60f37da | |||
baba8b5cf0 | |||
a4cd99ec90 | |||
e837532b22 | |||
f7c6f16777 | |||
3b3b2ed8c3 | |||
52d0182a52 | |||
405b9e7074 | |||
24c7a4e7e3 | |||
30a57ad5a4 | |||
d78c746552 | |||
773b745c76 | |||
45409fc2d6 | |||
f97d5df75f | |||
49b8232f12 | |||
ac3812f268 | |||
ed6ee02861 | |||
94979e3561 | |||
74e4415d58 | |||
146035de5a | |||
d8e1e4561d | |||
c1ca43113b | |||
26afe1d94a | |||
90622eb25a | |||
e4e765300d | |||
922c33df57 | |||
23894f9749 | |||
1716034926 | |||
acc1849fbb | |||
d1a25bfa65 | |||
dc0c8c704c | |||
bb58281fba | |||
5b9811a950 | |||
e9849bfedd | |||
6ecd4ec2f3 | |||
23782dc2fa | |||
a45d4592c3 | |||
92528c7350 |
.clang-format.gitignore.gitmodulesCMakeLists.txtJustfileREADME.md
automation
bsp_egse
bsp_hosted
CMakeLists.txtInitMission.cppInitMission.hObjectFactory.cppObjectFactory.h
boardconfig
comIF
fsfwconfig
main.cppbsp_linux_board
CMakeLists.txtInitMission.cppInitMission.hObjectFactory.cppObjectFactory.h
boardconfig
boardtest
main.cppbsp_q7s
CMakeLists.txt
boardconfig
boardtest
callbacks
CMakeLists.txtgnssCallback.cppgnssCallback.hgpioCallbacks.cppgpioCallbacks.hpcduSwitchCb.cpppcduSwitchCb.hrwSpiCallback.cpprwSpiCallback.h
comIF
core
CMakeLists.txtCoreController.cppCoreController.hInitMission.cppInitMission.hObjectFactory.cppObjectFactory.hParameterHandler.cppParameterHandler.hobsw.cpp
devices
CMakeLists.txtPlocMemoryDumper.cppPlocMemoryDumper.hPlocSupervisorHandler.cppPlocSupervisorHandler.hPlocUpdater.cppPlocUpdater.h
devicedefinitions
gpio
main.cppmemory
CMakeLists.txtFileSystemHandler.cppFileSystemHandler.hSdCardManager.cppSdCardManager.hdefinitions.hscratchApi.cppscratchApi.h
simple
spi
spiCallbacks
cmake
HardwareOsPostConfig.cmakeHardwareOsPreConfig.cmakePreProjectConfig.cmakeQ7SCrossCompileConfig.cmake
scripts
common/config
CMakeLists.txtOBSWVersion.hccsdsConfig.hcommonClassIds.hcommonConfig.cppcommonConfig.h.incommonObjects.hcommonSubsystemIds.hdevConf.h
fsfwdevices
tmtc
generators
linux
archive
gpio
tmtc
boardtest
CMakeLists.txtI2cTestClass.cppI2cTestClass.hLibgpiodTest.cppLibgpiodTest.hSpiTestClass.cppSpiTestClass.hUartTestClass.cppUartTestClass.h
csp
devices
CMakeLists.txtGPSHyperionLinuxController.cppGPSHyperionLinuxController.hHeaterHandler.cppHeaterHandler.hSolarArrayDeploymentHandler.cppSolarArrayDeploymentHandler.hSusHandler.cppSusHandler.h
devicedefinitions
startracker
fsfwconfig
obc
AxiPtmeConfig.cppAxiPtmeConfig.hCCSDSIPCoreBridge.cppCCSDSIPCoreBridge.hCMakeLists.txtPapbVcInterface.cppPapbVcInterface.hPdecConfig.cppPdecConfig.hPdecHandler.cppPdecHandler.hPtme.cppPtme.hPtmeConfig.cppPtmeConfig.hPtmeIF.hVcInterfaceIF.h
utility
misc/eclipse
mission
CMakeLists.txt
controller
core
devices
ACUHandler.cppACUHandler.hBpxBatteryHandler.cppBpxBatteryHandler.hCMakeLists.txtGPSHyperionHandler.cppGPSHyperionHandler.hGomspaceDeviceHandler.cppGomspaceDeviceHandler.hGyroADIS16507Handler.cppGyroADIS16507Handler.hGyroADIS1650XHandler.cppGyroADIS1650XHandler.hHeaterHandler.cppHeaterHandler.hIMTQHandler.cppIMTQHandler.hMGMHandlerLIS3MDL.cppMGMHandlerLIS3MDL.hMGMHandlerRM3100.cppMGMHandlerRM3100.hMax31865PT1000Handler.cppMax31865PT1000Handler.hP60DockHandler.cppP60DockHandler.hPCDUHandler.cppPCDUHandler.hPDU1Handler.cppPDU1Handler.hPDU2Handler.cppPDU2Handler.hPlocMPSoCHandler.cppPlocMPSoCHandler.hRadiationSensorHandler.cppRadiationSensorHandler.hRwHandler.cppRwHandler.hSolarArrayDeploymentHandler.cppSolarArrayDeploymentHandler.hStarTrackerHandler.cppStarTrackerHandler.hSusHandler.cppSusHandler.hSyrlinksHkHandler.cppSyrlinksHkHandler.hTmp1075Handler.cppTmp1075Handler.h
devicedefinitions
BpxBatteryDefinitions.hGPSDefinitions.hGomSpacePackets.hGomspaceDefinitions.hGyroADIS16507Definitions.hGyroADIS1650XDefinitions.hGyroL3GD20Definitions.hIMTQHandlerDefinitions.hMGMHandlerLIS3Definitions.hMGMHandlerRM3100Definitions.hMax31865Definitions.hPlocMPSoCDefinitions.hRadSensorDefinitions.hRwDefinitions.hSCEXDefinitions.hStarTrackerDefinitions.hSusDefinitions.hSyrlinksDefinitions.hTmp1075Definitions.h
max1227.cppmax1227.hmemory
tmtc
utility
scripts
test
thirdparty
tmtcunittest
CMakeLists.txt
controller
main.cppmocks
printChar.cppprintChar.hrebootLogic
.gitignore
testEnvironment.cpptestEnvironment.hunittest.mk.vscode
CMakeLists.txtREADME.mdsrc
watchdog
8
.clang-format
Normal file
8
.clang-format
Normal file
@ -0,0 +1,8 @@
|
||||
---
|
||||
BasedOnStyle: Google
|
||||
IndentWidth: 2
|
||||
---
|
||||
Language: Cpp
|
||||
ColumnLimit: 100
|
||||
ReflowComments: true
|
||||
---
|
3
.gitignore
vendored
3
.gitignore
vendored
@ -8,6 +8,9 @@
|
||||
!misc/eclipse/**/.cproject
|
||||
!misc/eclipse/**/.project
|
||||
|
||||
#vscode
|
||||
/.vscode
|
||||
|
||||
# Python
|
||||
__pycache__
|
||||
.idea
|
||||
|
2
.gitmodules
vendored
2
.gitmodules
vendored
@ -15,7 +15,7 @@
|
||||
url = https://github.com/rmspacefish/lwgps.git
|
||||
[submodule "generators/fsfwgen"]
|
||||
path = generators/fsfwgen
|
||||
url = https://egit.irs.uni-stuttgart.de/fsfw/fsfw-generators.git
|
||||
url = https://egit.irs.uni-stuttgart.de/fsfw/fsfw-gen.git
|
||||
[submodule "thirdparty/arcsec_star_tracker"]
|
||||
path = thirdparty/arcsec_star_tracker
|
||||
url = https://egit.irs.uni-stuttgart.de/eive/arcsec_star_tracker.git
|
||||
|
358
CMakeLists.txt
358
CMakeLists.txt
@ -13,34 +13,32 @@ cmake_minimum_required(VERSION 3.13)
|
||||
|
||||
set(CMAKE_SCRIPT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
|
||||
|
||||
if(TGT_BSP MATCHES "arm/q7s")
|
||||
option(EIVE_BUILD_WATCHDOG "Compile the OBSW watchdog insted" OFF)
|
||||
option(BUILD_Q7S_SIMPLE_MODE OFF "Simple mode with a minimal main function")
|
||||
endif()
|
||||
|
||||
option(ADD_ETL_LIB "Add ETL library" ON)
|
||||
option(ADD_JSON_LIB "Add JSON library" ON)
|
||||
option(EIVE_ADD_ETL_LIB "Add ETL library" ON)
|
||||
option(EIVE_ADD_JSON_LIB "Add JSON library" ON)
|
||||
|
||||
option(EIVE_SYSROOT_MAGIC "Perform sysroot magic which might not be necessary" OFF)
|
||||
option(EIVE_CREATE_UNIQUE_OBSW_BIN "Append username to generated binary name" ON)
|
||||
|
||||
if(NOT FSFW_OSAL)
|
||||
set(FSFW_OSAL host CACHE STRING "OS for the FSFW.")
|
||||
set(FSFW_OSAL linux CACHE STRING "OS for the FSFW.")
|
||||
endif()
|
||||
|
||||
if(TGT_BSP MATCHES "arm/raspberrypi" OR TGT_BSP MATCHES "arm/beagleboneblack")
|
||||
if(TGT_BSP)
|
||||
if(TGT_BSP MATCHES "arm/raspberrypi" OR TGT_BSP MATCHES "arm/beagleboneblack")
|
||||
option(LINUX_CROSS_COMPILE ON)
|
||||
option(EIVE_BUILD_GPSD_GPS_HANDLER "Build GPSD dependent GPS Handler" OFF)
|
||||
elseif(TGT_BSP MATCHES "arm/q7s")
|
||||
option(EIVE_BUILD_GPSD_GPS_HANDLER "Build GPSD dependent GPS Handler" ON)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# Perform steps like loading toolchain files where applicable.
|
||||
include(${CMAKE_SCRIPT_PATH}/PreProjectConfig.cmake)
|
||||
pre_project_config()
|
||||
|
||||
set(PROJECT_NAME_TO_SET eive-obsw-$ENV{USERNAME})
|
||||
if(EIVE_BUILD_WATCHDOG)
|
||||
set(PROJECT_NAME_TO_SET eive-watchdog)
|
||||
endif()
|
||||
|
||||
# Project Name
|
||||
project(${PROJECT_NAME_TO_SET} ASM C CXX)
|
||||
project(eive-obsw ASM C CXX)
|
||||
|
||||
################################################################################
|
||||
# Pre-Sources preparation
|
||||
@ -51,34 +49,42 @@ set(CMAKE_CXX_STANDARD 17)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED True)
|
||||
|
||||
# Set names and variables
|
||||
set(TARGET_NAME ${CMAKE_PROJECT_NAME})
|
||||
set(OBSW_NAME ${CMAKE_PROJECT_NAME})
|
||||
set(WATCHDOG_NAME eive-watchdog)
|
||||
set(SIMPLE_OBSW_NAME eive-simple)
|
||||
set(UNITTEST_NAME eive-unittest)
|
||||
set(LIB_FSFW_NAME fsfw)
|
||||
set(LIB_EIVE_MISSION eive-mission)
|
||||
set(LIB_ETL_NAME etl)
|
||||
set(LIB_CSP_NAME libcsp)
|
||||
set(LIB_LWGPS_NAME lwgps)
|
||||
set(LIB_ARCSEC wire)
|
||||
set(THIRD_PARTY_FOLDER thirdparty)
|
||||
set(LIB_CXX_FS -lstdc++fs)
|
||||
set(LIB_CATCH2 Catch2)
|
||||
set(LIB_GPS gps)
|
||||
set(LIB_JSON_NAME nlohmann_json::nlohmann_json)
|
||||
|
||||
# Set path names
|
||||
set(FSFW_PATH fsfw)
|
||||
set(MISSION_PATH mission)
|
||||
set(TEST_PATH test/testtasks)
|
||||
set(UNITTEST_PATH unittest)
|
||||
set(LINUX_PATH linux)
|
||||
set(COMMON_PATH common)
|
||||
set(WATCHDOG_PATH watchdog)
|
||||
set(COMMON_CONFIG_PATH ${COMMON_PATH}/config)
|
||||
set(UNITTEST_CFG_PATH ${UNITTEST_PATH}/testcfg)
|
||||
|
||||
set(FSFW_HAL_LIB_PATH fsfw_hal)
|
||||
set(CSP_LIB_PATH ${THIRD_PARTY_FOLDER}/libcsp)
|
||||
set(ETL_LIB_PATH ${THIRD_PARTY_FOLDER}/etl)
|
||||
set(LWGPS_LIB_PATH ${THIRD_PARTY_FOLDER}/lwgps)
|
||||
set(ARCSEC_LIB_PATH ${THIRD_PARTY_FOLDER}/arcsec_star_tracker)
|
||||
set(LIB_EIVE_MISSION_PATH mission)
|
||||
set(LIB_CSP_PATH ${THIRD_PARTY_FOLDER}/libcsp)
|
||||
set(LIB_ETL_PATH ${THIRD_PARTY_FOLDER}/etl)
|
||||
set(LIB_CATCH2_PATH ${THIRD_PARTY_FOLDER}/Catch2)
|
||||
set(LIB_LWGPS_PATH ${THIRD_PARTY_FOLDER}/lwgps)
|
||||
set(LIB_ARCSEC_PATH ${THIRD_PARTY_FOLDER}/arcsec_star_tracker)
|
||||
set(LIB_JSON_PATH ${THIRD_PARTY_FOLDER}/json)
|
||||
|
||||
set(FSFW_WARNING_SHADOW_LOCAL_GCC OFF)
|
||||
set(ADD_LINUX_FILES False)
|
||||
set(EIVE_ADD_LINUX_FILES False)
|
||||
|
||||
# Analyse different OS and architecture/target options, determine BSP_PATH,
|
||||
# display information about compiler etc.
|
||||
@ -87,28 +93,34 @@ pre_source_hw_os_config()
|
||||
|
||||
if(TGT_BSP)
|
||||
if(TGT_BSP MATCHES "arm/q7s" OR TGT_BSP MATCHES "arm/raspberrypi"
|
||||
OR TGT_BSP MATCHES "arm/beagleboneblack"
|
||||
OR TGT_BSP MATCHES "arm/beagleboneblack" OR TGT_BSP MATCHES "arm/egse"
|
||||
)
|
||||
set(FSFW_CONFIG_PATH "linux/fsfwconfig")
|
||||
if(NOT BUILD_Q7S_SIMPLE_MODE)
|
||||
set(ADD_LINUX_FILES TRUE)
|
||||
set(EIVE_ADD_LINUX_FILES TRUE)
|
||||
set(ADD_CSP_LIB TRUE)
|
||||
set(FSFW_HAL_ADD_LINUX ON)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(${TGT_BSP} MATCHES "arm/raspberrypi")
|
||||
if(TGT_BSP MATCHES "arm/raspberrypi" )
|
||||
# Used by configure file
|
||||
set(RASPBERRY_PI ON)
|
||||
set(FSFW_HAL_ADD_RASPBERRY_PI ON)
|
||||
endif()
|
||||
|
||||
if(${TGT_BSP} MATCHES "arm/beagleboneblack")
|
||||
if(TGT_BSP MATCHES "arm/egse")
|
||||
# Used by configure file
|
||||
set(EGSE ON)
|
||||
set(FSFW_HAL_LINUX_ADD_LIBGPIOD OFF)
|
||||
endif()
|
||||
|
||||
if(TGT_BSP MATCHES "arm/beagleboneblack")
|
||||
# Used by configure file
|
||||
set(BEAGLEBONEBLACK ON)
|
||||
endif()
|
||||
|
||||
if(${TGT_BSP} MATCHES "arm/q7s")
|
||||
if(TGT_BSP MATCHES "arm/q7s")
|
||||
# Used by configure file
|
||||
set(XIPHOS_Q7S ON)
|
||||
endif()
|
||||
@ -117,17 +129,19 @@ else()
|
||||
set(FSFW_CONFIG_PATH "${BSP_PATH}/fsfwconfig")
|
||||
endif()
|
||||
|
||||
|
||||
# Configuration files
|
||||
if(NOT EIVE_BUILD_WATCHDOG)
|
||||
configure_file(${COMMON_CONFIG_PATH}/commonConfig.h.in commonConfig.h)
|
||||
configure_file(${FSFW_CONFIG_PATH}/FSFWConfig.h.in FSFWConfig.h)
|
||||
configure_file(${FSFW_CONFIG_PATH}/OBSWConfig.h.in OBSWConfig.h)
|
||||
if(${TGT_BSP} MATCHES "arm/q7s")
|
||||
configure_file(${COMMON_CONFIG_PATH}/commonConfig.h.in commonConfig.h)
|
||||
configure_file(${FSFW_CONFIG_PATH}/FSFWConfig.h.in FSFWConfig.h)
|
||||
configure_file(${FSFW_CONFIG_PATH}/OBSWConfig.h.in OBSWConfig.h)
|
||||
if(TGT_BSP MATCHES "arm/q7s")
|
||||
configure_file(${BSP_PATH}/boardconfig/q7sConfig.h.in q7sConfig.h)
|
||||
elseif(${TGT_BSP} MATCHES "arm/raspberrypi")
|
||||
elseif(TGT_BSP MATCHES "arm/raspberrypi" OR TGT_BSP MATCHES "arm/egse")
|
||||
configure_file(${BSP_PATH}/boardconfig/rpiConfig.h.in rpiConfig.h)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
|
||||
|
||||
configure_file(${WATCHDOG_PATH}/watchdogConf.h.in watchdogConf.h)
|
||||
|
||||
# Set common config path for FSFW
|
||||
@ -135,123 +149,31 @@ set(FSFW_ADDITIONAL_INC_PATHS
|
||||
"${COMMON_PATH}/config"
|
||||
${CMAKE_CURRENT_BINARY_DIR}
|
||||
)
|
||||
# Set for lwgps library
|
||||
set(LWGPS_CONFIG_PATH "${COMMON_PATH}/config")
|
||||
|
||||
# Check whether the user has already installed Catch2 first
|
||||
find_package(Catch2 3)
|
||||
|
||||
################################################################################
|
||||
# Executable and Sources
|
||||
################################################################################
|
||||
|
||||
# Add executable
|
||||
add_executable(${TARGET_NAME})
|
||||
|
||||
if(ADD_ETL_LIB)
|
||||
add_subdirectory(${ETL_LIB_PATH})
|
||||
endif()
|
||||
|
||||
if(ADD_JSON_LIB)
|
||||
add_subdirectory(${LIB_JSON_PATH})
|
||||
endif()
|
||||
|
||||
if(NOT EIVE_BUILD_WATCHDOG)
|
||||
if(ADD_LINUX_FILES)
|
||||
add_subdirectory(${LINUX_PATH})
|
||||
endif()
|
||||
add_subdirectory(${BSP_PATH})
|
||||
add_subdirectory(${COMMON_PATH})
|
||||
if(ADD_CSP_LIB)
|
||||
add_subdirectory(${CSP_LIB_PATH})
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if((NOT BUILD_Q7S_SIMPLE_MODE) AND (NOT EIVE_BUILD_WATCHDOG))
|
||||
add_subdirectory(${LWGPS_LIB_PATH})
|
||||
add_subdirectory(${FSFW_PATH})
|
||||
add_subdirectory(${MISSION_PATH})
|
||||
add_subdirectory(${TEST_PATH})
|
||||
add_subdirectory(${ARCSEC_LIB_PATH})
|
||||
endif()
|
||||
|
||||
if(EIVE_BUILD_WATCHDOG)
|
||||
add_subdirectory(${WATCHDOG_PATH})
|
||||
endif()
|
||||
|
||||
################################################################################
|
||||
# Post-Sources preparation
|
||||
################################################################################
|
||||
|
||||
set_property(CACHE FSFW_OSAL PROPERTY STRINGS host linux)
|
||||
|
||||
if((NOT BUILD_Q7S_SIMPLE_MODE) AND (NOT EIVE_BUILD_WATCHDOG))
|
||||
# Add libraries for all sources.
|
||||
target_link_libraries(${TARGET_NAME} PRIVATE
|
||||
${LIB_FSFW_NAME}
|
||||
${LIB_OS_NAME}
|
||||
${LIB_LWGPS_NAME}
|
||||
)
|
||||
|
||||
if(TGT_BSP MATCHES "arm/q7s")
|
||||
target_link_libraries(${TARGET_NAME} PRIVATE
|
||||
${LIB_ARCSEC}
|
||||
)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(NOT EIVE_BUILD_WATCHDOG)
|
||||
if(ADD_CSP_LIB)
|
||||
target_link_libraries(${TARGET_NAME} PRIVATE
|
||||
${LIB_CSP_NAME}
|
||||
)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(ADD_ETL_LIB)
|
||||
target_link_libraries(${TARGET_NAME} PRIVATE
|
||||
${LIB_ETL_NAME}
|
||||
)
|
||||
endif()
|
||||
|
||||
if(ADD_JSON_LIB)
|
||||
target_link_libraries(${TARGET_NAME} PRIVATE
|
||||
${LIB_JSON_NAME}
|
||||
)
|
||||
endif()
|
||||
|
||||
target_link_libraries(${TARGET_NAME} PRIVATE
|
||||
${LIB_CXX_FS}
|
||||
)
|
||||
|
||||
# Add include paths for all sources.
|
||||
target_include_directories(${TARGET_NAME} PRIVATE
|
||||
${CMAKE_CURRENT_SOURCE_DIR}
|
||||
${FSFW_CONFIG_PATH}
|
||||
${CMAKE_CURRENT_BINARY_DIR}
|
||||
${ARCSEC_LIB_PATH}
|
||||
)
|
||||
|
||||
if(TGT_BSP MATCHES "arm/q7s")
|
||||
target_include_directories(${TARGET_NAME} PRIVATE
|
||||
${ARCSEC_LIB_PATH}
|
||||
)
|
||||
endif()
|
||||
|
||||
#global compiler options need to be set before adding executables
|
||||
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
|
||||
set(WARNING_FLAGS
|
||||
-Wall
|
||||
-Wextra
|
||||
-Wimplicit-fallthrough=1
|
||||
-Wno-unused-parameter
|
||||
-Wno-psabi
|
||||
add_compile_options(
|
||||
"-Wall"
|
||||
"-Wextra"
|
||||
"-Wimplicit-fallthrough=1"
|
||||
"-Wno-unused-parameter"
|
||||
"-Wno-psabi"
|
||||
)
|
||||
|
||||
# Remove unused sections.
|
||||
target_compile_options(${TARGET_NAME} PRIVATE
|
||||
add_compile_options(
|
||||
"-ffunction-sections"
|
||||
"-fdata-sections"
|
||||
)
|
||||
|
||||
# Removed unused sections.
|
||||
target_link_options(${TARGET_NAME} PRIVATE
|
||||
add_link_options(
|
||||
"-Wl,--gc-sections"
|
||||
)
|
||||
|
||||
@ -259,15 +181,162 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
|
||||
set(COMPILER_FLAGS "/permissive-")
|
||||
endif()
|
||||
|
||||
# Not installed, so use FetchContent to download and provide Catch2
|
||||
if(NOT Catch2_FOUND)
|
||||
include(FetchContent)
|
||||
|
||||
FetchContent_Declare(
|
||||
Catch2
|
||||
GIT_REPOSITORY https://github.com/catchorg/Catch2.git
|
||||
GIT_TAG v3.0.0-preview4
|
||||
)
|
||||
|
||||
FetchContent_MakeAvailable(Catch2)
|
||||
#fixes regression -preview4, to be confirmed in later releases
|
||||
set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
|
||||
set_target_properties(Catch2 PROPERTIES EXCLUDE_FROM_ALL "true")
|
||||
set_target_properties(Catch2WithMain PROPERTIES EXCLUDE_FROM_ALL "true")
|
||||
endif()
|
||||
|
||||
|
||||
|
||||
add_library(${LIB_EIVE_MISSION})
|
||||
|
||||
|
||||
# Add main executable
|
||||
add_executable(${OBSW_NAME})
|
||||
if(EIVE_CREATE_UNIQUE_OBSW_BIN)
|
||||
set(OBSW_BIN_NAME ${CMAKE_PROJECT_NAME}-$ENV{USERNAME})
|
||||
else()
|
||||
set(OBSW_BIN_NAME ${CMAKE_PROJECT_NAME})
|
||||
endif()
|
||||
set_target_properties(${OBSW_NAME} PROPERTIES OUTPUT_NAME ${OBSW_BIN_NAME})
|
||||
|
||||
#watchdog
|
||||
add_executable(${WATCHDOG_NAME} EXCLUDE_FROM_ALL)
|
||||
add_subdirectory(${WATCHDOG_PATH})
|
||||
target_link_libraries(${WATCHDOG_NAME} PUBLIC
|
||||
${LIB_CXX_FS}
|
||||
)
|
||||
target_include_directories(${WATCHDOG_NAME} PUBLIC
|
||||
${CMAKE_BINARY_DIR}
|
||||
)
|
||||
|
||||
#unittests
|
||||
add_executable(${UNITTEST_NAME} EXCLUDE_FROM_ALL)
|
||||
|
||||
|
||||
|
||||
if(EIVE_ADD_ETL_LIB)
|
||||
add_subdirectory(${LIB_ETL_PATH})
|
||||
endif()
|
||||
|
||||
if(EIVE_ADD_JSON_LIB)
|
||||
add_subdirectory(${LIB_JSON_PATH})
|
||||
endif()
|
||||
|
||||
|
||||
|
||||
if(EIVE_ADD_LINUX_FILES)
|
||||
add_subdirectory(${LIB_ARCSEC_PATH})
|
||||
add_subdirectory(${LINUX_PATH})
|
||||
endif()
|
||||
add_subdirectory(${BSP_PATH})
|
||||
if(ADD_CSP_LIB)
|
||||
add_subdirectory(${LIB_CSP_PATH})
|
||||
endif()
|
||||
|
||||
|
||||
add_subdirectory(${COMMON_PATH})
|
||||
|
||||
|
||||
|
||||
add_subdirectory(${LIB_LWGPS_PATH})
|
||||
add_subdirectory(${FSFW_PATH})
|
||||
add_subdirectory(${LIB_EIVE_MISSION_PATH})
|
||||
add_subdirectory(${TEST_PATH})
|
||||
|
||||
|
||||
add_subdirectory(${UNITTEST_PATH})
|
||||
|
||||
|
||||
################################################################################
|
||||
# Post-Sources preparation
|
||||
################################################################################
|
||||
|
||||
|
||||
|
||||
# Add libraries
|
||||
target_link_libraries(${LIB_EIVE_MISSION} PUBLIC
|
||||
${LIB_FSFW_NAME}
|
||||
${LIB_LWGPS_NAME}
|
||||
${LIB_OS_NAME}
|
||||
)
|
||||
|
||||
target_link_libraries(${OBSW_NAME} PRIVATE
|
||||
${LIB_EIVE_MISSION}
|
||||
)
|
||||
|
||||
if(TGT_BSP MATCHES "arm/q7s")
|
||||
target_link_libraries(${LIB_EIVE_MISSION} PUBLIC
|
||||
${LIB_ARCSEC}
|
||||
${LIB_GPS}
|
||||
)
|
||||
endif()
|
||||
|
||||
target_link_libraries(${UNITTEST_NAME} PRIVATE
|
||||
Catch2
|
||||
${LIB_EIVE_MISSION}
|
||||
)
|
||||
|
||||
if(TGT_BSP MATCHES "arm/egse")
|
||||
target_link_libraries(${OBSW_NAME} PRIVATE
|
||||
${LIB_ARCSEC}
|
||||
)
|
||||
endif()
|
||||
|
||||
if(ADD_CSP_LIB)
|
||||
target_link_libraries(${OBSW_NAME} PRIVATE
|
||||
${LIB_CSP_NAME}
|
||||
)
|
||||
endif()
|
||||
|
||||
|
||||
if(EIVE_ADD_ETL_LIB)
|
||||
target_link_libraries(${LIB_EIVE_MISSION} PUBLIC
|
||||
${LIB_ETL_NAME}
|
||||
)
|
||||
endif()
|
||||
|
||||
if(EIVE_ADD_JSON_LIB)
|
||||
target_link_libraries(${LIB_EIVE_MISSION} PUBLIC
|
||||
${LIB_JSON_NAME}
|
||||
)
|
||||
endif()
|
||||
|
||||
target_link_libraries(${LIB_EIVE_MISSION} PUBLIC
|
||||
${LIB_CXX_FS}
|
||||
)
|
||||
|
||||
# Add include paths for all sources.
|
||||
target_include_directories(${LIB_EIVE_MISSION} PUBLIC
|
||||
${CMAKE_CURRENT_SOURCE_DIR}
|
||||
${FSFW_CONFIG_PATH}
|
||||
${CMAKE_CURRENT_BINARY_DIR}
|
||||
${LIB_ARCSEC_PATH}
|
||||
)
|
||||
|
||||
if(TGT_BSP MATCHES "arm/q7s" OR TGT_BSP MATCHES "arm/egse")
|
||||
target_include_directories(${LIB_EIVE_MISSION} PUBLIC
|
||||
${ARCSEC_LIB_PATH}
|
||||
)
|
||||
endif()
|
||||
|
||||
if(CMAKE_VERBOSE)
|
||||
message(STATUS "Warning flags: ${WARNING_FLAGS}")
|
||||
endif()
|
||||
|
||||
|
||||
# Compile options for all sources.
|
||||
target_compile_options(${TARGET_NAME} PRIVATE
|
||||
${WARNING_FLAGS}
|
||||
)
|
||||
|
||||
if(${CMAKE_CROSSCOMPILING})
|
||||
include (${CMAKE_SCRIPT_PATH}/HardwareOsPostConfig.cmake)
|
||||
@ -299,11 +368,12 @@ string(CONCAT POST_BUILD_COMMENT
|
||||
)
|
||||
|
||||
add_custom_command(
|
||||
TARGET ${TARGET_NAME}
|
||||
TARGET ${OBSW_NAME}
|
||||
POST_BUILD
|
||||
COMMAND ${CMAKE_SIZE} ${TARGET_NAME}${FILE_SUFFIX}
|
||||
COMMAND ${CMAKE_SIZE} ${OBSW_BIN_NAME}${FILE_SUFFIX}
|
||||
COMMENT ${POST_BUILD_COMMENT}
|
||||
)
|
||||
|
||||
|
||||
include (${CMAKE_SCRIPT_PATH}/BuildType.cmake)
|
||||
set_build_type()
|
||||
|
12
Justfile
Normal file
12
Justfile
Normal file
@ -0,0 +1,12 @@
|
||||
python_script := './cmake/scripts/cmake-build-cfg.py'
|
||||
|
||||
default: q7s-debug-make
|
||||
|
||||
q7s-debug-make:
|
||||
{{python_script}} -o linux -g make -b debug -t "arm/q7s" -l build-Debug-Q7S
|
||||
|
||||
q7s-release-make:
|
||||
{{python_script}} -o linux -g make -b release -t "arm/q7s" -l build-Release-Q7S
|
||||
|
||||
q7s-debug-ninja:
|
||||
{{python_script}} -o linux -g ninja -b debug -t "arm/q7s" -l build-Debug-Q7S
|
232
README.md
232
README.md
@ -11,13 +11,18 @@
|
||||
4. [Useful and Common Host Commands](#host-commands)
|
||||
5. [Setting up Prerequisites](#set-up-prereq)
|
||||
6. [Remote Debugging](#remote-debugging)
|
||||
7. [Direct Debugging](#direct-debugging)
|
||||
8. [Transfering Files to the Q7S](#file-transfer)
|
||||
9. [Q7S OBC](#q7s)
|
||||
10. [Static Code Analysis](#static-code-analysis)
|
||||
11. [Eclipse](#eclipse)
|
||||
12. [Running the OBSW on a Raspberry Pi](#rpi)
|
||||
13. [FSFW](#fsfw)
|
||||
6. [Remote Reset](#remote-reset)
|
||||
8. [TMTC testing](#tmtc-testing)
|
||||
9. [Direct Debugging](#direct-debugging)
|
||||
10. [Transfering Files to the Q7S](#file-transfer)
|
||||
11. [Q7S OBC](#q7s)
|
||||
12. [Static Code Analysis](#static-code-analysis)
|
||||
13. [Eclipse](#eclipse)
|
||||
14. [Running the OBSW on a Raspberry Pi](#rpi)
|
||||
15. [Running OBSW on EGSE](#egse)
|
||||
16. [Manually preparing sysroots to compile gpsd](#gpsd)
|
||||
17. [FSFW](#fsfw)
|
||||
18. [Coding Style](#coding-style)
|
||||
|
||||
# <a id="general"></a> General information
|
||||
|
||||
@ -35,7 +40,7 @@ Target systems:
|
||||
relevant pages. The most recent datasheet can be found
|
||||
[here](https://trac2.xiphos.ca/manual/wiki/Q7RevB/UserManual).
|
||||
* Linux OS built with Yocto 2.5
|
||||
* Linux Kernel https://github.com/XiphosSystemsCorp/linux-xlnx.git . EIVE version can be found
|
||||
* [Linux Kernel](https://github.com/XiphosSystemsCorp/linux-xlnx.git) . EIVE version can be found
|
||||
[here](https://github.com/spacefisch/linux-xlnx) . Pre-compiled files can be
|
||||
found [here](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Software/q7s-linux-components&fileid=777299).
|
||||
* Q7S base project can be found [here](https://egit.irs.uni-stuttgart.de/eive/q7s-base)
|
||||
@ -65,7 +70,7 @@ prerequisites.
|
||||
as a [separate download](#arm-toolchain)
|
||||
2. [Q7S sysroot](#q7s-sysroot) on local development machine
|
||||
3. Recommended: Eclipse or [Vivado 2018.2 SDK](#vivado) for OBSW development
|
||||
3. [TCF agent] running on Q7S
|
||||
3. [TCF agent](https://wiki.eclipse.org/TCF) running on Q7S
|
||||
|
||||
## Hardware Design
|
||||
|
||||
@ -102,7 +107,7 @@ When using Windows, run theses steps in MSYS2.
|
||||
|
||||
```sh
|
||||
mkdir build-Debug-Q7S && cd build-Debug-Q7S
|
||||
cmake -DTGT_BSP="arm/q7s" -DCMAKE_BUILD_TYPE=Debug -DOS_FSFW=linux ..
|
||||
cmake -DTGT_BSP="arm/q7s" -DCMAKE_BUILD_TYPE=Debug ..
|
||||
cmake --build . -j
|
||||
```
|
||||
|
||||
@ -117,8 +122,7 @@ When using Windows, run theses steps in MSYS2.
|
||||
This will invoke a Python script which in turn invokes CMake with the correct
|
||||
arguments to configure CMake for Q7S cross-compilation.
|
||||
|
||||
You can build the hosted variant of the OBSW by replacing `-DOS_FSFW=linux` with
|
||||
`-DOS_FSFW=host`. There are also different values for `-DTGT_BSP` to build for the Raspberry Pi
|
||||
There are also different values for `-DTGT_BSP` to build for the Raspberry Pi
|
||||
or the Beagle Bone Black: `arm/raspberrypi` and `arm/beagleboneblack`.
|
||||
|
||||
5. Build the software with
|
||||
@ -157,20 +161,47 @@ automatically.
|
||||
|
||||
### Q7S OBSW
|
||||
|
||||
The EIVE OBSW is the default target if no target is specified.
|
||||
|
||||
```sh
|
||||
mkdir build-Debug-Q7S && cd build-Debug-Q7S
|
||||
cmake -DTGT_BSP=arm/q7s -DFSFW_OSAL=linux -DCMAKE_BUILD_TYPE=Debug ..
|
||||
cmake -DTGT_BSP=arm/q7s -DCMAKE_BUILD_TYPE=Debug ..
|
||||
cmake --build . -j
|
||||
```
|
||||
|
||||
### Q7S Watchdog
|
||||
|
||||
To build the EIVE watchdog, the corresponding target must be specified in the build command.
|
||||
The configure steps do not need to be repeated if the folder has already been configured.
|
||||
|
||||
```sh
|
||||
mkdir build-Debug-Q7S && cd build-Debug-Q7S
|
||||
cmake -DTGT_BSP=arm/q7s -DFSFW_OSAL=linux -DEIVE_BUILD_WATCHDOG=ON -DCMAKE_BUILD_TYPE=Debug ..
|
||||
mkdir build-Debug-Watchdog && cd build-Debug-Watchdog
|
||||
cmake -DTGT_BSP=arm/q7s -DCMAKE_BUILD_TYPE=Debug ..
|
||||
cmake --build . --target eive-watchdog -j
|
||||
```
|
||||
|
||||
### Hosted
|
||||
|
||||
You can also use the FSFW OSAL `host` to build on Windows or for generic OSes.
|
||||
Note: Currently this is not supported.
|
||||
|
||||
```sh
|
||||
mkdir build-Debug-Host && cd build-Debug-Host
|
||||
cmake -DFSFW_OSAL=host -DCMAKE_BUILD_TYPE=Debug ..
|
||||
cmake --build . -j
|
||||
```
|
||||
|
||||
### Unittests
|
||||
|
||||
To build the unittests, the corresponding target must be specified in the build command.
|
||||
The configure steps do not need to be repeated if the folder has already been configured.
|
||||
|
||||
```sh
|
||||
mkdir build-Debug-Unittest && cd build-Debug-Unittest
|
||||
cmake ..
|
||||
cmake --build . --target eive-unittests -j
|
||||
```
|
||||
|
||||
## Connect to EIVE flatsat
|
||||
|
||||
### DNS
|
||||
@ -324,6 +355,33 @@ For Linux, you can also download a more recent version of the
|
||||
[Linaro 8.3.0 cross-compiler](https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-a/downloads)
|
||||
from [here](https://developer.arm.com/-/media/Files/downloads/gnu-a/8.3-2019.03/binrel/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf.tar.xz?revision=e09a1c45-0ed3-4a8e-b06b-db3978fd8d56&la=en&hash=93ED4444B8B3A812B893373B490B90BBB28FD2E3)
|
||||
|
||||
### Compatibility issues with wayland on more recent Linux distributions
|
||||
|
||||
If Vivado crashes and you find following lines in the `hs_err_pid*` files:
|
||||
|
||||
```sh
|
||||
#
|
||||
# An unexpected error has occurred (11)
|
||||
#
|
||||
Stack:
|
||||
/opt/Xilinx/Vivado/2017.4/tps/lnx64/jre/lib/amd64/server/libjvm.so(+0x923da9) [0x7f666cf5eda9]
|
||||
/opt/Xilinx/Vivado/2017.4/tps/lnx64/jre/lib/amd64/server/libjvm.so(JVM_handle_linux_signal+0xb6) [0x7f666cf653f6]
|
||||
/opt/Xilinx/Vivado/2017.4/tps/lnx64/jre/lib/amd64/server/libjvm.so(+0x9209d3) [0x7f666cf5b9d3]
|
||||
/lib/x86_64-linux-gnu/libc.so.6(+0x35fc0) [0x7f66a993efc0]
|
||||
/opt/Xilinx/Vivado/2017.4/tps/lnx64/jre/lib/amd64/libawt_xawt.so(+0x42028) [0x7f664e24d028]
|
||||
...
|
||||
```
|
||||
|
||||
You can [solve this](https://forums.xilinx.com/t5/Design-Entry/Bug-Vivado-2017-4-crashing-on-rightclick-in-console-log/td-p/881811)
|
||||
by logging in with `xorg` like specified [here](https://www.maketecheasier.com/switch-xorg-wayland-ubuntu1710/).
|
||||
|
||||
### Using `docnav` on more recent Linux versions
|
||||
|
||||
If you want to use `docnav` for navigating Xilinx documentation, it is recommended to install
|
||||
it as a standalone version from [here](https://www.xilinx.com/support/download/index.html/content/xilinx/en/downloadNav/documentation-nav.html).
|
||||
This is because the `docnav` installed as part of version 2018.2 requires `libpng12`, which is not part of
|
||||
more recent disitributions anymore.
|
||||
|
||||
## <a id="arm-toolchain"></a> Installing toolchain without Vivado
|
||||
|
||||
You can download the toolchains for Windows and Linux
|
||||
@ -384,12 +442,24 @@ Beagle Bone Black for download here
|
||||
Download it and unzip it somewhere in the Xilinx installation folder.
|
||||
You can use the following command if `wget` can be used or for CI/CD:
|
||||
|
||||
```
|
||||
wget https://eive-cloud.irs.uni-stuttgart.de/index.php/s/agnJGYeRf6fw2ci/download/cortexa9hf-neon-xiphos-linux-gnueabi.tar.gz
|
||||
```sh
|
||||
wget https://eive-cloud.irs.uni-stuttgart.de/index.php/s/SyXpdBBQX32xPgE/download/cortexa9hf-neon-xiphos-linux-gnueabi.tar.gz
|
||||
```
|
||||
|
||||
Then, create a new environmental variables `Q7S_SYSROOT` and set it to the local system root path.
|
||||
|
||||
### Updating system root for CI
|
||||
|
||||
If the system root is updated, it needs to be manually updated on the buggy file server.
|
||||
If access on `buggy.irs.uni-stuttgart.de` is possible with `ssh` and the rootfs in the cloud
|
||||
[was updated](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Software/rootfs&fileid=831849)
|
||||
as well, you can update the rootfs like this:
|
||||
|
||||
```sh
|
||||
cd /var/www/eive/tools
|
||||
wget https://eive-cloud.irs.uni-stuttgart.de/index.php/s/SyXpdBBQX32xPgE/download/cortexa9hf-neon-xiphos-linux-gnueabi.tar.gz
|
||||
```
|
||||
|
||||
## Setting up UNIX environment for real-time functionalities
|
||||
|
||||
Please note that on most UNIX environments (e.g. Ubuntu), the real time functionalities
|
||||
@ -487,10 +557,10 @@ ssh root@192.168.133.10
|
||||
```
|
||||
|
||||
If this has not been done yet, you can access the serial
|
||||
console of the Q7S like this to set it
|
||||
console of the Q7S like this
|
||||
|
||||
```sh
|
||||
picocom -b 115200 /dev/ttyUSB0
|
||||
picocom -b 115200 /dev/q7sSerial
|
||||
```
|
||||
|
||||
The flatsat has the aliases and shell scripts `q7s_ssh` and `q7s_serial` for this task as well.
|
||||
@ -527,6 +597,63 @@ alias or shell script to do this quickly.
|
||||
Note: When now setting up a debug session in the Xilinx SDK or Eclipse, the host must be set
|
||||
to localhost instead of the IP address of the Q7S.
|
||||
|
||||
# <a id="remote-reset"></a> Remote Reset
|
||||
1. Launch xilinx hardware server on flatsat with alias
|
||||
````
|
||||
launch-hwserver-xilinx
|
||||
````
|
||||
2. On host PC start xsc
|
||||
3. In xsct console type the follwing command to connect to the hardware server (replace </flatsat-pc-ip-address/> with the IP address of the flatsat PC. Can be found out with ifconfig)
|
||||
````
|
||||
connect -url tcp:</flatsat-pc-ip-address/>:3121
|
||||
````
|
||||
4. The following command will list all available devices
|
||||
````
|
||||
targets
|
||||
````
|
||||
5. Connect to the APU of the Q7S
|
||||
````
|
||||
target </APU-number/>
|
||||
````
|
||||
6. Perform reset
|
||||
````
|
||||
rst
|
||||
````
|
||||
|
||||
# <a id="tmtc-testing"></a> TMTC testing
|
||||
|
||||
The OBSW supports sending PUS TM packets via TCP or the PDEC IP Core which transmits the data as
|
||||
CADU frames. To make the CADU frames receivabel by the
|
||||
[TMTC porgram](https://egit.irs.uni-stuttgart.de/eive/eive-tmtc), a python script is running as
|
||||
`systemd` service named `tmtc_bridge` on the flatsat PC which forwards TCP commands to the TCP
|
||||
server of the OBC and reads CADU frames from a serial interface.
|
||||
|
||||
You can check whether the service is running the following command on the flatsat PC
|
||||
|
||||
```sh
|
||||
systemctl status tmtc_bridge
|
||||
```
|
||||
|
||||
The PUS packets transported with the CADU frames are extracted
|
||||
and forwared to the TMTC program's TCP client. The code of the TMTC bridge can be found
|
||||
[here](https://egit.irs.uni-stuttgart.de/eive/tmtc-bridge). To connect the TMTC program to the
|
||||
TMTC-bridge a port forwarding from a host must be set up with the following command:
|
||||
|
||||
```sh
|
||||
ssh -L 1537:127.0.0.1:7100 eive@2001:7c0:2018:1099:babe:0:e1fe:f1a5 -t bash
|
||||
```
|
||||
|
||||
You can print the output of the `systemd` service with
|
||||
|
||||
```sh
|
||||
journalctl -u tmtc_bridge
|
||||
```
|
||||
|
||||
This can be helpful to determine whether any TCs arrive or TMs are coming back.
|
||||
|
||||
Note: The encoding of the TM packets and conversion of CADU frames takes some time.
|
||||
Thus the replies are received with a larger delay compared to a direct TCP connection.
|
||||
|
||||
# <a id="direct-debugging"></a> Direct Debugging
|
||||
|
||||
1. Assign static IP address to Q7S
|
||||
@ -939,26 +1066,7 @@ cat file.bin | hexdump -v -n X
|
||||
|
||||
## Preparation of a fresh rootfs and SD card
|
||||
|
||||
This section summarizes important changes between a fresh rootfs and the current
|
||||
EIVE implementation
|
||||
|
||||
### rootfs
|
||||
|
||||
- Mount point `/mnt/sd0` created for SD card 0. Created with `mkdir`
|
||||
- Mount point `/mnt/sd1` created for SD card 1. Created with `mkdir`
|
||||
- Folder `scripts` in `/home/root` folder.
|
||||
- `scripts` folder currently contains a few shell helper scripts
|
||||
- Folder `profile.d` in `/etc` folder which contains the `path-set.sh` script
|
||||
which is sourced at software startup
|
||||
- Library `libwire.so` in `/usr/lib` folder
|
||||
|
||||
### SD Cards
|
||||
|
||||
- Folder `bin` for binaries, for example the OBSW
|
||||
- Folder `misc` for miscellaneous files. Contains `ls` for directory listings
|
||||
- Folder `tc` for telecommands
|
||||
- Folder `tm` for telemetry
|
||||
- Folder `xdi` for XDI components (e.g. for firmware or device tree updates)
|
||||
See [q7s-package repository README](https://egit.irs.uni-stuttgart.de/eive/q7s-package)
|
||||
|
||||
# <a id="static-code-analysis"></a> Running cppcheck on the Software
|
||||
|
||||
@ -1006,7 +1114,7 @@ The [TCF agent](https://wiki.eclipse.org/TCF) can be used to perform remote debu
|
||||
1. Install the TCF agent plugin in Eclipse from
|
||||
the [releases](https://www.eclipse.org/tcf/downloads.php). Go to
|
||||
Help → Install New Software and use the download page, for
|
||||
example https://download.eclipse.org/tools/tcf/releases/1.6/1.6.2/ to search for the plugin and install it.
|
||||
example https://download.eclipse.org/tools/tcf/releases/1.7/1.7.0/ to search for the plugin and install it. You can find the newest version [here](https://www.eclipse.org/tcf/downloads.php)
|
||||
|
||||
2. Go to Window → Perspective → Open Perspective and open the **Target Explorer Perspective**.
|
||||
Here, the Q7S should show up if the local port forwarding was set up as explained previously.
|
||||
@ -1045,6 +1153,38 @@ sudo apt-get install gpiod libgpiod-dev
|
||||
|
||||
to install the required GPIO libraries before cloning the system root folder.
|
||||
|
||||
# <a id="egse"></a> Running OBSW on EGSE
|
||||
The EGSE is a test system from arcsec build arround a raspberry pi 4 to test the star tracker. The IP address of the EGSE (raspberry pi) is 192.168.18.31. An ssh session can be opened with
|
||||
````
|
||||
ssh pi@192.168.18.31
|
||||
````
|
||||
Password: raspberry
|
||||
|
||||
To run the obsw perform the following steps:
|
||||
1. Build the cmake EGSE Configuration
|
||||
* the sysroots for the EGSE can be found [here](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Software/egse&fileid=1190471)
|
||||
* toolchain for linux host can be downloaded from [here](https://github.com/Pro/raspi-toolchain)
|
||||
* toolchain for windows host from [here](https://gnutoolchains.com/raspberry/) (the raspios-buster-armhf toolchain is the right one for the EGSE)
|
||||
2. Disable the ser2net systemd service on the EGSE
|
||||
````sh
|
||||
$ sudo systemctl stop ser2net.service
|
||||
````
|
||||
3. Power on the star tracker by running
|
||||
````sh
|
||||
$ ~/powerctrl/enable0.sh`
|
||||
````
|
||||
4. Run portforwarding script for tmtc tcp connection and tcf agent on host PC
|
||||
````sh
|
||||
$ ./scripts/egse-port.sh
|
||||
````
|
||||
5. The star tracker can be powered off by running
|
||||
````sh
|
||||
$ ~/powerctrl/disable0.sh
|
||||
````
|
||||
|
||||
# <a id="gpsd"></a> Manually preparing sysroots to compile gpsd
|
||||
Copy all header files from [here](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Software/gpsd&fileid=1189985) to the /usr/include directory and all static libraries to /usr/lib.
|
||||
|
||||
# <a id="fsfw"></a> Flight Software Framework (FSFW)
|
||||
|
||||
An EIVE fork of the FSFW is submodules into this repository.
|
||||
@ -1064,3 +1204,15 @@ git merge upstream/master
|
||||
|
||||
Alternatively, changes from other upstreams (forks) and branches can be merged like that
|
||||
in the same way.
|
||||
|
||||
# <a id="coding-style"></a> Coding Style
|
||||
* the formatting is based on the clang-format tools
|
||||
## Setting up eclipse auto-fromatter with clang-format
|
||||
1. Help → Install New Software → Add
|
||||
2. In location insert the link http://www.cppstyle.com/luna
|
||||
3. The software package CppStyle should now be available for installation
|
||||
4. On windows download the clang-formatting tools from https://llvm.org/builds/. On linux clang-format can be installed with the package manager.
|
||||
5. Navigate to Preferences → C/C++ → CppStyle
|
||||
6. Insert the path to the clang-format executable
|
||||
7. Under C/C++ → Code Style → Formatter, change the formatter to CppStyle (clang-format)
|
||||
8. Code can now be formatted with the clang tool by using the key combination Ctrl + Shift + f
|
||||
|
@ -2,7 +2,9 @@ FROM ubuntu:focal
|
||||
|
||||
RUN apt-get update
|
||||
RUN apt-get --yes upgrade
|
||||
RUN apt-get --yes install cmake libgpiod-dev xz-utils nano curl
|
||||
#tzdata is a dependency, won't install otherwise
|
||||
ARG DEBIAN_FRONTEND=noninteractive
|
||||
RUN apt-get --yes install cmake libgpiod-dev xz-utils nano curl git gcc g++ lcov valgrind libgps-dev
|
||||
|
||||
# Q7S root filesystem, required for cross-compilation.
|
||||
RUN mkdir -p /usr/rootfs; \
|
||||
@ -14,6 +16,5 @@ RUN mkdir -p /usr/tools; \
|
||||
curl https://buggy.irs.uni-stuttgart.de/eive/tools/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf.tar.gz \
|
||||
| tar -xz -C /usr/tools
|
||||
|
||||
|
||||
ENV Q7S_SYSROOT="/usr/rootfs/cortexa9hf-neon-xiphos-linux-gnueabi"
|
||||
ENV PATH=$PATH:"/usr/tools/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin"
|
52
automation/Jenkinsfile
vendored
52
automation/Jenkinsfile
vendored
@ -1,48 +1,36 @@
|
||||
pipeline {
|
||||
agent any
|
||||
environment {
|
||||
BUILDDIR_Q7 = 'build_q7'
|
||||
BUILDDIR_LINUX = 'build_linux'
|
||||
}
|
||||
agent {
|
||||
docker {
|
||||
image 'eive-obsw-ci:d2'
|
||||
args '--sysctl fs.mqueue.msg_max=100'
|
||||
}
|
||||
}
|
||||
stages {
|
||||
stage('Build Container') {
|
||||
when {
|
||||
changeset "automation/Dockerfile-q7s"
|
||||
branch 'develop'
|
||||
}
|
||||
steps {
|
||||
sh 'docker build -t eive-fsw-build-q7s:gcc8 - < automation/Dockerfile-q7s'
|
||||
|
||||
}
|
||||
}
|
||||
stage('Clean') {
|
||||
when {
|
||||
anyOf {
|
||||
changelog 'cleanCI'
|
||||
changeset '*.cmake'
|
||||
changeset 'CMakeLists.txt'
|
||||
}
|
||||
}
|
||||
steps {
|
||||
sh 'rm -rf build-q7s-debug'
|
||||
sh 'rm -rf $BUILDDIR_Q7'
|
||||
sh 'rm -rf $BUILDDIR_LINUX'
|
||||
}
|
||||
}
|
||||
stage('Build Q7S') {
|
||||
agent {
|
||||
docker {
|
||||
image 'eive-fsw-build-q7s:gcc8'
|
||||
reuseNode true
|
||||
}
|
||||
}
|
||||
steps {
|
||||
dir('build-q7s-debug') {
|
||||
sh 'cmake -DTGT_BSP="arm/q7s" -DCMAKE_BUILD_TYPE=Debug -DFSFW_OSAL=linux ..'
|
||||
dir(BUILDDIR_Q7) {
|
||||
sh 'cmake -DTGT_BSP="arm/q7s" -DCMAKE_BUILD_TYPE=Debug ..'
|
||||
sh 'cmake --build . -j'
|
||||
}
|
||||
}
|
||||
}
|
||||
stage('Deploy') {
|
||||
when {
|
||||
tag 'v*.*.*'
|
||||
}
|
||||
stage('Unittests') {
|
||||
steps {
|
||||
sh 'echo Deploying'
|
||||
dir(BUILDDIR_LINUX) {
|
||||
sh 'cmake ..'
|
||||
sh 'cmake --build . -t eive-unittest -j'
|
||||
sh './eive-unittest'
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
7
bsp_egse/CMakeLists.txt
Normal file
7
bsp_egse/CMakeLists.txt
Normal file
@ -0,0 +1,7 @@
|
||||
target_sources(${OBSW_NAME} PUBLIC
|
||||
InitMission.cpp
|
||||
main.cpp
|
||||
ObjectFactory.cpp
|
||||
)
|
||||
|
||||
add_subdirectory(boardconfig)
|
192
bsp_egse/InitMission.cpp
Normal file
192
bsp_egse/InitMission.cpp
Normal file
@ -0,0 +1,192 @@
|
||||
#include "InitMission.h"
|
||||
|
||||
#include <fsfw/objectmanager/ObjectManager.h>
|
||||
#include <fsfw/objectmanager/ObjectManagerIF.h>
|
||||
#include <fsfw/returnvalues/HasReturnvaluesIF.h>
|
||||
#include <fsfw/serviceinterface/ServiceInterface.h>
|
||||
#include <fsfw/tasks/FixedTimeslotTaskIF.h>
|
||||
#include <fsfw/tasks/PeriodicTaskIF.h>
|
||||
#include <fsfw/tasks/TaskFactory.h>
|
||||
#include <mission/utility/InitMission.h>
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include "OBSWConfig.h"
|
||||
#include "ObjectFactory.h"
|
||||
#include "objects/systemObjectList.h"
|
||||
#include "pollingsequence/pollingSequenceFactory.h"
|
||||
|
||||
ServiceInterfaceStream sif::debug("DEBUG");
|
||||
ServiceInterfaceStream sif::info("INFO");
|
||||
ServiceInterfaceStream sif::warning("WARNING");
|
||||
ServiceInterfaceStream sif::error("ERROR");
|
||||
|
||||
ObjectManagerIF* objectManager = nullptr;
|
||||
|
||||
void initmission::initMission() {
|
||||
sif::info << "Make sure the systemd service ser2net on the egse has been stopped "
|
||||
<< "(alias stop-ser2net)" << std::endl;
|
||||
sif::info << "Make sure the power lines of the star tracker have been enabled "
|
||||
<< "(alias enable-startracker)" << std::endl;
|
||||
sif::info << "Building global objects.." << std::endl;
|
||||
/* Instantiate global object manager and also create all objects */
|
||||
ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr);
|
||||
sif::info << "Initializing all objects.." << std::endl;
|
||||
ObjectManager::instance()->initialize();
|
||||
|
||||
/* This function creates and starts all tasks */
|
||||
initTasks();
|
||||
}
|
||||
|
||||
void initmission::initTasks() {
|
||||
TaskFactory* factory = TaskFactory::instance();
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
if (factory == nullptr) {
|
||||
/* Should never happen ! */
|
||||
return;
|
||||
}
|
||||
#if OBSW_PRINT_MISSED_DEADLINES == 1
|
||||
void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline;
|
||||
#else
|
||||
void (*missedDeadlineFunc)(void) = nullptr;
|
||||
#endif
|
||||
|
||||
/* TMTC Distribution */
|
||||
PeriodicTaskIF* tmtcDistributor = factory->createPeriodicTask(
|
||||
"DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
|
||||
result = tmtcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Object add component failed" << std::endl;
|
||||
}
|
||||
result = tmtcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Object add component failed" << std::endl;
|
||||
}
|
||||
result = tmtcDistributor->addComponent(objects::TM_FUNNEL);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Object add component failed" << std::endl;
|
||||
}
|
||||
|
||||
PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
|
||||
"TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
|
||||
result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Add component TMTC Bridge failed" << std::endl;
|
||||
}
|
||||
PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
|
||||
"TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
|
||||
result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Add component TMTC Polling failed" << std::endl;
|
||||
}
|
||||
|
||||
/* PUS Services */
|
||||
std::vector<PeriodicTaskIF*> pusTasks;
|
||||
createPusTasks(*factory, missedDeadlineFunc, pusTasks);
|
||||
|
||||
std::vector<PeriodicTaskIF*> pstTasks;
|
||||
FixedTimeslotTaskIF* pst = factory->createFixedTimeslotTask(
|
||||
"STAR_TRACKER_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
|
||||
result = pst::pstUart(pst);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
|
||||
}
|
||||
pstTasks.push_back(pst);
|
||||
|
||||
PeriodicTaskIF* strHelperTask = factory->createPeriodicTask(
|
||||
"STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
|
||||
result = strHelperTask->addComponent(objects::STR_HELPER);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("STR_HELPER", objects::STR_HELPER);
|
||||
}
|
||||
pstTasks.push_back(strHelperTask);
|
||||
|
||||
auto taskStarter = [](std::vector<PeriodicTaskIF*>& taskVector, std::string name) {
|
||||
for (const auto& task : taskVector) {
|
||||
if (task != nullptr) {
|
||||
task->startTask();
|
||||
} else {
|
||||
sif::error << "Task in vector " << name << " is invalid!" << std::endl;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
sif::info << "Starting tasks.." << std::endl;
|
||||
tmtcDistributor->startTask();
|
||||
tmtcBridgeTask->startTask();
|
||||
tmtcPollingTask->startTask();
|
||||
|
||||
taskStarter(pstTasks, "PST Tasks");
|
||||
taskStarter(pusTasks, "PUS Tasks");
|
||||
|
||||
sif::info << "Tasks started.." << std::endl;
|
||||
}
|
||||
|
||||
void initmission::createPusTasks(TaskFactory& factory,
|
||||
TaskDeadlineMissedFunction missedDeadlineFunc,
|
||||
std::vector<PeriodicTaskIF*>& taskVec) {
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
|
||||
"PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
|
||||
result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Object add component failed" << std::endl;
|
||||
}
|
||||
taskVec.push_back(pusVerification);
|
||||
|
||||
PeriodicTaskIF* pusEvents = factory.createPeriodicTask(
|
||||
"PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
|
||||
result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
|
||||
}
|
||||
result = pusEvents->addComponent(objects::EVENT_MANAGER);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
|
||||
}
|
||||
taskVec.push_back(pusEvents);
|
||||
|
||||
PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
|
||||
"PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
|
||||
result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
|
||||
}
|
||||
result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
|
||||
}
|
||||
taskVec.push_back(pusHighPrio);
|
||||
|
||||
PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
|
||||
"PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
|
||||
}
|
||||
taskVec.push_back(pusMedPrio);
|
||||
|
||||
PeriodicTaskIF* pusLowPrio = factory.createPeriodicTask(
|
||||
"PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
|
||||
result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
|
||||
}
|
||||
result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("INT_ERR_RPRT", objects::INTERNAL_ERROR_REPORTER);
|
||||
}
|
||||
taskVec.push_back(pusLowPrio);
|
||||
}
|
21
bsp_egse/InitMission.h
Normal file
21
bsp_egse/InitMission.h
Normal file
@ -0,0 +1,21 @@
|
||||
#ifndef BSP_LINUX_INITMISSION_H_
|
||||
#define BSP_LINUX_INITMISSION_H_
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include "fsfw/tasks/Typedef.h"
|
||||
|
||||
class PeriodicTaskIF;
|
||||
class TaskFactory;
|
||||
|
||||
namespace initmission {
|
||||
void initMission();
|
||||
void initTasks();
|
||||
|
||||
void createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
|
||||
std::vector<PeriodicTaskIF*>& taskVec);
|
||||
void createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
|
||||
std::vector<PeriodicTaskIF*>& taskVec);
|
||||
}; // namespace initmission
|
||||
|
||||
#endif /* BSP_LINUX_INITMISSION_H_ */
|
49
bsp_egse/ObjectFactory.cpp
Normal file
49
bsp_egse/ObjectFactory.cpp
Normal file
@ -0,0 +1,49 @@
|
||||
#include "ObjectFactory.h"
|
||||
|
||||
#include <devConf.h>
|
||||
#include <fsfw_hal/linux/uart/UartComIF.h>
|
||||
#include <fsfw_hal/linux/uart/UartCookie.h>
|
||||
#include <mission/devices/GPSHyperionHandler.h>
|
||||
|
||||
#include "OBSWConfig.h"
|
||||
#include "busConf.h"
|
||||
#include "fsfw/datapoollocal/LocalDataPoolManager.h"
|
||||
#include "fsfw/tmtcpacket/pus/tm.h"
|
||||
#include "fsfw/tmtcservices/CommandingServiceBase.h"
|
||||
#include "fsfw/tmtcservices/PusServiceBase.h"
|
||||
#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
|
||||
#include "linux/devices/startracker/StarTrackerHandler.h"
|
||||
#include "mission/core/GenericFactory.h"
|
||||
#include "mission/utility/TmFunnel.h"
|
||||
#include "objects/systemObjectList.h"
|
||||
#include "tmtc/apid.h"
|
||||
#include "tmtc/pusIds.h"
|
||||
|
||||
void Factory::setStaticFrameworkObjectIds() {
|
||||
PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
|
||||
PusServiceBase::packetDestination = objects::TM_FUNNEL;
|
||||
|
||||
CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
|
||||
CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
|
||||
|
||||
TmFunnel::downlinkDestination = objects::TMTC_BRIDGE;
|
||||
TmFunnel::storageDestination = objects::NO_OBJECT;
|
||||
|
||||
VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
|
||||
TmPacketBase::timeStamperId = objects::TIME_STAMPER;
|
||||
}
|
||||
|
||||
void ObjectFactory::produce(void* args) {
|
||||
Factory::setStaticFrameworkObjectIds();
|
||||
ObjectFactory::produceGenericObjects();
|
||||
|
||||
UartCookie* starTrackerCookie =
|
||||
new UartCookie(objects::STAR_TRACKER, egse::STAR_TRACKER_UART, UartModes::NON_CANONICAL,
|
||||
uart::STAR_TRACKER_BAUD, startracker::MAX_FRAME_SIZE * 2 + 2);
|
||||
new UartComIF(objects::UART_COM_IF);
|
||||
starTrackerCookie->setNoFixedSizeReply();
|
||||
StrHelper* strHelper = new StrHelper(objects::STR_HELPER);
|
||||
StarTrackerHandler* starTrackerHandler = new StarTrackerHandler(
|
||||
objects::STAR_TRACKER, objects::UART_COM_IF, starTrackerCookie, strHelper);
|
||||
starTrackerHandler->setStartUpImmediately();
|
||||
}
|
8
bsp_egse/ObjectFactory.h
Normal file
8
bsp_egse/ObjectFactory.h
Normal file
@ -0,0 +1,8 @@
|
||||
#ifndef BSP_LINUX_OBJECTFACTORY_H_
|
||||
#define BSP_LINUX_OBJECTFACTORY_H_
|
||||
|
||||
namespace ObjectFactory {
|
||||
void produce(void* args);
|
||||
}; // namespace ObjectFactory
|
||||
|
||||
#endif /* BSP_LINUX_OBJECTFACTORY_H_ */
|
7
bsp_egse/boardconfig/CMakeLists.txt
Normal file
7
bsp_egse/boardconfig/CMakeLists.txt
Normal file
@ -0,0 +1,7 @@
|
||||
target_sources(${OBSW_NAME} PRIVATE
|
||||
print.c
|
||||
)
|
||||
|
||||
target_include_directories(${OBSW_NAME} PUBLIC
|
||||
${CMAKE_CURRENT_SOURCE_DIR}
|
||||
)
|
8
bsp_egse/boardconfig/busConf.h
Normal file
8
bsp_egse/boardconfig/busConf.h
Normal file
@ -0,0 +1,8 @@
|
||||
#ifndef BSP_EGSE_BOARDCONFIG_BUSCONF_H_
|
||||
#define BSP_EGSE_BOARDCONFIG_BUSCONF_H_
|
||||
|
||||
namespace egse {
|
||||
static constexpr char STAR_TRACKER_UART[] = "/dev/serial0";
|
||||
}
|
||||
|
||||
#endif /* BSP_EGSE_BOARDCONFIG_BUSCONF_H_ */
|
38
bsp_egse/boardconfig/etl_profile.h
Normal file
38
bsp_egse/boardconfig/etl_profile.h
Normal file
@ -0,0 +1,38 @@
|
||||
///\file
|
||||
|
||||
/******************************************************************************
|
||||
The MIT License(MIT)
|
||||
|
||||
Embedded Template Library.
|
||||
https://github.com/ETLCPP/etl
|
||||
https://www.etlcpp.com
|
||||
|
||||
Copyright(c) 2019 jwellbelove
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files(the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions :
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
******************************************************************************/
|
||||
#ifndef __ETL_PROFILE_H__
|
||||
#define __ETL_PROFILE_H__
|
||||
|
||||
#define ETL_CHECK_PUSH_POP
|
||||
|
||||
#define ETL_CPP11_SUPPORTED 1
|
||||
#define ETL_NO_NULLPTR_SUPPORT 0
|
||||
|
||||
#endif
|
15
bsp_egse/boardconfig/gcov.h
Normal file
15
bsp_egse/boardconfig/gcov.h
Normal file
@ -0,0 +1,15 @@
|
||||
#ifndef LINUX_GCOV_H_
|
||||
#define LINUX_GCOV_H_
|
||||
#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
|
||||
|
||||
#ifdef GCOV
|
||||
extern "C" void __gcov_flush();
|
||||
#else
|
||||
void __gcov_flush() {
|
||||
sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if "
|
||||
"coverage information is desired.\n"
|
||||
<< std::flush;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* LINUX_GCOV_H_ */
|
10
bsp_egse/boardconfig/print.c
Normal file
10
bsp_egse/boardconfig/print.c
Normal file
@ -0,0 +1,10 @@
|
||||
#include <bsp_egse/boardconfig/print.h>
|
||||
#include <stdio.h>
|
||||
|
||||
void printChar(const char* character, bool errStream) {
|
||||
if (errStream) {
|
||||
putc(*character, stderr);
|
||||
return;
|
||||
}
|
||||
putc(*character, stdout);
|
||||
}
|
8
bsp_egse/boardconfig/print.h
Normal file
8
bsp_egse/boardconfig/print.h
Normal file
@ -0,0 +1,8 @@
|
||||
#ifndef HOSTED_BOARDCONFIG_PRINT_H_
|
||||
#define HOSTED_BOARDCONFIG_PRINT_H_
|
||||
|
||||
#include <stdbool.h>
|
||||
|
||||
void printChar(const char* character, bool errStream);
|
||||
|
||||
#endif /* HOSTED_BOARDCONFIG_PRINT_H_ */
|
6
bsp_egse/boardconfig/rpiConfig.h.in
Normal file
6
bsp_egse/boardconfig/rpiConfig.h.in
Normal file
@ -0,0 +1,6 @@
|
||||
#ifndef BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_
|
||||
#define BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
#endif /* BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_ */
|
28
bsp_egse/main.cpp
Normal file
28
bsp_egse/main.cpp
Normal file
@ -0,0 +1,28 @@
|
||||
#include <iostream>
|
||||
|
||||
#include "InitMission.h"
|
||||
#include "OBSWConfig.h"
|
||||
#include "OBSWVersion.h"
|
||||
#include "fsfw/FSFWVersion.h"
|
||||
#include "fsfw/tasks/TaskFactory.h"
|
||||
|
||||
/**
|
||||
* @brief This is the main program entry point for the egse (raspberry pi 4)
|
||||
* @return
|
||||
*/
|
||||
int main(void) {
|
||||
std::cout << "-- EIVE OBSW --" << std::endl;
|
||||
std::cout << "-- Compiled for EGSE from Arcsec"
|
||||
<< " --" << std::endl;
|
||||
std::cout << "-- OBSW " << SW_NAME << " v" << SW_VERSION << "." << SW_SUBVERSION << "."
|
||||
<< SW_REVISION << ", FSFW v" << FSFW_VERSION << "." << FSFW_SUBVERSION << FSFW_REVISION
|
||||
<< "--" << std::endl;
|
||||
std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
|
||||
|
||||
initmission::initMission();
|
||||
|
||||
for (;;) {
|
||||
/* Suspend main thread by sleeping it. */
|
||||
TaskFactory::delayTask(5000);
|
||||
}
|
||||
}
|
@ -1,4 +1,4 @@
|
||||
target_sources(${TARGET_NAME} PUBLIC
|
||||
target_sources(${OBSW_NAME} PUBLIC
|
||||
InitMission.cpp
|
||||
main.cpp
|
||||
ObjectFactory.cpp
|
||||
|
@ -1,20 +1,19 @@
|
||||
#include "InitMission.h"
|
||||
#include "ObjectFactory.h"
|
||||
|
||||
#include <OBSWConfig.h>
|
||||
|
||||
#include <fsfw/objectmanager/ObjectManager.h>
|
||||
#include <fsfw/objectmanager/ObjectManagerIF.h>
|
||||
#include <fsfw/returnvalues/HasReturnvaluesIF.h>
|
||||
#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
|
||||
#include <fsfw/objectmanager/ObjectManager.h>
|
||||
#include <fsfw/tasks/FixedTimeslotTaskIF.h>
|
||||
#include <fsfw/tasks/PeriodicTaskIF.h>
|
||||
#include <fsfw/tasks/TaskFactory.h>
|
||||
|
||||
#include <mission/utility/InitMission.h>
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include "ObjectFactory.h"
|
||||
|
||||
#ifdef LINUX
|
||||
ServiceInterfaceStream sif::debug("DEBUG");
|
||||
ServiceInterfaceStream sif::info("INFO");
|
||||
@ -27,7 +26,7 @@ ServiceInterfaceStream sif::warning("WARNING", true);
|
||||
ServiceInterfaceStream sif::error("ERROR", true, false, true);
|
||||
#endif
|
||||
|
||||
ObjectManagerIF *objectManager = nullptr;
|
||||
ObjectManagerIF* objectManager = nullptr;
|
||||
|
||||
void initmission::initMission() {
|
||||
sif::info << "Building global objects.." << std::endl;
|
||||
@ -42,30 +41,29 @@ void initmission::initMission() {
|
||||
|
||||
void initmission::initTasks() {
|
||||
TaskFactory* factory = TaskFactory::instance();
|
||||
if(factory == nullptr) {
|
||||
if (factory == nullptr) {
|
||||
/* Should never happen ! */
|
||||
return;
|
||||
}
|
||||
#if OBSW_PRINT_MISSED_DEADLINES == 1
|
||||
void (*missedDeadlineFunc) (void) = TaskFactory::printMissedDeadline;
|
||||
void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline;
|
||||
#else
|
||||
void (*missedDeadlineFunc) (void) = nullptr;
|
||||
void (*missedDeadlineFunc)(void) = nullptr;
|
||||
#endif
|
||||
|
||||
/* TMTC Distribution */
|
||||
PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
|
||||
"DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
|
||||
ReturnValue_t result = tmTcDistributor->addComponent(
|
||||
objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK){
|
||||
ReturnValue_t result = tmTcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Object add component failed" << std::endl;
|
||||
}
|
||||
result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK){
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Object add component failed" << std::endl;
|
||||
}
|
||||
result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Object add component failed" << std::endl;
|
||||
}
|
||||
|
||||
@ -73,13 +71,13 @@ void initmission::initTasks() {
|
||||
PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
|
||||
"TMTC_UNIX_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
|
||||
result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Add component UDP Unix Bridge failed" << std::endl;
|
||||
}
|
||||
PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
|
||||
"UDP_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
|
||||
result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Add component UDP Polling failed" << std::endl;
|
||||
}
|
||||
|
||||
@ -87,47 +85,47 @@ void initmission::initTasks() {
|
||||
PeriodicTaskIF* pusVerification = factory->createPeriodicTask(
|
||||
"PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
|
||||
result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK){
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Object add component failed" << std::endl;
|
||||
}
|
||||
|
||||
PeriodicTaskIF* pusEvents = factory->createPeriodicTask(
|
||||
"PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
|
||||
result = pusVerification->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK){
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS5", objects::PUS_SERVICE_5_EVENT_REPORTING);
|
||||
}
|
||||
|
||||
PeriodicTaskIF* pusHighPrio = factory->createPeriodicTask(
|
||||
"PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
|
||||
result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
|
||||
}
|
||||
result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
|
||||
}
|
||||
|
||||
PeriodicTaskIF* pusMedPrio = factory->createPeriodicTask(
|
||||
"PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
|
||||
}
|
||||
|
||||
PeriodicTaskIF* pusLowPrio = factory->createPeriodicTask(
|
||||
"PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
|
||||
result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
|
||||
}
|
||||
|
||||
@ -135,7 +133,7 @@ void initmission::initTasks() {
|
||||
"TEST_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
|
||||
#if OBSW_ADD_TEST_CODE == 1
|
||||
result = testTask->addComponent(objects::TEST_TASK);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
|
||||
}
|
||||
#endif /* OBSW_ADD_TEST_CODE == 1 */
|
||||
|
@ -4,6 +4,6 @@
|
||||
namespace initmission {
|
||||
void initMission();
|
||||
void initTasks();
|
||||
};
|
||||
}; // namespace initmission
|
||||
|
||||
#endif /* BSP_LINUX_INITMISSION_H_ */
|
||||
|
@ -1,14 +1,14 @@
|
||||
#include "ObjectFactory.h"
|
||||
#include "OBSWConfig.h"
|
||||
|
||||
#include <fsfw/tmtcservices/CommandingServiceBase.h>
|
||||
#include <fsfw/tmtcservices/PusServiceBase.h>
|
||||
#include <mission/core/GenericFactory.h>
|
||||
#include <mission/utility/TmFunnel.h>
|
||||
#include <objects/systemObjectList.h>
|
||||
#include <tmtc/apid.h>
|
||||
#include <tmtc/pusIds.h>
|
||||
|
||||
#include <fsfw/tmtcservices/CommandingServiceBase.h>
|
||||
#include <fsfw/tmtcservices/PusServiceBase.h>
|
||||
|
||||
#include <mission/core/GenericFactory.h>
|
||||
#include <mission/utility/TmFunnel.h>
|
||||
#include "OBSWConfig.h"
|
||||
|
||||
#if OBSW_USE_TMTC_TCP_BRIDGE == 0
|
||||
#include "fsfw/osal/common/UdpTcPollingTask.h"
|
||||
@ -20,12 +20,11 @@
|
||||
|
||||
#include <fsfw/tmtcpacket/pus/tm.h>
|
||||
|
||||
|
||||
#if OBSW_ADD_TEST_CODE == 1
|
||||
#include <test/testtasks/TestTask.h>
|
||||
#endif
|
||||
|
||||
void Factory::setStaticFrameworkObjectIds(){
|
||||
void Factory::setStaticFrameworkObjectIds() {
|
||||
PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
|
||||
PusServiceBase::packetDestination = objects::TM_FUNNEL;
|
||||
|
||||
@ -40,22 +39,9 @@ void Factory::setStaticFrameworkObjectIds(){
|
||||
TmPacketBase::timeStamperId = objects::TIME_STAMPER;
|
||||
}
|
||||
|
||||
void ObjectFactory::produce(void* args){
|
||||
void ObjectFactory::produce(void* args) {
|
||||
Factory::setStaticFrameworkObjectIds();
|
||||
ObjectFactory::produceGenericObjects();
|
||||
|
||||
#if OBSW_USE_TMTC_TCP_BRIDGE == 0
|
||||
sif::info << "Setting up UDP TMTC bridge with listener port " <<
|
||||
UdpTmTcBridge::DEFAULT_SERVER_PORT << std::endl;
|
||||
new UdpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
new UdpTcPollingTask(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
|
||||
#else
|
||||
sif::info << "Setting up TCP TMTC bridge with listener port " <<
|
||||
TcpTmTcServer::DEFAULT_SERVER_PORT << std::endl;
|
||||
new TcpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
new TcpTmTcServer(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
|
||||
#endif
|
||||
|
||||
new TestTask(objects::TEST_TASK);
|
||||
|
||||
}
|
||||
|
@ -1,10 +1,9 @@
|
||||
#ifndef BSP_LINUX_OBJECTFACTORY_H_
|
||||
#define BSP_LINUX_OBJECTFACTORY_H_
|
||||
|
||||
|
||||
namespace ObjectFactory {
|
||||
void setStatics();
|
||||
void produce(void* args);
|
||||
};
|
||||
void setStatics();
|
||||
void produce(void* args);
|
||||
}; // namespace ObjectFactory
|
||||
|
||||
#endif /* BSP_LINUX_OBJECTFACTORY_H_ */
|
||||
|
@ -1,8 +1,8 @@
|
||||
target_sources(${TARGET_NAME} PRIVATE
|
||||
target_sources(${OBSW_NAME} PRIVATE
|
||||
print.c
|
||||
)
|
||||
|
||||
target_include_directories(${TARGET_NAME} PUBLIC
|
||||
target_include_directories(${OBSW_NAME} PUBLIC
|
||||
${CMAKE_CURRENT_SOURCE_DIR}
|
||||
)
|
||||
|
||||
|
@ -7,7 +7,8 @@ extern "C" void __gcov_flush();
|
||||
#else
|
||||
void __gcov_flush() {
|
||||
sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if "
|
||||
"coverage information is desired.\n" << std::flush;
|
||||
"coverage information is desired.\n"
|
||||
<< std::flush;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
@ -3,13 +3,9 @@
|
||||
#include <stdio.h>
|
||||
|
||||
void printChar(const char* character, bool errStream) {
|
||||
if(errStream) {
|
||||
if (errStream) {
|
||||
putc(*character, stderr);
|
||||
return;
|
||||
}
|
||||
putc(*character, stdout);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
@ -1,32 +1,31 @@
|
||||
#include "ArduinoComIF.h"
|
||||
#include "ArduinoCookie.h"
|
||||
|
||||
#include <fsfw/globalfunctions/DleEncoder.h>
|
||||
#include <fsfw/globalfunctions/CRC.h>
|
||||
#include <fsfw/globalfunctions/DleEncoder.h>
|
||||
#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
|
||||
|
||||
#include "ArduinoCookie.h"
|
||||
|
||||
// This only works on Linux
|
||||
#ifdef LINUX
|
||||
#include <termios.h>
|
||||
#include <fcntl.h>
|
||||
#include <termios.h>
|
||||
#include <unistd.h>
|
||||
#elif WIN32
|
||||
#include <windows.h>
|
||||
#include <strsafe.h>
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
#include <cstring>
|
||||
|
||||
ArduinoComIF::ArduinoComIF(object_id_t setObjectId, bool promptComIF,
|
||||
const char *serialDevice):
|
||||
rxBuffer(MAX_PACKET_SIZE * MAX_NUMBER_OF_SPI_DEVICES*10, true),
|
||||
SystemObject(setObjectId) {
|
||||
ArduinoComIF::ArduinoComIF(object_id_t setObjectId, bool promptComIF, const char *serialDevice)
|
||||
: rxBuffer(MAX_PACKET_SIZE * MAX_NUMBER_OF_SPI_DEVICES * 10, true), SystemObject(setObjectId) {
|
||||
#ifdef LINUX
|
||||
initialized = false;
|
||||
serialPort = ::open("/dev/ttyUSB0", O_RDWR);
|
||||
|
||||
if (serialPort < 0) {
|
||||
//configuration error
|
||||
// configuration error
|
||||
printf("Error %i from open: %s\n", errno, strerror(errno));
|
||||
return;
|
||||
}
|
||||
@ -44,73 +43,64 @@ ArduinoComIF::ArduinoComIF(object_id_t setObjectId, bool promptComIF,
|
||||
tty.c_cflag &= ~CSTOPB; // Clear stop field, only one stop bit used in communication
|
||||
tty.c_cflag |= CS8; // 8 bits per byte
|
||||
tty.c_cflag &= ~CRTSCTS; // Disable RTS/CTS hardware flow control
|
||||
tty.c_lflag &= ~ICANON; //Disable Canonical Mode
|
||||
tty.c_lflag &= ~ICANON; // Disable Canonical Mode
|
||||
tty.c_oflag &= ~OPOST; // Prevent special interpretation of output bytes (e.g. newline chars)
|
||||
tty.c_oflag &= ~ONLCR; // Prevent conversion of newline to carriage return/line feed
|
||||
tty.c_cc[VTIME] = 0; // Non Blocking
|
||||
tty.c_cc[VMIN] = 0;
|
||||
|
||||
cfsetispeed(&tty, B9600); //Baudrate
|
||||
cfsetispeed(&tty, B9600); // Baudrate
|
||||
|
||||
if (tcsetattr(serialPort, TCSANOW, &tty) != 0) {
|
||||
//printf("Error %i from tcsetattr: %s\n", errno, strerror(errno));
|
||||
// printf("Error %i from tcsetattr: %s\n", errno, strerror(errno));
|
||||
return;
|
||||
}
|
||||
|
||||
initialized = true;
|
||||
#elif WIN32
|
||||
DCB serialParams = { 0 };
|
||||
DCB serialParams = {0};
|
||||
|
||||
// we need to ask the COM port from the user.
|
||||
if(promptComIF) {
|
||||
if (promptComIF) {
|
||||
sif::info << "Please enter the COM port (c to cancel): " << std::flush;
|
||||
std::string comPort;
|
||||
while(hCom == INVALID_HANDLE_VALUE) {
|
||||
|
||||
while (hCom == INVALID_HANDLE_VALUE) {
|
||||
std::getline(std::cin, comPort);
|
||||
if(comPort[0] == 'c') {
|
||||
if (comPort[0] == 'c') {
|
||||
break;
|
||||
}
|
||||
const TCHAR *pcCommPort = comPort.c_str();
|
||||
hCom = CreateFileA(pcCommPort, //port name
|
||||
GENERIC_READ | GENERIC_WRITE, //Read/Write
|
||||
hCom = CreateFileA(pcCommPort, // port name
|
||||
GENERIC_READ | GENERIC_WRITE, // Read/Write
|
||||
0, // No Sharing
|
||||
NULL, // No Security
|
||||
OPEN_EXISTING,// Open existing port only
|
||||
OPEN_EXISTING, // Open existing port only
|
||||
0, // Non Overlapped I/O
|
||||
NULL); // Null for Comm Devices
|
||||
|
||||
if (hCom == INVALID_HANDLE_VALUE)
|
||||
{
|
||||
if(GetLastError() == 2) {
|
||||
if (hCom == INVALID_HANDLE_VALUE) {
|
||||
if (GetLastError() == 2) {
|
||||
sif::error << "COM Port does not found!" << std::endl;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
TCHAR err[128];
|
||||
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL,
|
||||
GetLastError(),
|
||||
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
||||
err, sizeof(err), NULL);
|
||||
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(),
|
||||
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), err, sizeof(err), NULL);
|
||||
// Handle the error.
|
||||
sif::info << "CreateFileA Error code: " << GetLastError()
|
||||
<< std::endl;
|
||||
sif::info << "CreateFileA Error code: " << GetLastError() << std::endl;
|
||||
sif::error << err << std::flush;
|
||||
}
|
||||
sif::info << "Please enter a valid COM port: " << std::flush;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
serialParams.DCBlength = sizeof(serialParams);
|
||||
if(baudRate == 9600) {
|
||||
if (baudRate == 9600) {
|
||||
serialParams.BaudRate = CBR_9600;
|
||||
}
|
||||
if(baudRate == 115200) {
|
||||
if (baudRate == 115200) {
|
||||
serialParams.BaudRate = CBR_115200;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
serialParams.BaudRate = baudRate;
|
||||
}
|
||||
|
||||
@ -119,7 +109,7 @@ ArduinoComIF::ArduinoComIF(object_id_t setObjectId, bool promptComIF,
|
||||
serialParams.StopBits = ONESTOPBIT;
|
||||
SetCommState(hCom, &serialParams);
|
||||
|
||||
COMMTIMEOUTS timeout = { 0 };
|
||||
COMMTIMEOUTS timeout = {0};
|
||||
// This will set the read operation to be blocking until data is received
|
||||
// and then read continuously until there is a gap of one millisecond.
|
||||
timeout.ReadIntervalTimeout = 1;
|
||||
@ -139,36 +129,29 @@ ArduinoComIF::~ArduinoComIF() {
|
||||
CloseHandle(hCom);
|
||||
#endif
|
||||
}
|
||||
ReturnValue_t ArduinoComIF::initializeInterface(CookieIF * cookie) {
|
||||
ReturnValue_t ArduinoComIF::initializeInterface(CookieIF *cookie) {
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t ArduinoComIF::sendMessage(CookieIF *cookie, const uint8_t *data,
|
||||
size_t len) {
|
||||
ArduinoCookie *arduinoCookie = dynamic_cast<ArduinoCookie*>(cookie);
|
||||
ReturnValue_t ArduinoComIF::sendMessage(CookieIF *cookie, const uint8_t *data, size_t len) {
|
||||
ArduinoCookie *arduinoCookie = dynamic_cast<ArduinoCookie *>(cookie);
|
||||
if (arduinoCookie == nullptr) {
|
||||
return INVALID_COOKIE_TYPE;
|
||||
}
|
||||
|
||||
return sendMessage(arduinoCookie->command, arduinoCookie->address, data,
|
||||
len);
|
||||
return sendMessage(arduinoCookie->command, arduinoCookie->address, data, len);
|
||||
}
|
||||
|
||||
ReturnValue_t ArduinoComIF::getSendSuccess(CookieIF *cookie) {
|
||||
ReturnValue_t ArduinoComIF::getSendSuccess(CookieIF *cookie) { return RETURN_OK; }
|
||||
|
||||
ReturnValue_t ArduinoComIF::requestReceiveMessage(CookieIF *cookie, size_t requestLen) {
|
||||
return RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t ArduinoComIF::requestReceiveMessage(CookieIF *cookie,
|
||||
size_t requestLen) {
|
||||
return RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t ArduinoComIF::readReceivedMessage(CookieIF *cookie,
|
||||
uint8_t **buffer, size_t *size) {
|
||||
|
||||
ReturnValue_t ArduinoComIF::readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) {
|
||||
handleSerialPortRx();
|
||||
|
||||
ArduinoCookie *arduinoCookie = dynamic_cast<ArduinoCookie*>(cookie);
|
||||
ArduinoCookie *arduinoCookie = dynamic_cast<ArduinoCookie *>(cookie);
|
||||
if (arduinoCookie == nullptr) {
|
||||
return INVALID_COOKIE_TYPE;
|
||||
}
|
||||
@ -178,13 +161,13 @@ ReturnValue_t ArduinoComIF::readReceivedMessage(CookieIF *cookie,
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t ArduinoComIF::sendMessage(uint8_t command,
|
||||
uint8_t address, const uint8_t *data, size_t dataLen) {
|
||||
ReturnValue_t ArduinoComIF::sendMessage(uint8_t command, uint8_t address, const uint8_t *data,
|
||||
size_t dataLen) {
|
||||
if (dataLen > UINT16_MAX) {
|
||||
return TOO_MUCH_DATA;
|
||||
}
|
||||
|
||||
//being conservative here
|
||||
// being conservative here
|
||||
uint8_t sendBuffer[(dataLen + 6) * 2 + 2];
|
||||
|
||||
sendBuffer[0] = DleEncoder::STX_CHAR;
|
||||
@ -193,61 +176,59 @@ ReturnValue_t ArduinoComIF::sendMessage(uint8_t command,
|
||||
size_t remainingLen = sizeof(sendBuffer) - 1;
|
||||
size_t encodedLen = 0;
|
||||
|
||||
ReturnValue_t result = DleEncoder::encode(&command, 1, currentPosition,
|
||||
remainingLen, &encodedLen, false);
|
||||
ReturnValue_t result =
|
||||
DleEncoder::encode(&command, 1, currentPosition, remainingLen, &encodedLen, false);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
currentPosition += encodedLen;
|
||||
remainingLen -= encodedLen; //DleEncoder will never return encodedLen > remainingLen
|
||||
remainingLen -= encodedLen; // DleEncoder will never return encodedLen > remainingLen
|
||||
|
||||
result = DleEncoder::encode(&address, 1, currentPosition, remainingLen,
|
||||
&encodedLen, false);
|
||||
result = DleEncoder::encode(&address, 1, currentPosition, remainingLen, &encodedLen, false);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
currentPosition += encodedLen;
|
||||
remainingLen -= encodedLen; //DleEncoder will never return encodedLen > remainingLen
|
||||
remainingLen -= encodedLen; // DleEncoder will never return encodedLen > remainingLen
|
||||
|
||||
uint8_t temporaryBuffer[2];
|
||||
|
||||
//note to Lukas: yes we _could_ use Serialize here, but for 16 bit it is a bit too much...
|
||||
temporaryBuffer[0] = dataLen >> 8; //we checked dataLen above
|
||||
// note to Lukas: yes we _could_ use Serialize here, but for 16 bit it is a bit too much...
|
||||
temporaryBuffer[0] = dataLen >> 8; // we checked dataLen above
|
||||
temporaryBuffer[1] = dataLen;
|
||||
|
||||
result = DleEncoder::encode(temporaryBuffer, 2, currentPosition,
|
||||
remainingLen, &encodedLen, false);
|
||||
result =
|
||||
DleEncoder::encode(temporaryBuffer, 2, currentPosition, remainingLen, &encodedLen, false);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
currentPosition += encodedLen;
|
||||
remainingLen -= encodedLen; //DleEncoder will never return encodedLen > remainingLen
|
||||
remainingLen -= encodedLen; // DleEncoder will never return encodedLen > remainingLen
|
||||
|
||||
//encoding the actual data
|
||||
result = DleEncoder::encode(data, dataLen, currentPosition, remainingLen,
|
||||
&encodedLen, false);
|
||||
// encoding the actual data
|
||||
result = DleEncoder::encode(data, dataLen, currentPosition, remainingLen, &encodedLen, false);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
currentPosition += encodedLen;
|
||||
remainingLen -= encodedLen; //DleEncoder will never return encodedLen > remainingLen
|
||||
remainingLen -= encodedLen; // DleEncoder will never return encodedLen > remainingLen
|
||||
|
||||
uint16_t crc = CRC::crc16ccitt(&command, 1);
|
||||
crc = CRC::crc16ccitt(&address, 1, crc);
|
||||
//fortunately the length is still there
|
||||
// fortunately the length is still there
|
||||
crc = CRC::crc16ccitt(temporaryBuffer, 2, crc);
|
||||
crc = CRC::crc16ccitt(data, dataLen, crc);
|
||||
|
||||
temporaryBuffer[0] = crc >> 8;
|
||||
temporaryBuffer[1] = crc;
|
||||
|
||||
result = DleEncoder::encode(temporaryBuffer, 2, currentPosition,
|
||||
remainingLen, &encodedLen, false);
|
||||
result =
|
||||
DleEncoder::encode(temporaryBuffer, 2, currentPosition, remainingLen, &encodedLen, false);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
currentPosition += encodedLen;
|
||||
remainingLen -= encodedLen; //DleEncoder will never return encodedLen > remainingLen
|
||||
remainingLen -= encodedLen; // DleEncoder will never return encodedLen > remainingLen
|
||||
|
||||
if (remainingLen > 0) {
|
||||
*currentPosition = DleEncoder::ETX_CHAR;
|
||||
@ -259,12 +240,12 @@ ReturnValue_t ArduinoComIF::sendMessage(uint8_t command,
|
||||
#ifdef LINUX
|
||||
ssize_t writtenlen = ::write(serialPort, sendBuffer, encodedLen);
|
||||
if (writtenlen < 0) {
|
||||
//we could try to find out what happened...
|
||||
// we could try to find out what happened...
|
||||
return RETURN_FAILED;
|
||||
}
|
||||
if (writtenlen != encodedLen) {
|
||||
//the OS failed us, we do not try to block until everything is written, as
|
||||
//we can not block the whole system here
|
||||
// the OS failed us, we do not try to block until everything is written, as
|
||||
// we can not block the whole system here
|
||||
return RETURN_FAILED;
|
||||
}
|
||||
return RETURN_OK;
|
||||
@ -279,8 +260,7 @@ void ArduinoComIF::handleSerialPortRx() {
|
||||
|
||||
uint8_t dataFromSerial[availableSpace];
|
||||
|
||||
ssize_t bytesRead = read(serialPort, dataFromSerial,
|
||||
sizeof(dataFromSerial));
|
||||
ssize_t bytesRead = read(serialPort, dataFromSerial, sizeof(dataFromSerial));
|
||||
|
||||
if (bytesRead < 0) {
|
||||
return;
|
||||
@ -292,18 +272,17 @@ void ArduinoComIF::handleSerialPortRx() {
|
||||
|
||||
uint32_t dataLenReceivedSoFar = 0;
|
||||
|
||||
rxBuffer.readData(dataReceivedSoFar, sizeof(dataReceivedSoFar), true,
|
||||
&dataLenReceivedSoFar);
|
||||
rxBuffer.readData(dataReceivedSoFar, sizeof(dataReceivedSoFar), true, &dataLenReceivedSoFar);
|
||||
|
||||
//look for STX
|
||||
// look for STX
|
||||
size_t firstSTXinRawData = 0;
|
||||
while ((firstSTXinRawData < dataLenReceivedSoFar)
|
||||
&& (dataReceivedSoFar[firstSTXinRawData] != DleEncoder::STX_CHAR)) {
|
||||
while ((firstSTXinRawData < dataLenReceivedSoFar) &&
|
||||
(dataReceivedSoFar[firstSTXinRawData] != DleEncoder::STX_CHAR)) {
|
||||
firstSTXinRawData++;
|
||||
}
|
||||
|
||||
if (dataReceivedSoFar[firstSTXinRawData] != DleEncoder::STX_CHAR) {
|
||||
//there is no STX in our data, throw it away...
|
||||
// there is no STX in our data, throw it away...
|
||||
rxBuffer.deleteData(dataLenReceivedSoFar);
|
||||
return;
|
||||
}
|
||||
@ -313,10 +292,9 @@ void ArduinoComIF::handleSerialPortRx() {
|
||||
|
||||
size_t readSize = 0;
|
||||
|
||||
ReturnValue_t result = DleEncoder::decode(
|
||||
dataReceivedSoFar + firstSTXinRawData,
|
||||
dataLenReceivedSoFar - firstSTXinRawData, &readSize, packet,
|
||||
sizeof(packet), &packetLen);
|
||||
ReturnValue_t result = DleEncoder::decode(dataReceivedSoFar + firstSTXinRawData,
|
||||
dataLenReceivedSoFar - firstSTXinRawData, &readSize,
|
||||
packet, sizeof(packet), &packetLen);
|
||||
|
||||
size_t toDelete = firstSTXinRawData;
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
@ -327,20 +305,18 @@ void ArduinoComIF::handleSerialPortRx() {
|
||||
toDelete += readSize;
|
||||
}
|
||||
|
||||
//remove Data which was processed
|
||||
// remove Data which was processed
|
||||
rxBuffer.deleteData(toDelete);
|
||||
#elif WIN32
|
||||
#endif
|
||||
}
|
||||
|
||||
void ArduinoComIF::setBaudrate(uint32_t baudRate) {
|
||||
this->baudRate = baudRate;
|
||||
}
|
||||
void ArduinoComIF::setBaudrate(uint32_t baudRate) { this->baudRate = baudRate; }
|
||||
|
||||
void ArduinoComIF::handlePacket(uint8_t *packet, size_t packetLen) {
|
||||
uint16_t crc = CRC::crc16ccitt(packet, packetLen);
|
||||
if (crc != 0) {
|
||||
//CRC error
|
||||
// CRC error
|
||||
return;
|
||||
}
|
||||
|
||||
@ -350,26 +326,25 @@ void ArduinoComIF::handlePacket(uint8_t *packet, size_t packetLen) {
|
||||
uint16_t size = (packet[2] << 8) + packet[3];
|
||||
|
||||
if (size != packetLen - 6) {
|
||||
//Invalid Length
|
||||
// Invalid Length
|
||||
return;
|
||||
}
|
||||
|
||||
switch (command) {
|
||||
case ArduinoCookie::SPI: {
|
||||
//ArduinoCookie **itsComplicated;
|
||||
// ArduinoCookie **itsComplicated;
|
||||
auto findIter = spiMap.find(address);
|
||||
if (findIter == spiMap.end()) {
|
||||
//we do no know this address
|
||||
// we do no know this address
|
||||
return;
|
||||
}
|
||||
ArduinoCookie& cookie = findIter->second;
|
||||
ArduinoCookie &cookie = findIter->second;
|
||||
if (packetLen > cookie.maxReplySize + 6) {
|
||||
packetLen = cookie.maxReplySize + 6;
|
||||
}
|
||||
std::memcpy(cookie.replyBuffer.data(), packet + 4, packetLen - 6);
|
||||
cookie.receivedDataLen = packetLen - 6;
|
||||
}
|
||||
break;
|
||||
} break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
|
@ -4,8 +4,8 @@
|
||||
#include <fsfw/container/FixedMap.h>
|
||||
#include <fsfw/container/SimpleRingBuffer.h>
|
||||
#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
|
||||
#include <fsfw/returnvalues/HasReturnvaluesIF.h>
|
||||
#include <fsfw/objectmanager/SystemObject.h>
|
||||
#include <fsfw/returnvalues/HasReturnvaluesIF.h>
|
||||
|
||||
#include <cstdint>
|
||||
#include <map>
|
||||
@ -14,12 +14,11 @@
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
//Forward declaration, so users don't peek
|
||||
// Forward declaration, so users don't peek
|
||||
class ArduinoCookie;
|
||||
|
||||
class ArduinoComIF: public SystemObject,
|
||||
public DeviceCommunicationIF {
|
||||
public:
|
||||
class ArduinoComIF : public SystemObject, public DeviceCommunicationIF {
|
||||
public:
|
||||
static const uint8_t MAX_NUMBER_OF_SPI_DEVICES = 8;
|
||||
static const uint8_t MAX_PACKET_SIZE = 64;
|
||||
|
||||
@ -33,16 +32,15 @@ public:
|
||||
virtual ~ArduinoComIF();
|
||||
|
||||
/** DeviceCommunicationIF overrides */
|
||||
virtual ReturnValue_t initializeInterface(CookieIF * cookie) override;
|
||||
virtual ReturnValue_t sendMessage(CookieIF *cookie,
|
||||
const uint8_t * sendData, size_t sendLen) override;
|
||||
virtual ReturnValue_t initializeInterface(CookieIF *cookie) override;
|
||||
virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t *sendData,
|
||||
size_t sendLen) override;
|
||||
virtual ReturnValue_t getSendSuccess(CookieIF *cookie) override;
|
||||
virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie,
|
||||
size_t requestLen) override;
|
||||
virtual ReturnValue_t readReceivedMessage(CookieIF *cookie,
|
||||
uint8_t **buffer, size_t *size) override;
|
||||
virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) override;
|
||||
virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
|
||||
size_t *size) override;
|
||||
|
||||
private:
|
||||
private:
|
||||
#ifdef LINUX
|
||||
#elif WIN32
|
||||
HANDLE hCom = INVALID_HANDLE_VALUE;
|
||||
@ -54,13 +52,12 @@ private:
|
||||
// Default baud rate is 9600 for now.
|
||||
uint32_t baudRate = 9600;
|
||||
|
||||
//used to know where to put the data if a reply is received
|
||||
// used to know where to put the data if a reply is received
|
||||
std::map<uint8_t, ArduinoCookie> spiMap;
|
||||
|
||||
SimpleRingBuffer rxBuffer;
|
||||
|
||||
ReturnValue_t sendMessage(uint8_t command, uint8_t address,
|
||||
const uint8_t *data, size_t dataLen);
|
||||
ReturnValue_t sendMessage(uint8_t command, uint8_t address, const uint8_t *data, size_t dataLen);
|
||||
void handleSerialPortRx();
|
||||
|
||||
void handlePacket(uint8_t *packet, size_t packetLen);
|
||||
|
@ -1,8 +1,8 @@
|
||||
#include <bsp_hosted/comIF/ArduinoCookie.h>
|
||||
|
||||
ArduinoCookie::ArduinoCookie(Protocol_t protocol, uint8_t address,
|
||||
const size_t maxReplySize) :
|
||||
protocol(protocol), command(protocol), address(address),
|
||||
maxReplySize(maxReplySize), replyBuffer(maxReplySize) {
|
||||
}
|
||||
|
||||
ArduinoCookie::ArduinoCookie(Protocol_t protocol, uint8_t address, const size_t maxReplySize)
|
||||
: protocol(protocol),
|
||||
command(protocol),
|
||||
address(address),
|
||||
maxReplySize(maxReplySize),
|
||||
replyBuffer(maxReplySize) {}
|
||||
|
@ -2,18 +2,14 @@
|
||||
#define MISSION_ARDUINO_ARDUINOCOOKIE_H_
|
||||
|
||||
#include <fsfw/devicehandlers/CookieIF.h>
|
||||
|
||||
#include <vector>
|
||||
|
||||
class ArduinoCookie: public CookieIF {
|
||||
public:
|
||||
enum Protocol_t: uint8_t {
|
||||
INVALID,
|
||||
SPI,
|
||||
I2C
|
||||
};
|
||||
class ArduinoCookie : public CookieIF {
|
||||
public:
|
||||
enum Protocol_t : uint8_t { INVALID, SPI, I2C };
|
||||
|
||||
ArduinoCookie(Protocol_t protocol, uint8_t address,
|
||||
const size_t maxReplySize);
|
||||
ArduinoCookie(Protocol_t protocol, uint8_t address, const size_t maxReplySize);
|
||||
|
||||
Protocol_t protocol;
|
||||
uint8_t command;
|
||||
@ -21,7 +17,6 @@ public:
|
||||
std::vector<uint8_t> replyBuffer;
|
||||
size_t receivedDataLen = 0;
|
||||
size_t maxReplySize;
|
||||
|
||||
};
|
||||
|
||||
#endif /* MISSION_ARDUINO_ARDUINOCOOKIE_H_ */
|
||||
|
@ -1,21 +1,27 @@
|
||||
target_sources(${TARGET_NAME} PRIVATE
|
||||
target_sources(${OBSW_NAME} PRIVATE
|
||||
ipc/MissionMessageTypes.cpp
|
||||
)
|
||||
|
||||
target_include_directories(${TARGET_NAME} PUBLIC
|
||||
target_include_directories(${OBSW_NAME} PUBLIC
|
||||
${CMAKE_CURRENT_SOURCE_DIR}
|
||||
)
|
||||
|
||||
# If a special translation file for object IDs exists, compile it.
|
||||
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/objects/translateObjects.cpp")
|
||||
target_sources(${TARGET_NAME} PRIVATE
|
||||
target_sources(${OBSW_NAME} PRIVATE
|
||||
objects/translateObjects.cpp
|
||||
)
|
||||
target_sources(${UNITTEST_NAME} PRIVATE
|
||||
objects/translateObjects.cpp
|
||||
)
|
||||
endif()
|
||||
|
||||
# If a special translation file for events exists, compile it.
|
||||
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/objects/translateObjects.cpp")
|
||||
target_sources(${TARGET_NAME} PRIVATE
|
||||
target_sources(${OBSW_NAME} PRIVATE
|
||||
events/translateEvents.cpp
|
||||
)
|
||||
target_sources(${UNITTEST_NAME} PRIVATE
|
||||
events/translateEvents.cpp
|
||||
)
|
||||
endif()
|
||||
|
@ -14,6 +14,12 @@
|
||||
debugging. */
|
||||
#define OBSW_VEBOSE_LEVEL 1
|
||||
|
||||
#define OBSW_USE_CCSDS_IP_CORE 0
|
||||
// Set to 1 if all telemetry should be sent to the PTME IP Core
|
||||
#define OBSW_TM_TO_PTME 0
|
||||
// Set to 1 if telecommands are received via the PDEC IP Core
|
||||
#define OBSW_TC_FROM_PDEC 0
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
#include "objects/systemObjectList.h"
|
||||
|
@ -1,10 +1,8 @@
|
||||
#ifndef FSFWCONFIG_DEVICES_GPIOIDS_H_
|
||||
#define FSFWCONFIG_DEVICES_GPIOIDS_H_
|
||||
|
||||
#include <linux/gpio/GpioIF.h>
|
||||
|
||||
namespace gpioIds {
|
||||
enum gpioId_t {
|
||||
enum gpioId_t {
|
||||
HEATER_0,
|
||||
HEATER_1,
|
||||
HEATER_2,
|
||||
@ -27,33 +25,33 @@ namespace gpioIds {
|
||||
TEST_ID_0,
|
||||
TEST_ID_1,
|
||||
|
||||
RTD_IC3,
|
||||
RTD_IC4,
|
||||
RTD_IC5,
|
||||
RTD_IC6,
|
||||
RTD_IC7,
|
||||
RTD_IC8,
|
||||
RTD_IC9,
|
||||
RTD_IC10,
|
||||
RTD_IC11,
|
||||
RTD_IC12,
|
||||
RTD_IC13,
|
||||
RTD_IC14,
|
||||
RTD_IC15,
|
||||
RTD_IC16,
|
||||
RTD_IC17,
|
||||
RTD_IC18,
|
||||
RTD_IC_3,
|
||||
RTD_IC_4,
|
||||
RTD_IC_5,
|
||||
RTD_IC_6,
|
||||
RTD_IC_7,
|
||||
RTD_IC_8,
|
||||
RTD_IC_9,
|
||||
RTD_IC_10,
|
||||
RTD_IC_11,
|
||||
RTD_IC_12,
|
||||
RTD_IC_13,
|
||||
RTD_IC_14,
|
||||
RTD_IC_15,
|
||||
RTD_IC_16,
|
||||
RTD_IC_17,
|
||||
RTD_IC_18,
|
||||
|
||||
SPI_MUX_BIT_1,
|
||||
SPI_MUX_BIT_2,
|
||||
SPI_MUX_BIT_3,
|
||||
SPI_MUX_BIT_4,
|
||||
SPI_MUX_BIT_5,
|
||||
SPI_MUX_BIT_6
|
||||
};
|
||||
SPI_MUX_BIT_6,
|
||||
|
||||
CS_RAD_SENSOR,
|
||||
ENABLE_RADFET
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
#endif /* FSFWCONFIG_DEVICES_GPIOIDS_H_ */
|
||||
|
@ -4,8 +4,8 @@
|
||||
#include <OBSWConfig.h>
|
||||
|
||||
namespace pcduSwitches {
|
||||
/* Switches are uint8_t datatype and go from 0 to 255 */
|
||||
enum switcherList {
|
||||
/* Switches are uint8_t datatype and go from 0 to 255 */
|
||||
enum SwitcherList {
|
||||
Q7S,
|
||||
PAYLOAD_PCDU_CH1,
|
||||
RW,
|
||||
@ -22,37 +22,36 @@ namespace pcduSwitches {
|
||||
SUS_NOMINAL,
|
||||
SOLAR_CELL_EXP,
|
||||
PLOC,
|
||||
ACS_BORAD_SIDE_A,
|
||||
ACS_BOARD_SIDE_A,
|
||||
NUMBER_OF_SWITCHES
|
||||
};
|
||||
};
|
||||
|
||||
static const uint8_t ON = 1;
|
||||
static const uint8_t OFF = 0;
|
||||
static const uint8_t ON = 1;
|
||||
static const uint8_t OFF = 0;
|
||||
|
||||
/* Output states after reboot of the PDUs */
|
||||
static const uint8_t INIT_STATE_Q7S = ON;
|
||||
static const uint8_t INIT_STATE_PAYLOAD_PCDU_CH1 = OFF;
|
||||
static const uint8_t INIT_STATE_RW = OFF;
|
||||
/* Output states after reboot of the PDUs */
|
||||
static const uint8_t INIT_STATE_Q7S = ON;
|
||||
static const uint8_t INIT_STATE_PAYLOAD_PCDU_CH1 = OFF;
|
||||
static const uint8_t INIT_STATE_RW = OFF;
|
||||
#if BOARD_TE0720 == 1
|
||||
/* Because the TE0720 is not connected to the PCDU, this switch is always on */
|
||||
static const uint8_t INIT_STATE_TCS_BOARD_8V_HEATER_IN = ON;
|
||||
/* Because the TE0720 is not connected to the PCDU, this switch is always on */
|
||||
static const uint8_t INIT_STATE_TCS_BOARD_8V_HEATER_IN = ON;
|
||||
#else
|
||||
static const uint8_t INIT_STATE_TCS_BOARD_8V_HEATER_IN = OFF;
|
||||
static const uint8_t INIT_STATE_TCS_BOARD_8V_HEATER_IN = OFF;
|
||||
#endif
|
||||
static const uint8_t INIT_STATE_SUS_REDUNDANT = OFF;
|
||||
static const uint8_t INIT_STATE_DEPLOYMENT_MECHANISM = OFF;
|
||||
static const uint8_t INIT_STATE_PAYLOAD_PCDU_CH6 = OFF;
|
||||
static const uint8_t INIT_STATE_ACS_BOARD_SIDE_B = OFF;
|
||||
static const uint8_t INIT_STATE_PAYLOAD_CAMERA = OFF;
|
||||
static const uint8_t INIT_STATE_TCS_BOARD_3V3 = OFF;
|
||||
static const uint8_t INIT_STATE_SYRLINKS = OFF;
|
||||
static const uint8_t INIT_STATE_STAR_TRACKER = OFF;
|
||||
static const uint8_t INIT_STATE_MGT = OFF;
|
||||
static const uint8_t INIT_STATE_SUS_NOMINAL = OFF;
|
||||
static const uint8_t INIT_STATE_SOLAR_CELL_EXP = OFF;
|
||||
static const uint8_t INIT_STATE_PLOC = OFF;
|
||||
static const uint8_t INIT_STATE_ACS_BOARD_SIDE_A = OFF;
|
||||
}
|
||||
|
||||
static const uint8_t INIT_STATE_SUS_REDUNDANT = OFF;
|
||||
static const uint8_t INIT_STATE_DEPLOYMENT_MECHANISM = OFF;
|
||||
static const uint8_t INIT_STATE_PAYLOAD_PCDU_CH6 = OFF;
|
||||
static const uint8_t INIT_STATE_ACS_BOARD_SIDE_B = OFF;
|
||||
static const uint8_t INIT_STATE_PAYLOAD_CAMERA = OFF;
|
||||
static const uint8_t INIT_STATE_TCS_BOARD_3V3 = OFF;
|
||||
static const uint8_t INIT_STATE_SYRLINKS = OFF;
|
||||
static const uint8_t INIT_STATE_STAR_TRACKER = OFF;
|
||||
static const uint8_t INIT_STATE_MGT = OFF;
|
||||
static const uint8_t INIT_STATE_SUS_NOMINAL = OFF;
|
||||
static const uint8_t INIT_STATE_SOLAR_CELL_EXP = OFF;
|
||||
static const uint8_t INIT_STATE_PLOC = OFF;
|
||||
static const uint8_t INIT_STATE_ACS_BOARD_SIDE_A = OFF;
|
||||
} // namespace pcduSwitches
|
||||
|
||||
#endif /* FSFWCONFIG_DEVICES_POWERSWITCHERLIST_H_ */
|
||||
|
@ -2,6 +2,7 @@
|
||||
#define CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
|
||||
|
||||
#include <common/config/commonSubsystemIds.h>
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
/**
|
||||
@ -9,9 +10,7 @@
|
||||
* Numbers 0-80 are reserved for FSFW Subsystem IDs (framework/events/)
|
||||
*/
|
||||
namespace SUBSYSTEM_ID {
|
||||
enum: uint8_t {
|
||||
SUBSYSTEM_ID_START = COMMON_SUBSYSTEM_ID_END
|
||||
};
|
||||
enum : uint8_t { SUBSYSTEM_ID_START = COMMON_SUBSYSTEM_ID_END };
|
||||
}
|
||||
|
||||
#endif /* CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_ */
|
||||
|
@ -89,173 +89,173 @@ const char *ACK_FAILURE_STRING = "ACK_FAILURE";
|
||||
const char *EXE_FAILURE_STRING = "EXE_FAILURE";
|
||||
const char *CRC_FAILURE_EVENT_STRING = "CRC_FAILURE_EVENT";
|
||||
|
||||
const char * translateEvents(Event event) {
|
||||
switch( (event & 0xffff) ) {
|
||||
case(2200):
|
||||
const char *translateEvents(Event event) {
|
||||
switch ((event & 0xffff)) {
|
||||
case (2200):
|
||||
return STORE_SEND_WRITE_FAILED_STRING;
|
||||
case(2201):
|
||||
case (2201):
|
||||
return STORE_WRITE_FAILED_STRING;
|
||||
case(2202):
|
||||
case (2202):
|
||||
return STORE_SEND_READ_FAILED_STRING;
|
||||
case(2203):
|
||||
case (2203):
|
||||
return STORE_READ_FAILED_STRING;
|
||||
case(2204):
|
||||
case (2204):
|
||||
return UNEXPECTED_MSG_STRING;
|
||||
case(2205):
|
||||
case (2205):
|
||||
return STORING_FAILED_STRING;
|
||||
case(2206):
|
||||
case (2206):
|
||||
return TM_DUMP_FAILED_STRING;
|
||||
case(2207):
|
||||
case (2207):
|
||||
return STORE_INIT_FAILED_STRING;
|
||||
case(2208):
|
||||
case (2208):
|
||||
return STORE_INIT_EMPTY_STRING;
|
||||
case(2209):
|
||||
case (2209):
|
||||
return STORE_CONTENT_CORRUPTED_STRING;
|
||||
case(2210):
|
||||
case (2210):
|
||||
return STORE_INITIALIZE_STRING;
|
||||
case(2211):
|
||||
case (2211):
|
||||
return INIT_DONE_STRING;
|
||||
case(2212):
|
||||
case (2212):
|
||||
return DUMP_FINISHED_STRING;
|
||||
case(2213):
|
||||
case (2213):
|
||||
return DELETION_FINISHED_STRING;
|
||||
case(2214):
|
||||
case (2214):
|
||||
return DELETION_FAILED_STRING;
|
||||
case(2215):
|
||||
case (2215):
|
||||
return AUTO_CATALOGS_SENDING_FAILED_STRING;
|
||||
case(2600):
|
||||
case (2600):
|
||||
return GET_DATA_FAILED_STRING;
|
||||
case(2601):
|
||||
case (2601):
|
||||
return STORE_DATA_FAILED_STRING;
|
||||
case(2800):
|
||||
case (2800):
|
||||
return DEVICE_BUILDING_COMMAND_FAILED_STRING;
|
||||
case(2801):
|
||||
case (2801):
|
||||
return DEVICE_SENDING_COMMAND_FAILED_STRING;
|
||||
case(2802):
|
||||
case (2802):
|
||||
return DEVICE_REQUESTING_REPLY_FAILED_STRING;
|
||||
case(2803):
|
||||
case (2803):
|
||||
return DEVICE_READING_REPLY_FAILED_STRING;
|
||||
case(2804):
|
||||
case (2804):
|
||||
return DEVICE_INTERPRETING_REPLY_FAILED_STRING;
|
||||
case(2805):
|
||||
case (2805):
|
||||
return DEVICE_MISSED_REPLY_STRING;
|
||||
case(2806):
|
||||
case (2806):
|
||||
return DEVICE_UNKNOWN_REPLY_STRING;
|
||||
case(2807):
|
||||
case (2807):
|
||||
return DEVICE_UNREQUESTED_REPLY_STRING;
|
||||
case(2808):
|
||||
case (2808):
|
||||
return INVALID_DEVICE_COMMAND_STRING;
|
||||
case(2809):
|
||||
case (2809):
|
||||
return MONITORING_LIMIT_EXCEEDED_STRING;
|
||||
case(2810):
|
||||
case (2810):
|
||||
return MONITORING_AMBIGUOUS_STRING;
|
||||
case(4201):
|
||||
case (4201):
|
||||
return FUSE_CURRENT_HIGH_STRING;
|
||||
case(4202):
|
||||
case (4202):
|
||||
return FUSE_WENT_OFF_STRING;
|
||||
case(4204):
|
||||
case (4204):
|
||||
return POWER_ABOVE_HIGH_LIMIT_STRING;
|
||||
case(4205):
|
||||
case (4205):
|
||||
return POWER_BELOW_LOW_LIMIT_STRING;
|
||||
case(4300):
|
||||
case (4300):
|
||||
return SWITCH_WENT_OFF_STRING;
|
||||
case(5000):
|
||||
case (5000):
|
||||
return HEATER_ON_STRING;
|
||||
case(5001):
|
||||
case (5001):
|
||||
return HEATER_OFF_STRING;
|
||||
case(5002):
|
||||
case (5002):
|
||||
return HEATER_TIMEOUT_STRING;
|
||||
case(5003):
|
||||
case (5003):
|
||||
return HEATER_STAYED_ON_STRING;
|
||||
case(5004):
|
||||
case (5004):
|
||||
return HEATER_STAYED_OFF_STRING;
|
||||
case(5200):
|
||||
case (5200):
|
||||
return TEMP_SENSOR_HIGH_STRING;
|
||||
case(5201):
|
||||
case (5201):
|
||||
return TEMP_SENSOR_LOW_STRING;
|
||||
case(5202):
|
||||
case (5202):
|
||||
return TEMP_SENSOR_GRADIENT_STRING;
|
||||
case(5901):
|
||||
case (5901):
|
||||
return COMPONENT_TEMP_LOW_STRING;
|
||||
case(5902):
|
||||
case (5902):
|
||||
return COMPONENT_TEMP_HIGH_STRING;
|
||||
case(5903):
|
||||
case (5903):
|
||||
return COMPONENT_TEMP_OOL_LOW_STRING;
|
||||
case(5904):
|
||||
case (5904):
|
||||
return COMPONENT_TEMP_OOL_HIGH_STRING;
|
||||
case(5905):
|
||||
case (5905):
|
||||
return TEMP_NOT_IN_OP_RANGE_STRING;
|
||||
case(7101):
|
||||
case (7101):
|
||||
return FDIR_CHANGED_STATE_STRING;
|
||||
case(7102):
|
||||
case (7102):
|
||||
return FDIR_STARTS_RECOVERY_STRING;
|
||||
case(7103):
|
||||
case (7103):
|
||||
return FDIR_TURNS_OFF_DEVICE_STRING;
|
||||
case(7201):
|
||||
case (7201):
|
||||
return MONITOR_CHANGED_STATE_STRING;
|
||||
case(7202):
|
||||
case (7202):
|
||||
return VALUE_BELOW_LOW_LIMIT_STRING;
|
||||
case(7203):
|
||||
case (7203):
|
||||
return VALUE_ABOVE_HIGH_LIMIT_STRING;
|
||||
case(7204):
|
||||
case (7204):
|
||||
return VALUE_OUT_OF_RANGE_STRING;
|
||||
case(7301):
|
||||
case (7301):
|
||||
return SWITCHING_TM_FAILED_STRING;
|
||||
case(7400):
|
||||
case (7400):
|
||||
return CHANGING_MODE_STRING;
|
||||
case(7401):
|
||||
case (7401):
|
||||
return MODE_INFO_STRING;
|
||||
case(7402):
|
||||
case (7402):
|
||||
return FALLBACK_FAILED_STRING;
|
||||
case(7403):
|
||||
case (7403):
|
||||
return MODE_TRANSITION_FAILED_STRING;
|
||||
case(7404):
|
||||
case (7404):
|
||||
return CANT_KEEP_MODE_STRING;
|
||||
case(7405):
|
||||
case (7405):
|
||||
return OBJECT_IN_INVALID_MODE_STRING;
|
||||
case(7406):
|
||||
case (7406):
|
||||
return FORCING_MODE_STRING;
|
||||
case(7407):
|
||||
case (7407):
|
||||
return MODE_CMD_REJECTED_STRING;
|
||||
case(7506):
|
||||
case (7506):
|
||||
return HEALTH_INFO_STRING;
|
||||
case(7507):
|
||||
case (7507):
|
||||
return CHILD_CHANGED_HEALTH_STRING;
|
||||
case(7508):
|
||||
case (7508):
|
||||
return CHILD_PROBLEMS_STRING;
|
||||
case(7509):
|
||||
case (7509):
|
||||
return OVERWRITING_HEALTH_STRING;
|
||||
case(7510):
|
||||
case (7510):
|
||||
return TRYING_RECOVERY_STRING;
|
||||
case(7511):
|
||||
case (7511):
|
||||
return RECOVERY_STEP_STRING;
|
||||
case(7512):
|
||||
case (7512):
|
||||
return RECOVERY_DONE_STRING;
|
||||
case(7900):
|
||||
case (7900):
|
||||
return RF_AVAILABLE_STRING;
|
||||
case(7901):
|
||||
case (7901):
|
||||
return RF_LOST_STRING;
|
||||
case(7902):
|
||||
case (7902):
|
||||
return BIT_LOCK_STRING;
|
||||
case(7903):
|
||||
case (7903):
|
||||
return BIT_LOCK_LOST_STRING;
|
||||
case(7905):
|
||||
case (7905):
|
||||
return FRAME_PROCESSING_FAILED_STRING;
|
||||
case(8900):
|
||||
case (8900):
|
||||
return CLOCK_SET_STRING;
|
||||
case(8901):
|
||||
case (8901):
|
||||
return CLOCK_SET_FAILURE_STRING;
|
||||
case(9700):
|
||||
case (9700):
|
||||
return TEST_STRING;
|
||||
case(10600):
|
||||
case (10600):
|
||||
return CHANGE_OF_SETUP_PARAMETER_STRING;
|
||||
case(11101):
|
||||
case (11101):
|
||||
return MEMORY_READ_RPT_CRC_FAILURE_STRING;
|
||||
case(11102):
|
||||
case (11102):
|
||||
return ACK_FAILURE_STRING;
|
||||
case(11103):
|
||||
case (11103):
|
||||
return EXE_FAILURE_STRING;
|
||||
case(11104):
|
||||
case (11104):
|
||||
return CRC_FAILURE_EVENT_STRING;
|
||||
default:
|
||||
return "UNKNOWN_EVENT";
|
||||
|
@ -3,6 +3,6 @@
|
||||
|
||||
#include <fsfw/events/Event.h>
|
||||
|
||||
const char * translateEvents(Event event);
|
||||
const char* translateEvents(Event event);
|
||||
|
||||
#endif /* FSFWCONFIG_EVENTS_TRANSLATEEVENTS_H_ */
|
||||
|
@ -1,7 +0,0 @@
|
||||
CXXSRC += $(wildcard $(CURRENTPATH)/cdatapool/*.cpp)
|
||||
CXXSRC += $(wildcard $(CURRENTPATH)/ipc/*.cpp)
|
||||
CXXSRC += $(wildcard $(CURRENTPATH)/objects/*.cpp)
|
||||
CXXSRC += $(wildcard $(CURRENTPATH)/pollingsequence/*.cpp)
|
||||
CXXSRC += $(wildcard $(CURRENTPATH)/events/*.cpp)
|
||||
|
||||
INCLUDES += $(CURRENTPATH)
|
@ -1,11 +1,10 @@
|
||||
#include "MissionMessageTypes.h"
|
||||
|
||||
#include <fsfw/ipc/CommandMessage.h>
|
||||
|
||||
void messagetypes::clearMissionMessage(CommandMessage* message) {
|
||||
switch(message->getMessageType()) {
|
||||
switch (message->getMessageType()) {
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
@ -17,6 +17,6 @@ enum MESSAGE_TYPE {
|
||||
};
|
||||
|
||||
void clearMissionMessage(CommandMessage* message);
|
||||
}
|
||||
} // namespace messagetypes
|
||||
|
||||
#endif /* CONFIG_IPC_MISSIONMESSAGETYPES_H_ */
|
||||
|
@ -1,12 +1,13 @@
|
||||
#ifndef HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
|
||||
#define HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
|
||||
|
||||
#include <cstdint>
|
||||
#include <commonObjects.h>
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
// The objects will be instantiated in the ID order
|
||||
namespace objects {
|
||||
enum sourceObjects: uint32_t {
|
||||
enum sourceObjects : uint32_t {
|
||||
|
||||
PUS_SERVICE_3 = 0x51000300,
|
||||
PUS_SERVICE_5 = 0x51000400,
|
||||
@ -25,7 +26,7 @@ namespace objects {
|
||||
|
||||
/* 0x49 ('I') for Communication Interfaces **/
|
||||
ARDUINO_COM_IF = 0x49000001
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
#endif /* BSP_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */
|
||||
|
@ -38,8 +38,8 @@ const char *FSFW_OBJECTS_END_STRING = "FSFW_OBJECTS_END";
|
||||
const char *DUMMY_INTERFACE_STRING = "DUMMY_INTERFACE";
|
||||
const char *NO_OBJECT_STRING = "NO_OBJECT";
|
||||
|
||||
const char* translateObject(object_id_t object) {
|
||||
switch( (object & 0xFFFFFFFF) ) {
|
||||
const char *translateObject(object_id_t object) {
|
||||
switch ((object & 0xFFFFFFFF)) {
|
||||
case 0x42694269:
|
||||
return TEST_TASK_STRING;
|
||||
case 0x4400AFFE:
|
||||
|
@ -1,9 +1,10 @@
|
||||
#ifndef CONFIG_RETURNVALUES_CLASSIDS_H_
|
||||
#define CONFIG_RETURNVALUES_CLASSIDS_H_
|
||||
|
||||
#include "commonClassIds.h"
|
||||
#include <fsfw/returnvalues/FwClassIds.h>
|
||||
|
||||
#include "commonClassIds.h"
|
||||
|
||||
/**
|
||||
* Source IDs starts at 73 for now
|
||||
* Framework IDs for ReturnValues run from 0 to 56
|
||||
@ -15,5 +16,4 @@ enum {
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
#endif /* CONFIG_RETURNVALUES_CLASSIDS_H_ */
|
||||
|
@ -12,8 +12,7 @@
|
||||
* APID is a 11 bit number
|
||||
*/
|
||||
namespace apid {
|
||||
static const uint16_t EIVE_OBSW = 0x65;
|
||||
static const uint16_t EIVE_OBSW = 0x65;
|
||||
}
|
||||
|
||||
|
||||
#endif /* FSFWCONFIG_TMTC_APID_H_ */
|
||||
|
@ -2,7 +2,7 @@
|
||||
#define CONFIG_TMTC_PUSIDS_HPP_
|
||||
|
||||
namespace pus {
|
||||
enum Ids{
|
||||
enum Ids {
|
||||
PUS_SERVICE_1 = 1,
|
||||
PUS_SERVICE_2 = 2,
|
||||
PUS_SERVICE_3 = 3,
|
||||
|
@ -1,10 +1,9 @@
|
||||
#include <iostream>
|
||||
|
||||
#include "InitMission.h"
|
||||
#include "OBSWVersion.h"
|
||||
|
||||
#include "fsfw/FSFWVersion.h"
|
||||
#include "fsfw/tasks/TaskFactory.h"
|
||||
|
||||
#include <iostream>
|
||||
#ifdef WIN32
|
||||
static const char* COMPILE_PRINTOUT = "Windows";
|
||||
#elif LINUX
|
||||
@ -17,21 +16,18 @@ static const char* COMPILE_PRINTOUT = "unknown OS";
|
||||
* Linux and Windows.
|
||||
* @return
|
||||
*/
|
||||
int main(void)
|
||||
{
|
||||
int main(void) {
|
||||
std::cout << "-- EIVE OBSW --" << std::endl;
|
||||
std::cout << "-- Compiled for " << COMPILE_PRINTOUT << " --" << std::endl;
|
||||
std::cout << "-- OBSW " << SW_NAME << " v" << SW_VERSION << "." << SW_SUBVERSION <<
|
||||
"." << SW_REVISION << ", FSFW v" << FSFW_VERSION << "." << FSFW_SUBVERSION << "." <<
|
||||
FSFW_REVISION << "--" << std::endl;
|
||||
std::cout << "-- OBSW " << SW_NAME << " v" << SW_VERSION << "." << SW_SUBVERSION << "."
|
||||
<< SW_REVISION << ", FSFW v" << FSFW_VERSION << "." << FSFW_SUBVERSION << "."
|
||||
<< FSFW_REVISION << "--" << std::endl;
|
||||
std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
|
||||
|
||||
initmission::initMission();
|
||||
|
||||
for(;;) {
|
||||
for (;;) {
|
||||
// suspend main thread by sleeping it.
|
||||
TaskFactory::delayTask(5000);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
@ -1,4 +1,4 @@
|
||||
target_sources(${TARGET_NAME} PUBLIC
|
||||
target_sources(${OBSW_NAME} PUBLIC
|
||||
InitMission.cpp
|
||||
main.cpp
|
||||
ObjectFactory.cpp
|
||||
|
@ -1,27 +1,27 @@
|
||||
#include "InitMission.h"
|
||||
#include "ObjectFactory.h"
|
||||
|
||||
#include "objects/systemObjectList.h"
|
||||
#include "OBSWConfig.h"
|
||||
#include "pollingsequence/pollingSequenceFactory.h"
|
||||
|
||||
#include <mission/utility/InitMission.h>
|
||||
#include <fsfw/objectmanager/ObjectManager.h>
|
||||
#include <fsfw/objectmanager/ObjectManagerIF.h>
|
||||
#include <fsfw/returnvalues/HasReturnvaluesIF.h>
|
||||
#include <fsfw/serviceinterface/ServiceInterface.h>
|
||||
#include <fsfw/objectmanager/ObjectManager.h>
|
||||
#include <fsfw/tasks/FixedTimeslotTaskIF.h>
|
||||
#include <fsfw/tasks/PeriodicTaskIF.h>
|
||||
#include <fsfw/tasks/TaskFactory.h>
|
||||
#include <mission/utility/InitMission.h>
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include "OBSWConfig.h"
|
||||
#include "ObjectFactory.h"
|
||||
#include "objects/systemObjectList.h"
|
||||
#include "pollingsequence/pollingSequenceFactory.h"
|
||||
|
||||
ServiceInterfaceStream sif::debug("DEBUG");
|
||||
ServiceInterfaceStream sif::info("INFO");
|
||||
ServiceInterfaceStream sif::warning("WARNING");
|
||||
ServiceInterfaceStream sif::error("ERROR");
|
||||
|
||||
ObjectManagerIF *objectManager = nullptr;
|
||||
ObjectManagerIF* objectManager = nullptr;
|
||||
|
||||
void initmission::initMission() {
|
||||
sif::info << "Building global objects.." << std::endl;
|
||||
@ -36,161 +36,210 @@ void initmission::initMission() {
|
||||
|
||||
void initmission::initTasks() {
|
||||
TaskFactory* factory = TaskFactory::instance();
|
||||
if(factory == nullptr) {
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
if (factory == nullptr) {
|
||||
/* Should never happen ! */
|
||||
return;
|
||||
}
|
||||
#if OBSW_PRINT_MISSED_DEADLINES == 1
|
||||
void (*missedDeadlineFunc) (void) = TaskFactory::printMissedDeadline;
|
||||
void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline;
|
||||
#else
|
||||
void (*missedDeadlineFunc) (void) = nullptr;
|
||||
void (*missedDeadlineFunc)(void) = nullptr;
|
||||
#endif
|
||||
|
||||
/* TMTC Distribution */
|
||||
PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
|
||||
"DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
|
||||
ReturnValue_t result = tmTcDistributor->addComponent(
|
||||
objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK){
|
||||
result = tmTcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Object add component failed" << std::endl;
|
||||
}
|
||||
result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK){
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Object add component failed" << std::endl;
|
||||
}
|
||||
result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Object add component failed" << std::endl;
|
||||
}
|
||||
|
||||
/* UDP bridge */
|
||||
PeriodicTaskIF* udpBridgeTask = factory->createPeriodicTask(
|
||||
"UDP_UNIX_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
|
||||
result = udpBridgeTask->addComponent(objects::TMTC_BRIDGE);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Add component UDP Unix Bridge failed" << std::endl;
|
||||
PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
|
||||
"TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
|
||||
result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Add component TMTC Bridge failed" << std::endl;
|
||||
}
|
||||
PeriodicTaskIF* udpPollingTask = factory->createPeriodicTask(
|
||||
"UDP_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
|
||||
result = udpPollingTask->addComponent(objects::TMTC_POLLING_TASK);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Add component UDP Polling failed" << std::endl;
|
||||
PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
|
||||
"TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
|
||||
result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Add component TMTC Polling failed" << std::endl;
|
||||
}
|
||||
|
||||
/* PUS Services */
|
||||
PeriodicTaskIF* pusVerification = factory->createPeriodicTask(
|
||||
"PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
|
||||
result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK){
|
||||
sif::error << "Object add component failed" << std::endl;
|
||||
}
|
||||
std::vector<PeriodicTaskIF*> pusTasks;
|
||||
createPusTasks(*factory, missedDeadlineFunc, pusTasks);
|
||||
|
||||
PeriodicTaskIF* pusEvents = factory->createPeriodicTask(
|
||||
"PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
|
||||
result = pusVerification->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK){
|
||||
initmission::printAddObjectError("PUS5", objects::PUS_SERVICE_5_EVENT_REPORTING);
|
||||
}
|
||||
|
||||
PeriodicTaskIF* pusHighPrio = factory->createPeriodicTask(
|
||||
"PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
|
||||
result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
|
||||
}
|
||||
result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
|
||||
}
|
||||
|
||||
PeriodicTaskIF* pusMedPrio = factory->createPeriodicTask(
|
||||
"PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
|
||||
}
|
||||
|
||||
PeriodicTaskIF* pusLowPrio = factory->createPeriodicTask(
|
||||
"PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
|
||||
result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
|
||||
}
|
||||
result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("INT_ERR_RPRT",
|
||||
objects::INTERNAL_ERROR_REPORTER);
|
||||
}
|
||||
|
||||
bool startTestPst = true;
|
||||
#if OBSW_ADD_TEST_PST == 1
|
||||
FixedTimeslotTaskIF* pstTestTask = factory->createFixedTimeslotTask("ACS_PST", 50,
|
||||
PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 2.0, missedDeadlineFunc);
|
||||
result = pst::pstTest(pstTestTask);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::info << "initmission::initTasks: ACS PST empty or invalid" << std::endl;
|
||||
startTestPst = false;
|
||||
}
|
||||
#endif /* RPI_TEST_ACS_BOARD == 1 */
|
||||
|
||||
PeriodicTaskIF* testTask = factory->createPeriodicTask(
|
||||
"TEST_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
|
||||
std::vector<PeriodicTaskIF*> pstTasks;
|
||||
createPstTasks(*factory, missedDeadlineFunc, pstTasks);
|
||||
#if OBSW_ADD_TEST_CODE == 1
|
||||
result = testTask->addComponent(objects::TEST_TASK);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
|
||||
}
|
||||
std::vector<PeriodicTaskIF*> testTasks;
|
||||
createTestTasks(*factory, missedDeadlineFunc, pstTasks);
|
||||
#endif /* OBSW_ADD_TEST_CODE == 1 */
|
||||
#if RPI_ADD_SPI_TEST == 1
|
||||
result = testTask->addComponent(objects::SPI_TEST);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
|
||||
|
||||
auto taskStarter = [](std::vector<PeriodicTaskIF*>& taskVector, std::string name) {
|
||||
for (const auto& task : taskVector) {
|
||||
if (task != nullptr) {
|
||||
task->startTask();
|
||||
} else {
|
||||
sif::error << "Task in vector " << name << " is invalid!" << std::endl;
|
||||
}
|
||||
#endif /* RPI_ADD_SPI_TEST == 1 */
|
||||
#if RPI_ADD_GPIO_TEST == 1
|
||||
result = testTask->addComponent(objects::LIBGPIOD_TEST);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("GPIOD_TEST", objects::LIBGPIOD_TEST);
|
||||
}
|
||||
#endif /* RPI_ADD_GPIO_TEST == 1 */
|
||||
#if RPI_ADD_UART_TEST == 1
|
||||
result = testTask->addComponent(objects::UART_TEST);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("UART_TEST", objects::UART_TEST);
|
||||
}
|
||||
#endif /* RPI_ADD_GPIO_TEST == 1 */
|
||||
};
|
||||
|
||||
sif::info << "Starting tasks.." << std::endl;
|
||||
tmTcDistributor->startTask();
|
||||
udpBridgeTask->startTask();
|
||||
udpPollingTask->startTask();
|
||||
|
||||
pusVerification->startTask();
|
||||
pusEvents->startTask();
|
||||
pusHighPrio->startTask();
|
||||
pusMedPrio->startTask();
|
||||
pusLowPrio->startTask();
|
||||
tmtcBridgeTask->startTask();
|
||||
tmtcPollingTask->startTask();
|
||||
|
||||
taskStarter(pusTasks, "PUS Tasks");
|
||||
#if OBSW_ADD_TEST_CODE == 1
|
||||
testTask->startTask();
|
||||
taskStarter(testTasks, "Test Tasks");
|
||||
#endif /* OBSW_ADD_TEST_CODE == 1 */
|
||||
taskStarter(pstTasks, "PST Tasks");
|
||||
|
||||
#if OBSW_ADD_TEST_PST == 1
|
||||
if(startTestPst) {
|
||||
if (startTestPst) {
|
||||
pstTestTask->startTask();
|
||||
}
|
||||
#endif /* RPI_TEST_ACS_BOARD == 1 */
|
||||
sif::info << "Tasks started.." << std::endl;
|
||||
}
|
||||
|
||||
void initmission::createPusTasks(TaskFactory& factory,
|
||||
TaskDeadlineMissedFunction missedDeadlineFunc,
|
||||
std::vector<PeriodicTaskIF*>& taskVec) {
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
|
||||
"PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
|
||||
result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Object add component failed" << std::endl;
|
||||
}
|
||||
taskVec.push_back(pusVerification);
|
||||
|
||||
PeriodicTaskIF* pusEvents = factory.createPeriodicTask(
|
||||
"PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
|
||||
result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
|
||||
}
|
||||
result = pusEvents->addComponent(objects::EVENT_MANAGER);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
|
||||
}
|
||||
taskVec.push_back(pusEvents);
|
||||
|
||||
PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
|
||||
"PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
|
||||
result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
|
||||
}
|
||||
result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
|
||||
}
|
||||
taskVec.push_back(pusHighPrio);
|
||||
|
||||
PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
|
||||
"PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
|
||||
}
|
||||
taskVec.push_back(pusMedPrio);
|
||||
|
||||
PeriodicTaskIF* pusLowPrio = factory.createPeriodicTask(
|
||||
"PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
|
||||
result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
|
||||
}
|
||||
result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("INT_ERR_RPRT", objects::INTERNAL_ERROR_REPORTER);
|
||||
}
|
||||
taskVec.push_back(pusLowPrio);
|
||||
}
|
||||
|
||||
void initmission::createPstTasks(TaskFactory& factory,
|
||||
TaskDeadlineMissedFunction missedDeadlineFunc,
|
||||
std::vector<PeriodicTaskIF*>& taskVec) {
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
#if OBSW_ADD_SPI_TEST_CODE == 0
|
||||
FixedTimeslotTaskIF* spiPst = factory.createFixedTimeslotTask(
|
||||
"SPI_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0, missedDeadlineFunc);
|
||||
result = pst::pstSpi(spiPst);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
|
||||
}
|
||||
taskVec.push_back(spiPst);
|
||||
#endif
|
||||
}
|
||||
|
||||
void initmission::createTestTasks(TaskFactory& factory,
|
||||
TaskDeadlineMissedFunction missedDeadlineFunc,
|
||||
std::vector<PeriodicTaskIF*>& taskVec) {
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
PeriodicTaskIF* testTask = factory.createPeriodicTask(
|
||||
"TEST_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
|
||||
result = testTask->addComponent(objects::TEST_TASK);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
|
||||
}
|
||||
#if OBSW_ADD_SPI_TEST_CODE == 1
|
||||
result = testTask->addComponent(objects::SPI_TEST);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
|
||||
}
|
||||
#endif /* RPI_ADD_SPI_TEST == 1 */
|
||||
#if RPI_ADD_GPIO_TEST == 1
|
||||
result = testTask->addComponent(objects::LIBGPIOD_TEST);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("GPIOD_TEST", objects::LIBGPIOD_TEST);
|
||||
}
|
||||
#endif /* RPI_ADD_GPIO_TEST == 1 */
|
||||
#if OBSW_ADD_UART_TEST_CODE == 1
|
||||
result = testTask->addComponent(objects::UART_TEST);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("UART_TEST", objects::UART_TEST);
|
||||
}
|
||||
#endif /* RPI_ADD_GPIO_TEST == 1 */
|
||||
taskVec.push_back(testTask);
|
||||
|
||||
bool startTestPst = true;
|
||||
static_cast<void>(startTestPst);
|
||||
#if OBSW_ADD_TEST_PST == 1
|
||||
FixedTimeslotTaskIF* pstTestTask = factory->createFixedTimeslotTask(
|
||||
"TEST_PST", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 2.0, missedDeadlineFunc);
|
||||
result = pst::pstTest(pstTestTask);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::info << "initmission::initTasks: ACS PST empty or invalid" << std::endl;
|
||||
startTestPst = false;
|
||||
}
|
||||
#endif /* RPI_TEST_ACS_BOARD == 1 */
|
||||
}
|
||||
|
@ -1,9 +1,23 @@
|
||||
#ifndef BSP_LINUX_INITMISSION_H_
|
||||
#define BSP_LINUX_INITMISSION_H_
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include "fsfw/tasks/Typedef.h"
|
||||
|
||||
class PeriodicTaskIF;
|
||||
class TaskFactory;
|
||||
|
||||
namespace initmission {
|
||||
void initMission();
|
||||
void initTasks();
|
||||
};
|
||||
|
||||
void createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
|
||||
std::vector<PeriodicTaskIF*>& taskVec);
|
||||
void createTestTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
|
||||
std::vector<PeriodicTaskIF*>& taskVec);
|
||||
void createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
|
||||
std::vector<PeriodicTaskIF*>& taskVec);
|
||||
}; // namespace initmission
|
||||
|
||||
#endif /* BSP_LINUX_INITMISSION_H_ */
|
||||
|
@ -1,47 +1,46 @@
|
||||
#include <devConf.h>
|
||||
#include "ObjectFactory.h"
|
||||
|
||||
#include "objects/systemObjectList.h"
|
||||
#include "OBSWConfig.h"
|
||||
#include "devConf.h"
|
||||
#include "devices/addresses.h"
|
||||
#include "devices/gpioIds.h"
|
||||
#include "OBSWConfig.h"
|
||||
#include "tmtc/apid.h"
|
||||
#include "tmtc/pusIds.h"
|
||||
#include "fsfw/datapoollocal/LocalDataPoolManager.h"
|
||||
#include "fsfw/tasks/TaskFactory.h"
|
||||
#include "fsfw/tmtcpacket/pus/tm.h"
|
||||
#include "fsfw/tmtcservices/CommandingServiceBase.h"
|
||||
#include "fsfw/tmtcservices/PusServiceBase.h"
|
||||
#include "linux/boardtest/LibgpiodTest.h"
|
||||
#include "linux/boardtest/SpiTestClass.h"
|
||||
#include "linux/boardtest/UartTestClass.h"
|
||||
|
||||
#include "mission/core/GenericFactory.h"
|
||||
#include "mission/devices/GPSHyperionHandler.h"
|
||||
#include "mission/devices/GyroADIS1650XHandler.h"
|
||||
#include "mission/utility/TmFunnel.h"
|
||||
#include <mission/devices/GPSHyperionHandler.h>
|
||||
#include "mission/devices/MGMHandlerLIS3MDL.h"
|
||||
#include "mission/devices/MGMHandlerRM3100.h"
|
||||
#include "mission/devices/GyroADIS16507Handler.h"
|
||||
|
||||
#include "fsfw/datapoollocal/LocalDataPoolManager.h"
|
||||
#include "fsfw/tmtcservices/CommandingServiceBase.h"
|
||||
#include "fsfw/tmtcservices/PusServiceBase.h"
|
||||
#include "fsfw/tmtcpacket/pus/tm.h"
|
||||
#include "fsfw/tasks/TaskFactory.h"
|
||||
#include "objects/systemObjectList.h"
|
||||
#include "tmtc/apid.h"
|
||||
#include "tmtc/pusIds.h"
|
||||
|
||||
/* UDP server includes */
|
||||
#if OBSW_USE_TMTC_TCP_BRIDGE == 1
|
||||
#include <fsfw/src/fsfw/osal/common/TcpTmTcBridge.h>
|
||||
#include <fsfw/src/fsfw/osal/common/TcpTmTcServer.h>
|
||||
#else
|
||||
#include "fsfw/osal/common/UdpTmTcBridge.h"
|
||||
#include "fsfw/osal/common/UdpTcPollingTask.h"
|
||||
#include "fsfw/osal/common/UdpTmTcBridge.h"
|
||||
#endif
|
||||
|
||||
#include "fsfw_hal/devicehandlers/GyroL3GD20Handler.h"
|
||||
#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
|
||||
#include "fsfw_hal/linux/rpi/GpioRPi.h"
|
||||
#include "fsfw_hal/common/gpio/GpioCookie.h"
|
||||
#include "fsfw_hal/linux/spi/SpiCookie.h"
|
||||
#include "fsfw_hal/linux/spi/SpiComIF.h"
|
||||
#include <fsfw_hal/linux/uart/UartComIF.h>
|
||||
#include <fsfw_hal/linux/uart/UartCookie.h>
|
||||
|
||||
#include "fsfw_hal/common/gpio/GpioCookie.h"
|
||||
#include "fsfw_hal/devicehandlers/GyroL3GD20Handler.h"
|
||||
#include "fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h"
|
||||
#include "fsfw_hal/devicehandlers/MgmRM3100Handler.h"
|
||||
#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
|
||||
#include "fsfw_hal/linux/rpi/GpioRPi.h"
|
||||
#include "fsfw_hal/linux/spi/SpiComIF.h"
|
||||
#include "fsfw_hal/linux/spi/SpiCookie.h"
|
||||
|
||||
void Factory::setStaticFrameworkObjectIds() {
|
||||
PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
|
||||
PusServiceBase::packetDestination = objects::TM_FUNNEL;
|
||||
@ -57,20 +56,10 @@ void Factory::setStaticFrameworkObjectIds() {
|
||||
TmPacketBase::timeStamperId = objects::TIME_STAMPER;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void ObjectFactory::produce(void* args){
|
||||
void ObjectFactory::produce(void* args) {
|
||||
Factory::setStaticFrameworkObjectIds();
|
||||
ObjectFactory::produceGenericObjects();
|
||||
|
||||
#if OBSW_USE_TMTC_TCP_BRIDGE == 1
|
||||
new TcpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
new TcpTmTcServer(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
|
||||
#else
|
||||
new UdpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
new UdpTcPollingTask(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
|
||||
#endif
|
||||
|
||||
GpioIF* gpioIF = new LinuxLibgpioIF(objects::GPIO_IF);
|
||||
GpioCookie* gpioCookie = nullptr;
|
||||
static_cast<void>(gpioCookie);
|
||||
@ -81,14 +70,118 @@ void ObjectFactory::produce(void* args){
|
||||
SpiCookie* spiCookie = nullptr;
|
||||
static_cast<void>(spiCookie);
|
||||
|
||||
#if OBSW_ADD_ACS_BOARD == 1
|
||||
if (gpioCookie == nullptr) {
|
||||
gpioCookie = new GpioCookie();
|
||||
}
|
||||
// TODO: Missing pin for Gyro 2
|
||||
gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_0_LIS3_CS, gpio::MGM_0_BCM_PIN, "MGM_0_LIS3",
|
||||
gpio::Direction::OUT, 1);
|
||||
gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_1_RM3100_CS, gpio::MGM_1_BCM_PIN,
|
||||
"MGM_1_RM3100", gpio::Direction::OUT, 1);
|
||||
gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_2_LIS3_CS, gpio::MGM_2_BCM_PIN, "MGM_2_LIS3",
|
||||
gpio::Direction::OUT, 1);
|
||||
gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_3_RM3100_CS, gpio::MGM_3_BCM_PIN,
|
||||
"MGM_3_RM3100", gpio::Direction::OUT, 1);
|
||||
gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_0_ADIS_CS, gpio::GYRO_0_BCM_PIN,
|
||||
"GYRO_0_ADIS", gpio::Direction::OUT, 1);
|
||||
gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_1_L3G_CS, gpio::GYRO_1_BCM_PIN, "GYRO_1_L3G",
|
||||
gpio::Direction::OUT, 1);
|
||||
gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_2_ADIS_CS, gpio::GYRO_2_BCM_PIN,
|
||||
"GYRO_2_ADIS", gpio::Direction::OUT, 1);
|
||||
gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_3_L3G_CS, gpio::GYRO_3_BCM_PIN, "GYRO_3_L3G",
|
||||
gpio::Direction::OUT, 1);
|
||||
gpioIF->addGpios(gpioCookie);
|
||||
|
||||
spiDev = "/dev/spidev0.1";
|
||||
spiCookie =
|
||||
new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, spiDev,
|
||||
MGMLIS3MDL::MAX_BUFFER_SIZE, spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
|
||||
auto mgmLis3Handler =
|
||||
new MgmLIS3MDLHandler(objects::MGM_0_LIS3_HANDLER, objects::SPI_COM_IF, spiCookie, 0);
|
||||
mgmLis3Handler->setStartUpImmediately();
|
||||
#if FSFW_HAL_LIS3MDL_MGM_DEBUG == 1
|
||||
mgmLis3Handler->setToGoToNormalMode(true);
|
||||
#endif
|
||||
|
||||
spiCookie =
|
||||
new SpiCookie(addresses::MGM_1_RM3100, gpioIds::MGM_1_RM3100_CS, spiDev,
|
||||
RM3100::MAX_BUFFER_SIZE, spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
|
||||
auto mgmRm3100Handler =
|
||||
new MgmRM3100Handler(objects::MGM_1_RM3100_HANDLER, objects::SPI_COM_IF, spiCookie, 0);
|
||||
mgmRm3100Handler->setStartUpImmediately();
|
||||
#if FSFW_HAL_RM3100_MGM_DEBUG == 1
|
||||
mgmRm3100Handler->setToGoToNormalMode(true);
|
||||
#endif
|
||||
|
||||
spiCookie =
|
||||
new SpiCookie(addresses::MGM_2_LIS3, gpioIds::MGM_2_LIS3_CS, spiDev,
|
||||
MGMLIS3MDL::MAX_BUFFER_SIZE, spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
|
||||
mgmLis3Handler =
|
||||
new MgmLIS3MDLHandler(objects::MGM_2_LIS3_HANDLER, objects::SPI_COM_IF, spiCookie, 0);
|
||||
mgmLis3Handler->setStartUpImmediately();
|
||||
#if FSFW_HAL_LIS3MDL_MGM_DEBUG == 1
|
||||
mgmLis3Handler->setToGoToNormalMode(true);
|
||||
#endif
|
||||
|
||||
spiCookie =
|
||||
new SpiCookie(addresses::MGM_3_RM3100, gpioIds::MGM_3_RM3100_CS, spiDev,
|
||||
RM3100::MAX_BUFFER_SIZE, spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
|
||||
mgmRm3100Handler =
|
||||
new MgmRM3100Handler(objects::MGM_3_RM3100_HANDLER, objects::SPI_COM_IF, spiCookie, 0);
|
||||
mgmRm3100Handler->setStartUpImmediately();
|
||||
#if FSFW_HAL_RM3100_MGM_DEBUG == 1
|
||||
mgmRm3100Handler->setToGoToNormalMode(true);
|
||||
#endif
|
||||
|
||||
spiCookie =
|
||||
new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, spiDev,
|
||||
ADIS16507::MAXIMUM_REPLY_SIZE, spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
|
||||
auto adisHandler =
|
||||
new GyroADIS16507Handler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_COM_IF, spiCookie);
|
||||
adisHandler->setStartUpImmediately();
|
||||
spiCookie =
|
||||
new SpiCookie(addresses::GYRO_1_L3G, gpioIds::GYRO_1_L3G_CS, spiDev, L3GD20H::MAX_BUFFER_SIZE,
|
||||
spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
|
||||
auto gyroL3gHandler =
|
||||
new GyroHandlerL3GD20H(objects::GYRO_1_L3G_HANDLER, objects::SPI_COM_IF, spiCookie, 0);
|
||||
gyroL3gHandler->setStartUpImmediately();
|
||||
#if FSFW_HAL_L3GD20_GYRO_DEBUG == 1
|
||||
gyroL3gHandler->setToGoToNormalMode(true);
|
||||
#endif
|
||||
|
||||
spiCookie =
|
||||
new SpiCookie(addresses::GYRO_2_ADIS, gpioIds::GYRO_2_ADIS_CS, spiDev,
|
||||
ADIS16507::MAXIMUM_REPLY_SIZE, spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
|
||||
adisHandler =
|
||||
new GyroADIS16507Handler(objects::GYRO_2_ADIS_HANDLER, objects::SPI_COM_IF, spiCookie);
|
||||
adisHandler->setStartUpImmediately();
|
||||
|
||||
spiCookie =
|
||||
new SpiCookie(addresses::GYRO_3_L3G, gpioIds::GYRO_3_L3G_CS, spiDev, L3GD20H::MAX_BUFFER_SIZE,
|
||||
spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
|
||||
gyroL3gHandler =
|
||||
new GyroHandlerL3GD20H(objects::GYRO_3_L3G_HANDLER, objects::SPI_COM_IF, spiCookie, 0);
|
||||
gyroL3gHandler->setStartUpImmediately();
|
||||
#if FSFW_HAL_L3GD20_GYRO_DEBUG == 1
|
||||
gyroL3gHandler->setToGoToNormalMode(true);
|
||||
#endif
|
||||
|
||||
#endif /* RPI_TEST_ACS_BOARD == 1 */
|
||||
|
||||
#if OBSW_ADD_TEST_CODE == 1
|
||||
createTestTasks();
|
||||
#endif /* OBSW_ADD_TEST_CODE == 1 */
|
||||
}
|
||||
|
||||
void ObjectFactory::createTestTasks() {
|
||||
new TestTask(objects::TEST_TASK);
|
||||
|
||||
#if RPI_ADD_SPI_TEST == 1
|
||||
#if OBSW_ADD_SPI_TEST_CODE == 1
|
||||
new SpiTestClass(objects::SPI_TEST, gpioIF);
|
||||
#endif
|
||||
|
||||
#if RPI_ADD_UART_TEST == 1
|
||||
#if OBSW_ADD_UART_TEST_CODE == 1
|
||||
new UartTestClass(objects::UART_TEST);
|
||||
#else
|
||||
new UartComIF(objects::UART_COM_IF);
|
||||
@ -108,72 +201,30 @@ void ObjectFactory::produce(void* args){
|
||||
new LibgpiodTest(objects::LIBGPIOD_TEST, objects::GPIO_IF, gpioCookieLoopback);
|
||||
#endif /* RPI_LOOPBACK_TEST_GPIO == 1 */
|
||||
|
||||
#if RPI_TEST_ACS_BOARD == 1
|
||||
if(gpioCookie == nullptr) {
|
||||
gpioCookie = new GpioCookie();
|
||||
}
|
||||
gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_0_LIS3_CS, gpio::MGM_0_BCM_PIN,
|
||||
"MGM_0_LIS3", gpio::Direction::OUT, 1);
|
||||
gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_1_RM3100_CS, gpio::MGM_1_BCM_PIN,
|
||||
"MGM_1_RM3100", gpio::Direction::OUT, 1);
|
||||
gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_2_LIS3_CS, gpio::MGM_2_BCM_PIN,
|
||||
"MGM_2_LIS3", gpio::Direction::OUT, 1);
|
||||
gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_3_RM3100_CS, gpio::MGM_3_BCM_PIN,
|
||||
"MGM_3_RM3100", gpio::Direction::OUT, 1);
|
||||
gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_0_ADIS_CS, gpio::GYRO_0_BCM_PIN,
|
||||
"GYRO_0_ADIS", gpio::Direction::OUT, 1);
|
||||
gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_1_L3G_CS, gpio::GYRO_1_BCM_PIN,
|
||||
"GYRO_1_L3G", gpio::Direction::OUT, 1);
|
||||
gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_2_L3G_CS, gpio::GYRO_2_BCM_PIN,
|
||||
"GYRO_2_L3G", gpio::Direction::OUT, 1);
|
||||
gpioIF->addGpios(gpioCookie);
|
||||
|
||||
spiDev = "/dev/spidev0.0";
|
||||
spiCookie = new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, spiDev,
|
||||
MGMLIS3MDL::MAX_BUFFER_SIZE, spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
|
||||
auto mgmLis3Handler = new MGMHandlerLIS3MDL(objects::MGM_0_LIS3_HANDLER,
|
||||
objects::SPI_COM_IF, spiCookie);
|
||||
mgmLis3Handler->setStartUpImmediately();
|
||||
|
||||
spiCookie = new SpiCookie(addresses::MGM_1_RM3100, gpioIds::MGM_1_RM3100_CS, spiDev,
|
||||
RM3100::MAX_BUFFER_SIZE, spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
|
||||
auto mgmRm3100Handler = new MGMHandlerRM3100(objects::MGM_1_RM3100_HANDLER,
|
||||
objects::SPI_COM_IF, spiCookie);
|
||||
mgmRm3100Handler->setStartUpImmediately();
|
||||
|
||||
spiCookie = new SpiCookie(addresses::GYRO_1_L3G, gpioIds::GYRO_1_L3G_CS, spiDev,
|
||||
L3GD20H::MAX_BUFFER_SIZE, spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
|
||||
auto gyroL3gHandler = new GyroHandlerL3GD20H(objects::GYRO_1_L3G_HANDLER, objects::SPI_COM_IF,
|
||||
spiCookie);
|
||||
gyroL3gHandler->setStartUpImmediately();
|
||||
|
||||
#endif /* RPI_TEST_ACS_BOARD == 1 */
|
||||
|
||||
#if RPI_TEST_ADIS16507 == 1
|
||||
if(gpioCookie == nullptr) {
|
||||
if (gpioCookie == nullptr) {
|
||||
gpioCookie = new GpioCookie();
|
||||
}
|
||||
gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_0_ADIS_CS, gpio::GYRO_0_BCM_PIN,
|
||||
"GYRO_0_ADIS", gpio::Direction::OUT, 1);
|
||||
gpioIF->addGpios(gpioCookie);
|
||||
|
||||
spiDev = "/dev/spidev0.0";
|
||||
spiDev = "/dev/spidev0.1";
|
||||
spiCookie = new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, spiDev,
|
||||
ADIS16507::MAXIMUM_REPLY_SIZE, spi::DEFAULT_ADIS16507_MODE, spi::DEFAULT_ADIS16507_SPEED,
|
||||
nullptr, nullptr);
|
||||
auto adisGyroHandler = new GyroADIS16507Handler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_COM_IF, spiCookie);
|
||||
ADIS16507::MAXIMUM_REPLY_SIZE, spi::DEFAULT_ADIS16507_MODE,
|
||||
spi::DEFAULT_ADIS16507_SPEED, nullptr, nullptr);
|
||||
auto adisGyroHandler =
|
||||
new GyroADIS16507Handler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_COM_IF, spiCookie);
|
||||
adisGyroHandler->setStartUpImmediately();
|
||||
#endif /* RPI_TEST_ADIS16507 == 1 */
|
||||
|
||||
#if RPI_TEST_GPS_HANDLER == 1
|
||||
UartCookie* uartCookie = new UartCookie(objects::GPS0_HANDLER, "/dev/serial0",
|
||||
UartModes::CANONICAL, 9600, 1024);
|
||||
UartCookie* uartCookie =
|
||||
new UartCookie(objects::GPS0_HANDLER, "/dev/serial0", UartModes::CANONICAL, 9600, 1024);
|
||||
uartCookie->setToFlushInput(true);
|
||||
uartCookie->setReadCycles(6);
|
||||
GPSHyperionHandler* gpsHandler = new GPSHyperionHandler(objects::GPS0_HANDLER,
|
||||
objects::UART_COM_IF, uartCookie, false);
|
||||
GPSHyperionHandler* gpsHandler =
|
||||
new GPSHyperionHandler(objects::GPS0_HANDLER, objects::UART_COM_IF, uartCookie, false);
|
||||
gpsHandler->setStartUpImmediately();
|
||||
#endif
|
||||
|
||||
#endif /* OBSW_ADD_TEST_CODE == 1 */
|
||||
}
|
||||
|
@ -1,10 +1,11 @@
|
||||
#ifndef BSP_LINUX_OBJECTFACTORY_H_
|
||||
#define BSP_LINUX_OBJECTFACTORY_H_
|
||||
|
||||
|
||||
namespace ObjectFactory {
|
||||
void setStatics();
|
||||
void produce(void* args);
|
||||
};
|
||||
void setStatics();
|
||||
void produce(void* args);
|
||||
|
||||
void createTestTasks();
|
||||
}; // namespace ObjectFactory
|
||||
|
||||
#endif /* BSP_LINUX_OBJECTFACTORY_H_ */
|
||||
|
@ -1,7 +1,7 @@
|
||||
target_sources(${TARGET_NAME} PRIVATE
|
||||
target_sources(${OBSW_NAME} PRIVATE
|
||||
print.c
|
||||
)
|
||||
|
||||
target_include_directories(${TARGET_NAME} PUBLIC
|
||||
target_include_directories(${OBSW_NAME} PUBLIC
|
||||
${CMAKE_CURRENT_SOURCE_DIR}
|
||||
)
|
||||
|
@ -7,7 +7,8 @@ extern "C" void __gcov_flush();
|
||||
#else
|
||||
void __gcov_flush() {
|
||||
sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if "
|
||||
"coverage information is desired.\n" << std::flush;
|
||||
"coverage information is desired.\n"
|
||||
<< std::flush;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
@ -1,14 +1,10 @@
|
||||
#include <bsp_q7s/boardconfig/print.h>
|
||||
#include <bsp_linux_board/boardconfig/print.h>
|
||||
#include <stdio.h>
|
||||
|
||||
void printChar(const char* character, bool errStream) {
|
||||
if(errStream) {
|
||||
if (errStream) {
|
||||
putc(*character, stderr);
|
||||
return;
|
||||
}
|
||||
putc(*character, stdout);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
@ -19,13 +19,14 @@
|
||||
|
||||
/* Adapt these values accordingly */
|
||||
namespace gpio {
|
||||
static constexpr uint8_t MGM_0_BCM_PIN = 0;
|
||||
static constexpr uint8_t MGM_1_BCM_PIN = 1;
|
||||
static constexpr uint8_t MGM_2_BCM_PIN = 17;
|
||||
static constexpr uint8_t MGM_3_BCM_PIN = 27;
|
||||
static constexpr uint8_t MGM_0_BCM_PIN = 17;
|
||||
static constexpr uint8_t MGM_1_BCM_PIN = 27;
|
||||
static constexpr uint8_t MGM_2_BCM_PIN = 22;
|
||||
static constexpr uint8_t MGM_3_BCM_PIN = 23;
|
||||
static constexpr uint8_t GYRO_0_BCM_PIN = 5;
|
||||
static constexpr uint8_t GYRO_1_BCM_PIN = 6;
|
||||
static constexpr uint8_t GYRO_2_BCM_PIN = 4;
|
||||
static constexpr uint8_t GYRO_2_BCM_PIN = 13;
|
||||
static constexpr uint8_t GYRO_3_BCM_PIN = 19;
|
||||
}
|
||||
|
||||
#endif /* BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_ */
|
||||
|
@ -1,4 +1,4 @@
|
||||
target_sources(${TARGET_NAME} PRIVATE
|
||||
target_sources(${OBSW_NAME} PRIVATE
|
||||
)
|
||||
|
||||
|
||||
|
@ -1,12 +1,11 @@
|
||||
#include <iostream>
|
||||
|
||||
#include "InitMission.h"
|
||||
#include "OBSWConfig.h"
|
||||
#include "OBSWVersion.h"
|
||||
|
||||
#include "fsfw/FSFWVersion.h"
|
||||
#include "fsfw/tasks/TaskFactory.h"
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#ifdef RASPBERRY_PI
|
||||
static const char* const BOARD_NAME = "Raspberry Pi";
|
||||
#elif defined(BEAGLEBONEBLACK)
|
||||
@ -19,21 +18,18 @@ static const char* const BOARD_NAME = "Unknown Board";
|
||||
* @brief This is the main program and entry point for the Raspberry Pi.
|
||||
* @return
|
||||
*/
|
||||
int main(void)
|
||||
{
|
||||
int main(void) {
|
||||
std::cout << "-- EIVE OBSW --" << std::endl;
|
||||
std::cout << "-- Compiled for Linux board " << BOARD_NAME << " --" << std::endl;
|
||||
std::cout << "-- OBSW " << SW_NAME << " v" << SW_VERSION << "." << SW_SUBVERSION <<
|
||||
"." << SW_REVISION << ", FSFW v" << FSFW_VERSION << "." << FSFW_SUBVERSION <<
|
||||
FSFW_REVISION << "--" << std::endl;
|
||||
std::cout << "-- OBSW " << SW_NAME << " v" << SW_VERSION << "." << SW_SUBVERSION << "."
|
||||
<< SW_REVISION << ", FSFW v" << FSFW_VERSION << "." << FSFW_SUBVERSION << FSFW_REVISION
|
||||
<< "--" << std::endl;
|
||||
std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
|
||||
|
||||
initmission::initMission();
|
||||
|
||||
for(;;) {
|
||||
for (;;) {
|
||||
/* Suspend main thread by sleeping it. */
|
||||
TaskFactory::delayTask(5000);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
@ -1,17 +1,25 @@
|
||||
target_sources(${TARGET_NAME} PUBLIC
|
||||
#simple mode
|
||||
add_executable(${SIMPLE_OBSW_NAME} EXCLUDE_FROM_ALL)
|
||||
target_compile_definitions(${SIMPLE_OBSW_NAME} PRIVATE "Q7S_SIMPLE_MODE")
|
||||
target_sources(${SIMPLE_OBSW_NAME} PUBLIC
|
||||
main.cpp
|
||||
)
|
||||
#I think this is unintentional? (produces linker errors for stuff in /linux)
|
||||
target_link_libraries(${SIMPLE_OBSW_NAME} PUBLIC
|
||||
${LIB_FSFW_NAME}
|
||||
)
|
||||
target_compile_definitions(${SIMPLE_OBSW_NAME} PRIVATE "Q7S_SIMPLE_MODE")
|
||||
add_subdirectory(simple)
|
||||
|
||||
target_sources(${OBSW_NAME} PUBLIC
|
||||
main.cpp
|
||||
)
|
||||
|
||||
add_subdirectory(boardtest)
|
||||
|
||||
if(Q7S_SIMPLE_MODE)
|
||||
add_subdirectory(simple)
|
||||
else()
|
||||
add_subdirectory(boardconfig)
|
||||
add_subdirectory(comIF)
|
||||
add_subdirectory(gpio)
|
||||
add_subdirectory(core)
|
||||
add_subdirectory(memory)
|
||||
add_subdirectory(spiCallbacks)
|
||||
add_subdirectory(devices)
|
||||
endif()
|
||||
add_subdirectory(boardconfig)
|
||||
add_subdirectory(comIF)
|
||||
add_subdirectory(core)
|
||||
add_subdirectory(memory)
|
||||
add_subdirectory(callbacks)
|
||||
add_subdirectory(devices)
|
||||
|
@ -1,7 +1,12 @@
|
||||
target_sources(${TARGET_NAME} PRIVATE
|
||||
target_sources(${OBSW_NAME} PRIVATE
|
||||
print.c
|
||||
)
|
||||
|
||||
target_include_directories(${TARGET_NAME} PUBLIC
|
||||
target_sources(${SIMPLE_OBSW_NAME} PRIVATE
|
||||
print.c
|
||||
)
|
||||
|
||||
|
||||
target_include_directories(${OBSW_NAME} PUBLIC
|
||||
${CMAKE_CURRENT_SOURCE_DIR}
|
||||
)
|
||||
|
@ -3,54 +3,98 @@
|
||||
|
||||
namespace q7s {
|
||||
|
||||
static constexpr char SPI_DEFAULT_DEV[] = "/dev/spidev2.0";
|
||||
static constexpr char SPI_RW_DEV[] = "/dev/spidev3.0";
|
||||
static constexpr char SPI_DEFAULT_DEV[] = "/dev/spi-main";
|
||||
static constexpr char SPI_RW_DEV[] = "/dev/spi-rw";
|
||||
|
||||
static constexpr char I2C_DEFAULT_DEV[] = "/dev/i2c-1";
|
||||
static constexpr char I2C_DEFAULT_DEV[] = "/dev/i2c-eive";
|
||||
|
||||
static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ttyUL3";
|
||||
static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ttyUL4";
|
||||
static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ttyUL8";
|
||||
static constexpr char UART_GNSS_DEV[] = "/dev/ul-gps";
|
||||
static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ul-plmpsoc";
|
||||
static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ul-plsv";
|
||||
static constexpr char UART_SYRLINKS_DEV[] = "/dev/ul-syrlinks";
|
||||
static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ul-str";
|
||||
|
||||
static constexpr char GPIO_ACS_BOARD_DEFAULT_CHIP[] = "gpiochip5";
|
||||
static constexpr char GPIO_MGM2_LIS3_CHIP[] = "gpiochip6";
|
||||
static constexpr char UIO_PDEC_REGISTERS[] = "/dev/uio0";
|
||||
static constexpr char UIO_PDEC_CONFIG_MEMORY[] = "/dev/uio2";
|
||||
static constexpr char UIO_PDEC_RAM[] = "/dev/uio3";
|
||||
static constexpr char UIO_PTME[] = "/dev/uio1";
|
||||
static constexpr int MAP_ID_PTME_CONFIG = 3;
|
||||
|
||||
// TODO: Determine new pins, additional ADIS gyro device
|
||||
static constexpr uint32_t GPIO_GYRO_0_ADIS_CS = 1;
|
||||
static constexpr uint32_t GPIO_GYRO_1_L3G_CS = 7;
|
||||
static constexpr uint32_t GPIO_GYRO_2_ADIS_CS = 3;
|
||||
static constexpr uint32_t GPIO_GYRO_3_L3G_CS = 3;
|
||||
namespace uiomapids {
|
||||
static const int PTME_VC0 = 0;
|
||||
static const int PTME_VC1 = 1;
|
||||
static const int PTME_VC2 = 2;
|
||||
static const int PTME_VC3 = 3;
|
||||
static const int PTME_CONFIG = 4;
|
||||
} // namespace uiomapids
|
||||
|
||||
static constexpr uint32_t GPIO_MGM_0_LIS3_CS = 5;
|
||||
static constexpr uint32_t GPIO_MGM_1_RM3100_CS = 16;
|
||||
static constexpr uint32_t GPIO_MGM_2_LIS3_CS = 0;
|
||||
static constexpr uint32_t GPIO_MGM_3_RM3100_CS = 10;
|
||||
namespace gpioNames {
|
||||
|
||||
static constexpr char GPIO_RW_DEFAULT_CHIP[] = "gpiochip5";
|
||||
static constexpr uint32_t GPIO_RW_0_CS = 7;
|
||||
static constexpr uint32_t GPIO_RW_1_CS = 3;
|
||||
static constexpr uint32_t GPIO_RW_2_CS = 11;
|
||||
static constexpr uint32_t GPIO_RW_3_CS = 6;
|
||||
static constexpr char GYRO_0_ADIS_CS[] = "gyro_0_adis_chip_select";
|
||||
static constexpr char GYRO_1_L3G_CS[] = "gyro_1_l3g_chip_select";
|
||||
static constexpr char GYRO_2_ADIS_CS[] = "gyro_2_adis_chip_select";
|
||||
static constexpr char GYRO_3_L3G_CS[] = "gyro_3_l3g_chip_select";
|
||||
static constexpr char MGM_0_CS[] = "mgm_0_lis3_chip_select";
|
||||
static constexpr char MGM_1_CS[] = "mgm_1_rm3100_chip_select";
|
||||
static constexpr char MGM_2_CS[] = "mgm_2_lis3_chip_select";
|
||||
static constexpr char MGM_3_CS[] = "mgm_3_rm3100_chip_select";
|
||||
static constexpr char RESET_GNSS_0[] = "reset_gnss_0";
|
||||
static constexpr char RESET_GNSS_1[] = "reset_gnss_1";
|
||||
static constexpr char GNSS_0_ENABLE[] = "enable_gnss_0";
|
||||
static constexpr char GNSS_1_ENABLE[] = "enable_gnss_1";
|
||||
static constexpr char GYRO_0_ENABLE[] = "enable_gyro_0";
|
||||
static constexpr char GYRO_2_ENABLE[] = "enable_gyro_2";
|
||||
static constexpr char GNSS_SELECT[] = "gnss_mux_select";
|
||||
static constexpr char GNSS_MUX_SELECT[] = "gnss_mux_select";
|
||||
|
||||
static constexpr char GPIO_RW_SPI_MUX_CHIP[] = "gpiochip11";
|
||||
static constexpr uint32_t GPIO_RW_SPI_MUX_CS = 57;
|
||||
static constexpr char HEATER_0[] = "heater0";
|
||||
static constexpr char HEATER_1[] = "heater1";
|
||||
static constexpr char HEATER_2[] = "heater2";
|
||||
static constexpr char HEATER_3[] = "heater3";
|
||||
static constexpr char HEATER_4[] = "heater4";
|
||||
static constexpr char HEATER_5[] = "heater5";
|
||||
static constexpr char HEATER_6[] = "heater6";
|
||||
static constexpr char HEATER_7[] = "heater7";
|
||||
static constexpr char SA_DPL_PIN_0[] = "sa_dpl_0";
|
||||
static constexpr char SA_DPL_PIN_1[] = "sa_dpl_1";
|
||||
static constexpr char SPI_MUX_BIT_0_PIN[] = "spi_mux_bit_0";
|
||||
static constexpr char SPI_MUX_BIT_1_PIN[] = "spi_mux_bit_1";
|
||||
static constexpr char SPI_MUX_BIT_2_PIN[] = "spi_mux_bit_2";
|
||||
static constexpr char SPI_MUX_BIT_3_PIN[] = "spi_mux_bit_3";
|
||||
static constexpr char SPI_MUX_BIT_4_PIN[] = "spi_mux_bit_4";
|
||||
static constexpr char SPI_MUX_BIT_5_PIN[] = "spi_mux_bit_5";
|
||||
static constexpr char EN_RW_CS[] = "en_rw_cs";
|
||||
static constexpr char EN_RW_1[] = "enable_rw_1";
|
||||
static constexpr char EN_RW_2[] = "enable_rw_2";
|
||||
static constexpr char EN_RW_3[] = "enable_rw_3";
|
||||
static constexpr char EN_RW_4[] = "enable_rw_4";
|
||||
|
||||
static constexpr char GPIO_HEATER_CHIP[] = "gpiochip7";
|
||||
static constexpr uint32_t GPIO_HEATER_0_PIN = 6;
|
||||
static constexpr uint32_t GPIO_HEATER_1_PIN = 12;
|
||||
static constexpr uint32_t GPIO_HEATER_2_PIN = 7;
|
||||
static constexpr uint32_t GPIO_HEATER_3_PIN = 5;
|
||||
static constexpr uint32_t GPIO_HEATER_4_PIN = 3;
|
||||
static constexpr uint32_t GPIO_HEATER_5_PIN = 0;
|
||||
static constexpr uint32_t GPIO_HEATER_6_PIN = 1;
|
||||
static constexpr uint32_t GPIO_HEATER_7_PIN = 11;
|
||||
static constexpr char RAD_SENSOR_CHIP_SELECT[] = "rad_sensor_chip_select";
|
||||
static constexpr char ENABLE_RADFET[] = "enable_radfet";
|
||||
static constexpr char PAPB_BUSY_SIGNAL_VC0[] = "papb_busy_signal_vc0";
|
||||
static constexpr char PAPB_EMPTY_SIGNAL_VC0[] = "papb_empty_signal_vc0";
|
||||
static constexpr char PAPB_BUSY_SIGNAL_VC1[] = "papb_busy_signal_vc1";
|
||||
static constexpr char PAPB_EMPTY_SIGNAL_VC1[] = "papb_empty_signal_vc1";
|
||||
static constexpr char PAPB_BUSY_SIGNAL_VC2[] = "papb_busy_signal_vc2";
|
||||
static constexpr char PAPB_EMPTY_SIGNAL_VC2[] = "papb_empty_signal_vc2";
|
||||
static constexpr char PAPB_BUSY_SIGNAL_VC3[] = "papb_busy_signal_vc3";
|
||||
static constexpr char PAPB_EMPTY_SIGNAL_VC3[] = "papb_empty_signal_vc3";
|
||||
static constexpr char RS485_EN_TX_CLOCK[] = "tx_clock_enable_ltc2872";
|
||||
static constexpr char RS485_EN_TX_DATA[] = "tx_data_enable_ltc2872";
|
||||
static constexpr char RS485_EN_RX_CLOCK[] = "rx_clock_enable_ltc2872";
|
||||
static constexpr char RS485_EN_RX_DATA[] = "rx_data_enable_ltc2872";
|
||||
static constexpr char PDEC_RESET[] = "pdec_reset";
|
||||
|
||||
static constexpr char GPIO_SOLAR_ARR_DEPL_CHIP[] = "gpiochip7";
|
||||
static constexpr uint32_t GPIO_SOL_DEPL_SA_0_PIN = 4;
|
||||
static constexpr uint32_t GPIO_SOL_DEPL_SA_1_PIN = 2;
|
||||
static constexpr char PL_PCDU_ENABLE_VBAT0[] = "enable_plpcdu_vbat0";
|
||||
static constexpr char PL_PCDU_ENABLE_VBAT1[] = "enable_plpcdu_vbat1";
|
||||
static constexpr char PL_PCDU_ENABLE_DRO[] = "enable_plpcdu_dro";
|
||||
static constexpr char PL_PCDU_ENABLE_X8[] = "enable_plpcdu_x8";
|
||||
static constexpr char PL_PCDU_ENABLE_TX[] = "enable_plpcdu_tx";
|
||||
static constexpr char PL_PCDU_ENABLE_HPA[] = "enable_plpcdu_hpa";
|
||||
static constexpr char PL_PCDU_ENABLE_MPA[] = "enable_plpcdu_mpa";
|
||||
static constexpr char PL_PCDU_ADC_CS[] = "plpcdu_adc_chip_select";
|
||||
|
||||
static constexpr char GPIO_RAD_SENSOR_CHIP[] = "gpiochip5";
|
||||
static constexpr uint32_t GPIO_RAD_SENSOR_CS = 19;
|
||||
}
|
||||
} // namespace gpioNames
|
||||
} // namespace q7s
|
||||
|
||||
#endif /* BSP_Q7S_BOARDCONFIG_BUSCONF_H_ */
|
||||
|
@ -7,7 +7,8 @@ extern "C" void __gcov_flush();
|
||||
#else
|
||||
void __gcov_flush() {
|
||||
sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if "
|
||||
"coverage information is desired.\n" << std::flush;
|
||||
"coverage information is desired.\n"
|
||||
<< std::flush;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
@ -2,13 +2,9 @@
|
||||
#include <stdio.h>
|
||||
|
||||
void printChar(const char* character, bool errStream) {
|
||||
if(errStream) {
|
||||
if (errStream) {
|
||||
putc(*character, stderr);
|
||||
return;
|
||||
}
|
||||
putc(*character, stdout);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
@ -3,7 +3,16 @@
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
#cmakedefine01 Q7S_SIMPLE_MODE
|
||||
/*******************************************************************/
|
||||
/** All of the following flags should be enabled for mission code */
|
||||
/*******************************************************************/
|
||||
|
||||
//! Timers can mess up the code when debugging
|
||||
//! All of this should be enabled for mission code!
|
||||
|
||||
/*******************************************************************/
|
||||
/** Other flags */
|
||||
/*******************************************************************/
|
||||
|
||||
#define Q7S_SD_NONE 0
|
||||
#define Q7S_SD_COLD_REDUNDANT 1
|
||||
@ -17,16 +26,6 @@
|
||||
|
||||
// Probably better if this is disabled for mission code. Convenient for development
|
||||
#define Q7S_CHECK_FOR_ALREADY_RUNNING_IMG 1
|
||||
#define Q7S_ADD_RTD_DEVICES 0
|
||||
|
||||
/* Only one of those 2 should be enabled! */
|
||||
/* Add code for ACS board */
|
||||
#define OBSW_ADD_ACS_BOARD 0
|
||||
#if OBSW_ADD_ACS_BOARD == 0
|
||||
#define Q7S_ADD_SPI_TEST 0
|
||||
#endif
|
||||
|
||||
#define Q7S_ADD_SYRLINKS_HANDLER 1
|
||||
|
||||
#define Q7S_SIMPLE_ADD_FILE_SYSTEM_TEST 0
|
||||
|
||||
|
@ -1,8 +1,10 @@
|
||||
target_sources(${TARGET_NAME} PRIVATE
|
||||
target_sources(${OBSW_NAME} PRIVATE
|
||||
FileSystemTest.cpp
|
||||
Q7STestTask.cpp
|
||||
)
|
||||
|
||||
|
||||
|
||||
|
||||
if(EIVE_BUILD_Q7S_SIMPLE_MODE)
|
||||
target_sources(${SIMPLE_OBSW_NAME} PRIVATE
|
||||
FileSystemTest.cpp
|
||||
)
|
||||
endif()
|
@ -1,26 +1,23 @@
|
||||
#include "FileSystemTest.h"
|
||||
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
|
||||
#include "fsfw/timemanager/Stopwatch.h"
|
||||
|
||||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
|
||||
enum SdCard {
|
||||
SDC0,
|
||||
SDC1
|
||||
};
|
||||
enum SdCard { SDC0, SDC1 };
|
||||
|
||||
FileSystemTest::FileSystemTest() {
|
||||
using namespace std;
|
||||
SdCard sdCard = SdCard::SDC0;
|
||||
cout << "SD Card Test for SD card " << static_cast<int>(sdCard) << std::endl;
|
||||
//Stopwatch stopwatch;
|
||||
// Stopwatch stopwatch;
|
||||
std::system("q7hw sd info all > /tmp/sd_status.txt");
|
||||
//stopwatch.stop(true);
|
||||
// stopwatch.stop(true);
|
||||
std::system("q7hw sd set 0 on > /tmp/sd_set.txt");
|
||||
//stopwatch.stop(true);
|
||||
// stopwatch.stop(true);
|
||||
std::system("q7hw sd set 0 off > /tmp/sd_set.txt");
|
||||
//stopwatch.stop(true);
|
||||
// stopwatch.stop(true);
|
||||
}
|
||||
|
||||
FileSystemTest::~FileSystemTest() {
|
||||
}
|
||||
FileSystemTest::~FileSystemTest() {}
|
||||
|
@ -2,12 +2,11 @@
|
||||
#define BSP_Q7S_BOARDTEST_FILESYSTEMTEST_H_
|
||||
|
||||
class FileSystemTest {
|
||||
public:
|
||||
public:
|
||||
FileSystemTest();
|
||||
virtual~ FileSystemTest();
|
||||
private:
|
||||
virtual ~FileSystemTest();
|
||||
|
||||
private:
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif /* BSP_Q7S_BOARDTEST_FILESYSTEMTEST_H_ */
|
||||
|
@ -1,41 +1,57 @@
|
||||
#include "Q7STestTask.h"
|
||||
|
||||
#include <bsp_q7s/core/CoreController.h>
|
||||
#include <bsp_q7s/memory/FileSystemHandler.h>
|
||||
#include <fsfw/objectmanager/ObjectManager.h>
|
||||
#include "Q7STestTask.h"
|
||||
#include <gps.h>
|
||||
#include <libgpsmm.h>
|
||||
|
||||
#include <cstdio>
|
||||
#include <ctime>
|
||||
#include <fstream>
|
||||
#include <iomanip>
|
||||
#include <iostream>
|
||||
#include <nlohmann/json.hpp>
|
||||
|
||||
#include "bsp_q7s/memory/SdCardManager.h"
|
||||
#include "bsp_q7s/memory/scratchApi.h"
|
||||
|
||||
#include "fsfw/timemanager/Stopwatch.h"
|
||||
#include "fsfw/tasks/TaskFactory.h"
|
||||
|
||||
#include "fsfw/timemanager/Stopwatch.h"
|
||||
#include "test/DummyParameter.h"
|
||||
|
||||
#include <nlohmann/json.hpp>
|
||||
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include <cstdio>
|
||||
|
||||
Q7STestTask::Q7STestTask(object_id_t objectId): TestTask(objectId) {
|
||||
Q7STestTask::Q7STestTask(object_id_t objectId) : TestTask(objectId) {
|
||||
doTestSdCard = false;
|
||||
doTestScratchApi = false;
|
||||
doTestGps = false;
|
||||
}
|
||||
|
||||
ReturnValue_t Q7STestTask::performOneShotAction() {
|
||||
//testSdCard();
|
||||
//testScratchApi();
|
||||
//testJsonLibDirect();
|
||||
//testDummyParams();
|
||||
//testProtHandler();
|
||||
//FsOpCodes opCode = FsOpCodes::ATTEMPT_DIR_REMOVAL_NON_EMPTY;
|
||||
//testFileSystemHandlerDirect(opCode);
|
||||
if (doTestSdCard) {
|
||||
testSdCard();
|
||||
}
|
||||
if (doTestScratchApi) {
|
||||
testScratchApi();
|
||||
}
|
||||
// testJsonLibDirect();
|
||||
// testDummyParams();
|
||||
// testProtHandler();
|
||||
FsOpCodes opCode = FsOpCodes::APPEND_TO_FILE;
|
||||
testFileSystemHandlerDirect(opCode);
|
||||
return TestTask::performOneShotAction();
|
||||
}
|
||||
|
||||
ReturnValue_t Q7STestTask::performPeriodicAction() {
|
||||
if (doTestGps) {
|
||||
testGpsDaemon();
|
||||
}
|
||||
return TestTask::performPeriodicAction();
|
||||
}
|
||||
|
||||
void Q7STestTask::testSdCard() {
|
||||
using namespace std;
|
||||
Stopwatch stopwatch;
|
||||
int result = std::system("q7hw sd info all > /tmp/sd_status.txt");
|
||||
if(result != 0) {
|
||||
if (result != 0) {
|
||||
sif::debug << "system call failed with " << result << endl;
|
||||
}
|
||||
ifstream sdStatus("/tmp/sd_status.txt");
|
||||
@ -44,11 +60,10 @@ void Q7STestTask::testSdCard() {
|
||||
while (std::getline(sdStatus, line)) {
|
||||
std::istringstream iss(line);
|
||||
string word;
|
||||
while(iss >> word) {
|
||||
if(word == "on") {
|
||||
while (iss >> word) {
|
||||
if (word == "on") {
|
||||
sif::info << "SD card " << static_cast<int>(idx) << " is on" << endl;
|
||||
}
|
||||
else if(word == "off") {
|
||||
} else if (word == "off") {
|
||||
sif::info << "SD card " << static_cast<int>(idx) << " is off" << endl;
|
||||
}
|
||||
}
|
||||
@ -69,23 +84,23 @@ void Q7STestTask::fileTests() {
|
||||
|
||||
void Q7STestTask::testScratchApi() {
|
||||
ReturnValue_t result = scratch::writeNumber("TEST", 1);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::debug << "Q7STestTask::scratchApiTest: Writing number failed" << std::endl;
|
||||
}
|
||||
int number = 0;
|
||||
result = scratch::readNumber("TEST", number);
|
||||
sif::info << "Q7STestTask::testScratchApi: Value for key \"TEST\": " << number << std::endl;
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::debug << "Q7STestTask::scratchApiTest: Reading number failed" << std::endl;
|
||||
}
|
||||
|
||||
result = scratch::writeString("TEST2", "halloWelt");
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::debug << "Q7STestTask::scratchApiTest: Writing string failed" << std::endl;
|
||||
}
|
||||
std::string string;
|
||||
result = scratch::readString("TEST2", string);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::debug << "Q7STestTask::scratchApiTest: Reading number failed" << std::endl;
|
||||
}
|
||||
sif::info << "Q7STestTask::testScratchApi: Value for key \"TEST2\": " << string << std::endl;
|
||||
@ -112,13 +127,12 @@ void Q7STestTask::testDummyParams() {
|
||||
DummyParameter param(mntPrefix, "dummy_json.txt");
|
||||
param.printKeys();
|
||||
param.print();
|
||||
if(not param.getJsonFileExists()) {
|
||||
if (not param.getJsonFileExists()) {
|
||||
param.writeJsonFile();
|
||||
}
|
||||
|
||||
ReturnValue_t result = param.readJsonFile();
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
}
|
||||
|
||||
param.setValue(DummyParameter::DUMMY_KEY_PARAM_1, 3);
|
||||
@ -127,17 +141,27 @@ void Q7STestTask::testDummyParams() {
|
||||
param.writeJsonFile();
|
||||
param.print();
|
||||
|
||||
int test = param.getValue<int>(DummyParameter::DUMMY_KEY_PARAM_1);
|
||||
std::string test2 = param.getValue<std::string>(DummyParameter::DUMMY_KEY_PARAM_2);
|
||||
int test = 0;
|
||||
result = param.getValue<int>(DummyParameter::DUMMY_KEY_PARAM_1, test);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::warning << "Q7STestTask::testDummyParams: Key " << DummyParameter::DUMMY_KEY_PARAM_1
|
||||
<< " does not exist" << std::endl;
|
||||
}
|
||||
std::string test2;
|
||||
result = param.getValue<std::string>(DummyParameter::DUMMY_KEY_PARAM_2, test2);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::warning << "Q7STestTask::testDummyParams: Key " << DummyParameter::DUMMY_KEY_PARAM_1
|
||||
<< " does not exist" << std::endl;
|
||||
}
|
||||
sif::info << "Test value (3 expected): " << test << std::endl;
|
||||
sif::info << "Test value 2 (\"blirb\" expected): " << test2 << std::endl;
|
||||
}
|
||||
|
||||
ReturnValue_t Q7STestTask::initialize() {
|
||||
coreController = ObjectManager::instance()->get<CoreController>(objects::CORE_CONTROLLER);
|
||||
if(coreController == nullptr) {
|
||||
sif::warning << "Q7STestTask::initialize: Could not retrieve CORE_CONTROLLER object" <<
|
||||
std::endl;
|
||||
if (coreController == nullptr) {
|
||||
sif::warning << "Q7STestTask::initialize: Could not retrieve CORE_CONTROLLER object"
|
||||
<< std::endl;
|
||||
}
|
||||
return TestTask::initialize();
|
||||
}
|
||||
@ -146,78 +170,92 @@ void Q7STestTask::testProtHandler() {
|
||||
bool opPerformed = false;
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
// If any chips are unlocked, lock them here
|
||||
result = coreController->setBootCopyProtection(
|
||||
CoreController::Chip::ALL_CHIP, CoreController::Copy::ALL_COPY, true,
|
||||
result = coreController->setBootCopyProtection(xsc::Chip::ALL_CHIP, xsc::Copy::ALL_COPY, true,
|
||||
opPerformed, true);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
|
||||
}
|
||||
|
||||
// unlock own copy
|
||||
result = coreController->setBootCopyProtection(
|
||||
CoreController::Chip::SELF_CHIP, CoreController::Copy::SELF_COPY, false,
|
||||
result = coreController->setBootCopyProtection(xsc::Chip::SELF_CHIP, xsc::Copy::SELF_COPY, false,
|
||||
opPerformed, true);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
|
||||
}
|
||||
if(not opPerformed) {
|
||||
if (not opPerformed) {
|
||||
sif::warning << "Q7STestTask::testProtHandler: No op performed" << std::endl;
|
||||
}
|
||||
int retval = std::system("print-chip-prot-status.sh");
|
||||
if(retval != 0) {
|
||||
if (retval != 0) {
|
||||
utility::handleSystemError(retval, "Q7STestTask::testProtHandler");
|
||||
}
|
||||
|
||||
// lock own copy
|
||||
result = coreController->setBootCopyProtection(
|
||||
CoreController::Chip::SELF_CHIP, CoreController::Copy::SELF_COPY, true,
|
||||
result = coreController->setBootCopyProtection(xsc::Chip::SELF_CHIP, xsc::Copy::SELF_COPY, true,
|
||||
opPerformed, true);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
|
||||
}
|
||||
if(not opPerformed) {
|
||||
if (not opPerformed) {
|
||||
sif::warning << "Q7STestTask::testProtHandler: No op performed" << std::endl;
|
||||
}
|
||||
retval = std::system("print-chip-prot-status.sh");
|
||||
if(retval != 0) {
|
||||
if (retval != 0) {
|
||||
utility::handleSystemError(retval, "Q7STestTask::testProtHandler");
|
||||
}
|
||||
|
||||
// unlock specific copy
|
||||
result = coreController->setBootCopyProtection(
|
||||
CoreController::Chip::CHIP_1, CoreController::Copy::COPY_1, false,
|
||||
result = coreController->setBootCopyProtection(xsc::Chip::CHIP_1, xsc::Copy::COPY_1, false,
|
||||
opPerformed, true);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
|
||||
}
|
||||
if(not opPerformed) {
|
||||
if (not opPerformed) {
|
||||
sif::warning << "Q7STestTask::testProtHandler: No op performed" << std::endl;
|
||||
}
|
||||
retval = std::system("print-chip-prot-status.sh");
|
||||
if(retval != 0) {
|
||||
if (retval != 0) {
|
||||
utility::handleSystemError(retval, "Q7STestTask::testProtHandler");
|
||||
}
|
||||
|
||||
// lock specific copy
|
||||
result = coreController->setBootCopyProtection(
|
||||
CoreController::Chip::CHIP_1, CoreController::Copy::COPY_1, true,
|
||||
result = coreController->setBootCopyProtection(xsc::Chip::CHIP_1, xsc::Copy::COPY_1, true,
|
||||
opPerformed, true);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
|
||||
}
|
||||
if(not opPerformed) {
|
||||
if (not opPerformed) {
|
||||
sif::warning << "Q7STestTask::testProtHandler: No op performed" << std::endl;
|
||||
}
|
||||
retval = std::system("print-chip-prot-status.sh");
|
||||
if(retval != 0) {
|
||||
if (retval != 0) {
|
||||
utility::handleSystemError(retval, "Q7STestTask::testProtHandler");
|
||||
}
|
||||
}
|
||||
|
||||
void Q7STestTask::testGpsDaemon() {
|
||||
gpsmm gpsmm(GPSD_SHARED_MEMORY, 0);
|
||||
gps_data_t* gps;
|
||||
gps = gpsmm.read();
|
||||
if (gps == nullptr) {
|
||||
sif::warning << "Q7STestTask: Reading GPS data failed" << std::endl;
|
||||
}
|
||||
sif::info << "-- Q7STestTask: GPS shared memory read test --" << std::endl;
|
||||
time_t timeRaw = gps->fix.time.tv_sec;
|
||||
std::tm* time = gmtime(&timeRaw);
|
||||
sif::info << "Time: " << std::put_time(time, "%c %Z") << std::endl;
|
||||
sif::info << "Visible satellites: " << gps->satellites_visible << std::endl;
|
||||
sif::info << "Satellites used: " << gps->satellites_used << std::endl;
|
||||
sif::info << "Fix (0:Not Seen|1:No Fix|2:2D|3:3D): " << gps->fix.mode << std::endl;
|
||||
sif::info << "Latitude: " << gps->fix.latitude << std::endl;
|
||||
sif::info << "Longitude: " << gps->fix.longitude << std::endl;
|
||||
sif::info << "Altitude(MSL): " << gps->fix.altMSL << std::endl;
|
||||
sif::info << "Speed(m/s): " << gps->fix.speed << std::endl;
|
||||
}
|
||||
|
||||
void Q7STestTask::testFileSystemHandlerDirect(FsOpCodes opCode) {
|
||||
auto fsHandler = ObjectManager::instance()->
|
||||
get<FileSystemHandler>(objects::FILE_SYSTEM_HANDLER);
|
||||
if(fsHandler == nullptr) {
|
||||
auto fsHandler = ObjectManager::instance()->get<FileSystemHandler>(objects::FILE_SYSTEM_HANDLER);
|
||||
if (fsHandler == nullptr) {
|
||||
sif::warning << "Q7STestTask::testFileSystemHandlerDirect: No FS handler running.."
|
||||
<< std::endl;
|
||||
}
|
||||
@ -226,112 +264,134 @@ void Q7STestTask::testFileSystemHandlerDirect(FsOpCodes opCode) {
|
||||
|
||||
// Lambda for common code
|
||||
auto createNonEmptyTmpDir = [&]() {
|
||||
if(not std::filesystem::exists("/tmp/test")) {
|
||||
result = fsHandler->createDirectory("/tmp/test", &cfg);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (not std::filesystem::exists("/tmp/test")) {
|
||||
result = fsHandler->createDirectory("/tmp", "test", false, &cfg);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
// Creating sample files
|
||||
sif::info << "Creating sample files in directory" << std::endl;
|
||||
result = fsHandler->createFile("/tmp/test", "test1.txt", nullptr, 0, &cfg);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
result = fsHandler->createFile("/tmp/test", "test2.txt", nullptr, 0, &cfg);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
return result;
|
||||
};
|
||||
|
||||
|
||||
switch(opCode) {
|
||||
case(FsOpCodes::CREATE_EMPTY_FILE_IN_TMP): {
|
||||
switch (opCode) {
|
||||
case (FsOpCodes::CREATE_EMPTY_FILE_IN_TMP): {
|
||||
// No mount prefix, cause file is created in tmp
|
||||
cfg.useMountPrefix = false;
|
||||
sif::info << "Creating empty file in /tmp folder" << std::endl;
|
||||
// Do not delete file, user can check existence in shell
|
||||
fsHandler->createFile("/tmp", "test.txt", nullptr, 0, &cfg);
|
||||
fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
|
||||
break;
|
||||
}
|
||||
case(FsOpCodes::REMOVE_TMP_FILE): {
|
||||
case (FsOpCodes::REMOVE_TMP_FILE): {
|
||||
sif::info << "Deleting /tmp/test.txt sample file" << std::endl;
|
||||
// No mount prefix, cause file is created in tmp
|
||||
cfg.useMountPrefix = false;
|
||||
if(not std::filesystem::exists("/tmp/test.txt")) {
|
||||
if (not std::filesystem::exists("/tmp/test.txt")) {
|
||||
// Creating sample file
|
||||
sif::info << "Creating sample file /tmp/test.txt to delete" << std::endl;
|
||||
fsHandler->createFile("/tmp", "test.txt", nullptr, 0, &cfg);
|
||||
fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
|
||||
}
|
||||
result = fsHandler->removeFile("/tmp", "test.txt", &cfg);
|
||||
if(result == HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::info << "File removed successfully" << std::endl;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
sif::warning << "File removal failed!" << std::endl;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case(FsOpCodes::CREATE_DIR_IN_TMP): {
|
||||
case (FsOpCodes::CREATE_DIR_IN_TMP): {
|
||||
// No mount prefix, cause file is created in tmp
|
||||
cfg.useMountPrefix = false;
|
||||
sif::info << "Creating empty file in /tmp folder" << std::endl;
|
||||
// Do not delete file, user can check existence in shell
|
||||
ReturnValue_t result = fsHandler->createDirectory("/tmp/test", &cfg);
|
||||
if(result == HasReturnvaluesIF::RETURN_OK) {
|
||||
ReturnValue_t result = fsHandler->createDirectory("/tmp/", "test", false, &cfg);
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::info << "Directory created successfully" << std::endl;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
sif::warning << "Directory creation failed!" << std::endl;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case(FsOpCodes::REMOVE_EMPTY_DIR_IN_TMP): {
|
||||
case (FsOpCodes::REMOVE_EMPTY_DIR_IN_TMP): {
|
||||
// No mount prefix, cause file is created in tmp
|
||||
cfg.useMountPrefix = false;
|
||||
if(not std::filesystem::exists("/tmp/test")) {
|
||||
result = fsHandler->createDirectory("/tmp/test", &cfg);
|
||||
}
|
||||
else {
|
||||
if (not std::filesystem::exists("/tmp/test")) {
|
||||
result = fsHandler->createDirectory("/tmp", "test", false, &cfg);
|
||||
} else {
|
||||
// Delete any leftover files to regular dir removal works
|
||||
std::remove("/tmp/test/*");
|
||||
}
|
||||
result = fsHandler->removeDirectory("/tmp/test", false, &cfg);
|
||||
if(result == HasReturnvaluesIF::RETURN_OK) {
|
||||
result = fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::info << "Directory removed successfully" << std::endl;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
sif::warning << "Directory removal failed!" << std::endl;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case(FsOpCodes::REMOVE_FILLED_DIR_IN_TMP): {
|
||||
case (FsOpCodes::REMOVE_FILLED_DIR_IN_TMP): {
|
||||
result = createNonEmptyTmpDir();
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return;
|
||||
}
|
||||
result = fsHandler->removeDirectory("/tmp/test", true, &cfg);
|
||||
if(result == HasReturnvaluesIF::RETURN_OK) {
|
||||
result = fsHandler->removeDirectory("/tmp/", "test", true, &cfg);
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::info << "Directory removed recursively successfully" << std::endl;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
sif::warning << "Recursive directory removal failed!" << std::endl;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case(FsOpCodes::ATTEMPT_DIR_REMOVAL_NON_EMPTY): {
|
||||
case (FsOpCodes::ATTEMPT_DIR_REMOVAL_NON_EMPTY): {
|
||||
result = createNonEmptyTmpDir();
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return;
|
||||
}
|
||||
result = fsHandler->removeDirectory("/tmp/test", false, &cfg);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
result = fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::info << "Directory removal attempt failed as expected" << std::endl;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
sif::warning << "Directory removal worked when it should not have!" << std::endl;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case (FsOpCodes::RENAME_FILE): {
|
||||
// No mount prefix, cause file is created in tmp
|
||||
cfg.useMountPrefix = false;
|
||||
if (std::filesystem::exists("/tmp/test.txt")) {
|
||||
fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
|
||||
}
|
||||
sif::info << "Creating empty file /tmp/test.txt and rename to /tmp/test2.txt" << std::endl;
|
||||
// Do not delete file, user can check existence in shell
|
||||
fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
|
||||
fsHandler->renameFile("/tmp/", "test.txt", "test2.txt", &cfg);
|
||||
break;
|
||||
}
|
||||
case (FsOpCodes::APPEND_TO_FILE): {
|
||||
// No mount prefix, cause file is created in tmp
|
||||
cfg.useMountPrefix = false;
|
||||
if (std::filesystem::exists("/tmp/test.txt")) {
|
||||
fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
|
||||
}
|
||||
if (std::filesystem::exists("/tmp/test.txt")) {
|
||||
fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
|
||||
}
|
||||
sif::info << "Creating empty file /tmp/test.txt and adding content" << std::endl;
|
||||
std::string content = "Hello World\n";
|
||||
// Do not delete file, user can check existence in shell
|
||||
fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
|
||||
fsHandler->appendToFile("/tmp/", "test.txt", reinterpret_cast<const uint8_t*>(content.data()),
|
||||
content.size(), 0, &cfg);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -3,14 +3,24 @@
|
||||
|
||||
#include "test/testtasks/TestTask.h"
|
||||
|
||||
class Q7STestTask: public TestTask {
|
||||
public:
|
||||
class CoreController;
|
||||
|
||||
class Q7STestTask : public TestTask {
|
||||
public:
|
||||
Q7STestTask(object_id_t objectId);
|
||||
|
||||
ReturnValue_t initialize() override;
|
||||
private:
|
||||
|
||||
private:
|
||||
bool doTestSdCard = false;
|
||||
bool doTestScratchApi = false;
|
||||
bool doTestGps = false;
|
||||
|
||||
CoreController* coreController = nullptr;
|
||||
ReturnValue_t performOneShotAction() override;
|
||||
ReturnValue_t performPeriodicAction() override;
|
||||
|
||||
void testGpsDaemon();
|
||||
|
||||
void testSdCard();
|
||||
void fileTests();
|
||||
@ -27,9 +37,10 @@ private:
|
||||
REMOVE_EMPTY_DIR_IN_TMP,
|
||||
ATTEMPT_DIR_REMOVAL_NON_EMPTY,
|
||||
REMOVE_FILLED_DIR_IN_TMP,
|
||||
RENAME_FILE,
|
||||
APPEND_TO_FILE,
|
||||
};
|
||||
void testFileSystemHandlerDirect(FsOpCodes opCode);
|
||||
};
|
||||
|
||||
|
||||
#endif /* BSP_Q7S_BOARDTEST_Q7STESTTASK_H_ */
|
||||
|
6
bsp_q7s/callbacks/CMakeLists.txt
Normal file
6
bsp_q7s/callbacks/CMakeLists.txt
Normal file
@ -0,0 +1,6 @@
|
||||
target_sources(${OBSW_NAME} PRIVATE
|
||||
rwSpiCallback.cpp
|
||||
gnssCallback.cpp
|
||||
pcduSwitchCb.cpp
|
||||
gpioCallbacks.cpp
|
||||
)
|
25
bsp_q7s/callbacks/gnssCallback.cpp
Normal file
25
bsp_q7s/callbacks/gnssCallback.cpp
Normal file
@ -0,0 +1,25 @@
|
||||
#include "gnssCallback.h"
|
||||
|
||||
#include "devices/gpioIds.h"
|
||||
#include "fsfw/tasks/TaskFactory.h"
|
||||
|
||||
ReturnValue_t gps::triggerGpioResetPin(void* args) {
|
||||
ResetArgs* resetArgs = reinterpret_cast<ResetArgs*>(args);
|
||||
if (args == nullptr) {
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
if (resetArgs->gpioComIF == nullptr) {
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
gpioId_t gpioId;
|
||||
if (resetArgs->gnss1) {
|
||||
gpioId = gpioIds::GNSS_1_NRESET;
|
||||
|
||||
} else {
|
||||
gpioId = gpioIds::GNSS_0_NRESET;
|
||||
}
|
||||
resetArgs->gpioComIF->pullLow(gpioId);
|
||||
TaskFactory::delayTask(resetArgs->waitPeriodMs);
|
||||
resetArgs->gpioComIF->pullHigh(gpioId);
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
19
bsp_q7s/callbacks/gnssCallback.h
Normal file
19
bsp_q7s/callbacks/gnssCallback.h
Normal file
@ -0,0 +1,19 @@
|
||||
#ifndef BSP_Q7S_CALLBACKS_GNSSCALLBACK_H_
|
||||
#define BSP_Q7S_CALLBACKS_GNSSCALLBACK_H_
|
||||
|
||||
#include "fsfw/returnvalues/HasReturnvaluesIF.h"
|
||||
#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
|
||||
|
||||
struct ResetArgs {
|
||||
bool gnss1 = false;
|
||||
LinuxLibgpioIF* gpioComIF = nullptr;
|
||||
uint32_t waitPeriodMs = 100;
|
||||
};
|
||||
|
||||
namespace gps {
|
||||
|
||||
ReturnValue_t triggerGpioResetPin(void* args);
|
||||
|
||||
}
|
||||
|
||||
#endif /* BSP_Q7S_CALLBACKS_GNSSCALLBACK_H_ */
|
487
bsp_q7s/callbacks/gpioCallbacks.cpp
Normal file
487
bsp_q7s/callbacks/gpioCallbacks.cpp
Normal file
@ -0,0 +1,487 @@
|
||||
#include "gpioCallbacks.h"
|
||||
|
||||
#include <devices/gpioIds.h>
|
||||
#include <fsfw/serviceinterface/ServiceInterface.h>
|
||||
#include <fsfw_hal/common/gpio/GpioCookie.h>
|
||||
#include <fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
|
||||
|
||||
#include "busConf.h"
|
||||
|
||||
namespace gpioCallbacks {
|
||||
|
||||
GpioIF* gpioComInterface;
|
||||
|
||||
void initSpiCsDecoder(GpioIF* gpioComIF) {
|
||||
using namespace gpio;
|
||||
ReturnValue_t result;
|
||||
|
||||
if (gpioComIF == nullptr) {
|
||||
sif::debug << "initSpiCsDecoder: Invalid gpioComIF" << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
gpioComInterface = gpioComIF;
|
||||
|
||||
GpioCookie* spiMuxGpios = new GpioCookie;
|
||||
|
||||
GpiodRegularByLineName* spiMuxBit = nullptr;
|
||||
/** Setting mux bit 1 to low will disable IC21 on the interface board */
|
||||
spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_0_PIN, "SPI Mux Bit 1",
|
||||
Direction::OUT, Levels::HIGH);
|
||||
spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_0, spiMuxBit);
|
||||
/** Setting mux bit 2 to low disables IC1 on the TCS board */
|
||||
spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_1_PIN, "SPI Mux Bit 2",
|
||||
Direction::OUT, Levels::HIGH);
|
||||
spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_1, spiMuxBit);
|
||||
/** Setting mux bit 3 to low disables IC2 on the TCS board and IC22 on the interface board */
|
||||
spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_2_PIN, "SPI Mux Bit 3",
|
||||
Direction::OUT, Levels::LOW);
|
||||
spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_2, spiMuxBit);
|
||||
|
||||
/** The following gpios can take arbitrary initial values */
|
||||
spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_3_PIN, "SPI Mux Bit 4",
|
||||
Direction::OUT, Levels::LOW);
|
||||
spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_3, spiMuxBit);
|
||||
spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_4_PIN, "SPI Mux Bit 5",
|
||||
Direction::OUT, Levels::LOW);
|
||||
spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_4, spiMuxBit);
|
||||
spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_5_PIN, "SPI Mux Bit 6",
|
||||
Direction::OUT, Levels::LOW);
|
||||
spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_5, spiMuxBit);
|
||||
GpiodRegularByLineName* enRwDecoder = new GpiodRegularByLineName(
|
||||
q7s::gpioNames::EN_RW_CS, "EN_RW_CS", Direction::OUT, Levels::HIGH);
|
||||
spiMuxGpios->addGpio(gpioIds::EN_RW_CS, enRwDecoder);
|
||||
|
||||
result = gpioComInterface->addGpios(spiMuxGpios);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "initSpiCsDecoder: Failed to add mux bit gpios to gpioComIF" << std::endl;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp, gpio::Levels value,
|
||||
void* args) {
|
||||
using namespace gpio;
|
||||
if (gpioComInterface == nullptr) {
|
||||
sif::debug << "spiCsDecoderCallback: No gpioComIF specified. Call initSpiCsDecoder "
|
||||
<< "to specify gpioComIF" << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
/* Reading is not supported by the callback function */
|
||||
if (gpioOp == gpio::GpioOperation::READ) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (value == Levels::HIGH) {
|
||||
switch (gpioId) {
|
||||
case (gpioIds::RTD_IC_3): {
|
||||
disableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_4): {
|
||||
disableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_5): {
|
||||
disableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_6): {
|
||||
disableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_7): {
|
||||
disableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_8): {
|
||||
disableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_9): {
|
||||
disableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_10): {
|
||||
disableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_11): {
|
||||
disableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_12): {
|
||||
disableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_13): {
|
||||
disableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_14): {
|
||||
disableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_15): {
|
||||
disableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_16): {
|
||||
disableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_17): {
|
||||
disableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_18): {
|
||||
disableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_0): {
|
||||
disableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_1): {
|
||||
disableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_2): {
|
||||
disableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_3): {
|
||||
disableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_4): {
|
||||
disableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_5): {
|
||||
disableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_6): {
|
||||
disableDecoderInterfaceBoardIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_7): {
|
||||
disableDecoderInterfaceBoardIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_8): {
|
||||
disableDecoderInterfaceBoardIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_9): {
|
||||
disableDecoderInterfaceBoardIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_10): {
|
||||
disableDecoderInterfaceBoardIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_11): {
|
||||
disableDecoderInterfaceBoardIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_RW1): {
|
||||
disableRwDecoder();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_RW2): {
|
||||
disableRwDecoder();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_RW3): {
|
||||
disableRwDecoder();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_RW4): {
|
||||
disableRwDecoder();
|
||||
break;
|
||||
}
|
||||
default:
|
||||
sif::debug << "spiCsDecoderCallback: Invalid gpio id " << gpioId << std::endl;
|
||||
}
|
||||
} else if (value == Levels::LOW) {
|
||||
switch (gpioId) {
|
||||
case (gpioIds::RTD_IC_3): {
|
||||
selectY7();
|
||||
enableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_4): {
|
||||
selectY6();
|
||||
enableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_5): {
|
||||
selectY5();
|
||||
enableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_6): {
|
||||
selectY4();
|
||||
enableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_7): {
|
||||
selectY3();
|
||||
enableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_8): {
|
||||
selectY2();
|
||||
enableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_9): {
|
||||
selectY1();
|
||||
enableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_10): {
|
||||
selectY0();
|
||||
enableDecoderTcsIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_11): {
|
||||
selectY7();
|
||||
enableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_12): {
|
||||
selectY6();
|
||||
enableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_13): {
|
||||
selectY5();
|
||||
enableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_14): {
|
||||
selectY4();
|
||||
enableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_15): {
|
||||
selectY3();
|
||||
enableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_16): {
|
||||
selectY2();
|
||||
enableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_17): {
|
||||
selectY1();
|
||||
enableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::RTD_IC_18): {
|
||||
selectY0();
|
||||
enableDecoderTcsIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_0): {
|
||||
selectY0();
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_1): {
|
||||
selectY1();
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_2): {
|
||||
selectY2();
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_3): {
|
||||
selectY3();
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_4): {
|
||||
selectY4();
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_5): {
|
||||
selectY5();
|
||||
enableDecoderInterfaceBoardIc1();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_6): {
|
||||
selectY0();
|
||||
enableDecoderInterfaceBoardIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_7): {
|
||||
selectY1();
|
||||
enableDecoderInterfaceBoardIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_8): {
|
||||
selectY2();
|
||||
enableDecoderInterfaceBoardIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_9): {
|
||||
selectY3();
|
||||
enableDecoderInterfaceBoardIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_10): {
|
||||
selectY4();
|
||||
enableDecoderInterfaceBoardIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_SUS_11): {
|
||||
selectY5();
|
||||
enableDecoderInterfaceBoardIc2();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_RW1): {
|
||||
selectY0();
|
||||
enableRwDecoder();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_RW2): {
|
||||
selectY1();
|
||||
enableRwDecoder();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_RW3): {
|
||||
selectY2();
|
||||
enableRwDecoder();
|
||||
break;
|
||||
}
|
||||
case (gpioIds::CS_RW4): {
|
||||
selectY3();
|
||||
enableRwDecoder();
|
||||
break;
|
||||
}
|
||||
default:
|
||||
sif::debug << "spiCsDecoderCallback: Invalid gpio id " << gpioId << std::endl;
|
||||
}
|
||||
} else {
|
||||
sif::debug << "spiCsDecoderCallback: Invalid value. Must be 0 or 1" << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void enableDecoderTcsIc1() {
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_0);
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
|
||||
}
|
||||
|
||||
void enableDecoderTcsIc2() {
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_0);
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
|
||||
}
|
||||
|
||||
void enableDecoderInterfaceBoardIc1() {
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
|
||||
}
|
||||
|
||||
void enableDecoderInterfaceBoardIc2() {
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
|
||||
}
|
||||
|
||||
void disableDecoderTcsIc1() {
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
|
||||
}
|
||||
|
||||
void disableDecoderTcsIc2() {
|
||||
// DO NOT CHANGE THE ORDER HERE
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
|
||||
}
|
||||
|
||||
void disableDecoderInterfaceBoardIc1() {
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
|
||||
}
|
||||
|
||||
void disableDecoderInterfaceBoardIc2() {
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
|
||||
}
|
||||
|
||||
void enableRwDecoder() { gpioComInterface->pullHigh(gpioIds::EN_RW_CS); }
|
||||
|
||||
void disableRwDecoder() { gpioComInterface->pullLow(gpioIds::EN_RW_CS); }
|
||||
|
||||
void selectY0() {
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
|
||||
}
|
||||
|
||||
void selectY1() {
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
|
||||
}
|
||||
|
||||
void selectY2() {
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
|
||||
}
|
||||
|
||||
void selectY3() {
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
|
||||
}
|
||||
|
||||
void selectY4() {
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
|
||||
}
|
||||
|
||||
void selectY5() {
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
|
||||
}
|
||||
|
||||
void selectY6() {
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
|
||||
}
|
||||
|
||||
void selectY7() {
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
|
||||
gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
|
||||
}
|
||||
|
||||
void disableAllDecoder() {
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_0);
|
||||
gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
|
||||
gpioComInterface->pullLow(gpioIds::EN_RW_CS);
|
||||
}
|
||||
|
||||
} // namespace gpioCallbacks
|
73
bsp_q7s/callbacks/gpioCallbacks.h
Normal file
73
bsp_q7s/callbacks/gpioCallbacks.h
Normal file
@ -0,0 +1,73 @@
|
||||
#ifndef LINUX_GPIO_GPIOCALLBACKS_H_
|
||||
#define LINUX_GPIO_GPIOCALLBACKS_H_
|
||||
|
||||
#include <fsfw_hal/common/gpio/GpioIF.h>
|
||||
#include <fsfw_hal/common/gpio/gpioDefinitions.h>
|
||||
|
||||
namespace gpioCallbacks {
|
||||
|
||||
/**
|
||||
* @brief This function initializes the GPIOs used to control the SN74LVC138APWR decoders on
|
||||
* the TCS Board and the interface board.
|
||||
*/
|
||||
void initSpiCsDecoder(GpioIF* gpioComIF);
|
||||
|
||||
/**
|
||||
* @brief This function implements the decoding to multiply gpios by using the decoder
|
||||
* chips SN74LVC138APWR on the TCS board and the interface board.
|
||||
*/
|
||||
void spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp, gpio::Levels value,
|
||||
void* args);
|
||||
|
||||
/**
|
||||
* @brief This function sets mux bits 1-3 to a state which will only enable the decoder
|
||||
* on the TCS board which is named to IC1 in the schematic.
|
||||
*/
|
||||
void enableDecoderTcsIc1();
|
||||
|
||||
/**
|
||||
* @brief This function sets mux bits 1-3 to a state which will only enable the decoder
|
||||
* on the TCS board which is named to IC2 in the schematic.
|
||||
*/
|
||||
void enableDecoderTcsIc2();
|
||||
|
||||
/**
|
||||
* @brief This function sets mux bits 1-3 to a state which will only enable the decoder
|
||||
* on the inteface board board which is named to IC21 in the schematic.
|
||||
*/
|
||||
void enableDecoderInterfaceBoardIc1();
|
||||
|
||||
/**
|
||||
* @brief This function sets mux bits 1-3 to a state which will only enable the decoder
|
||||
* on the inteface board board which is named to IC22 in the schematic.
|
||||
*/
|
||||
void enableDecoderInterfaceBoardIc2();
|
||||
|
||||
void disableDecoderTcsIc1();
|
||||
void disableDecoderTcsIc2();
|
||||
void disableDecoderInterfaceBoardIc1();
|
||||
void disableDecoderInterfaceBoardIc2();
|
||||
|
||||
/**
|
||||
* @brief Enables the reaction wheel chip select decoder (IC3).
|
||||
*/
|
||||
void enableRwDecoder();
|
||||
void disableRwDecoder();
|
||||
|
||||
/**
|
||||
* @brief This function disables all decoder.
|
||||
*/
|
||||
void disableAllDecoder();
|
||||
|
||||
/** The following functions enable the appropriate channel of the currently enabled decoder */
|
||||
void selectY0();
|
||||
void selectY1();
|
||||
void selectY2();
|
||||
void selectY3();
|
||||
void selectY4();
|
||||
void selectY5();
|
||||
void selectY6();
|
||||
void selectY7();
|
||||
} // namespace gpioCallbacks
|
||||
|
||||
#endif /* LINUX_GPIO_GPIOCALLBACKS_H_ */
|
32
bsp_q7s/callbacks/pcduSwitchCb.cpp
Normal file
32
bsp_q7s/callbacks/pcduSwitchCb.cpp
Normal file
@ -0,0 +1,32 @@
|
||||
#include "pcduSwitchCb.h"
|
||||
|
||||
#include <fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
|
||||
|
||||
#include "devices/gpioIds.h"
|
||||
|
||||
void pcdu::switchCallback(GOMSPACE::Pdu pdu, uint8_t channel, bool state, void* args) {
|
||||
LinuxLibgpioIF* gpioComIF = reinterpret_cast<LinuxLibgpioIF*>(args);
|
||||
if (gpioComIF == nullptr) {
|
||||
return;
|
||||
}
|
||||
if (pdu == GOMSPACE::Pdu::PDU1) {
|
||||
PDU1::SwitchChannels typedChannel = static_cast<PDU1::SwitchChannels>(channel);
|
||||
if (typedChannel == PDU1::SwitchChannels::ACS_A_SIDE) {
|
||||
if (state) {
|
||||
gpioComIF->pullHigh(gpioIds::GNSS_0_NRESET);
|
||||
} else {
|
||||
gpioComIF->pullLow(gpioIds::GNSS_0_NRESET);
|
||||
}
|
||||
}
|
||||
|
||||
} else if (pdu == GOMSPACE::Pdu::PDU2) {
|
||||
PDU2::SwitchChannels typedChannel = static_cast<PDU2::SwitchChannels>(channel);
|
||||
if (typedChannel == PDU2::SwitchChannels::ACS_B_SIDE) {
|
||||
if (state) {
|
||||
gpioComIF->pullHigh(gpioIds::GNSS_1_NRESET);
|
||||
} else {
|
||||
gpioComIF->pullLow(gpioIds::GNSS_1_NRESET);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
14
bsp_q7s/callbacks/pcduSwitchCb.h
Normal file
14
bsp_q7s/callbacks/pcduSwitchCb.h
Normal file
@ -0,0 +1,14 @@
|
||||
#ifndef BSP_Q7S_CALLBACKS_PCDUSWITCHCB_H_
|
||||
#define BSP_Q7S_CALLBACKS_PCDUSWITCHCB_H_
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
#include "mission/devices/devicedefinitions/GomspaceDefinitions.h"
|
||||
|
||||
namespace pcdu {
|
||||
|
||||
void switchCallback(GOMSPACE::Pdu pdu, uint8_t channel, bool state, void* args);
|
||||
|
||||
}
|
||||
|
||||
#endif /* BSP_Q7S_CALLBACKS_PCDUSWITCHCB_H_ */
|
232
bsp_q7s/callbacks/rwSpiCallback.cpp
Normal file
232
bsp_q7s/callbacks/rwSpiCallback.cpp
Normal file
@ -0,0 +1,232 @@
|
||||
#include "rwSpiCallback.h"
|
||||
|
||||
#include "devices/gpioIds.h"
|
||||
#include "fsfw/serviceinterface/ServiceInterface.h"
|
||||
#include "fsfw_hal/linux/UnixFileGuard.h"
|
||||
#include "fsfw_hal/linux/spi/SpiCookie.h"
|
||||
#include "mission/devices/RwHandler.h"
|
||||
|
||||
namespace rwSpiCallback {
|
||||
|
||||
ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sendData,
|
||||
size_t sendLen, void* args) {
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
|
||||
RwHandler* handler = reinterpret_cast<RwHandler*>(args);
|
||||
if (handler == nullptr) {
|
||||
sif::error << "rwSpiCallback::spiCallback: Pointer to handler is invalid" << std::endl;
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
|
||||
uint8_t writeBuffer[2];
|
||||
uint8_t writeSize = 0;
|
||||
|
||||
gpioId_t gpioId = cookie->getChipSelectPin();
|
||||
GpioIF* gpioIF = comIf->getGpioInterface();
|
||||
MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
|
||||
uint32_t timeoutMs = 0;
|
||||
MutexIF* mutex = comIf->getMutex(&timeoutType, &timeoutMs);
|
||||
if (mutex == nullptr or gpioIF == nullptr) {
|
||||
sif::debug << "rwSpiCallback::spiCallback: Mutex or GPIO interface invalid" << std::endl;
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
|
||||
int fileDescriptor = 0;
|
||||
std::string device = cookie->getSpiDevice();
|
||||
UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "rwSpiCallback::spiCallback");
|
||||
if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "rwSpiCallback::spiCallback: Failed to open device file" << std::endl;
|
||||
return SpiComIF::OPENING_FILE_FAILED;
|
||||
}
|
||||
spi::SpiModes spiMode = spi::SpiModes::MODE_0;
|
||||
uint32_t spiSpeed = 0;
|
||||
cookie->getSpiParameters(spiMode, spiSpeed, nullptr);
|
||||
comIf->setSpiSpeedAndMode(fileDescriptor, spiMode, spiSpeed);
|
||||
|
||||
result = mutex->lockMutex(timeoutType, timeoutMs);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::debug << "rwSpiCallback::spiCallback: Failed to lock mutex" << std::endl;
|
||||
return result;
|
||||
}
|
||||
|
||||
/** Sending frame start sign */
|
||||
writeBuffer[0] = 0x7E;
|
||||
writeSize = 1;
|
||||
|
||||
// Pull SPI CS low. For now, no support for active high given
|
||||
if (gpioId != gpio::NO_GPIO) {
|
||||
if (gpioIF->pullLow(gpioId) != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "rwSpiCallback::spiCallback: Failed to pull chip select low" << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
if (write(fileDescriptor, writeBuffer, writeSize) != static_cast<ssize_t>(writeSize)) {
|
||||
sif::error << "rwSpiCallback::spiCallback: Write failed!" << std::endl;
|
||||
closeSpi(gpioId, gpioIF, mutex);
|
||||
return RwHandler::SPI_WRITE_FAILURE;
|
||||
}
|
||||
|
||||
/** Encoding and sending command */
|
||||
size_t idx = 0;
|
||||
while (idx < sendLen) {
|
||||
switch (*(sendData + idx)) {
|
||||
case 0x7E:
|
||||
writeBuffer[0] = 0x7D;
|
||||
writeBuffer[1] = 0x5E;
|
||||
writeSize = 2;
|
||||
break;
|
||||
case 0x7D:
|
||||
writeBuffer[0] = 0x7D;
|
||||
writeBuffer[1] = 0x5D;
|
||||
writeSize = 2;
|
||||
break;
|
||||
default:
|
||||
writeBuffer[0] = *(sendData + idx);
|
||||
writeSize = 1;
|
||||
break;
|
||||
}
|
||||
if (write(fileDescriptor, writeBuffer, writeSize) != static_cast<ssize_t>(writeSize)) {
|
||||
sif::error << "rwSpiCallback::spiCallback: Write failed!" << std::endl;
|
||||
closeSpi(gpioId, gpioIF, mutex);
|
||||
return RwHandler::SPI_WRITE_FAILURE;
|
||||
}
|
||||
idx++;
|
||||
}
|
||||
|
||||
/** Sending frame end sign */
|
||||
writeBuffer[0] = 0x7E;
|
||||
writeSize = 1;
|
||||
|
||||
if (write(fileDescriptor, writeBuffer, writeSize) != static_cast<ssize_t>(writeSize)) {
|
||||
sif::error << "rwSpiCallback::spiCallback: Write failed!" << std::endl;
|
||||
closeSpi(gpioId, gpioIF, mutex);
|
||||
return RwHandler::SPI_WRITE_FAILURE;
|
||||
}
|
||||
|
||||
uint8_t* rxBuf = nullptr;
|
||||
result = comIf->getReadBuffer(cookie->getSpiAddress(), &rxBuf);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
closeSpi(gpioId, gpioIF, mutex);
|
||||
return result;
|
||||
}
|
||||
|
||||
size_t replyBufferSize = cookie->getMaxBufferSize();
|
||||
|
||||
/** There must be a delay of at least 20 ms after sending the command */
|
||||
usleep(RwDefinitions::SPI_REPLY_DELAY);
|
||||
|
||||
/**
|
||||
* The reaction wheel responds with empty frames while preparing the reply data.
|
||||
* However, receiving more than 5 empty frames will be interpreted as an error.
|
||||
*/
|
||||
uint8_t byteRead = 0;
|
||||
for (int idx = 0; idx < 10; idx++) {
|
||||
if (read(fileDescriptor, &byteRead, 1) != 1) {
|
||||
sif::error << "rwSpiCallback::spiCallback: Read failed" << std::endl;
|
||||
closeSpi(gpioId, gpioIF, mutex);
|
||||
return RwHandler::SPI_READ_FAILURE;
|
||||
}
|
||||
if (idx == 0) {
|
||||
if (byteRead != FLAG_BYTE) {
|
||||
sif::error << "Invalid data, expected start marker" << std::endl;
|
||||
closeSpi(gpioId, gpioIF, mutex);
|
||||
return RwHandler::NO_START_MARKER;
|
||||
}
|
||||
}
|
||||
|
||||
if (byteRead != FLAG_BYTE) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (idx == 9) {
|
||||
sif::error << "rwSpiCallback::spiCallback: Empty frame timeout" << std::endl;
|
||||
closeSpi(gpioId, gpioIF, mutex);
|
||||
return RwHandler::NO_REPLY;
|
||||
}
|
||||
}
|
||||
|
||||
#if FSFW_HAL_SPI_WIRETAPPING == 1
|
||||
sif::info << "RW start marker detected" << std::endl;
|
||||
#endif
|
||||
|
||||
size_t decodedFrameLen = 0;
|
||||
while (decodedFrameLen < replyBufferSize) {
|
||||
/** First byte already read in */
|
||||
if (decodedFrameLen != 0) {
|
||||
byteRead = 0;
|
||||
if (read(fileDescriptor, &byteRead, 1) != 1) {
|
||||
sif::error << "rwSpiCallback::spiCallback: Read failed" << std::endl;
|
||||
result = RwHandler::SPI_READ_FAILURE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (byteRead == FLAG_BYTE) {
|
||||
/** Reached end of frame */
|
||||
break;
|
||||
} else if (byteRead == 0x7D) {
|
||||
if (read(fileDescriptor, &byteRead, 1) != 1) {
|
||||
sif::error << "rwSpiCallback::spiCallback: Read failed" << std::endl;
|
||||
result = RwHandler::SPI_READ_FAILURE;
|
||||
break;
|
||||
}
|
||||
if (byteRead == 0x5E) {
|
||||
*(rxBuf + decodedFrameLen) = 0x7E;
|
||||
decodedFrameLen++;
|
||||
continue;
|
||||
} else if (byteRead == 0x5D) {
|
||||
*(rxBuf + decodedFrameLen) = 0x7D;
|
||||
decodedFrameLen++;
|
||||
continue;
|
||||
} else {
|
||||
sif::error << "rwSpiCallback::spiCallback: Invalid substitute" << std::endl;
|
||||
closeSpi(gpioId, gpioIF, mutex);
|
||||
result = RwHandler::INVALID_SUBSTITUTE;
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
*(rxBuf + decodedFrameLen) = byteRead;
|
||||
decodedFrameLen++;
|
||||
continue;
|
||||
}
|
||||
|
||||
/**
|
||||
* There might be the unlikely case that each byte in a get-telemetry reply has been
|
||||
* replaced by its substitute. Than the next byte must correspond to the end sign 0x7E.
|
||||
* Otherwise there might be something wrong.
|
||||
*/
|
||||
if (decodedFrameLen == replyBufferSize) {
|
||||
if (read(fileDescriptor, &byteRead, 1) != 1) {
|
||||
sif::error << "rwSpiCallback::spiCallback: Failed to read last byte" << std::endl;
|
||||
result = RwHandler::SPI_READ_FAILURE;
|
||||
break;
|
||||
}
|
||||
if (byteRead != 0x7E) {
|
||||
sif::error << "rwSpiCallback::spiCallback: Missing end sign 0x7E" << std::endl;
|
||||
decodedFrameLen--;
|
||||
result = RwHandler::MISSING_END_SIGN;
|
||||
break;
|
||||
}
|
||||
}
|
||||
result = HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
cookie->setTransferSize(decodedFrameLen);
|
||||
|
||||
closeSpi(gpioId, gpioIF, mutex);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void closeSpi(gpioId_t gpioId, GpioIF* gpioIF, MutexIF* mutex) {
|
||||
if (gpioId != gpio::NO_GPIO) {
|
||||
if (gpioIF->pullHigh(gpioId) != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "closeSpi: Failed to pull chip select high" << std::endl;
|
||||
}
|
||||
}
|
||||
if (mutex->unlockMutex() != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "rwSpiCallback::closeSpi: Failed to unlock mutex" << std::endl;
|
||||
;
|
||||
}
|
||||
}
|
||||
} // namespace rwSpiCallback
|
@ -1,13 +1,15 @@
|
||||
#ifndef BSP_Q7S_RW_SPI_CALLBACK_H_
|
||||
#define BSP_Q7S_RW_SPI_CALLBACK_H_
|
||||
|
||||
#include <fsfw/returnvalues/HasReturnvaluesIF.h>
|
||||
#include <fsfw_hal/linux/spi/SpiComIF.h>
|
||||
#include <fsfw_hal/common/gpio/GpioCookie.h>
|
||||
|
||||
#include "fsfw/returnvalues/HasReturnvaluesIF.h"
|
||||
#include "fsfw_hal/common/gpio/GpioCookie.h"
|
||||
#include "fsfw_hal/linux/spi/SpiComIF.h"
|
||||
|
||||
namespace rwSpiCallback {
|
||||
|
||||
//! This is the end and start marker of the frame datalinklayer
|
||||
static constexpr uint8_t FLAG_BYTE = 0x7E;
|
||||
|
||||
/**
|
||||
* @brief This is the callback function to send commands to the nano avionics reaction wheels and
|
||||
* receive the replies.
|
||||
@ -28,7 +30,7 @@ namespace rwSpiCallback {
|
||||
* To switch between the to SPI peripherals, an EMIO is used which will also be controlled
|
||||
* by this function.
|
||||
*/
|
||||
ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie *cookie, const uint8_t *sendData,
|
||||
ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sendData,
|
||||
size_t sendLen, void* args);
|
||||
|
||||
/**
|
||||
@ -40,5 +42,5 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie *cookie, const uint8_t *sen
|
||||
*/
|
||||
void closeSpi(gpioId_t gpioId, GpioIF* gpioIF, MutexIF* mutex);
|
||||
|
||||
}
|
||||
} // namespace rwSpiCallback
|
||||
#endif /* BSP_Q7S_RW_SPI_CALLBACK_H_ */
|
@ -1,4 +1,4 @@
|
||||
target_sources(${TARGET_NAME} PRIVATE
|
||||
target_sources(${OBSW_NAME} PRIVATE
|
||||
)
|
||||
|
||||
|
||||
|
@ -1,6 +1,10 @@
|
||||
target_sources(${TARGET_NAME} PRIVATE
|
||||
target_sources(${OBSW_NAME} PRIVATE
|
||||
CoreController.cpp
|
||||
obsw.cpp
|
||||
InitMission.cpp
|
||||
ObjectFactory.cpp
|
||||
)
|
||||
|
||||
target_sources(${SIMPLE_OBSW_NAME} PRIVATE
|
||||
InitMission.cpp
|
||||
)
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -2,59 +2,95 @@
|
||||
#define BSP_Q7S_CORE_CORECONTROLLER_H_
|
||||
|
||||
#include <fsfw/globalfunctions/PeriodicOperationDivider.h>
|
||||
#include "fsfw/controller/ExtendedControllerBase.h"
|
||||
#include <libxiphos.h>
|
||||
|
||||
#include <cstddef>
|
||||
|
||||
#include "bsp_q7s/memory/SdCardManager.h"
|
||||
|
||||
#include "events/subsystemIdRanges.h"
|
||||
|
||||
#include "fsfw/controller/ExtendedControllerBase.h"
|
||||
|
||||
class Timer;
|
||||
class SdCardManager;
|
||||
|
||||
class CoreController: public ExtendedControllerBase {
|
||||
public:
|
||||
enum Chip: uint8_t {
|
||||
CHIP_0,
|
||||
CHIP_1,
|
||||
NO_CHIP,
|
||||
SELF_CHIP,
|
||||
ALL_CHIP
|
||||
};
|
||||
namespace xsc {
|
||||
|
||||
enum Copy: uint8_t {
|
||||
COPY_0,
|
||||
COPY_1,
|
||||
NO_COPY,
|
||||
SELF_COPY,
|
||||
ALL_COPY
|
||||
};
|
||||
enum Chip : int { CHIP_0, CHIP_1, NO_CHIP, SELF_CHIP, ALL_CHIP };
|
||||
enum Copy : int { COPY_0, COPY_1, NO_COPY, SELF_COPY, ALL_COPY };
|
||||
|
||||
} // namespace xsc
|
||||
|
||||
struct RebootFile {
|
||||
static constexpr uint8_t DEFAULT_MAX_BOOT_CNT = 10;
|
||||
|
||||
bool enabled = true;
|
||||
size_t maxCount = DEFAULT_MAX_BOOT_CNT;
|
||||
uint32_t img00Cnt = 0;
|
||||
uint32_t img01Cnt = 0;
|
||||
uint32_t img10Cnt = 0;
|
||||
uint32_t img11Cnt = 0;
|
||||
bool img00Lock = false;
|
||||
bool img01Lock = false;
|
||||
bool img10Lock = false;
|
||||
bool img11Lock = false;
|
||||
uint32_t* relevantBootCnt = &img00Cnt;
|
||||
bool bootFlag = false;
|
||||
xsc::Chip lastChip = xsc::Chip::CHIP_0;
|
||||
xsc::Copy lastCopy = xsc::Copy::COPY_0;
|
||||
xsc::Chip mechanismNextChip = xsc::Chip::NO_CHIP;
|
||||
xsc::Copy mechanismNextCopy = xsc::Copy::NO_COPY;
|
||||
};
|
||||
|
||||
class CoreController : public ExtendedControllerBase {
|
||||
public:
|
||||
static xsc::Chip CURRENT_CHIP;
|
||||
static xsc::Copy CURRENT_COPY;
|
||||
|
||||
static constexpr char CHIP_PROT_SCRIPT[] = "/home/root/scripts/get-chip-prot-status.sh";
|
||||
static constexpr char CHIP_STATE_FILE[] = "/tmp/chip_prot_status.txt";
|
||||
static constexpr char CURR_COPY_FILE[] = "/tmp/curr_copy.txt";
|
||||
static constexpr char VERSION_FILE[] = "/conf/sd_status";
|
||||
static constexpr char CONF_FOLDER[] = "conf";
|
||||
static constexpr char VERSION_FILE_NAME[] = "version.txt";
|
||||
static constexpr char REBOOT_FILE_NAME[] = "reboot.txt";
|
||||
const std::string VERSION_FILE =
|
||||
"/" + std::string(CONF_FOLDER) + "/" + std::string(VERSION_FILE_NAME);
|
||||
const std::string REBOOT_FILE =
|
||||
"/" + std::string(CONF_FOLDER) + "/" + std::string(REBOOT_FILE_NAME);
|
||||
|
||||
static constexpr ActionId_t LIST_DIRECTORY_INTO_FILE = 0;
|
||||
static constexpr ActionId_t SWITCH_REBOOT_FILE_HANDLING = 5;
|
||||
static constexpr ActionId_t RESET_REBOOT_COUNTERS = 6;
|
||||
static constexpr ActionId_t SWITCH_IMG_LOCK = 7;
|
||||
static constexpr ActionId_t SET_MAX_REBOOT_CNT = 8;
|
||||
|
||||
static constexpr ActionId_t REBOOT_OBC = 32;
|
||||
static constexpr ActionId_t MOUNT_OTHER_COPY = 33;
|
||||
|
||||
|
||||
static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CORE;
|
||||
|
||||
static constexpr Event ALLOC_FAILURE = event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);
|
||||
|
||||
//! [EXPORT] : [COMMENT] Software reboot occured. Can also be a systemd reboot.
|
||||
//! P1: Current Chip, P2: Current Copy
|
||||
static constexpr Event REBOOT_SW = event::makeEvent(SUBSYSTEM_ID, 1, severity::MEDIUM);
|
||||
//! [EXPORT] : [COMMENT] The reboot mechanism was triggered.
|
||||
//! P1: First 16 bits: Last Chip, Last 16 bits: Last Copy,
|
||||
//! P2: Each byte is the respective reboot count for the slots
|
||||
static constexpr Event REBOOT_MECHANISM_TRIGGERED =
|
||||
event::makeEvent(SUBSYSTEM_ID, 2, severity::MEDIUM);
|
||||
//! Trying to find a way how to determine that the reboot came from ProASIC3 or PCDU..
|
||||
static constexpr Event REBOOT_HW = event::makeEvent(SUBSYSTEM_ID, 3, severity::MEDIUM);
|
||||
|
||||
CoreController(object_id_t objectId);
|
||||
virtual~ CoreController();
|
||||
virtual ~CoreController();
|
||||
|
||||
ReturnValue_t initialize() override;
|
||||
|
||||
ReturnValue_t initializeAfterTaskCreation() override;
|
||||
|
||||
ReturnValue_t executeAction(ActionId_t actionId,
|
||||
MessageQueueId_t commandedBy, const uint8_t *data, size_t size) override;
|
||||
ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
|
||||
const uint8_t* data, size_t size) override;
|
||||
|
||||
ReturnValue_t handleCommandMessage(CommandMessage *message) override;
|
||||
ReturnValue_t handleCommandMessage(CommandMessage* message) override;
|
||||
void performControlOperation() override;
|
||||
|
||||
/**
|
||||
@ -63,7 +99,7 @@ public:
|
||||
*/
|
||||
static ReturnValue_t generateChipStateFile();
|
||||
static ReturnValue_t incrementAllocationFailureCount();
|
||||
static void getCurrentBootCopy(Chip& chip, Copy& copy);
|
||||
static void getCurrentBootCopy(xsc::Chip& chip, xsc::Copy& copy);
|
||||
|
||||
ReturnValue_t updateProtInfo(bool regenerateChipStateFile = true);
|
||||
|
||||
@ -78,15 +114,12 @@ public:
|
||||
* @param updateProtFile Specify whether the protection info file is updated
|
||||
* @return
|
||||
*/
|
||||
ReturnValue_t setBootCopyProtection(Chip targetChip, Copy targetCopy,
|
||||
bool protect, bool& protOperationPerformed, bool updateProtFile = true);
|
||||
ReturnValue_t setBootCopyProtection(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect,
|
||||
bool& protOperationPerformed, bool updateProtFile = true);
|
||||
|
||||
bool sdInitFinished() const;
|
||||
|
||||
private:
|
||||
static Chip CURRENT_CHIP;
|
||||
static Copy CURRENT_COPY;
|
||||
|
||||
private:
|
||||
// Designated value for rechecking FIFO open
|
||||
static constexpr int RETRY_FIFO_OPEN = -2;
|
||||
int watchdogFifoFd = 0;
|
||||
@ -135,8 +168,9 @@ private:
|
||||
sd::SdState currentlyCommandedState = sd::SdState::OFF;
|
||||
sd::SdCard commandedCard = sd::SdCard::NONE;
|
||||
sd::SdState commandedState = sd::SdState::OFF;
|
||||
};
|
||||
SdInfo sdInfo;
|
||||
} sdInfo;
|
||||
RebootFile rebootFile = {};
|
||||
bool doPerformMountedSdCardOps = true;
|
||||
|
||||
/**
|
||||
* Index 0: Chip 0 Copy 0
|
||||
@ -150,9 +184,8 @@ private:
|
||||
ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
|
||||
LocalDataPoolManager& poolManager) override;
|
||||
LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
|
||||
ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
|
||||
uint32_t *msToReachTheMode);
|
||||
|
||||
ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode, uint32_t* msToReachTheMode);
|
||||
void performMountedSdCardOperations();
|
||||
ReturnValue_t initVersionFile();
|
||||
ReturnValue_t initBootCopy();
|
||||
ReturnValue_t initWatchdogFifo();
|
||||
@ -164,21 +197,29 @@ private:
|
||||
ReturnValue_t sdCardSetup(sd::SdCard sdCard, sd::SdState targetState, std::string sdChar,
|
||||
bool printOutput = true);
|
||||
ReturnValue_t sdColdRedundantBlockingInit();
|
||||
|
||||
void currentStateSetter(sd::SdCard sdCard, sd::SdState newState);
|
||||
void determinePreferredSdCard();
|
||||
void executeNextExternalSdCommand();
|
||||
void checkExternalSdCommandStatus();
|
||||
void performRebootFileHandling(bool recreateFile);
|
||||
|
||||
ReturnValue_t actionListDirectoryIntoFile(ActionId_t actionId, MessageQueueId_t commandedBy,
|
||||
const uint8_t *data, size_t size);
|
||||
ReturnValue_t actionPerformReboot(const uint8_t *data, size_t size);
|
||||
const uint8_t* data, size_t size);
|
||||
ReturnValue_t actionPerformReboot(const uint8_t* data, size_t size);
|
||||
|
||||
void performWatchdogControlOperation();
|
||||
|
||||
ReturnValue_t handleProtInfoUpdateLine(std::string nextLine);
|
||||
int handleBootCopyProtAtIndex(Chip targetChip, Copy targetCopy, bool protect,
|
||||
bool &protOperationPerformed, bool selfChip, bool selfCopy, bool allChips,
|
||||
bool allCopies, uint8_t arrIdx);
|
||||
int handleBootCopyProtAtIndex(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect,
|
||||
bool& protOperationPerformed, bool selfChip, bool selfCopy,
|
||||
bool allChips, bool allCopies, uint8_t arrIdx);
|
||||
void determineAndExecuteReboot(RebootFile& rf, bool& needsReboot, xsc::Chip& tgtChip,
|
||||
xsc::Copy& tgtCopy);
|
||||
void resetRebootCount(xsc::Chip tgtChip, xsc::Copy tgtCopy);
|
||||
void setRebootMechanismLock(bool lock, xsc::Chip tgtChip, xsc::Copy tgtCopy);
|
||||
bool parseRebootFile(std::string path, RebootFile& file);
|
||||
void rewriteRebootFile(RebootFile file);
|
||||
};
|
||||
|
||||
#endif /* BSP_Q7S_CORE_CORECONTROLLER_H_ */
|
||||
|
@ -1,28 +1,27 @@
|
||||
#include "InitMission.h"
|
||||
#include "ObjectFactory.h"
|
||||
#include "OBSWConfig.h"
|
||||
#include "pollingsequence/pollingSequenceFactory.h"
|
||||
|
||||
#include "mission/utility/InitMission.h"
|
||||
|
||||
#include "fsfw/platform.h"
|
||||
#include "fsfw/objectmanager/ObjectManagerIF.h"
|
||||
#include "fsfw/returnvalues/HasReturnvaluesIF.h"
|
||||
#include "fsfw/serviceinterface/ServiceInterfaceStream.h"
|
||||
#include "fsfw/objectmanager/ObjectManager.h"
|
||||
#include "fsfw/tasks/FixedTimeslotTaskIF.h"
|
||||
#include "fsfw/tasks/PeriodicTaskIF.h"
|
||||
#include "fsfw/tasks/TaskFactory.h"
|
||||
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
|
||||
#include "OBSWConfig.h"
|
||||
#include "ObjectFactory.h"
|
||||
#include "fsfw/objectmanager/ObjectManager.h"
|
||||
#include "fsfw/objectmanager/ObjectManagerIF.h"
|
||||
#include "fsfw/platform.h"
|
||||
#include "fsfw/returnvalues/HasReturnvaluesIF.h"
|
||||
#include "fsfw/serviceinterface/ServiceInterfaceStream.h"
|
||||
#include "fsfw/tasks/FixedTimeslotTaskIF.h"
|
||||
#include "fsfw/tasks/PeriodicTaskIF.h"
|
||||
#include "fsfw/tasks/TaskFactory.h"
|
||||
#include "mission/utility/InitMission.h"
|
||||
#include "pollingsequence/pollingSequenceFactory.h"
|
||||
|
||||
/* This is configured for linux without CR */
|
||||
#ifdef PLATFORM_UNIX
|
||||
ServiceInterfaceStream sif::debug("DEBUG");
|
||||
ServiceInterfaceStream sif::info("INFO");
|
||||
ServiceInterfaceStream sif::warning("WARNING");
|
||||
ServiceInterfaceStream sif::error("ERROR", false, false, true);
|
||||
ServiceInterfaceStream sif::error("ERROR");
|
||||
#else
|
||||
ServiceInterfaceStream sif::debug("DEBUG", true);
|
||||
ServiceInterfaceStream sif::info("INFO", true);
|
||||
@ -30,10 +29,9 @@ ServiceInterfaceStream sif::warning("WARNING", true);
|
||||
ServiceInterfaceStream sif::error("ERROR", true, false, true);
|
||||
#endif
|
||||
|
||||
ObjectManagerIF *objectManager = nullptr;
|
||||
ObjectManagerIF* objectManager = nullptr;
|
||||
|
||||
void initmission::initMission() {
|
||||
|
||||
sif::info << "Building global objects.." << std::endl;
|
||||
/* Instantiate global object manager and also create all objects */
|
||||
ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr);
|
||||
@ -47,21 +45,21 @@ void initmission::initMission() {
|
||||
void initmission::initTasks() {
|
||||
TaskFactory* factory = TaskFactory::instance();
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
if(factory == nullptr) {
|
||||
if (factory == nullptr) {
|
||||
/* Should never happen ! */
|
||||
return;
|
||||
}
|
||||
#if OBSW_PRINT_MISSED_DEADLINES == 1
|
||||
void (*missedDeadlineFunc) (void) = TaskFactory::printMissedDeadline;
|
||||
void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline;
|
||||
#else
|
||||
void (*missedDeadlineFunc) (void) = nullptr;
|
||||
void (*missedDeadlineFunc)(void) = nullptr;
|
||||
#endif
|
||||
|
||||
#if BOARD_TE0720 == 0
|
||||
PeriodicTaskIF* coreController = factory->createPeriodicTask(
|
||||
"CORE_CTRL", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
|
||||
result = coreController->addComponent(objects::CORE_CONTROLLER);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("CORE_CTRL", objects::CORE_CONTROLLER);
|
||||
}
|
||||
#endif
|
||||
@ -70,48 +68,88 @@ void initmission::initTasks() {
|
||||
PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
|
||||
"DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
|
||||
result = tmTcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("CCSDS_DISTRIB", objects::CCSDS_PACKET_DISTRIBUTOR);
|
||||
}
|
||||
result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS_PACKET_DISTRIB", objects::PUS_PACKET_DISTRIBUTOR);
|
||||
}
|
||||
result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("TM_FUNNEL", objects::TM_FUNNEL);
|
||||
}
|
||||
|
||||
/* UDP bridge */
|
||||
#if OBSW_ADD_TCPIP_BRIDGE == 1
|
||||
// TMTC bridge
|
||||
PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
|
||||
"UDP_UNIX_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
|
||||
"TCPIP_TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
|
||||
result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("UDP_BRIDGE", objects::TMTC_BRIDGE);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("TMTC_BRIDGE", objects::TMTC_BRIDGE);
|
||||
}
|
||||
PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
|
||||
"UDP_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
|
||||
"TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
|
||||
result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("UDP_POLLING", objects::TMTC_POLLING_TASK);
|
||||
}
|
||||
#endif
|
||||
|
||||
# if BOARD_TE0720 == 0
|
||||
#if OBSW_USE_CCSDS_IP_CORE == 1
|
||||
PeriodicTaskIF* ccsdsHandlerTask = factory->createPeriodicTask(
|
||||
"CCSDS_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
|
||||
result = ccsdsHandlerTask->addComponent(objects::CCSDS_HANDLER);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("CCSDS Handler", objects::CCSDS_HANDLER);
|
||||
}
|
||||
|
||||
// Minimal distance between two received TCs amounts to 0.6 seconds
|
||||
// If a command has not been read before the next one arrives, the old command will be
|
||||
// overwritten by the PDEC.
|
||||
PeriodicTaskIF* pdecHandlerTask = factory->createPeriodicTask(
|
||||
"PDEC_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
|
||||
result = pdecHandlerTask->addComponent(objects::PDEC_HANDLER);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PDEC Handler", objects::PDEC_HANDLER);
|
||||
}
|
||||
#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
|
||||
|
||||
#if OBSW_ADD_ACS_HANDLERS == 1
|
||||
PeriodicTaskIF* acsCtrl = factory->createPeriodicTask(
|
||||
"ACS_CTRL", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
|
||||
result = acsCtrl->addComponent(objects::GPS_CONTROLLER);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("ACS_CTRL", objects::GPS_CONTROLLER);
|
||||
}
|
||||
#endif /* OBSW_ADD_ACS_HANDLERS */
|
||||
|
||||
#if BOARD_TE0720 == 0
|
||||
// FS task, task interval does not matter because it runs in permanent loop, priority low
|
||||
// because it is a non-essential background task
|
||||
PeriodicTaskIF* fsTask = factory->createPeriodicTask(
|
||||
"FILE_SYSTEM_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
|
||||
result = fsTask->addComponent(objects::FILE_SYSTEM_HANDLER);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("FILE_SYSTEM_TASK", objects::FILE_SYSTEM_HANDLER);
|
||||
}
|
||||
|
||||
#if OBSW_ADD_STAR_TRACKER == 1
|
||||
PeriodicTaskIF* strHelperTask = factory->createPeriodicTask(
|
||||
"STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
|
||||
result = strHelperTask->addComponent(objects::STR_HELPER);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("STR_HELPER", objects::STR_HELPER);
|
||||
}
|
||||
#endif /* OBSW_ADD_STAR_TRACKER == 1 */
|
||||
|
||||
#endif /* BOARD_TE0720 */
|
||||
|
||||
#if OBSW_TEST_CCSDS_BRIDGE == 1
|
||||
PeriodicTaskIF* ptmeTestTask = factory->createPeriodicTask(
|
||||
"PTME_TEST", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
|
||||
result = ptmeTestTask->addComponent(objects::CCSDS_IP_CORE_BRIDGE);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PTME_TEST", objects::CCSDS_IP_CORE_BRIDGE);
|
||||
}
|
||||
#endif
|
||||
@ -121,17 +159,16 @@ void initmission::initTasks() {
|
||||
std::vector<PeriodicTaskIF*> pstTasks;
|
||||
createPstTasks(*factory, missedDeadlineFunc, pstTasks);
|
||||
|
||||
#if OBSW_ADD_TEST_TASK == 1
|
||||
#if OBSW_ADD_TEST_CODE == 1
|
||||
std::vector<PeriodicTaskIF*> testTasks;
|
||||
createTestTasks(*factory, missedDeadlineFunc, testTasks);
|
||||
#endif
|
||||
|
||||
auto taskStarter = [](std::vector<PeriodicTaskIF*>& taskVector, std::string name) {
|
||||
for(const auto& task: taskVector) {
|
||||
if(task != nullptr) {
|
||||
for (const auto& task : taskVector) {
|
||||
if (task != nullptr) {
|
||||
task->startTask();
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
sif::error << "Task in vector " << name << " is invalid!" << std::endl;
|
||||
}
|
||||
}
|
||||
@ -139,15 +176,24 @@ void initmission::initTasks() {
|
||||
|
||||
sif::info << "Starting tasks.." << std::endl;
|
||||
tmTcDistributor->startTask();
|
||||
|
||||
#if OBSW_ADD_TCPIP_BRIDGE == 1
|
||||
tmtcBridgeTask->startTask();
|
||||
tmtcPollingTask->startTask();
|
||||
#endif
|
||||
|
||||
#if OBSW_USE_CCSDS_IP_CORE == 1
|
||||
ccsdsHandlerTask->startTask();
|
||||
pdecHandlerTask->startTask();
|
||||
#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
|
||||
|
||||
#if BOARD_TE0720 == 0
|
||||
coreController->startTask();
|
||||
#endif
|
||||
|
||||
taskStarter(pstTasks, "PST task vector");
|
||||
taskStarter(pusTasks, "PUS task vector");
|
||||
#if OBSW_ADD_TEST_TASK == 1
|
||||
#if OBSW_ADD_TEST_CODE == 1
|
||||
taskStarter(testTasks, "Test task vector");
|
||||
#endif
|
||||
|
||||
@ -157,59 +203,72 @@ void initmission::initTasks() {
|
||||
|
||||
#if BOARD_TE0720 == 0
|
||||
fsTask->startTask();
|
||||
#if OBSW_ADD_STAR_TRACKER == 1
|
||||
strHelperTask > startTask();
|
||||
#endif /* OBSW_ADD_STAR_TRACKER == 1 */
|
||||
#endif
|
||||
|
||||
#if OBSW_ADD_ACS_HANDLERS == 1
|
||||
acsCtrl->startTask();
|
||||
#endif
|
||||
|
||||
sif::info << "Tasks started.." << std::endl;
|
||||
}
|
||||
|
||||
void initmission::createPstTasks(TaskFactory& factory,
|
||||
TaskDeadlineMissedFunction missedDeadlineFunc, std::vector<PeriodicTaskIF*> &taskVec) {
|
||||
TaskDeadlineMissedFunction missedDeadlineFunc,
|
||||
std::vector<PeriodicTaskIF*>& taskVec) {
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
#if BOARD_TE0720 == 0
|
||||
/* Polling Sequence Table Default */
|
||||
#if Q7S_ADD_SPI_TEST == 0
|
||||
#if OBSW_ADD_SPI_TEST_CODE == 0
|
||||
FixedTimeslotTaskIF* spiPst = factory.createFixedTimeslotTask(
|
||||
"PST_TASK_DEFAULT", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0,
|
||||
missedDeadlineFunc);
|
||||
"PST_TASK_DEFAULT", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
|
||||
result = pst::pstSpi(spiPst);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
|
||||
sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
|
||||
}
|
||||
} else {
|
||||
taskVec.push_back(spiPst);
|
||||
}
|
||||
#endif
|
||||
|
||||
FixedTimeslotTaskIF* uartPst = factory.createFixedTimeslotTask(
|
||||
"UART_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0, missedDeadlineFunc);
|
||||
"UART_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.2, missedDeadlineFunc);
|
||||
result = pst::pstUart(uartPst);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
|
||||
}
|
||||
taskVec.push_back(uartPst);
|
||||
FixedTimeslotTaskIF* gpioPst = factory.createFixedTimeslotTask(
|
||||
"GPIO_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0, missedDeadlineFunc);
|
||||
"GPIO_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.2, missedDeadlineFunc);
|
||||
result = pst::pstGpio(gpioPst);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
|
||||
}
|
||||
taskVec.push_back(gpioPst);
|
||||
|
||||
#if OBSW_ADD_I2C_TEST_CODE == 0
|
||||
FixedTimeslotTaskIF* i2cPst = factory.createFixedTimeslotTask(
|
||||
"I2C_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0, missedDeadlineFunc);
|
||||
"I2C_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.2, missedDeadlineFunc);
|
||||
result = pst::pstI2c(i2cPst);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
|
||||
}
|
||||
taskVec.push_back(i2cPst);
|
||||
#endif
|
||||
|
||||
FixedTimeslotTaskIF* gomSpacePstTask = factory.createFixedTimeslotTask(
|
||||
"GS_PST_TASK", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc);
|
||||
result = pst::pstGompaceCan(gomSpacePstTask);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "InitMission::initTasks: GomSpace PST initialization failed!" << std::endl;
|
||||
}
|
||||
taskVec.push_back(gomSpacePstTask);
|
||||
#else /* BOARD_TE7020 == 0 */
|
||||
FixedTimeslotTaskIF * pollingSequenceTaskTE0720 = factory.createFixedTimeslotTask(
|
||||
"PST_TASK_TE0720", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE * 8, 3.0,
|
||||
missedDeadlineFunc);
|
||||
FixedTimeslotTaskIF* pollingSequenceTaskTE0720 = factory.createFixedTimeslotTask(
|
||||
"PST_TASK_TE0720", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE * 8, 3.0, missedDeadlineFunc);
|
||||
result = pst::pollingSequenceTE0720(pollingSequenceTaskTE0720);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "InitMission::initTasks: Creating TE0720 PST failed!" << std::endl;
|
||||
@ -218,14 +277,15 @@ void initmission::createPstTasks(TaskFactory& factory,
|
||||
#endif /* BOARD_TE7020 == 1 */
|
||||
}
|
||||
|
||||
void initmission::createPusTasks(TaskFactory &factory,
|
||||
TaskDeadlineMissedFunction missedDeadlineFunc, std::vector<PeriodicTaskIF*> &taskVec) {
|
||||
void initmission::createPusTasks(TaskFactory& factory,
|
||||
TaskDeadlineMissedFunction missedDeadlineFunc,
|
||||
std::vector<PeriodicTaskIF*>& taskVec) {
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
/* PUS Services */
|
||||
PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
|
||||
"PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
|
||||
result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS_VERIF", objects::PUS_SERVICE_1_VERIFICATION);
|
||||
}
|
||||
taskVec.push_back(pusVerification);
|
||||
@ -233,11 +293,11 @@ void initmission::createPusTasks(TaskFactory &factory,
|
||||
PeriodicTaskIF* pusEvents = factory.createPeriodicTask(
|
||||
"PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
|
||||
result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
|
||||
}
|
||||
result = pusEvents->addComponent(objects::EVENT_MANAGER);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
|
||||
}
|
||||
taskVec.push_back(pusEvents);
|
||||
@ -245,11 +305,11 @@ void initmission::createPusTasks(TaskFactory &factory,
|
||||
PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
|
||||
"PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
|
||||
result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS_2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
|
||||
}
|
||||
result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS_9", objects::PUS_SERVICE_9_TIME_MGMT);
|
||||
}
|
||||
taskVec.push_back(pusHighPrio);
|
||||
@ -257,19 +317,19 @@ void initmission::createPusTasks(TaskFactory &factory,
|
||||
PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
|
||||
"PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS_8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
|
||||
if(result!=HasReturnvaluesIF::RETURN_OK){
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "Object add component failed" << std::endl;
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS_200", objects::PUS_SERVICE_200_MODE_MGMT);
|
||||
}
|
||||
result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS_20", objects::PUS_SERVICE_20_PARAMETERS);
|
||||
}
|
||||
taskVec.push_back(pusMedPrio);
|
||||
@ -277,37 +337,57 @@ void initmission::createPusTasks(TaskFactory &factory,
|
||||
PeriodicTaskIF* pusLowPrio = factory.createPeriodicTask(
|
||||
"PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
|
||||
result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("PUS_17", objects::PUS_SERVICE_17_TEST);
|
||||
}
|
||||
result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("ERROR_REPORTER", objects::INTERNAL_ERROR_REPORTER);
|
||||
}
|
||||
taskVec.push_back(pusLowPrio);
|
||||
}
|
||||
|
||||
void initmission::createTestTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
|
||||
void initmission::createTestTasks(TaskFactory& factory,
|
||||
TaskDeadlineMissedFunction missedDeadlineFunc,
|
||||
std::vector<PeriodicTaskIF*>& taskVec) {
|
||||
#if OBSW_ADD_TEST_TASK == 1 && OBSW_ADD_TEST_CODE == 1
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
static_cast<void>(result); // supress warning in case it is not used
|
||||
|
||||
PeriodicTaskIF* testTask = factory.createPeriodicTask(
|
||||
"TEST_TASK", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1, missedDeadlineFunc);
|
||||
|
||||
result = testTask->addComponent(objects::TEST_TASK);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
|
||||
}
|
||||
|
||||
#if Q7S_ADD_SPI_TEST == 1
|
||||
#if OBSW_ADD_SPI_TEST_CODE == 1
|
||||
result = testTask->addComponent(objects::SPI_TEST);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
|
||||
}
|
||||
#endif
|
||||
#if OBSW_ADD_I2C_TEST_CODE == 1
|
||||
result = testTask->addComponent(objects::I2C_TEST);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("I2C_TEST", objects::I2C_TEST);
|
||||
}
|
||||
#endif
|
||||
#if OBSW_ADD_UART_TEST_CODE == 1
|
||||
result = testTask->addComponent(objects::UART_TEST);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("UART_TEST", objects::UART_TEST);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1
|
||||
result = testTask->addComponent(objects::LIBGPIOD_TEST);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
initmission::printAddObjectError("GPIOD_TEST", objects::LIBGPIOD_TEST);
|
||||
}
|
||||
#endif /* BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1 */
|
||||
taskVec.push_back(testTask);
|
||||
|
||||
#endif // OBSW_ADD_TEST_TASK == 1 && OBSW_ADD_TEST_CODE == 1
|
||||
}
|
||||
|
@ -1,9 +1,10 @@
|
||||
#ifndef BSP_Q7S_INITMISSION_H_
|
||||
#define BSP_Q7S_INITMISSION_H_
|
||||
|
||||
#include "fsfw/tasks/Typedef.h"
|
||||
#include <vector>
|
||||
|
||||
#include "fsfw/tasks/Typedef.h"
|
||||
|
||||
class PeriodicTaskIF;
|
||||
class TaskFactory;
|
||||
|
||||
@ -17,6 +18,6 @@ void createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadl
|
||||
std::vector<PeriodicTaskIF*>& taskVec);
|
||||
void createTestTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
|
||||
std::vector<PeriodicTaskIF*>& taskVec);
|
||||
};
|
||||
}; // namespace initmission
|
||||
|
||||
#endif /* BSP_Q7S_INITMISSION_H_ */
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -4,6 +4,7 @@
|
||||
class LinuxLibgpioIF;
|
||||
class UartComIF;
|
||||
class SpiComIF;
|
||||
class I2cComIF;
|
||||
|
||||
namespace ObjectFactory {
|
||||
|
||||
@ -11,9 +12,11 @@ void setStatics();
|
||||
void produce(void* args);
|
||||
|
||||
void createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, UartComIF** uartComIF,
|
||||
SpiComIF** spiComIF);
|
||||
SpiComIF** spiComIF, I2cComIF** i2cComIF);
|
||||
|
||||
void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF);
|
||||
void createTmpComponents();
|
||||
void createPcduComponents();
|
||||
void createPcduComponents(LinuxLibgpioIF* gpioComIF);
|
||||
void createRadSensorComponent(LinuxLibgpioIF* gpioComIF);
|
||||
void createSunSensorComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF);
|
||||
void createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComIF* uartComIF);
|
||||
@ -22,8 +25,9 @@ void createSolarArrayDeploymentComponents();
|
||||
void createSyrlinksComponents();
|
||||
void createRtdComponents(LinuxLibgpioIF* gpioComIF);
|
||||
void createReactionWheelComponents(LinuxLibgpioIF* gpioComIF);
|
||||
void createTestComponents();
|
||||
void createCcsdsComponents(LinuxLibgpioIF* gpioComIF);
|
||||
void createTestComponents(LinuxLibgpioIF* gpioComIF);
|
||||
|
||||
};
|
||||
}; // namespace ObjectFactory
|
||||
|
||||
#endif /* BSP_Q7S_OBJECTFACTORY_H_ */
|
||||
|
@ -1,8 +1,5 @@
|
||||
#include "ParameterHandler.h"
|
||||
|
||||
ParameterHandler::ParameterHandler(std::string mountPrefix): mountPrefix(mountPrefix) {
|
||||
}
|
||||
ParameterHandler::ParameterHandler(std::string mountPrefix) : mountPrefix(mountPrefix) {}
|
||||
|
||||
void ParameterHandler::setMountPrefix(std::string prefix) {
|
||||
mountPrefix = prefix;
|
||||
}
|
||||
void ParameterHandler::setMountPrefix(std::string prefix) { mountPrefix = prefix; }
|
||||
|
@ -4,19 +4,17 @@
|
||||
#include <nlohmann/json.hpp>
|
||||
#include <string>
|
||||
|
||||
|
||||
|
||||
class ParameterHandler {
|
||||
public:
|
||||
public:
|
||||
ParameterHandler(std::string mountPrefix);
|
||||
|
||||
void setMountPrefix(std::string prefix);
|
||||
|
||||
void setUpDummyParameter();
|
||||
private:
|
||||
|
||||
private:
|
||||
std::string mountPrefix;
|
||||
DummyParameter dummyParam;
|
||||
};
|
||||
|
||||
|
||||
#endif /* BSP_Q7S_CORE_PARAMETERHANDLER_H_ */
|
||||
|
@ -1,14 +1,14 @@
|
||||
#include "obsw.h"
|
||||
#include "OBSWVersion.h"
|
||||
#include "OBSWConfig.h"
|
||||
#include "InitMission.h"
|
||||
#include "watchdogConf.h"
|
||||
|
||||
#include "fsfw/tasks/TaskFactory.h"
|
||||
#include "fsfw/FSFWVersion.h"
|
||||
|
||||
#include <iostream>
|
||||
#include <filesystem>
|
||||
#include <iostream>
|
||||
|
||||
#include "InitMission.h"
|
||||
#include "OBSWConfig.h"
|
||||
#include "OBSWVersion.h"
|
||||
#include "fsfw/FSFWVersion.h"
|
||||
#include "fsfw/tasks/TaskFactory.h"
|
||||
#include "watchdogConf.h"
|
||||
|
||||
static int OBSW_ALREADY_RUNNING = -2;
|
||||
|
||||
@ -19,23 +19,24 @@ int obsw::obsw() {
|
||||
#else
|
||||
std::cout << "-- Compiled for Linux (TE0720) --" << std::endl;
|
||||
#endif
|
||||
std::cout << "-- OBSW v" << SW_VERSION << "." << SW_SUBVERSION <<
|
||||
"." << SW_REVISION << ", FSFW v" << FSFW_VERSION << "." << FSFW_SUBVERSION << "." <<
|
||||
FSFW_REVISION << "--" << std::endl;
|
||||
std::cout << "-- OBSW v" << SW_VERSION << "." << SW_SUBVERSION << "." << SW_REVISION << ", FSFW v"
|
||||
<< FSFW_VERSION << "." << FSFW_SUBVERSION << "." << FSFW_REVISION << "--" << std::endl;
|
||||
std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
|
||||
|
||||
#if Q7S_CHECK_FOR_ALREADY_RUNNING_IMG == 1
|
||||
// Check special file here. This file is created or deleted by the eive-watchdog application
|
||||
// or systemd service!
|
||||
if(std::filesystem::exists(watchdog::RUNNING_FILE_NAME)) {
|
||||
sif::warning << "File " << watchdog::RUNNING_FILE_NAME << " exists so the software might "
|
||||
"already be running. Aborting.." << std::endl;
|
||||
if (std::filesystem::exists(watchdog::RUNNING_FILE_NAME)) {
|
||||
sif::warning << "File " << watchdog::RUNNING_FILE_NAME
|
||||
<< " exists so the software might "
|
||||
"already be running. Check if obsw systemd service has been stopped."
|
||||
<< std::endl;
|
||||
return OBSW_ALREADY_RUNNING;
|
||||
}
|
||||
#endif
|
||||
initmission::initMission();
|
||||
|
||||
for(;;) {
|
||||
for (;;) {
|
||||
/* Suspend main thread by sleeping it. */
|
||||
TaskFactory::delayTask(5000);
|
||||
}
|
||||
|
@ -1,4 +1,4 @@
|
||||
target_sources(${TARGET_NAME} PRIVATE
|
||||
target_sources(${OBSW_NAME} PRIVATE
|
||||
PlocSupervisorHandler.cpp
|
||||
PlocUpdater.cpp
|
||||
PlocMemoryDumper.cpp
|
||||
|
@ -1,21 +1,23 @@
|
||||
#include <fsfw/src/fsfw/serialize/SerializeAdapter.h>
|
||||
#include "fsfw/ipc/QueueFactory.h"
|
||||
#include "PlocMemoryDumper.h"
|
||||
|
||||
#include <fstream>
|
||||
#include <fsfw/src/fsfw/serialize/SerializeAdapter.h>
|
||||
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <string>
|
||||
|
||||
PlocMemoryDumper::PlocMemoryDumper(object_id_t objectId) :
|
||||
SystemObject(objectId), commandActionHelper(this), actionHelper(this, nullptr) {
|
||||
commandQueue = QueueFactory::instance()->createMessageQueue(QUEUE_SIZE);
|
||||
#include "fsfw/ipc/QueueFactory.h"
|
||||
|
||||
PlocMemoryDumper::PlocMemoryDumper(object_id_t objectId)
|
||||
: SystemObject(objectId), commandActionHelper(this), actionHelper(this, nullptr) {
|
||||
auto mqArgs = MqArgs(this->getObjectId());
|
||||
commandQueue = QueueFactory::instance()->createMessageQueue(
|
||||
QUEUE_SIZE, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
|
||||
}
|
||||
|
||||
PlocMemoryDumper::~PlocMemoryDumper() {
|
||||
}
|
||||
PlocMemoryDumper::~PlocMemoryDumper() {}
|
||||
|
||||
ReturnValue_t PlocMemoryDumper::initialize() {
|
||||
|
||||
ReturnValue_t result = SystemObject::initialize();
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
@ -38,9 +40,8 @@ ReturnValue_t PlocMemoryDumper::performOperation(uint8_t operationCode) {
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocMemoryDumper::executeAction(ActionId_t actionId,
|
||||
MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
|
||||
|
||||
ReturnValue_t PlocMemoryDumper::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
|
||||
const uint8_t* data, size_t size) {
|
||||
if (state != State::IDLE) {
|
||||
return IS_BUSY;
|
||||
}
|
||||
@ -71,13 +72,9 @@ ReturnValue_t PlocMemoryDumper::executeAction(ActionId_t actionId,
|
||||
return EXECUTION_FINISHED;
|
||||
}
|
||||
|
||||
MessageQueueId_t PlocMemoryDumper::getCommandQueue() const {
|
||||
return commandQueue->getId();
|
||||
}
|
||||
MessageQueueId_t PlocMemoryDumper::getCommandQueue() const { return commandQueue->getId(); }
|
||||
|
||||
MessageQueueIF* PlocMemoryDumper::getCommandQueuePtr() {
|
||||
return commandQueue;
|
||||
}
|
||||
MessageQueueIF* PlocMemoryDumper::getCommandQueuePtr() { return commandQueue; }
|
||||
|
||||
void PlocMemoryDumper::readCommandQueue() {
|
||||
CommandMessage message;
|
||||
@ -121,17 +118,12 @@ void PlocMemoryDumper::doStateMachine() {
|
||||
}
|
||||
}
|
||||
|
||||
void PlocMemoryDumper::stepSuccessfulReceived(ActionId_t actionId,
|
||||
uint8_t step) {
|
||||
}
|
||||
void PlocMemoryDumper::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) {}
|
||||
|
||||
void PlocMemoryDumper::stepFailedReceived(ActionId_t actionId, uint8_t step,
|
||||
ReturnValue_t returnCode) {
|
||||
}
|
||||
ReturnValue_t returnCode) {}
|
||||
|
||||
void PlocMemoryDumper::dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) {
|
||||
|
||||
}
|
||||
void PlocMemoryDumper::dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) {}
|
||||
|
||||
void PlocMemoryDumper::completionSuccessfulReceived(ActionId_t actionId) {
|
||||
switch (pendingCommand) {
|
||||
@ -140,8 +132,7 @@ void PlocMemoryDumper::completionSuccessfulReceived(ActionId_t actionId) {
|
||||
if (mram.endAddress == mram.startAddress) {
|
||||
triggerEvent(MRAM_DUMP_FINISHED);
|
||||
state = State::IDLE;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
state = State::COMMAND_CONSECUTIVE_MRAM_DUMP;
|
||||
}
|
||||
break;
|
||||
@ -153,11 +144,10 @@ void PlocMemoryDumper::completionSuccessfulReceived(ActionId_t actionId) {
|
||||
}
|
||||
}
|
||||
|
||||
void PlocMemoryDumper::completionFailedReceived(ActionId_t actionId,
|
||||
ReturnValue_t returnCode) {
|
||||
switch(pendingCommand) {
|
||||
case(PLOC_SPV::FIRST_MRAM_DUMP):
|
||||
case(PLOC_SPV::CONSECUTIVE_MRAM_DUMP):
|
||||
void PlocMemoryDumper::completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) {
|
||||
switch (pendingCommand) {
|
||||
case (PLOC_SPV::FIRST_MRAM_DUMP):
|
||||
case (PLOC_SPV::CONSECUTIVE_MRAM_DUMP):
|
||||
triggerEvent(MRAM_DUMP_FAILED, mram.lastStartAddress);
|
||||
break;
|
||||
default:
|
||||
@ -179,8 +169,7 @@ void PlocMemoryDumper::commandNextMramDump(ActionId_t dumpCommand) {
|
||||
tempEndAddress = mram.startAddress + MAX_MRAM_DUMP_SIZE;
|
||||
mram.startAddress += MAX_MRAM_DUMP_SIZE;
|
||||
mram.lastStartAddress = tempStartAddress;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
tempStartAddress = mram.startAddress;
|
||||
tempEndAddress = mram.endAddress;
|
||||
mram.startAddress = mram.endAddress;
|
||||
@ -188,8 +177,8 @@ void PlocMemoryDumper::commandNextMramDump(ActionId_t dumpCommand) {
|
||||
|
||||
MemoryParams params(tempStartAddress, tempEndAddress);
|
||||
|
||||
result = commandActionHelper.commandAction(objects::PLOC_SUPERVISOR_HANDLER,
|
||||
dumpCommand, ¶ms);
|
||||
result =
|
||||
commandActionHelper.commandAction(objects::PLOC_SUPERVISOR_HANDLER, dumpCommand, ¶ms);
|
||||
if (result != RETURN_OK) {
|
||||
sif::warning << "PlocMemoryDumper::commandNextMramDump: Failed to send mram dump command "
|
||||
<< "with start address " << tempStartAddress << " and end address "
|
||||
@ -203,4 +192,3 @@ void PlocMemoryDumper::commandNextMramDump(ActionId_t dumpCommand) {
|
||||
pendingCommand = dumpCommand;
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -3,18 +3,18 @@
|
||||
|
||||
#include <bsp_q7s/devices/devicedefinitions/PlocMemDumpDefinitions.h>
|
||||
#include <bsp_q7s/devices/devicedefinitions/PlocSupervisorDefinitions.h>
|
||||
|
||||
#include "OBSWConfig.h"
|
||||
#include "fsfw/action/CommandActionHelper.h"
|
||||
#include "bsp_q7s/memory/SdCardManager.h"
|
||||
#include "fsfw/action/ActionHelper.h"
|
||||
#include "fsfw/action/HasActionsIF.h"
|
||||
#include "fsfw/action/CommandActionHelper.h"
|
||||
#include "fsfw/action/CommandsActionsIF.h"
|
||||
#include "fsfw/action/HasActionsIF.h"
|
||||
#include "fsfw/objectmanager/SystemObject.h"
|
||||
#include "fsfw/returnvalues/HasReturnvaluesIF.h"
|
||||
#include "fsfw/tasks/ExecutableObjectIF.h"
|
||||
#include "fsfw/objectmanager/SystemObject.h"
|
||||
#include "bsp_q7s/memory/SdCardManager.h"
|
||||
#include "linux/fsfwconfig/objects/systemObjectList.h"
|
||||
#include "fsfw/tmtcpacket/SpacePacket.h"
|
||||
|
||||
#include "linux/fsfwconfig/objects/systemObjectList.h"
|
||||
|
||||
/**
|
||||
* @brief Because the buffer of the linux tty driver is limited to 2 x 65535 bytes, this class is
|
||||
@ -29,8 +29,7 @@ class PlocMemoryDumper : public SystemObject,
|
||||
public ExecutableObjectIF,
|
||||
public HasReturnvaluesIF,
|
||||
public CommandsActionsIF {
|
||||
public:
|
||||
|
||||
public:
|
||||
static const ActionId_t NONE = 0;
|
||||
static const ActionId_t DUMP_MRAM = 1;
|
||||
|
||||
@ -49,13 +48,13 @@ public:
|
||||
void completionSuccessfulReceived(ActionId_t actionId) override;
|
||||
void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) override;
|
||||
|
||||
private:
|
||||
|
||||
private:
|
||||
static const uint32_t QUEUE_SIZE = 10;
|
||||
|
||||
static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_MEMORY_DUMPER;
|
||||
|
||||
//! [EXPORT] : [COMMENT] The capacity of the MRAM amounts to 512 kB. Thus the maximum address must not be higher than 0x7d000.
|
||||
//! [EXPORT] : [COMMENT] The capacity of the MRAM amounts to 512 kB. Thus the maximum address must
|
||||
//! not be higher than 0x7d000.
|
||||
static const ReturnValue_t MRAM_ADDRESS_TOO_HIGH = MAKE_RETURN_CODE(0xA0);
|
||||
//! [EXPORT] : [COMMENT] The specified end address is lower than the start address
|
||||
static const ReturnValue_t MRAM_INVALID_ADDRESS_COMBINATION = MAKE_RETURN_CODE(0xA1);
|
||||
@ -82,7 +81,7 @@ private:
|
||||
|
||||
ActionHelper actionHelper;
|
||||
|
||||
enum class State: uint8_t {
|
||||
enum class State : uint8_t {
|
||||
IDLE,
|
||||
COMMAND_FIRST_MRAM_DUMP,
|
||||
COMMAND_CONSECUTIVE_MRAM_DUMP,
|
||||
|
@ -1,26 +1,28 @@
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <filesystem>
|
||||
|
||||
#include "PlocSupervisorHandler.h"
|
||||
#include "OBSWConfig.h"
|
||||
|
||||
#include <fsfw/globalfunctions/CRC.h>
|
||||
#include <fsfw/datapool/PoolReadGuard.h>
|
||||
#include <fsfw/globalfunctions/CRC.h>
|
||||
#include <fsfw/timemanager/Clock.h>
|
||||
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
|
||||
#include "OBSWConfig.h"
|
||||
|
||||
PlocSupervisorHandler::PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid,
|
||||
CookieIF * comCookie) :
|
||||
DeviceHandlerBase(objectId, uartComIFid, comCookie), hkset(this), bootStatusReport(this), latchupStatusReport(
|
||||
this) {
|
||||
CookieIF* comCookie)
|
||||
: DeviceHandlerBase(objectId, uartComIFid, comCookie),
|
||||
hkset(this),
|
||||
bootStatusReport(this),
|
||||
latchupStatusReport(this) {
|
||||
if (comCookie == NULL) {
|
||||
sif::error << "PlocSupervisorHandler: Invalid com cookie" << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
PlocSupervisorHandler::~PlocSupervisorHandler() {
|
||||
}
|
||||
PlocSupervisorHandler::~PlocSupervisorHandler() {}
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::initialize() {
|
||||
ReturnValue_t result = RETURN_OK;
|
||||
@ -41,8 +43,7 @@ ReturnValue_t PlocSupervisorHandler::initialize() {
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
void PlocSupervisorHandler::doStartUp(){
|
||||
void PlocSupervisorHandler::doStartUp() {
|
||||
#if OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP == 1
|
||||
setMode(MODE_NORMAL);
|
||||
#else
|
||||
@ -50,210 +51,206 @@ void PlocSupervisorHandler::doStartUp(){
|
||||
#endif
|
||||
}
|
||||
|
||||
void PlocSupervisorHandler::doShutDown(){
|
||||
setMode(_MODE_POWER_DOWN);
|
||||
}
|
||||
void PlocSupervisorHandler::doShutDown() { setMode(_MODE_POWER_DOWN); }
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::buildNormalDeviceCommand(
|
||||
DeviceCommandId_t * id) {
|
||||
ReturnValue_t PlocSupervisorHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
|
||||
return NOTHING_TO_SEND;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::buildTransitionDeviceCommand(
|
||||
DeviceCommandId_t * id){
|
||||
ReturnValue_t PlocSupervisorHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
|
||||
return NOTHING_TO_SEND;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(
|
||||
DeviceCommandId_t deviceCommand, const uint8_t * commandData,
|
||||
ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
|
||||
const uint8_t* commandData,
|
||||
size_t commandDataLen) {
|
||||
ReturnValue_t result = RETURN_FAILED;
|
||||
switch(deviceCommand) {
|
||||
case(PLOC_SPV::GET_HK_REPORT): {
|
||||
switch (deviceCommand) {
|
||||
case (PLOC_SPV::GET_HK_REPORT): {
|
||||
prepareEmptyCmd(PLOC_SPV::APID_GET_HK_REPORT);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::RESTART_MPSOC): {
|
||||
case (PLOC_SPV::RESTART_MPSOC): {
|
||||
prepareEmptyCmd(PLOC_SPV::APID_RESTART_MPSOC);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::START_MPSOC): {
|
||||
case (PLOC_SPV::START_MPSOC): {
|
||||
prepareEmptyCmd(PLOC_SPV::APID_START_MPSOC);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::SHUTDOWN_MPSOC): {
|
||||
case (PLOC_SPV::SHUTDOWN_MPSOC): {
|
||||
prepareEmptyCmd(PLOC_SPV::APID_SHUTWOWN_MPSOC);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::SEL_MPSOC_BOOT_IMAGE): {
|
||||
case (PLOC_SPV::SEL_MPSOC_BOOT_IMAGE): {
|
||||
prepareSelBootImageCmd(commandData);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::RESET_MPSOC): {
|
||||
case (PLOC_SPV::RESET_MPSOC): {
|
||||
prepareEmptyCmd(PLOC_SPV::APID_RESET_MPSOC);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::SET_TIME_REF): {
|
||||
case (PLOC_SPV::SET_TIME_REF): {
|
||||
result = prepareSetTimeRefCmd();
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::SET_BOOT_TIMEOUT): {
|
||||
case (PLOC_SPV::SET_BOOT_TIMEOUT): {
|
||||
prepareSetBootTimeoutCmd(commandData);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::SET_MAX_RESTART_TRIES): {
|
||||
case (PLOC_SPV::SET_MAX_RESTART_TRIES): {
|
||||
prepareRestartTriesCmd(commandData);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::DISABLE_PERIOIC_HK_TRANSMISSION): {
|
||||
case (PLOC_SPV::DISABLE_PERIOIC_HK_TRANSMISSION): {
|
||||
prepareDisableHk();
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::GET_BOOT_STATUS_REPORT): {
|
||||
case (PLOC_SPV::GET_BOOT_STATUS_REPORT): {
|
||||
prepareEmptyCmd(PLOC_SPV::APID_GET_BOOT_STATUS_RPT);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::WATCHDOGS_ENABLE): {
|
||||
case (PLOC_SPV::WATCHDOGS_ENABLE): {
|
||||
prepareWatchdogsEnableCmd(commandData);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::WATCHDOGS_CONFIG_TIMEOUT): {
|
||||
case (PLOC_SPV::WATCHDOGS_CONFIG_TIMEOUT): {
|
||||
result = prepareWatchdogsConfigTimeoutCmd(commandData);
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::ENABLE_LATCHUP_ALERT): {
|
||||
case (PLOC_SPV::ENABLE_LATCHUP_ALERT): {
|
||||
result = prepareLatchupConfigCmd(commandData, deviceCommand);
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::DISABLE_LATCHUP_ALERT): {
|
||||
case (PLOC_SPV::DISABLE_LATCHUP_ALERT): {
|
||||
result = prepareLatchupConfigCmd(commandData, deviceCommand);
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::AUTO_CALIBRATE_ALERT): {
|
||||
case (PLOC_SPV::AUTO_CALIBRATE_ALERT): {
|
||||
result = prepareAutoCalibrateAlertCmd(commandData);
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::SET_ALERT_LIMIT): {
|
||||
case (PLOC_SPV::SET_ALERT_LIMIT): {
|
||||
result = prepareSetAlertLimitCmd(commandData);
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::SET_ALERT_IRQ_FILTER): {
|
||||
case (PLOC_SPV::SET_ALERT_IRQ_FILTER): {
|
||||
result = prepareSetAlertIrqFilterCmd(commandData);
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::SET_ADC_SWEEP_PERIOD): {
|
||||
case (PLOC_SPV::SET_ADC_SWEEP_PERIOD): {
|
||||
result = prepareSetAdcSweetPeriodCmd(commandData);
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::SET_ADC_ENABLED_CHANNELS): {
|
||||
case (PLOC_SPV::SET_ADC_ENABLED_CHANNELS): {
|
||||
prepareSetAdcEnabledChannelsCmd(commandData);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::SET_ADC_WINDOW_AND_STRIDE): {
|
||||
case (PLOC_SPV::SET_ADC_WINDOW_AND_STRIDE): {
|
||||
prepareSetAdcWindowAndStrideCmd(commandData);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::SET_ADC_THRESHOLD): {
|
||||
case (PLOC_SPV::SET_ADC_THRESHOLD): {
|
||||
prepareSetAdcThresholdCmd(commandData);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::GET_LATCHUP_STATUS_REPORT): {
|
||||
case (PLOC_SPV::GET_LATCHUP_STATUS_REPORT): {
|
||||
prepareEmptyCmd(PLOC_SPV::APID_GET_LATCHUP_STATUS_REPORT);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::COPY_ADC_DATA_TO_MRAM): {
|
||||
case (PLOC_SPV::COPY_ADC_DATA_TO_MRAM): {
|
||||
prepareEmptyCmd(PLOC_SPV::APID_COPY_ADC_DATA_TO_MRAM);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::ENABLE_NVMS): {
|
||||
case (PLOC_SPV::ENABLE_NVMS): {
|
||||
prepareEnableNvmsCmd(commandData);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::SELECT_NVM): {
|
||||
case (PLOC_SPV::SELECT_NVM): {
|
||||
prepareSelectNvmCmd(commandData);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::RUN_AUTO_EM_TESTS): {
|
||||
case (PLOC_SPV::RUN_AUTO_EM_TESTS): {
|
||||
result = prepareRunAutoEmTest(commandData);
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::WIPE_MRAM): {
|
||||
case (PLOC_SPV::WIPE_MRAM): {
|
||||
result = prepareWipeMramCmd(commandData);
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::FIRST_MRAM_DUMP):
|
||||
case(PLOC_SPV::CONSECUTIVE_MRAM_DUMP):
|
||||
case (PLOC_SPV::FIRST_MRAM_DUMP):
|
||||
case (PLOC_SPV::CONSECUTIVE_MRAM_DUMP):
|
||||
result = prepareDumpMramCmd(commandData);
|
||||
break;
|
||||
case(PLOC_SPV::PRINT_CPU_STATS): {
|
||||
case (PLOC_SPV::PRINT_CPU_STATS): {
|
||||
preparePrintCpuStatsCmd(commandData);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::SET_DBG_VERBOSITY): {
|
||||
case (PLOC_SPV::SET_DBG_VERBOSITY): {
|
||||
prepareSetDbgVerbosityCmd(commandData);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::CAN_LOOPBACK_TEST): {
|
||||
case (PLOC_SPV::CAN_LOOPBACK_TEST): {
|
||||
prepareEmptyCmd(PLOC_SPV::APID_CAN_LOOPBACK_TEST);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::SET_GPIO): {
|
||||
case (PLOC_SPV::SET_GPIO): {
|
||||
prepareSetGpioCmd(commandData);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::READ_GPIO): {
|
||||
case (PLOC_SPV::READ_GPIO): {
|
||||
prepareReadGpioCmd(commandData);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::RESTART_SUPERVISOR): {
|
||||
case (PLOC_SPV::RESTART_SUPERVISOR): {
|
||||
prepareEmptyCmd(PLOC_SPV::APID_RESTART_SUPERVISOR);
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::FACTORY_RESET_CLEAR_ALL): {
|
||||
case (PLOC_SPV::FACTORY_RESET_CLEAR_ALL): {
|
||||
PLOC_SPV::FactoryReset packet(PLOC_SPV::FactoryReset::Op::CLEAR_ALL);
|
||||
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::FACTORY_RESET_CLEAR_MIRROR): {
|
||||
case (PLOC_SPV::FACTORY_RESET_CLEAR_MIRROR): {
|
||||
PLOC_SPV::FactoryReset packet(PLOC_SPV::FactoryReset::Op::MIRROR_ENTRIES);
|
||||
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::FACTORY_RESET_CLEAR_CIRCULAR): {
|
||||
case (PLOC_SPV::FACTORY_RESET_CLEAR_CIRCULAR): {
|
||||
PLOC_SPV::FactoryReset packet(PLOC_SPV::FactoryReset::Op::CIRCULAR_ENTRIES);
|
||||
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
||||
result = RETURN_OK;
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::UPDATE_AVAILABLE):
|
||||
case(PLOC_SPV::UPDATE_IMAGE_DATA):
|
||||
case(PLOC_SPV::UPDATE_VERIFY):
|
||||
case (PLOC_SPV::UPDATE_AVAILABLE):
|
||||
case (PLOC_SPV::UPDATE_IMAGE_DATA):
|
||||
case (PLOC_SPV::UPDATE_VERIFY):
|
||||
// Simply forward data from PLOC Updater to supervisor
|
||||
std::memcpy(commandBuffer, commandData, commandDataLen);
|
||||
rawPacket = commandBuffer;
|
||||
@ -330,14 +327,12 @@ void PlocSupervisorHandler::fillCommandAndReplyMap() {
|
||||
PLOC_SPV::SIZE_LATCHUP_STATUS_REPORT);
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t *start,
|
||||
size_t remainingSize, DeviceCommandId_t *foundId, size_t *foundLen) {
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t* start, size_t remainingSize,
|
||||
DeviceCommandId_t* foundId, size_t* foundLen) {
|
||||
if (nextReplyId == PLOC_SPV::FIRST_MRAM_DUMP) {
|
||||
*foundId = PLOC_SPV::FIRST_MRAM_DUMP;
|
||||
return parseMramPackets(start, remainingSize, foundLen);
|
||||
}
|
||||
else if (nextReplyId == PLOC_SPV::CONSECUTIVE_MRAM_DUMP) {
|
||||
} else if (nextReplyId == PLOC_SPV::CONSECUTIVE_MRAM_DUMP) {
|
||||
*foundId = PLOC_SPV::CONSECUTIVE_MRAM_DUMP;
|
||||
return parseMramPackets(start, remainingSize, foundLen);
|
||||
}
|
||||
@ -346,32 +341,32 @@ ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t *start,
|
||||
|
||||
uint16_t apid = (*(start) << 8 | *(start + 1)) & APID_MASK;
|
||||
|
||||
switch(apid) {
|
||||
case(PLOC_SPV::APID_ACK_SUCCESS):
|
||||
switch (apid) {
|
||||
case (PLOC_SPV::APID_ACK_SUCCESS):
|
||||
*foundLen = PLOC_SPV::SIZE_ACK_REPORT;
|
||||
*foundId = PLOC_SPV::ACK_REPORT;
|
||||
break;
|
||||
case(PLOC_SPV::APID_ACK_FAILURE):
|
||||
case (PLOC_SPV::APID_ACK_FAILURE):
|
||||
*foundLen = PLOC_SPV::SIZE_ACK_REPORT;
|
||||
*foundId = PLOC_SPV::ACK_REPORT;
|
||||
break;
|
||||
case(PLOC_SPV::APID_HK_REPORT):
|
||||
case (PLOC_SPV::APID_HK_REPORT):
|
||||
*foundLen = PLOC_SPV::SIZE_HK_REPORT;
|
||||
*foundId = PLOC_SPV::HK_REPORT;
|
||||
break;
|
||||
case(PLOC_SPV::APID_BOOT_STATUS_REPORT):
|
||||
case (PLOC_SPV::APID_BOOT_STATUS_REPORT):
|
||||
*foundLen = PLOC_SPV::SIZE_BOOT_STATUS_REPORT;
|
||||
*foundId = PLOC_SPV::BOOT_STATUS_REPORT;
|
||||
break;
|
||||
case(PLOC_SPV::APID_LATCHUP_STATUS_REPORT):
|
||||
case (PLOC_SPV::APID_LATCHUP_STATUS_REPORT):
|
||||
*foundLen = PLOC_SPV::SIZE_LATCHUP_STATUS_REPORT;
|
||||
*foundId = PLOC_SPV::LATCHUP_REPORT;
|
||||
break;
|
||||
case(PLOC_SPV::APID_EXE_SUCCESS):
|
||||
case (PLOC_SPV::APID_EXE_SUCCESS):
|
||||
*foundLen = PLOC_SPV::SIZE_EXE_REPORT;
|
||||
*foundId = PLOC_SPV::EXE_REPORT;
|
||||
break;
|
||||
case(PLOC_SPV::APID_EXE_FAILURE):
|
||||
case (PLOC_SPV::APID_EXE_FAILURE):
|
||||
*foundLen = PLOC_SPV::SIZE_EXE_REPORT;
|
||||
*foundId = PLOC_SPV::EXE_REPORT;
|
||||
break;
|
||||
@ -386,8 +381,7 @@ ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t *start,
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
|
||||
const uint8_t *packet) {
|
||||
|
||||
const uint8_t* packet) {
|
||||
ReturnValue_t result = RETURN_OK;
|
||||
|
||||
switch (id) {
|
||||
@ -416,7 +410,8 @@ ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
sif::debug << "PlocSupervisorHandler::interpretDeviceReply: Unknown device reply id" << std::endl;
|
||||
sif::debug << "PlocSupervisorHandler::interpretDeviceReply: Unknown device reply id"
|
||||
<< std::endl;
|
||||
return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
|
||||
}
|
||||
}
|
||||
@ -424,63 +419,58 @@ ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
|
||||
return result;
|
||||
}
|
||||
|
||||
void PlocSupervisorHandler::setNormalDatapoolEntriesInvalid(){
|
||||
void PlocSupervisorHandler::setNormalDatapoolEntriesInvalid() {}
|
||||
|
||||
}
|
||||
|
||||
uint32_t PlocSupervisorHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo){
|
||||
return 500;
|
||||
}
|
||||
uint32_t PlocSupervisorHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
|
||||
LocalDataPoolManager& poolManager) {
|
||||
localDataPoolMap.emplace(PLOC_SPV::NUM_TMS, new PoolEntry<uint32_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::TEMP_PS, new PoolEntry<uint32_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::TEMP_PL, new PoolEntry<uint32_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::SOC_STATE, new PoolEntry<uint32_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::NVM0_1_STATE, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::NVM3_STATE, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::MISSION_IO_STATE, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::FMC_STATE, new PoolEntry<uint32_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::NUM_TCS, new PoolEntry<uint32_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::UPTIME, new PoolEntry<uint32_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::CPULOAD, new PoolEntry<uint32_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::AVAILABLEHEAP, new PoolEntry<uint32_t>({0}));
|
||||
|
||||
localDataPoolMap.emplace(PLOC_SPV::NUM_TMS, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::TEMP_PS, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::TEMP_PL, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::SOC_STATE, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::NVM0_1_STATE, new PoolEntry<uint8_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::NVM3_STATE, new PoolEntry<uint8_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::MISSION_IO_STATE, new PoolEntry<uint8_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::FMC_STATE, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::NUM_TCS, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::UPTIME, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::CPULOAD, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::AVAILABLEHEAP, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::BOOT_SIGNAL, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::RESET_COUNTER, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::BOOT_AFTER_MS, new PoolEntry<uint32_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::BOOT_TIMEOUT_MS, new PoolEntry<uint32_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::ACTIVE_NVM, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::BP0_STATE, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::BP1_STATE, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::BP2_STATE, new PoolEntry<uint8_t>({0}));
|
||||
|
||||
localDataPoolMap.emplace(PLOC_SPV::BOOT_SIGNAL, new PoolEntry<uint8_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::RESET_COUNTER, new PoolEntry<uint8_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::BOOT_AFTER_MS, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::BOOT_TIMEOUT_MS, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::ACTIVE_NVM, new PoolEntry<uint8_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::BP0_STATE, new PoolEntry<uint8_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::BP1_STATE, new PoolEntry<uint8_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::BP2_STATE, new PoolEntry<uint8_t>( { 0 }));
|
||||
|
||||
localDataPoolMap.emplace(PLOC_SPV::LATCHUP_ID, new PoolEntry<uint8_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::CNT0, new PoolEntry<uint16_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::CNT1, new PoolEntry<uint16_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::CNT2, new PoolEntry<uint16_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::CNT3, new PoolEntry<uint16_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::CNT4, new PoolEntry<uint16_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::CNT5, new PoolEntry<uint16_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::CNT6, new PoolEntry<uint16_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_SEC, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_MIN, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_HOUR, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_DAY, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_MON, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_YEAR, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_MSEC, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_IS_SET, new PoolEntry<uint32_t>( { 0 }));
|
||||
localDataPoolMap.emplace(PLOC_SPV::LATCHUP_ID, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::CNT0, new PoolEntry<uint16_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::CNT1, new PoolEntry<uint16_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::CNT2, new PoolEntry<uint16_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::CNT3, new PoolEntry<uint16_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::CNT4, new PoolEntry<uint16_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::CNT5, new PoolEntry<uint16_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::CNT6, new PoolEntry<uint16_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_SEC, new PoolEntry<uint32_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_MIN, new PoolEntry<uint32_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_HOUR, new PoolEntry<uint32_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_DAY, new PoolEntry<uint32_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_MON, new PoolEntry<uint32_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_YEAR, new PoolEntry<uint32_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_MSEC, new PoolEntry<uint32_t>({0}));
|
||||
localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_IS_SET, new PoolEntry<uint32_t>({0}));
|
||||
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::iterator command,
|
||||
uint8_t expectedReplies, bool useAlternateId,
|
||||
uint8_t expectedReplies,
|
||||
bool useAlternateId,
|
||||
DeviceCommandId_t alternateReplyID) {
|
||||
|
||||
ReturnValue_t result = RETURN_OK;
|
||||
|
||||
uint8_t enabledReplies = 0;
|
||||
@ -585,15 +575,15 @@ ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::ite
|
||||
* Every command causes at least one acknowledgment and one execution report. Therefore both
|
||||
* replies will be enabled here.
|
||||
*/
|
||||
result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
|
||||
PLOC_SPV::ACK_REPORT);
|
||||
result =
|
||||
DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, PLOC_SPV::ACK_REPORT);
|
||||
if (result != RETURN_OK) {
|
||||
sif::debug << "PlocSupervisorHandler::enableReplyInReplyMap: Reply with id "
|
||||
<< PLOC_SPV::ACK_REPORT << " not in replyMap" << std::endl;
|
||||
}
|
||||
|
||||
result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
|
||||
PLOC_SPV::EXE_REPORT);
|
||||
result =
|
||||
DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, PLOC_SPV::EXE_REPORT);
|
||||
if (result != RETURN_OK) {
|
||||
sif::debug << "PlocSupervisorHandler::enableReplyInReplyMap: Reply with id "
|
||||
<< PLOC_SPV::EXE_REPORT << " not in replyMap" << std::endl;
|
||||
@ -603,7 +593,6 @@ ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::ite
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::verifyPacket(const uint8_t* start, size_t foundLen) {
|
||||
|
||||
uint16_t receivedCrc = *(start + foundLen - 2) << 8 | *(start + foundLen - 1);
|
||||
|
||||
uint16_t recalculatedCrc = CRC::crc16ccitt(start, foundLen - 2);
|
||||
@ -616,11 +605,10 @@ ReturnValue_t PlocSupervisorHandler::verifyPacket(const uint8_t* start, size_t f
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::handleAckReport(const uint8_t* data) {
|
||||
|
||||
ReturnValue_t result = RETURN_OK;
|
||||
|
||||
result = verifyPacket(data, PLOC_SPV::SIZE_ACK_REPORT);
|
||||
if(result == CRC_FAILURE) {
|
||||
if (result == CRC_FAILURE) {
|
||||
sif::error << "PlocSupervisorHandler::handleAckReport: CRC failure" << std::endl;
|
||||
nextReplyId = PLOC_SPV::NONE;
|
||||
replyRawReplyIfnotWiretapped(data, PLOC_SPV::SIZE_ACK_REPORT);
|
||||
@ -632,10 +620,11 @@ ReturnValue_t PlocSupervisorHandler::handleAckReport(const uint8_t* data) {
|
||||
|
||||
uint16_t apid = (*(data) << 8 | *(data + 1)) & APID_MASK;
|
||||
|
||||
switch(apid) {
|
||||
switch (apid) {
|
||||
case PLOC_SPV::APID_ACK_FAILURE: {
|
||||
//TODO: Interpretation of status field in acknowledgment report
|
||||
sif::debug << "PlocSupervisorHandler::handleAckReport: Received Ack failure report" << std::endl;
|
||||
// TODO: Interpretation of status field in acknowledgment report
|
||||
sif::debug << "PlocSupervisorHandler::handleAckReport: Received Ack failure report"
|
||||
<< std::endl;
|
||||
DeviceCommandId_t commandId = getPendingCommand();
|
||||
if (commandId != DeviceHandlerIF::NO_COMMAND_ID) {
|
||||
triggerEvent(SUPV_ACK_FAILURE, commandId);
|
||||
@ -651,7 +640,8 @@ ReturnValue_t PlocSupervisorHandler::handleAckReport(const uint8_t* data) {
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
sif::debug << "PlocSupervisorHandler::handleAckReport: Invalid APID in Ack report" << std::endl;
|
||||
sif::debug << "PlocSupervisorHandler::handleAckReport: Invalid APID in Ack report"
|
||||
<< std::endl;
|
||||
result = RETURN_FAILED;
|
||||
break;
|
||||
}
|
||||
@ -661,11 +651,10 @@ ReturnValue_t PlocSupervisorHandler::handleAckReport(const uint8_t* data) {
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::handleExecutionReport(const uint8_t* data) {
|
||||
|
||||
ReturnValue_t result = RETURN_OK;
|
||||
|
||||
result = verifyPacket(data, PLOC_SPV::SIZE_EXE_REPORT);
|
||||
if(result == CRC_FAILURE) {
|
||||
if (result == CRC_FAILURE) {
|
||||
sif::error << "PlocSupervisorHandler::handleExecutionReport: CRC failure" << std::endl;
|
||||
nextReplyId = PLOC_SPV::NONE;
|
||||
return result;
|
||||
@ -678,15 +667,16 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionReport(const uint8_t* data)
|
||||
break;
|
||||
}
|
||||
case (PLOC_SPV::APID_EXE_FAILURE): {
|
||||
//TODO: Interpretation of status field in execution report
|
||||
sif::error << "PlocSupervisorHandler::handleExecutionReport: Received execution failure report"
|
||||
// TODO: Interpretation of status field in execution report
|
||||
sif::error
|
||||
<< "PlocSupervisorHandler::handleExecutionReport: Received execution failure report"
|
||||
<< std::endl;
|
||||
DeviceCommandId_t commandId = getPendingCommand();
|
||||
if (commandId != DeviceHandlerIF::NO_COMMAND_ID) {
|
||||
triggerEvent(SUPV_EXE_FAILURE, commandId);
|
||||
}
|
||||
else {
|
||||
sif::debug << "PlocSupervisorHandler::handleExecutionReport: Unknown command id" << std::endl;
|
||||
} else {
|
||||
sif::debug << "PlocSupervisorHandler::handleExecutionReport: Unknown command id"
|
||||
<< std::endl;
|
||||
}
|
||||
sendFailureReport(PLOC_SPV::EXE_REPORT, RECEIVED_EXE_FAILURE);
|
||||
disableExeReportReply();
|
||||
@ -706,43 +696,41 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionReport(const uint8_t* data)
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) {
|
||||
|
||||
ReturnValue_t result = RETURN_OK;
|
||||
|
||||
result = verifyPacket(data, PLOC_SPV::SIZE_HK_REPORT);
|
||||
|
||||
if(result == CRC_FAILURE) {
|
||||
sif::error << "PlocSupervisorHandler::handleHkReport: Hk report has invalid crc"
|
||||
<< std::endl;
|
||||
if (result == CRC_FAILURE) {
|
||||
sif::error << "PlocSupervisorHandler::handleHkReport: Hk report has invalid crc" << std::endl;
|
||||
}
|
||||
|
||||
uint16_t offset = PLOC_SPV::DATA_FIELD_OFFSET;
|
||||
hkset.tempPs = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
|
||||
| *(data + offset + 3);
|
||||
hkset.tempPs = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
|
||||
*(data + offset + 3);
|
||||
offset += 4;
|
||||
hkset.tempPl = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
|
||||
| *(data + offset + 3);
|
||||
hkset.tempPl = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
|
||||
*(data + offset + 3);
|
||||
offset += 4;
|
||||
hkset.tempSup = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
|
||||
| *(data + offset + 3);
|
||||
hkset.tempSup = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
|
||||
*(data + offset + 3);
|
||||
offset += 4;
|
||||
hkset.uptime = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
|
||||
| *(data + offset + 3);
|
||||
hkset.uptime = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
|
||||
*(data + offset + 3);
|
||||
offset += 4;
|
||||
hkset.cpuLoad = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
|
||||
| *(data + offset + 3);
|
||||
hkset.cpuLoad = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
|
||||
*(data + offset + 3);
|
||||
offset += 4;
|
||||
hkset.availableHeap = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
|
||||
| *(data + offset + 3);
|
||||
hkset.availableHeap = *(data + offset) << 24 | *(data + offset + 1) << 16 |
|
||||
*(data + offset + 2) << 8 | *(data + offset + 3);
|
||||
offset += 4;
|
||||
hkset.numTcs = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
|
||||
| *(data + offset + 3);
|
||||
hkset.numTcs = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
|
||||
*(data + offset + 3);
|
||||
offset += 4;
|
||||
hkset.numTms = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
|
||||
| *(data + offset + 3);
|
||||
hkset.numTms = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
|
||||
*(data + offset + 3);
|
||||
offset += 4;
|
||||
hkset.socState = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
|
||||
| *(data + offset + 3);
|
||||
hkset.socState = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
|
||||
*(data + offset + 3);
|
||||
offset += 4;
|
||||
hkset.nvm0_1_state = *(data + offset);
|
||||
offset += 1;
|
||||
@ -761,7 +749,8 @@ ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) {
|
||||
sif::info << "PlocSupervisorHandler::handleHkReport: temp_sup: " << hkset.tempSup << std::endl;
|
||||
sif::info << "PlocSupervisorHandler::handleHkReport: uptime: " << hkset.uptime << std::endl;
|
||||
sif::info << "PlocSupervisorHandler::handleHkReport: cpu_load: " << hkset.cpuLoad << std::endl;
|
||||
sif::info << "PlocSupervisorHandler::handleHkReport: available_heap: " << hkset.availableHeap << std::endl;
|
||||
sif::info << "PlocSupervisorHandler::handleHkReport: available_heap: " << hkset.availableHeap
|
||||
<< std::endl;
|
||||
sif::info << "PlocSupervisorHandler::handleHkReport: num_tcs: " << hkset.numTcs << std::endl;
|
||||
sif::info << "PlocSupervisorHandler::handleHkReport: num_tms: " << hkset.numTms << std::endl;
|
||||
sif::info << "PlocSupervisorHandler::handleHkReport: soc_state: " << hkset.socState << std::endl;
|
||||
@ -780,14 +769,14 @@ ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) {
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::handleBootStatusReport(const uint8_t* data) {
|
||||
|
||||
ReturnValue_t result = RETURN_OK;
|
||||
|
||||
result = verifyPacket(data, PLOC_SPV::SIZE_BOOT_STATUS_REPORT);
|
||||
|
||||
if(result == CRC_FAILURE) {
|
||||
if (result == CRC_FAILURE) {
|
||||
sif::error << "PlocSupervisorHandler::handleBootStatusReport: Boot status report has invalid"
|
||||
" crc" << std::endl;
|
||||
" crc"
|
||||
<< std::endl;
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -835,12 +824,11 @@ ReturnValue_t PlocSupervisorHandler::handleBootStatusReport(const uint8_t* data)
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::handleLatchupStatusReport(const uint8_t* data) {
|
||||
|
||||
ReturnValue_t result = RETURN_OK;
|
||||
|
||||
result = verifyPacket(data, PLOC_SPV::SIZE_LATCHUP_STATUS_REPORT);
|
||||
|
||||
if(result == CRC_FAILURE) {
|
||||
if (result == CRC_FAILURE) {
|
||||
sif::error << "PlocSupervisorHandler::handleLatchupStatusReport: Latchup status report has "
|
||||
<< "invalid crc" << std::endl;
|
||||
return result;
|
||||
@ -921,15 +909,15 @@ ReturnValue_t PlocSupervisorHandler::handleLatchupStatusReport(const uint8_t* da
|
||||
<< latchupStatusReport.timeYear << std::endl;
|
||||
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: Msec: "
|
||||
<< latchupStatusReport.timeMsec << std::endl;
|
||||
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: isSet: 0x"
|
||||
<< std::hex << latchupStatusReport.timeMsec << std::dec << std::endl;
|
||||
sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: isSet: 0x" << std::hex
|
||||
<< latchupStatusReport.timeMsec << std::dec << std::endl;
|
||||
#endif
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void PlocSupervisorHandler::setNextReplyId() {
|
||||
switch(getPendingCommand()) {
|
||||
switch (getPendingCommand()) {
|
||||
case PLOC_SPV::GET_HK_REPORT:
|
||||
nextReplyId = PLOC_SPV::HK_REPORT;
|
||||
break;
|
||||
@ -952,16 +940,14 @@ void PlocSupervisorHandler::setNextReplyId() {
|
||||
}
|
||||
}
|
||||
|
||||
size_t PlocSupervisorHandler::getNextReplyLength(DeviceCommandId_t commandId){
|
||||
|
||||
size_t PlocSupervisorHandler::getNextReplyLength(DeviceCommandId_t commandId) {
|
||||
size_t replyLen = 0;
|
||||
|
||||
if (nextReplyId == PLOC_SPV::NONE) {
|
||||
return replyLen;
|
||||
}
|
||||
|
||||
if (nextReplyId == PLOC_SPV::FIRST_MRAM_DUMP
|
||||
|| nextReplyId == PLOC_SPV::CONSECUTIVE_MRAM_DUMP) {
|
||||
if (nextReplyId == PLOC_SPV::FIRST_MRAM_DUMP || nextReplyId == PLOC_SPV::CONSECUTIVE_MRAM_DUMP) {
|
||||
/**
|
||||
* Try to read 20 MRAM packets. If reply is larger, the packets will be read with the
|
||||
* next doSendRead call. The command will be as long active as the packet with the sequence
|
||||
@ -978,8 +964,7 @@ size_t PlocSupervisorHandler::getNextReplyLength(DeviceCommandId_t commandId){
|
||||
return replyLen;
|
||||
}
|
||||
replyLen = iter->second.replyLen;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
sif::debug << "PlocSupervisorHandler::getNextReplyLength: No entry for reply with reply id "
|
||||
<< std::hex << nextReplyId << " in deviceReplyMap" << std::endl;
|
||||
}
|
||||
@ -987,8 +972,8 @@ size_t PlocSupervisorHandler::getNextReplyLength(DeviceCommandId_t commandId){
|
||||
return replyLen;
|
||||
}
|
||||
|
||||
void PlocSupervisorHandler::handleDeviceTM(const uint8_t* data, size_t dataSize, DeviceCommandId_t replyId) {
|
||||
|
||||
void PlocSupervisorHandler::handleDeviceTM(const uint8_t* data, size_t dataSize,
|
||||
DeviceCommandId_t replyId) {
|
||||
ReturnValue_t result = RETURN_OK;
|
||||
|
||||
if (wiretappingMode == RAW) {
|
||||
@ -1018,7 +1003,7 @@ void PlocSupervisorHandler::prepareEmptyCmd(uint16_t apid) {
|
||||
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
||||
}
|
||||
|
||||
void PlocSupervisorHandler::prepareSelBootImageCmd(const uint8_t * commandData) {
|
||||
void PlocSupervisorHandler::prepareSelBootImageCmd(const uint8_t* commandData) {
|
||||
PLOC_SPV::MPSoCBootSelect packet(*commandData, *(commandData + 1), *(commandData + 2),
|
||||
*(commandData + 3));
|
||||
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
||||
@ -1042,20 +1027,20 @@ void PlocSupervisorHandler::prepareDisableHk() {
|
||||
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
||||
}
|
||||
|
||||
void PlocSupervisorHandler::prepareSetBootTimeoutCmd(const uint8_t * commandData) {
|
||||
uint32_t timeout = *(commandData) << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8
|
||||
| *(commandData + 3);
|
||||
void PlocSupervisorHandler::prepareSetBootTimeoutCmd(const uint8_t* commandData) {
|
||||
uint32_t timeout = *(commandData) << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8 |
|
||||
*(commandData + 3);
|
||||
PLOC_SPV::SetBootTimeout packet(timeout);
|
||||
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
||||
}
|
||||
|
||||
void PlocSupervisorHandler::prepareRestartTriesCmd(const uint8_t * commandData) {
|
||||
void PlocSupervisorHandler::prepareRestartTriesCmd(const uint8_t* commandData) {
|
||||
uint8_t restartTries = *(commandData);
|
||||
PLOC_SPV::SetRestartTries packet(restartTries);
|
||||
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
||||
}
|
||||
|
||||
void PlocSupervisorHandler::prepareWatchdogsEnableCmd(const uint8_t * commandData) {
|
||||
void PlocSupervisorHandler::prepareWatchdogsEnableCmd(const uint8_t* commandData) {
|
||||
uint8_t offset = 0;
|
||||
uint8_t watchdogPs = *(commandData + offset);
|
||||
offset += 1;
|
||||
@ -1066,15 +1051,15 @@ void PlocSupervisorHandler::prepareWatchdogsEnableCmd(const uint8_t * commandDat
|
||||
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::prepareWatchdogsConfigTimeoutCmd(const uint8_t * commandData) {
|
||||
ReturnValue_t PlocSupervisorHandler::prepareWatchdogsConfigTimeoutCmd(const uint8_t* commandData) {
|
||||
uint8_t offset = 0;
|
||||
uint8_t watchdog = *(commandData + offset);
|
||||
offset += 1;
|
||||
if (watchdog > 2) {
|
||||
return INVALID_WATCHDOG;
|
||||
}
|
||||
uint32_t timeout = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16
|
||||
| *(commandData + offset + 2) << 8 | *(commandData + offset + 3);
|
||||
uint32_t timeout = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16 |
|
||||
*(commandData + offset + 2) << 8 | *(commandData + offset + 3);
|
||||
if (timeout < 1000 || timeout > 360000) {
|
||||
return INVALID_WATCHDOG_TIMEOUT;
|
||||
}
|
||||
@ -1115,8 +1100,8 @@ ReturnValue_t PlocSupervisorHandler::prepareAutoCalibrateAlertCmd(const uint8_t*
|
||||
uint8_t offset = 0;
|
||||
uint8_t latchupId = *commandData;
|
||||
offset += 1;
|
||||
uint32_t mg = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16
|
||||
| *(commandData + offset + 2) << 8 | *(commandData + offset + 3);
|
||||
uint32_t mg = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16 |
|
||||
*(commandData + offset + 2) << 8 | *(commandData + offset + 3);
|
||||
if (latchupId > 6) {
|
||||
return INVALID_LATCHUP_ID;
|
||||
}
|
||||
@ -1141,8 +1126,8 @@ ReturnValue_t PlocSupervisorHandler::prepareSetAlertLimitCmd(const uint8_t* comm
|
||||
uint8_t offset = 0;
|
||||
uint8_t latchupId = *commandData;
|
||||
offset += 1;
|
||||
uint32_t dutycycle = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16
|
||||
| *(commandData + offset + 2) << 8 | *(commandData + offset + 3);
|
||||
uint32_t dutycycle = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16 |
|
||||
*(commandData + offset + 2) << 8 | *(commandData + offset + 3);
|
||||
if (latchupId > 6) {
|
||||
return INVALID_LATCHUP_ID;
|
||||
}
|
||||
@ -1152,8 +1137,8 @@ ReturnValue_t PlocSupervisorHandler::prepareSetAlertLimitCmd(const uint8_t* comm
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::prepareSetAdcSweetPeriodCmd(const uint8_t* commandData) {
|
||||
uint32_t sweepPeriod = *(commandData) << 24 | *(commandData + 1) << 16
|
||||
| *(commandData + 2) << 8 | *(commandData + 3);
|
||||
uint32_t sweepPeriod = *(commandData) << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8 |
|
||||
*(commandData + 3);
|
||||
if (sweepPeriod < 21) {
|
||||
return SWEEP_PERIOD_TOO_SMALL;
|
||||
}
|
||||
@ -1178,8 +1163,8 @@ void PlocSupervisorHandler::prepareSetAdcWindowAndStrideCmd(const uint8_t* comma
|
||||
}
|
||||
|
||||
void PlocSupervisorHandler::prepareSetAdcThresholdCmd(const uint8_t* commandData) {
|
||||
uint32_t threshold = *(commandData) << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8
|
||||
| *(commandData + 3);
|
||||
uint32_t threshold = *(commandData) << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8 |
|
||||
*(commandData + 3);
|
||||
PLOC_SPV::SetAdcThreshold packet(threshold);
|
||||
packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
|
||||
}
|
||||
@ -1275,12 +1260,11 @@ void PlocSupervisorHandler::packetToOutBuffer(uint8_t* packetData, size_t fullSi
|
||||
}
|
||||
|
||||
void PlocSupervisorHandler::disableAllReplies() {
|
||||
|
||||
DeviceReplyMap::iterator iter;
|
||||
|
||||
/* Disable ack reply */
|
||||
iter = deviceReplyMap.find(PLOC_SPV::ACK_REPORT);
|
||||
DeviceReplyInfo *info = &(iter->second);
|
||||
DeviceReplyInfo* info = &(iter->second);
|
||||
info->delayCycles = 0;
|
||||
info->command = deviceCommandMap.end();
|
||||
|
||||
@ -1305,7 +1289,6 @@ void PlocSupervisorHandler::disableAllReplies() {
|
||||
}
|
||||
|
||||
void PlocSupervisorHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status) {
|
||||
|
||||
DeviceReplyIter iter = deviceReplyMap.find(replyId);
|
||||
|
||||
if (iter == deviceReplyMap.end()) {
|
||||
@ -1316,7 +1299,8 @@ void PlocSupervisorHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnV
|
||||
DeviceCommandInfo* info = &(iter->second.command->second);
|
||||
|
||||
if (info == nullptr) {
|
||||
sif::debug << "PlocSupervisorHandler::sendFailureReport: Reply has no active command" << std::endl;
|
||||
sif::debug << "PlocSupervisorHandler::sendFailureReport: Reply has no active command"
|
||||
<< std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
@ -1328,14 +1312,14 @@ void PlocSupervisorHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnV
|
||||
|
||||
void PlocSupervisorHandler::disableExeReportReply() {
|
||||
DeviceReplyIter iter = deviceReplyMap.find(PLOC_SPV::EXE_REPORT);
|
||||
DeviceReplyInfo *info = &(iter->second);
|
||||
DeviceReplyInfo* info = &(iter->second);
|
||||
info->delayCycles = 0;
|
||||
info->command = deviceCommandMap.end();
|
||||
/* Expected replies is set to one here. The value will set to 0 in replyToReply() */
|
||||
info->command->second.expectedReplies = 1;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::parseMramPackets(const uint8_t *packet, size_t remainingSize,
|
||||
ReturnValue_t PlocSupervisorHandler::parseMramPackets(const uint8_t* packet, size_t remainingSize,
|
||||
size_t* foundLen) {
|
||||
ReturnValue_t result = IGNORE_FULL_PACKET;
|
||||
uint16_t packetLen = 0;
|
||||
@ -1367,7 +1351,6 @@ ReturnValue_t PlocSupervisorHandler::parseMramPackets(const uint8_t *packet, siz
|
||||
}
|
||||
|
||||
ReturnValue_t PlocSupervisorHandler::handleMramDumpPacket(DeviceCommandId_t id) {
|
||||
|
||||
ReturnValue_t result = RETURN_FAILED;
|
||||
|
||||
// Prepare packet for downlink
|
||||
@ -1380,8 +1363,7 @@ ReturnValue_t PlocSupervisorHandler::handleMramDumpPacket(DeviceCommandId_t id)
|
||||
}
|
||||
handleMramDumpFile(id);
|
||||
if (downlinkMramDump == true) {
|
||||
handleDeviceTM(spacePacketBuffer + PLOC_SPV::SPACE_PACKET_HEADER_LENGTH, packetLen - 1,
|
||||
id);
|
||||
handleDeviceTM(spacePacketBuffer + PLOC_SPV::SPACE_PACKET_HEADER_LENGTH, packetLen - 1, id);
|
||||
}
|
||||
packetInBuffer = false;
|
||||
receivedMramDumpPackets++;
|
||||
@ -1407,35 +1389,34 @@ void PlocSupervisorHandler::increaseExpectedMramReplies(DeviceCommandId_t id) {
|
||||
<< "in reply map" << std::endl;
|
||||
return;
|
||||
}
|
||||
DeviceReplyInfo *mramReplyInfo = &(mramDumpIter->second);
|
||||
DeviceReplyInfo* mramReplyInfo = &(mramDumpIter->second);
|
||||
if (mramReplyInfo == nullptr) {
|
||||
sif::debug << "PlocSupervisorHandler::increaseExpectedReplies: MRAM reply info nullptr"
|
||||
<< std::endl;
|
||||
return;
|
||||
}
|
||||
DeviceReplyInfo *exeReplyInfo = &(exeReportIter->second);
|
||||
DeviceReplyInfo* exeReplyInfo = &(exeReportIter->second);
|
||||
if (exeReplyInfo == nullptr) {
|
||||
sif::debug << "PlocSupervisorHandler::increaseExpectedReplies: Execution reply info"
|
||||
<< " nullptr" << std::endl;
|
||||
return;
|
||||
}
|
||||
DeviceCommandInfo* info = &(mramReplyInfo->command->second);
|
||||
if (info == nullptr){
|
||||
if (info == nullptr) {
|
||||
sif::debug << "PlocSupervisorHandler::increaseExpectedReplies: Command info nullptr"
|
||||
<< std::endl;
|
||||
return;
|
||||
}
|
||||
uint8_t sequenceFlags = spacePacketBuffer[2] >> 6;
|
||||
if (sequenceFlags != static_cast<uint8_t>(PLOC_SPV::SequenceFlags::LAST_PKT)
|
||||
&& (sequenceFlags != static_cast<uint8_t>(PLOC_SPV::SequenceFlags::STANDALONE_PKT))) {
|
||||
if (sequenceFlags != static_cast<uint8_t>(PLOC_SPV::SequenceFlags::LAST_PKT) &&
|
||||
(sequenceFlags != static_cast<uint8_t>(PLOC_SPV::SequenceFlags::STANDALONE_PKT))) {
|
||||
// Command expects at least one MRAM packet more and the execution report
|
||||
info->expectedReplies = 2;
|
||||
// Wait maximum of 2 cycles for next MRAM packet
|
||||
mramReplyInfo->delayCycles = 2;
|
||||
// Also adapting delay cycles for execution report
|
||||
exeReplyInfo->delayCycles = 3;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
// Command expects the execution report
|
||||
info->expectedReplies = 1;
|
||||
mramReplyInfo->delayCycles = 0;
|
||||
@ -1456,8 +1437,8 @@ ReturnValue_t PlocSupervisorHandler::handleMramDumpFile(DeviceCommandId_t id) {
|
||||
uint16_t packetLen = readSpacePacketLength(spacePacketBuffer);
|
||||
uint8_t sequenceFlags = readSequenceFlags(spacePacketBuffer);
|
||||
if (id == PLOC_SPV::FIRST_MRAM_DUMP) {
|
||||
if (sequenceFlags == static_cast<uint8_t>(PLOC_SPV::SequenceFlags::FIRST_PKT)
|
||||
|| (sequenceFlags == static_cast<uint8_t>(PLOC_SPV::SequenceFlags::STANDALONE_PKT))) {
|
||||
if (sequenceFlags == static_cast<uint8_t>(PLOC_SPV::SequenceFlags::FIRST_PKT) ||
|
||||
(sequenceFlags == static_cast<uint8_t>(PLOC_SPV::SequenceFlags::STANDALONE_PKT))) {
|
||||
result = createMramDumpFile();
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
@ -1523,8 +1504,8 @@ ReturnValue_t PlocSupervisorHandler::getTimeStampString(std::string& timeStamp)
|
||||
<< std::endl;
|
||||
return GET_TIME_FAILURE;
|
||||
}
|
||||
timeStamp = std::to_string(time.year) + "-" + std::to_string(time.month) + "-"
|
||||
+ std::to_string(time.day) + "--" + std::to_string(time.hour) + "-"
|
||||
+ std::to_string(time.minute) + "-" + std::to_string(time.second);
|
||||
timeStamp = std::to_string(time.year) + "-" + std::to_string(time.month) + "-" +
|
||||
std::to_string(time.day) + "--" + std::to_string(time.hour) + "-" +
|
||||
std::to_string(time.minute) + "-" + std::to_string(time.second);
|
||||
return RETURN_OK;
|
||||
}
|
||||
|
@ -1,12 +1,12 @@
|
||||
#ifndef MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_
|
||||
#define MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_
|
||||
|
||||
#include "devicedefinitions/PlocSupervisorDefinitions.h"
|
||||
#include <bsp_q7s/memory/SdCardManager.h>
|
||||
|
||||
#include <fsfw/devicehandlers/DeviceHandlerBase.h>
|
||||
#include <fsfw_hal/linux/uart/UartComIF.h>
|
||||
|
||||
#include "devicedefinitions/PlocSupervisorDefinitions.h"
|
||||
|
||||
/**
|
||||
* @brief This is the device handler for the supervisor of the PLOC which is programmed by
|
||||
* Thales.
|
||||
@ -19,26 +19,24 @@
|
||||
* Arbeitsdaten/08_Used%20Components/PLOC&fileid=940960
|
||||
* @author J. Meier
|
||||
*/
|
||||
class PlocSupervisorHandler: public DeviceHandlerBase {
|
||||
public:
|
||||
|
||||
PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF * comCookie);
|
||||
class PlocSupervisorHandler : public DeviceHandlerBase {
|
||||
public:
|
||||
PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie);
|
||||
virtual ~PlocSupervisorHandler();
|
||||
|
||||
virtual ReturnValue_t initialize() override;
|
||||
|
||||
protected:
|
||||
protected:
|
||||
void doStartUp() override;
|
||||
void doShutDown() override;
|
||||
ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) override;
|
||||
ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) override;
|
||||
ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
|
||||
ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t* id) override;
|
||||
void fillCommandAndReplyMap() override;
|
||||
ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
|
||||
const uint8_t * commandData,size_t commandDataLen) override;
|
||||
ReturnValue_t scanForReply(const uint8_t *start, size_t remainingSize,
|
||||
DeviceCommandId_t *foundId, size_t *foundLen) override;
|
||||
ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
|
||||
const uint8_t *packet) override;
|
||||
ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t* commandData,
|
||||
size_t commandDataLen) override;
|
||||
ReturnValue_t scanForReply(const uint8_t* start, size_t remainingSize, DeviceCommandId_t* foundId,
|
||||
size_t* foundLen) override;
|
||||
ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) override;
|
||||
void setNormalDatapoolEntriesInvalid() override;
|
||||
uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
|
||||
ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
|
||||
@ -48,8 +46,7 @@ protected:
|
||||
DeviceCommandId_t alternateReplyID = 0) override;
|
||||
size_t getNextReplyLength(DeviceCommandId_t deviceCommand) override;
|
||||
|
||||
private:
|
||||
|
||||
private:
|
||||
static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_SUPERVISOR_HANDLER;
|
||||
|
||||
//! [EXPORT] : [COMMENT] Space Packet received from PLOC supervisor has invalid CRC
|
||||
@ -64,25 +61,32 @@ private:
|
||||
static const ReturnValue_t GET_TIME_FAILURE = MAKE_RETURN_CODE(0xA4);
|
||||
//! [EXPORT] : [COMMENT] Invalid communication interface specified
|
||||
static const ReturnValue_t INVALID_UART_COM_IF = MAKE_RETURN_CODE(0xA5);
|
||||
//! [EXPORT] : [COMMENT] Received command with invalid watchdog parameter. Valid watchdogs are 0 for PS, 1 for PL and 2 for INT
|
||||
//! [EXPORT] : [COMMENT] Received command with invalid watchdog parameter. Valid watchdogs are 0
|
||||
//! for PS, 1 for PL and 2 for INT
|
||||
static const ReturnValue_t INVALID_WATCHDOG = MAKE_RETURN_CODE(0xA6);
|
||||
//! [EXPORT] : [COMMENT] Received watchdog timeout config command with invalid timeout. Valid timeouts must be in the range between 1000 and 360000 ms.
|
||||
//! [EXPORT] : [COMMENT] Received watchdog timeout config command with invalid timeout. Valid
|
||||
//! timeouts must be in the range between 1000 and 360000 ms.
|
||||
static const ReturnValue_t INVALID_WATCHDOG_TIMEOUT = MAKE_RETURN_CODE(0xA7);
|
||||
//! [EXPORT] : [COMMENT] Received latchup config command with invalid latchup ID
|
||||
static const ReturnValue_t INVALID_LATCHUP_ID = MAKE_RETURN_CODE(0xA8);
|
||||
//! [EXPORT] : [COMMENT] Received set adc sweep period command with invalid sweep period. Must be larger than 21.
|
||||
//! [EXPORT] : [COMMENT] Received set adc sweep period command with invalid sweep period. Must be
|
||||
//! larger than 21.
|
||||
static const ReturnValue_t SWEEP_PERIOD_TOO_SMALL = MAKE_RETURN_CODE(0xA9);
|
||||
//! [EXPORT] : [COMMENT] Receive auto EM test command with invalid test param. Valid params are 1 and 2.
|
||||
//! [EXPORT] : [COMMENT] Receive auto EM test command with invalid test param. Valid params are 1
|
||||
//! and 2.
|
||||
static const ReturnValue_t INVALID_TEST_PARAM = MAKE_RETURN_CODE(0xAA);
|
||||
//! [EXPORT] : [COMMENT] Returned when scanning for MRAM dump packets failed.
|
||||
static const ReturnValue_t MRAM_PACKET_PARSING_FAILURE = MAKE_RETURN_CODE(0xAB);
|
||||
//! [EXPORT] : [COMMENT] Returned when the start and stop addresses of the MRAM dump or MRAM wipe commands are invalid (e.g. start address bigger than stop address)
|
||||
//! [EXPORT] : [COMMENT] Returned when the start and stop addresses of the MRAM dump or MRAM wipe
|
||||
//! commands are invalid (e.g. start address bigger than stop address)
|
||||
static const ReturnValue_t INVALID_MRAM_ADDRESSES = MAKE_RETURN_CODE(0xAC);
|
||||
//! [EXPORT] : [COMMENT] Expect reception of an MRAM dump packet but received space packet with other apid.
|
||||
//! [EXPORT] : [COMMENT] Expect reception of an MRAM dump packet but received space packet with
|
||||
//! other apid.
|
||||
static const ReturnValue_t NO_MRAM_PACKET = MAKE_RETURN_CODE(0xAD);
|
||||
//! [EXPORT] : [COMMENT] Path to PLOC directory on SD card does not exist
|
||||
static const ReturnValue_t PATH_DOES_NOT_EXIST = MAKE_RETURN_CODE(0xAE);
|
||||
//! [EXPORT] : [COMMENT] MRAM dump file does not exists. The file should actually already have been created with the reception of the first dump packet.
|
||||
//! [EXPORT] : [COMMENT] MRAM dump file does not exists. The file should actually already have
|
||||
//! been created with the reception of the first dump packet.
|
||||
static const ReturnValue_t MRAM_FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xAF);
|
||||
|
||||
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_SUPERVISOR_HANDLER;
|
||||
@ -209,7 +213,7 @@ private:
|
||||
/**
|
||||
* @brief This function initializes the space packet to select the boot image of the MPSoC.
|
||||
*/
|
||||
void prepareSelBootImageCmd(const uint8_t * commandData);
|
||||
void prepareSelBootImageCmd(const uint8_t* commandData);
|
||||
|
||||
void prepareDisableHk();
|
||||
|
||||
@ -223,21 +227,21 @@ private:
|
||||
* @brief This function fills the commandBuffer with the data to change the boot timeout
|
||||
* value in the PLOC supervisor.
|
||||
*/
|
||||
void prepareSetBootTimeoutCmd(const uint8_t * commandData);
|
||||
void prepareSetBootTimeoutCmd(const uint8_t* commandData);
|
||||
|
||||
void prepareRestartTriesCmd(const uint8_t * commandData);
|
||||
void prepareRestartTriesCmd(const uint8_t* commandData);
|
||||
|
||||
/**
|
||||
* @brief This function fills the command buffer with the packet to enable or disable the
|
||||
* watchdogs on the PLOC.
|
||||
*/
|
||||
void prepareWatchdogsEnableCmd(const uint8_t * commandData);
|
||||
void prepareWatchdogsEnableCmd(const uint8_t* commandData);
|
||||
|
||||
/**
|
||||
* @brief This function fills the command buffer with the packet to set the watchdog timer
|
||||
* of one of the three watchdogs (PS, PL, INT).
|
||||
*/
|
||||
ReturnValue_t prepareWatchdogsConfigTimeoutCmd(const uint8_t * commandData);
|
||||
ReturnValue_t prepareWatchdogsConfigTimeoutCmd(const uint8_t* commandData);
|
||||
|
||||
ReturnValue_t prepareLatchupConfigCmd(const uint8_t* commandData,
|
||||
DeviceCommandId_t deviceCommand);
|
||||
@ -258,7 +262,6 @@ private:
|
||||
void prepareSetGpioCmd(const uint8_t* commandData);
|
||||
void prepareReadGpioCmd(const uint8_t* commandData);
|
||||
|
||||
|
||||
/**
|
||||
* @brief Copies the content of a space packet to the command buffer.
|
||||
*/
|
||||
@ -290,7 +293,7 @@ private:
|
||||
* @brief Function is called in scanForReply and fills the spacePacketBuffer with the read
|
||||
* data until a full packet has been received.
|
||||
*/
|
||||
ReturnValue_t parseMramPackets(const uint8_t *packet, size_t remainingSize, size_t* foundlen);
|
||||
ReturnValue_t parseMramPackets(const uint8_t* packet, size_t remainingSize, size_t* foundlen);
|
||||
|
||||
/**
|
||||
* @brief This function generates the Service 8 packets for the MRAM dump data.
|
||||
|
@ -1,17 +1,19 @@
|
||||
#include "fsfw/ipc/QueueFactory.h"
|
||||
#include "PlocUpdater.h"
|
||||
|
||||
#include <fstream>
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <string>
|
||||
|
||||
PlocUpdater::PlocUpdater(object_id_t objectId) :
|
||||
SystemObject(objectId), commandActionHelper(this), actionHelper(this, nullptr) {
|
||||
commandQueue = QueueFactory::instance()->createMessageQueue(QUEUE_SIZE);
|
||||
#include "fsfw/ipc/QueueFactory.h"
|
||||
|
||||
PlocUpdater::PlocUpdater(object_id_t objectId)
|
||||
: SystemObject(objectId), commandActionHelper(this), actionHelper(this, nullptr) {
|
||||
auto mqArgs = MqArgs(this->getObjectId());
|
||||
commandQueue = QueueFactory::instance()->createMessageQueue(
|
||||
QUEUE_SIZE, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
|
||||
}
|
||||
|
||||
PlocUpdater::~PlocUpdater() {
|
||||
}
|
||||
PlocUpdater::~PlocUpdater() {}
|
||||
|
||||
ReturnValue_t PlocUpdater::initialize() {
|
||||
#if BOARD_TE0720 == 0
|
||||
@ -39,8 +41,8 @@ ReturnValue_t PlocUpdater::performOperation(uint8_t operationCode) {
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t PlocUpdater::executeAction(ActionId_t actionId,
|
||||
MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
|
||||
ReturnValue_t PlocUpdater::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
|
||||
const uint8_t* data, size_t size) {
|
||||
ReturnValue_t result = RETURN_FAILED;
|
||||
|
||||
if (state != State::IDLE) {
|
||||
@ -99,13 +101,9 @@ ReturnValue_t PlocUpdater::executeAction(ActionId_t actionId,
|
||||
return EXECUTION_FINISHED;
|
||||
}
|
||||
|
||||
MessageQueueId_t PlocUpdater::getCommandQueue() const {
|
||||
return commandQueue->getId();
|
||||
}
|
||||
MessageQueueId_t PlocUpdater::getCommandQueue() const { return commandQueue->getId(); }
|
||||
|
||||
MessageQueueIF* PlocUpdater::getCommandQueuePtr() {
|
||||
return commandQueue;
|
||||
}
|
||||
MessageQueueIF* PlocUpdater::getCommandQueuePtr() { return commandQueue; }
|
||||
|
||||
void PlocUpdater::readCommandQueue() {
|
||||
CommandMessage message;
|
||||
@ -167,74 +165,37 @@ ReturnValue_t PlocUpdater::getImageLocation(const uint8_t* data, size_t size) {
|
||||
|
||||
#if BOARD_TE0720 == 0
|
||||
// Check if file is stored on SD card and if associated SD card is mounted
|
||||
if (std::string(reinterpret_cast<const char*>(data), SD_PREFIX_LENGTH) == std::string(SdCardManager::SD_0_MOUNT_POINT)) {
|
||||
if (!isSdCardMounted(sd::SLOT_0)) {
|
||||
sif::warning << "PlocUpdater::prepareNvm0AUpdate: SD card 0 not mounted" << std::endl;
|
||||
if (std::string(reinterpret_cast<const char*>(data), SD_PREFIX_LENGTH) ==
|
||||
std::string(SdCardManager::SD_0_MOUNT_POINT)) {
|
||||
if (!sdcMan->isSdCardMounted(sd::SLOT_0)) {
|
||||
sif::warning << "PlocUpdater::getImageLocation: SD card 0 not mounted" << std::endl;
|
||||
return SD_NOT_MOUNTED;
|
||||
}
|
||||
}
|
||||
else if (std::string(reinterpret_cast<const char*>(data), SD_PREFIX_LENGTH) == std::string(SdCardManager::SD_1_MOUNT_POINT)) {
|
||||
if (!isSdCardMounted(sd::SLOT_0)) {
|
||||
sif::warning << "PlocUpdater::prepareNvm0AUpdate: SD card 1 not mounted" << std::endl;
|
||||
} else if (std::string(reinterpret_cast<const char*>(data), SD_PREFIX_LENGTH) ==
|
||||
std::string(SdCardManager::SD_1_MOUNT_POINT)) {
|
||||
if (!sdcMan->isSdCardMounted(sd::SLOT_0)) {
|
||||
sif::warning << "PlocUpdater::getImageLocation: SD card 1 not mounted" << std::endl;
|
||||
return SD_NOT_MOUNTED;
|
||||
}
|
||||
}
|
||||
else {
|
||||
//update image not stored on SD card
|
||||
} else {
|
||||
// update image not stored on SD card
|
||||
}
|
||||
#endif /* BOARD_TE0720 == 0 */
|
||||
|
||||
updateFile = std::string(reinterpret_cast<const char*>(data), size);
|
||||
|
||||
// Check if file exists
|
||||
if(not std::filesystem::exists(updateFile)) {
|
||||
if (not std::filesystem::exists(updateFile)) {
|
||||
return FILE_NOT_EXISTS;
|
||||
}
|
||||
return RETURN_OK;
|
||||
}
|
||||
|
||||
#if BOARD_TE0720 == 0
|
||||
bool PlocUpdater::isSdCardMounted(sd::SdCard sdCard) {
|
||||
SdCardManager::SdStatePair active;
|
||||
ReturnValue_t result = sdcMan->getSdCardActiveStatus(active);
|
||||
if (result != RETURN_OK) {
|
||||
sif::debug << "PlocUpdater::isSdCardMounted: Failed to get SD card active state";
|
||||
return false;
|
||||
}
|
||||
if (sdCard == sd::SLOT_0) {
|
||||
if (active.first == sd::MOUNTED) {
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else if (sdCard == sd::SLOT_1) {
|
||||
if (active.second == sd::MOUNTED) {
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else {
|
||||
sif::debug << "PlocUpdater::isSdCardMounted: Unknown SD card specified" << std::endl;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
#endif /* #if BOARD_TE0720 == 0 */
|
||||
void PlocUpdater::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) {}
|
||||
|
||||
void PlocUpdater::stepSuccessfulReceived(ActionId_t actionId,
|
||||
uint8_t step) {
|
||||
}
|
||||
void PlocUpdater::stepFailedReceived(ActionId_t actionId, uint8_t step, ReturnValue_t returnCode) {}
|
||||
|
||||
void PlocUpdater::stepFailedReceived(ActionId_t actionId, uint8_t step,
|
||||
ReturnValue_t returnCode) {
|
||||
}
|
||||
|
||||
void PlocUpdater::dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) {
|
||||
|
||||
}
|
||||
void PlocUpdater::dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) {}
|
||||
|
||||
void PlocUpdater::completionSuccessfulReceived(ActionId_t actionId) {
|
||||
switch (pendingCommand) {
|
||||
@ -245,8 +206,7 @@ void PlocUpdater::completionSuccessfulReceived(ActionId_t actionId) {
|
||||
if (remainingPackets == 0) {
|
||||
packetsSent = 0; // Reset packets sent variable for next update sequence
|
||||
state = State::UPDATE_VERIFY;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
state = State::UPDATE_TRANSFER;
|
||||
}
|
||||
break;
|
||||
@ -263,24 +223,22 @@ void PlocUpdater::completionSuccessfulReceived(ActionId_t actionId) {
|
||||
}
|
||||
}
|
||||
|
||||
void PlocUpdater::completionFailedReceived(ActionId_t actionId,
|
||||
ReturnValue_t returnCode) {
|
||||
switch(pendingCommand) {
|
||||
case(PLOC_SPV::UPDATE_AVAILABLE): {
|
||||
void PlocUpdater::completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) {
|
||||
switch (pendingCommand) {
|
||||
case (PLOC_SPV::UPDATE_AVAILABLE): {
|
||||
triggerEvent(UPDATE_AVAILABLE_FAILED);
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::UPDATE_IMAGE_DATA): {
|
||||
case (PLOC_SPV::UPDATE_IMAGE_DATA): {
|
||||
triggerEvent(UPDATE_TRANSFER_FAILED, packetsSent);
|
||||
break;
|
||||
}
|
||||
case(PLOC_SPV::UPDATE_VERIFY): {
|
||||
case (PLOC_SPV::UPDATE_VERIFY): {
|
||||
triggerEvent(UPDATE_VERIFY_FAILED);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
sif::debug << "PlocUpdater::completionFailedReceived: Invalid pending command "
|
||||
<< std::endl;
|
||||
sif::debug << "PlocUpdater::completionFailedReceived: Invalid pending command " << std::endl;
|
||||
break;
|
||||
}
|
||||
state = State::IDLE;
|
||||
@ -300,7 +258,7 @@ void PlocUpdater::commandUpdateAvailable() {
|
||||
imageSize = static_cast<size_t>(file.tellg());
|
||||
file.close();
|
||||
|
||||
numOfUpdatePackets = imageSize / MAX_SP_DATA ;
|
||||
numOfUpdatePackets = imageSize / MAX_SP_DATA;
|
||||
if (imageSize % MAX_SP_DATA) {
|
||||
numOfUpdatePackets++;
|
||||
}
|
||||
@ -311,10 +269,12 @@ void PlocUpdater::commandUpdateAvailable() {
|
||||
calcImageCrc();
|
||||
|
||||
PLOC_SPV::UpdateInfo packet(PLOC_SPV::APID_UPDATE_AVAILABLE, static_cast<uint8_t>(image),
|
||||
static_cast<uint8_t>(partition), imageSize, imageCrc, numOfUpdatePackets);
|
||||
static_cast<uint8_t>(partition), imageSize, imageCrc,
|
||||
numOfUpdatePackets);
|
||||
|
||||
result = commandActionHelper.commandAction(objects::PLOC_SUPERVISOR_HANDLER,
|
||||
PLOC_SPV::UPDATE_AVAILABLE, packet.getWholeData(), packet.getFullSize());
|
||||
PLOC_SPV::UPDATE_AVAILABLE, packet.getWholeData(),
|
||||
packet.getFullSize());
|
||||
if (result != RETURN_OK) {
|
||||
sif::warning << "PlocUpdater::commandUpdateAvailable: Failed to send update available"
|
||||
<< " packet to supervisor handler" << std::endl;
|
||||
@ -344,8 +304,7 @@ void PlocUpdater::commandUpdatePacket() {
|
||||
|
||||
if (remainingPackets == 1) {
|
||||
payloadLength = imageSize - static_cast<uint16_t>(file.tellg());
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
payloadLength = MAX_SP_DATA;
|
||||
}
|
||||
|
||||
@ -360,7 +319,8 @@ void PlocUpdater::commandUpdatePacket() {
|
||||
packet.makeCrc();
|
||||
|
||||
result = commandActionHelper.commandAction(objects::PLOC_SUPERVISOR_HANDLER,
|
||||
PLOC_SPV::UPDATE_IMAGE_DATA, packet.getWholeData(), packet.getFullSize());
|
||||
PLOC_SPV::UPDATE_IMAGE_DATA, packet.getWholeData(),
|
||||
packet.getFullSize());
|
||||
|
||||
if (result != RETURN_OK) {
|
||||
sif::warning << "PlocUpdater::commandUpdateAvailable: Failed to send update"
|
||||
@ -382,10 +342,12 @@ void PlocUpdater::commandUpdateVerify() {
|
||||
ReturnValue_t result = RETURN_OK;
|
||||
|
||||
PLOC_SPV::UpdateInfo packet(PLOC_SPV::APID_UPDATE_VERIFY, static_cast<uint8_t>(image),
|
||||
static_cast<uint8_t>(partition), imageSize, imageCrc, numOfUpdatePackets);
|
||||
static_cast<uint8_t>(partition), imageSize, imageCrc,
|
||||
numOfUpdatePackets);
|
||||
|
||||
result = commandActionHelper.commandAction(objects::PLOC_SUPERVISOR_HANDLER,
|
||||
PLOC_SPV::UPDATE_VERIFY, packet.getWholeData(), packet.getFullSize());
|
||||
result =
|
||||
commandActionHelper.commandAction(objects::PLOC_SUPERVISOR_HANDLER, PLOC_SPV::UPDATE_VERIFY,
|
||||
packet.getWholeData(), packet.getFullSize());
|
||||
if (result != RETURN_OK) {
|
||||
sif::warning << "PlocUpdater::commandUpdateAvailable: Failed to send update available"
|
||||
<< " packet to supervisor handler" << std::endl;
|
||||
@ -425,12 +387,9 @@ void PlocUpdater::calcImageCrc() {
|
||||
void PlocUpdater::adjustSequenceFlags(PLOC_SPV::UpdatePacket& packet) {
|
||||
if (packetsSent == 0) {
|
||||
packet.setSequenceFlags(static_cast<uint8_t>(PLOC_SPV::SequenceFlags::FIRST_PKT));
|
||||
}
|
||||
else if (remainingPackets == 1) {
|
||||
} else if (remainingPackets == 1) {
|
||||
packet.setSequenceFlags(static_cast<uint8_t>(PLOC_SPV::SequenceFlags::LAST_PKT));
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
packet.setSequenceFlags(static_cast<uint8_t>(PLOC_SPV::SequenceFlags::CONTINUED_PKT));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -2,27 +2,25 @@
|
||||
#define MISSION_DEVICES_PLOCUPDATER_H_
|
||||
|
||||
#include "OBSWConfig.h"
|
||||
#include "bsp_q7s/memory/SdCardManager.h"
|
||||
#include "devicedefinitions/PlocSupervisorDefinitions.h"
|
||||
|
||||
#include "fsfw/action/CommandActionHelper.h"
|
||||
#include "fsfw/action/ActionHelper.h"
|
||||
#include "fsfw/action/HasActionsIF.h"
|
||||
#include "fsfw/action/CommandActionHelper.h"
|
||||
#include "fsfw/action/CommandsActionsIF.h"
|
||||
#include "fsfw/action/HasActionsIF.h"
|
||||
#include "fsfw/objectmanager/SystemObject.h"
|
||||
#include "fsfw/returnvalues/HasReturnvaluesIF.h"
|
||||
#include "fsfw/tasks/ExecutableObjectIF.h"
|
||||
#include "fsfw/objectmanager/SystemObject.h"
|
||||
#include "bsp_q7s/memory/SdCardManager.h"
|
||||
#include "linux/fsfwconfig/objects/systemObjectList.h"
|
||||
#include "fsfw/tmtcpacket/SpacePacket.h"
|
||||
|
||||
#include "linux/fsfwconfig/objects/systemObjectList.h"
|
||||
|
||||
/**
|
||||
* @brief An object of this class can be used to perform the software updates of the PLOC. The
|
||||
* software update will be read from one of the SD cards, split into multiple space
|
||||
* packets and sent to the PlocSupervisorHandler.
|
||||
*
|
||||
* @details The MPSoC has two boot memories (NVM0 and NVM1) where each stores two images (Partition A
|
||||
* and Partition B)
|
||||
* @details The MPSoC has two boot memories (NVM0 and NVM1) where each stores two images (Partition
|
||||
* A and Partition B)
|
||||
*
|
||||
* @author J. Meier
|
||||
*/
|
||||
@ -31,8 +29,7 @@ class PlocUpdater : public SystemObject,
|
||||
public ExecutableObjectIF,
|
||||
public HasReturnvaluesIF,
|
||||
public CommandsActionsIF {
|
||||
public:
|
||||
|
||||
public:
|
||||
static const ActionId_t UPDATE_A_UBOOT = 0;
|
||||
static const ActionId_t UPDATE_A_BITSTREAM = 1;
|
||||
static const ActionId_t UPDATE_A_LINUX = 2;
|
||||
@ -57,15 +54,15 @@ public:
|
||||
void completionSuccessfulReceived(ActionId_t actionId) override;
|
||||
void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) override;
|
||||
|
||||
private:
|
||||
|
||||
private:
|
||||
static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_UPDATER;
|
||||
|
||||
//! [EXPORT] : [COMMENT] Updater is already performing an update
|
||||
static const ReturnValue_t UPDATER_BUSY = MAKE_RETURN_CODE(0xA0);
|
||||
//! [EXPORT] : [COMMENT] Received update command with invalid path string (too long).
|
||||
static const ReturnValue_t NAME_TOO_LONG = MAKE_RETURN_CODE(0xA1);
|
||||
//! [EXPORT] : [COMMENT] Received command to initiate update but SD card with update image not mounted.
|
||||
//! [EXPORT] : [COMMENT] Received command to initiate update but SD card with update image not
|
||||
//! mounted.
|
||||
static const ReturnValue_t SD_NOT_MOUNTED = MAKE_RETURN_CODE(0xA2);
|
||||
//! [EXPORT] : [COMMENT] Update file received with update command does not exist.
|
||||
static const ReturnValue_t FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xA3);
|
||||
@ -74,13 +71,15 @@ private:
|
||||
|
||||
//! [EXPORT] : [COMMENT] Try to read update file but the file does not exist.
|
||||
//! P1: Indicates in which state the file read fails
|
||||
//! P2: During the update transfer the second parameter gives information about the number of already sent packets
|
||||
//! P2: During the update transfer the second parameter gives information about the number of
|
||||
//! already sent packets
|
||||
static const Event UPDATE_FILE_NOT_EXISTS = MAKE_EVENT(0, severity::LOW);
|
||||
//! [EXPORT] : [COMMENT] Failed to send command to supervisor handler
|
||||
//! P1: Return value of CommandActionHelper::commandAction
|
||||
//! P2: Action ID of command to send
|
||||
static const Event ACTION_COMMANDING_FAILED = MAKE_EVENT(1, severity::LOW);
|
||||
//! [EXPORT] : [COMMENT] Supervisor handler replied action message indicating a command execution failure of the update available command
|
||||
//! [EXPORT] : [COMMENT] Supervisor handler replied action message indicating a command execution
|
||||
//! failure of the update available command
|
||||
static const Event UPDATE_AVAILABLE_FAILED = MAKE_EVENT(2, severity::LOW);
|
||||
//! [EXPORT] : [COMMENT] Supervisor handler failed to transfer an update space packet.
|
||||
//! P1: Parameter holds the number of update packets already sent (inclusive the failed packet)
|
||||
@ -110,7 +109,7 @@ private:
|
||||
|
||||
ActionHelper actionHelper;
|
||||
|
||||
enum class State: uint8_t {
|
||||
enum class State : uint8_t {
|
||||
IDLE,
|
||||
UPDATE_AVAILABLE,
|
||||
UPDATE_TRANSFER,
|
||||
@ -122,21 +121,11 @@ private:
|
||||
|
||||
ActionId_t pendingCommand = PLOC_SPV::NONE;
|
||||
|
||||
enum class Image: uint8_t {
|
||||
NONE,
|
||||
A,
|
||||
B
|
||||
};
|
||||
enum class Image : uint8_t { NONE, A, B };
|
||||
|
||||
Image image = Image::NONE;
|
||||
|
||||
enum class Partition: uint8_t {
|
||||
NONE,
|
||||
UBOOT,
|
||||
BITSTREAM,
|
||||
LINUX_OS,
|
||||
APP_SW
|
||||
};
|
||||
enum class Partition : uint8_t { NONE, UBOOT, BITSTREAM, LINUX_OS, APP_SW };
|
||||
|
||||
Partition partition = Partition::NONE;
|
||||
|
||||
@ -174,13 +163,6 @@ private:
|
||||
*/
|
||||
void commandUpdateVerify();
|
||||
|
||||
#if BOARD_TE0720 == 0
|
||||
/**
|
||||
* @brief Checks whether the SD card to read from is mounted or not.
|
||||
*/
|
||||
bool isSdCardMounted(sd::SdCard sdCard);
|
||||
#endif
|
||||
|
||||
void calcImageCrc();
|
||||
|
||||
void adjustSequenceFlags(PLOC_SPV::UpdatePacket& packet);
|
||||
|
@ -3,20 +3,19 @@
|
||||
|
||||
#include <fsfw/src/fsfw/serialize/SerialLinkedListAdapter.h>
|
||||
|
||||
class MemoryParams: public SerialLinkedListAdapter<SerializeIF> {
|
||||
public:
|
||||
|
||||
class MemoryParams : public SerialLinkedListAdapter<SerializeIF> {
|
||||
public:
|
||||
/**
|
||||
* @brief Constructor
|
||||
* @param startAddress Start of address range to dump
|
||||
* @param endAddress End of address range to dump
|
||||
*/
|
||||
MemoryParams(uint32_t startAddress, uint32_t endAddress) :
|
||||
startAddress(startAddress), endAddress(endAddress) {
|
||||
MemoryParams(uint32_t startAddress, uint32_t endAddress)
|
||||
: startAddress(startAddress), endAddress(endAddress) {
|
||||
setLinks();
|
||||
}
|
||||
private:
|
||||
|
||||
private:
|
||||
void setLinks() {
|
||||
setStart(&startAddress);
|
||||
startAddress.setNext(&endAddress);
|
||||
@ -24,10 +23,6 @@ private:
|
||||
|
||||
SerializeElement<uint32_t> startAddress;
|
||||
SerializeElement<uint32_t> endAddress;
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
#endif /* BSP_Q7S_DEVICES_DEVICEDEFINITIONS_PLOCMEMDUMPDEFINITIONS_H_ */
|
||||
|
File diff suppressed because it is too large
Load Diff
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user