Major major Release V2

merge develop into main

Author: Strooom

TODO.md

@@ -1,38 +1,32 @@
-# Short Term ToDo's
+# MuMo SW V3
+## ToDo's
 
-* getbatteryChargeFromVoltage table right by doing a discharge test over 24h
-
-* CLI : 
-  - UART2 activeren bij USB connectie
+### Priority High
 
+* measurementsGroupCollection
+  * make it work for variable amount of EEPROM memory
+  * target unit test for wait time after page write into eeprom
 
+### Priority Medium
 * deviceStatusReq doen werken met echte waarden
   - ontvangstwaarden van laatste downlink opslaan
   - batterijspanning omzetten in uint8 : omrekening toevoegen aan battery
 
+* Power events
+when connecting / disconnection USB, this should be logged as an measurement-event and transmitted in the measurements
+
 
-* wrapping of measurementsCollection : writing and reading measurements
-* erase old measurements when space needed for new ones
+### Priority Low
+* Make ePaper display more lowPower
+  * use partial update or fast update. Full update once per x updates
 
+* ST HAL
+  * remove HAL code from C++ wrapper
 
-# Medium Term ToDo's
-* integrate qrCode as full static class. 
-  - add unit testing
-  - move code from screen to graphics
+* getbatteryChargeFromVoltage table right by doing a discharge test over 24h
 
-# Long Term ToDo's
 
+* merge hw aes tests into 1, in order to not have too many target unit tests
 * make generic unit tests also run on target
-* OTAA
-* make EEPROM work for multiples of 64K : 
-  - I2C address = 0x50 + address/64K
-  - address = address % 64K
-* target unit test for wait time after page write into eeprom
 
-* report number of measurements on bootscreen
-* merge hw aes tests into 1, in order to not have too many target unit tests
-* Put some of the aesKey stuff, only needed for SW-AES in conditional compilation, eg key expansion
-* read LoRaWAN properties in a safe way to display them in mainController.. I need some getters() io making them public
- - frameCount
- - devAddr
- - keys
+* when a certain device/channel is not active, it should not be allowed on the display...

behuizing.md

@@ -0,0 +1,21 @@
+073
+
+DevAddr  : 260B4863
+AppSKey  : 6E14FDE278291903A94442FF75D8198A
+NwkSKey  : 93A5743B38DDE35E38B85DD37955D551
+
+
+
+074
+
+DevAddr  : 260B992D
+AppSKey  : 9757B56A6296C34084C1CE7BA2BBB6AF
+NwkSKey  : CBC848CE49A4F8D23F5C2A9624E1C66C
+
+
+017
+
+UID      : 0080E115055045D7
+DevAddr  : 260B1723
+NwkSKey  : 687F33B28C045E0412383B50D8853984
+AppSKey  : 862DDA53CFB9A19169EDF0F4CC31480D

docs/kmska.md

@@ -42,7 +42,9 @@ extern "C" {
 
 /* Exported macro ------------------------------------------------------------*/
 /* USER CODE BEGIN EM */
-
+// WARNING : it is critical for an interrupt handler to be declared here. 
+// Even if the function is defined (eg in stm32wlxx_it.cpp), it will not be linked when not declared here.
+// The result is that a catch-all handler will be used, stopping code execution.
 /* USER CODE END EM */
 
 /* Exported functions prototypes ---------------------------------------------*/
@@ -55,10 +57,11 @@ void SVC_Handler(void);
 void DebugMon_Handler(void);
 void PendSV_Handler(void);
 void SysTick_Handler(void);
-void TAMP_STAMP_LSECSS_SSRU_IRQHandler(void);
+void USART1_IRQHandler(void);
+void USART2_IRQHandler(void);
 void EXTI3_IRQHandler(void);
+void EXTI4_IRQHandler(void);
 void RTC_WKUP_IRQHandler(void);
-void USART2_IRQHandler(void);
 void LPTIM1_IRQHandler(void);
 void SUBGHZ_Radio_IRQHandler(void);
 /* USER CODE BEGIN EFP */

include/stm32wlxx_it.h

@@ -49,7 +49,7 @@ class aesBlock {
     void mixColumns();
 
     union {
-        uint8_t asByte[lengthInBytes]{};        // interprete the data as 16 bytes
-        uint32_t asUint32[lengthInWords];         // interprete the data as 4 32bit words
-    } state;                                    // fancy name for data in the block
+        uint8_t asByte[lengthInBytes]{};         // interprete the data as 16 bytes
+        uint32_t asUint32[lengthInWords];        // interprete the data as 4 32bit words
+    } state;                                     // fancy name for data in the block
 };

lib/aes/aesblock.hpp

@@ -4,47 +4,44 @@
 #include <rcon.hpp>
 #include <hexascii.hpp>
 
- uint8_t* aesKey::asBytes() {
-    return key.asByte;
-}
-
- uint32_t* aesKey::asWords() {
-    return key.asUint32;
-}
-
 void aesKey::setFromByteArray(const uint8_t bytes[lengthInBytes]) {
-    (void)memcpy(key.asByte, bytes, lengthInBytes);
+    (void)memcpy(keyAsBytes, bytes, lengthInBytes);
+    syncWordsFromBytes();
+    syncHexStringFromBytes();
+#ifndef HARDWARE_AES
     expandKey();
-}
-
-void aesKey::setFromWordArray(const uint32_t wordsIn[lengthInWords]) {
-    for (uint32_t wordIndex = 0; wordIndex < 4; wordIndex++) {
-        key.asUint32[wordIndex] = wordsIn[wordIndex];
-    }
+#endif
 }
 
 void aesKey::setFromHexString(const char* string) {
-    uint8_t tmpBytes[lengthInBytes];
-    hexAscii::hexStringToByteArray(tmpBytes, string, 32U);
-    (void)memcpy(key.asByte, tmpBytes, lengthInBytes);
+    hexAscii::hexStringToByteArray(keyAsBytes, string, 32U);
+    syncWordsFromBytes();
+    syncHexStringFromBytes();
+#ifndef HARDWARE_AES
     expandKey();
+#endif
 }
 
-uint32_t aesKey::swapLittleBigEndian( uint32_t wordIn) {
+uint32_t aesKey::swapLittleBigEndian(uint32_t wordIn) {
     // ARM Cortex-M4 stores uin32_t in little endian format, but STM32WLE5 AES peripheral expects big endian format. This function swaps the bytes in a word.
     uint32_t wordOut;
     wordOut = (wordIn & 0xFF000000) >> 24 | (wordIn & 0x00FF0000) >> 8 | (wordIn & 0x0000FF00) << 8 | (wordIn & 0x000000FF) << 24;
     return wordOut;
 }
 
+#ifndef HARDWARE_AES
 void aesKey::expandKey() {
-    (void)memcpy(expandedKey, key.asByte, 16);
+    for (uint32_t index = 0; index < lengthInBytes; index++) {
+        expandedKey[index] = keyAsBytes[index];
+    }
     for (uint8_t round = 1; round <= 10; round++) {
         (void)memcpy(expandedKey + (round * 16), expandedKey + ((round - 1) * 16), 16);
         calculateRoundKey(round);
     }
 }
+#endif
 
+#ifndef HARDWARE_AES
 void aesKey::calculateRoundKey(uint8_t round) {
     unsigned char temp[4];
     uint8_t* expandedKeyPtr = expandedKey + (round * 16);
@@ -61,3 +58,11 @@ void aesKey::calculateRoundKey(uint8_t round) {
         temp[index % 4] = expandedKeyPtr[index];
     }
 }
+#endif
+
+void aesKey::syncWordsFromBytes() {
+    (void)memcpy(keyAsWords, keyAsBytes, lengthInBytes);
+}
+void aesKey::syncHexStringFromBytes() {
+    hexAscii::byteArrayToHexString(keyAsHexString, keyAsBytes, lengthInBytes);
+}

lib/aes/aeskey.cpp

@@ -10,27 +10,38 @@ class aesKey {
   public:
     static constexpr uint32_t lengthInBytes{16};
     static constexpr uint32_t lengthInWords{4};
+    static constexpr uint32_t lengthAsHexAscii{32};
 
     void setFromByteArray(const uint8_t bytes[lengthInBytes]);
-    void setFromWordArray(const uint32_t wordsIn[lengthInWords]);
     void setFromHexString(const char* string);
-    static uint32_t swapLittleBigEndian(uint32_t wordIn);
 
-    uint8_t* asBytes();         // return the key as bytes
-    uint32_t* asWords();        // return the key as words
+    uint8_t getAsByte(uint32_t index) const { return keyAsBytes[index]; }
+    uint32_t getAsWord(uint32_t index) const { return keyAsWords[index]; }
+    const char* getAsHexString() const { return keyAsHexString; }
+
+    static uint32_t swapLittleBigEndian(uint32_t wordIn);
 
+#ifndef HARDWARE_AES
     uint8_t expandedKey[176];
+#endif
 
 #ifndef unitTesting
 
   private:
 #endif
+    // These are 3 representations of the same key data, in different formats for easy retrieval. They are synced when setting the key.
+    // representation as hexAscii aligns with how The Things Network shows the AES keys, so copy paste from there is possible.
+    // representation as bytes : first to hexAscii characters map to first byte of the array
+
+    uint8_t keyAsBytes[lengthInBytes]{};
+    uint32_t keyAsWords[lengthInWords]{};
+    char keyAsHexString[lengthAsHexAscii + 1]{};
 
-    union {
-        uint8_t asByte[lengthInBytes]{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};        // interprete the data as 16 bytes
-        uint32_t asUint32[lengthInWords];           // interprete the data as 4 32bit words
-    } key;
+    void syncWordsFromBytes();
+    void syncHexStringFromBytes();
 
+#ifndef HARDWARE_AES
     void expandKey();
     void calculateRoundKey(uint8_t round);
+#endif
 };

lib/aes/aeskey.hpp

@@ -3,8 +3,6 @@
 #include <main.h>
 #endif
 
-// #define MODIFY_REG(REG, CLEARMASK, SETMASK)  WRITE_REG((REG), (((READ_REG(REG)) & (~(CLEARMASK))) | (SETMASK)))
-
 void stm32wle5_aes::initialize(aesMode theMode) {
     uint32_t aesControlRegisterValue{0};
     aesControlRegisterValue |= (0b10 << 1);                                  // set dataTypeSelection to byte, for bigEndian / littleEndian conversion
@@ -33,10 +31,10 @@ void stm32wle5_aes::disable() {
 
 void stm32wle5_aes::setKey(aesKey& theKey) {
 #ifndef generic
-    AES->KEYR0 = aesKey::swapLittleBigEndian(theKey.asWords()[3]);        // LeastSignificant bits
-    AES->KEYR1 = aesKey::swapLittleBigEndian(theKey.asWords()[2]);
-    AES->KEYR2 = aesKey::swapLittleBigEndian(theKey.asWords()[1]);
-    AES->KEYR3 = aesKey::swapLittleBigEndian(theKey.asWords()[0]);        // MostSignificant bits
+    AES->KEYR0 = aesKey::swapLittleBigEndian(theKey.getAsWord(3));
+    AES->KEYR1 = aesKey::swapLittleBigEndian(theKey.getAsWord(2));
+    AES->KEYR2 = aesKey::swapLittleBigEndian(theKey.getAsWord(1));
+    AES->KEYR3 = aesKey::swapLittleBigEndian(theKey.getAsWord(0));
 #endif
 }
 
@@ -67,7 +65,7 @@ void stm32wle5_aes::read(aesBlock& theBlock) {
 #endif
 }
 
-void stm32wle5_aes::write(uint32_t* wordsIn) {
+void stm32wle5_aes::write(const uint32_t* wordsIn) {
 #ifndef generic
     AES->DINR = wordsIn[0];
     AES->DINR = wordsIn[1];

lib/aes/stm32wle5_aes.cpp

@@ -23,7 +23,7 @@ class stm32wle5_aes {
     static void setInitializationVector( aesBlock& theBlock);
     static void write(aesBlock& theBlock);
     static void read(aesBlock& theBlock);
-    static void write(uint32_t *wordsIn);
+    static void write(const uint32_t *wordsIn);
     static void read(uint32_t *wordsOut);
     static bool isComputationComplete();
     static void clearComputationComplete();