Merge branch 'arduino:main' into benjamindannegard/api-documentation

Author: BenjaminDannegard

extras/uno-r4-wifi-usb-bridge

@@ -0,0 +1,64 @@
+// To use ArduinoGraphics APIs, please include BEFORE Arduino_LED_Matrix and TextAnimation
+#include "ArduinoGraphics.h"
+#include "Arduino_LED_Matrix.h"
+#include "TextAnimation.h"
+
+ArduinoLEDMatrix matrix;
+
+// 100 frames maximum. Compute as maximum length of text you want to print (eg. 20 chars) 
+// multiplied by font width (eg. 5 for Font_5x7), so 20 chars * 5 px = 100. If you enter lower
+// value (or your text get unexpectedly long), animation will be cut and end soon.
+TEXT_ANIMATION_DEFINE(anim, 100)
+
+int counter;
+bool requestNext = false;
+
+void setup() {
+  pinMode(LED_BUILTIN, OUTPUT);
+
+  matrix.begin();
+  matrix.beginDraw();
+
+  matrix.stroke(0xFFFFFFFF);
+  matrix.textFont(Font_5x7);
+  matrix.textScrollSpeed(60);
+  matrix.setCallback(matrixCallback);
+  
+  const char text[] = "   UNO r4 ";
+  matrix.beginText(0, 1, 0xFFFFFF);
+  matrix.println(text);
+  matrix.endTextAnimation(SCROLL_LEFT, anim);
+  
+  matrix.loadTextAnimationSequence(anim);
+  matrix.play();
+
+  // now animation play asynchronously. Will call matrixCallback once completed.
+}
+
+void matrixCallback() {
+  // callback is executed in IRQ and should run as fast as possible
+  requestNext = true;
+}
+
+void loop() {
+  if (requestNext) {
+    requestNext = false;
+
+    matrix.beginText(0, 1, 0xFFFFFF);
+    matrix.print("   ");
+    matrix.println(counter);
+    matrix.endTextAnimation(SCROLL_RIGHT, anim);
+  
+    if (counter++ >= 20) {
+      counter = 0;
+    }
+
+    matrix.loadTextAnimationSequence(anim);
+    matrix.play();
+  }
+
+  delay(500);
+  digitalWrite(LED_BUILTIN, 0);
+  delay(500);
+  digitalWrite(LED_BUILTIN, 1);
+}

libraries/Arduino_LED_Matrix/examples/TextWithArduinoGraphicsAsynchronous/TextWithArduinoGraphicsAsynchronous.ino

@@ -141,8 +141,10 @@ static uint32_t reverse(uint32_t x)
 }
 
 // TODO: this is dangerous, use with care
-#define loadSequence(frames)                loadWrapper(frames, sizeof(frames))
-#define renderBitmap(bitmap, rows, columns) loadPixels(&bitmap[0][0], rows*columns)
+#define loadSequence(frames)                    loadWrapper(frames, sizeof(frames))
+#define renderBitmap(bitmap, rows, columns)     loadPixels(&bitmap[0][0], rows*columns)
+#define endTextAnimation(scrollDirection, anim) endTextToAnimationBuffer(scrollDirection, anim ## _buf, sizeof(anim ## _buf), anim ## _buf_used)
+#define loadTextAnimationSequence(anim)         loadWrapper(anim ## _buf, anim ## _buf_used)
 
 static uint8_t __attribute__((aligned)) framebuffer[NUM_LEDS / 8];
 
@@ -227,11 +229,11 @@ class ArduinoLEDMatrix
         return false;
     }
 
-    void loadPixels(uint8_t *arr, size_t size){
+    static void loadPixelsToBuffer(uint8_t* arr, size_t size, uint32_t* dst) {
         uint32_t partialBuffer = 0;
         uint8_t pixelIndex = 0;
         uint8_t *frameP = arr;
-        uint32_t *frameHolderP = _frameHolder;
+        uint32_t *frameHolderP = dst;
         while (pixelIndex < size) {
             partialBuffer |= *frameP++;
             if ((pixelIndex + 1) % 32 == 0) {
@@ -240,6 +242,10 @@ class ArduinoLEDMatrix
             partialBuffer = partialBuffer << 1;
             pixelIndex++;
         }
+    }
+
+    void loadPixels(uint8_t *arr, size_t size){
+        loadPixelsToBuffer(arr, size, _frameHolder);
         loadFrame(_frameHolder);
     };
 
@@ -255,9 +261,9 @@ class ArduinoLEDMatrix
 
     void clear() {
         const uint32_t fullOff[] = {
-        	0x00000000,
-        	0x00000000,
-        	0x00000000
+            0x00000000,
+            0x00000000,
+            0x00000000
         };
         loadFrame(fullOff);
 #ifdef MATRIX_WITH_ARDUINOGRAPHICS
@@ -280,16 +286,48 @@ class ArduinoLEDMatrix
       renderBitmap(_canvasBuffer, canvasHeight, canvasWidth);
     }
 
-    // display the drawing
+    // display the drawing or capture it to buffer when rendering dynamic anymation
     void endDraw() {
       ArduinoGraphics::endDraw();
-      renderBitmap(_canvasBuffer, canvasHeight, canvasWidth);
+
+      if (!captureAnimation) {
+        renderBitmap(_canvasBuffer, canvasHeight, canvasWidth);
+      } else {
+        if (captureAnimationHowManyRemains >= 4) {
+          loadPixelsToBuffer(&_canvasBuffer[0][0], sizeof(_canvasBuffer), captureAnimationFrame);
+          captureAnimationFrame[3] = _textScrollSpeed;
+          captureAnimationFrame += 4;
+          captureAnimationHowManyRemains -= 16;
+        }
+      }
+    }
+
+    void endTextToAnimationBuffer(int scrollDirection, uint32_t frames[][4], uint32_t howManyMax, uint32_t& howManyUsed) {
+      captureAnimationFrame = &frames[0][0];
+      captureAnimationHowManyRemains = howManyMax;
+
+      captureAnimation = true;
+      ArduinoGraphics::textScrollSpeed(0);
+      ArduinoGraphics::endText(scrollDirection);
+      ArduinoGraphics::textScrollSpeed(_textScrollSpeed);
+      captureAnimation = false;
+        
+      howManyUsed = howManyMax - captureAnimationHowManyRemains;
+    }
+
+    void textScrollSpeed(unsigned long speed) {
+      ArduinoGraphics::textScrollSpeed(speed);
+      _textScrollSpeed = speed;
     }
 
   private:
+    uint32_t* captureAnimationFrame = nullptr;
+    uint32_t captureAnimationHowManyRemains = 0;
+    bool captureAnimation = false;
     static const byte canvasWidth = 12;
     static const byte canvasHeight = 8;
     uint8_t _canvasBuffer[canvasHeight][canvasWidth] = {{0}};
+    unsigned long _textScrollSpeed = 100;
 #endif
 
 private:

libraries/Arduino_LED_Matrix/src/Arduino_LED_Matrix.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "Arduino.h"
+
+#if not __has_include("ArduinoGraphics.h")
+#error "TextAnimation work only when ArduinoGraphics is installed and used. Include ArduinoGraphics first."
+#endif
+
+#define TEXT_ANIMATION_DECLARE(NAME, MAX_CHARS) \
+	extern uint32_t NAME ## _buf[MAX_CHARS][4]; \
+	extern uint32_t NAME ## _buf_used; 
+
+#define TEXT_ANIMATION_DEFINE(NAME, MAX_CHARS) \
+	uint32_t NAME ## _buf[MAX_CHARS][4]; \
+	uint32_t NAME ## _buf_used = 0; 

libraries/Arduino_LED_Matrix/src/TextAnimation.h

@@ -69,7 +69,6 @@
                                              SE05X_EC_SIGNATURE_RAW_LENGTH
 
 #define SE05X_SHA256_LENGTH              32
-#define SE05X_SN_LENGTH                  18
 
 #define SE05X_TEMP_OBJECT                9999
 
@@ -108,22 +107,35 @@ void SE05XClass::end()
     Se05x_API_SessionClose(&_se05x_session);
 }
 
+int SE05XClass::serialNumber(byte sn[])
+{
+    return serialNumber(sn, SE05X_SN_LENGTH);
+}
+
+int SE05XClass::serialNumber(byte sn[], size_t length)
+{
+    size_t uidLen = length;
+    const int kSE05x_AppletResID_UNIQUE_ID = 0x7FFF0206;
+    smStatus_t status;
+
+    status = Se05x_API_ReadObject(&_se05x_session, kSE05x_AppletResID_UNIQUE_ID, 0, length, sn, &uidLen);
+    if (status != SM_OK || length != uidLen) {
+        SMLOG_E("Error in Se05x_API_ReadObject \n");
+        return 0;
+    }
+    return 1;
+}
+
 String SE05XClass::serialNumber()
 {
     String result = (char*)NULL;
     byte UID[SE05X_SN_LENGTH];
-    size_t uidLen = SE05X_SN_LENGTH;
-    const int kSE05x_AppletResID_UNIQUE_ID = 0x7FFF0206,
 
-    status = Se05x_API_ReadObject(&_se05x_session, kSE05x_AppletResID_UNIQUE_ID, 0, uidLen, UID, &uidLen);
-    if (status != SM_OK) {
-        SMLOG_E("Error in Se05x_API_ReadObject \n");
-        return "";
-    }
+    serialNumber(UID, sizeof(UID));
 
-    result.reserve(uidLen * 2);
+    result.reserve(SE05X_SN_LENGTH * 2);
 
-    for (size_t i = 0; i < uidLen; i++) {
+    for (size_t i = 0; i < SE05X_SN_LENGTH; i++) {
         byte b = UID[i];
 
         if (b < 16) {
@@ -168,11 +180,11 @@ int SE05XClass::random(byte data[], size_t length)
     smStatus_t status;
     uint16_t   offset = 0;
     uint16_t   left = length;
-    
+
     while (left > 0) {
         uint16_t chunk     = (left > SE05X_MAX_CHUNK_SIZE) ? SE05X_MAX_CHUNK_SIZE : left;
         size_t max_buffer  = chunk;
-        
+
         status = Se05x_API_GetRandom(&_se05x_session, chunk, (data + offset), &max_buffer);
         if (status != SM_OK) {
             SMLOG_E("Error in Se05x_API_GetRandom \n");
@@ -337,7 +349,7 @@ int SE05XClass::beginSHA256()
 {
     smStatus_t      status;
     SE05x_CryptoModeSubType_t subtype;
-    
+
     subtype.digest = kSE05x_DigestMode_SHA256;
 
     status = Se05x_API_CreateCryptoObject(&_se05x_session, kSE05x_CryptoObject_DIGEST_SHA256, kSE05x_CryptoContext_DIGEST, subtype);
@@ -357,7 +369,7 @@ int SE05XClass::beginSHA256()
 int SE05XClass::updateSHA256(const byte in[], size_t inLen)
 {
     smStatus_t      status;
-    
+
     status = Se05x_API_DigestUpdate(&_se05x_session, kSE05x_CryptoObject_DIGEST_SHA256, in, inLen);
     if (status != SM_OK) {
         SMLOG_E("Error in Se05x_API_DigestUpdate \n");
@@ -374,7 +386,7 @@ int SE05XClass::endSHA256(byte out[], size_t* outLen)
     if (*outLen < SE05X_SHA256_LENGTH) {
         SMLOG_E("Error in endSHA256 \n");
         *outLen = 0;
-        return 0;  
+        return 0;
     }
 
     status = Se05x_API_DigestFinal(&_se05x_session, kSE05x_CryptoObject_DIGEST_SHA256, NULL, 0, out, outLen);
@@ -530,7 +542,7 @@ int SE05XClass::ecdsaVerify(const byte message[], const byte signature[], const
     }
 
     if (!deleteBinaryObject(SE05X_TEMP_OBJECT)) {
-        SMLOG_E("ecdsaVerify failure deleting temporary object\n");     
+        SMLOG_E("ecdsaVerify failure deleting temporary object\n");
         return 0;
     }
 
@@ -574,7 +586,7 @@ int SE05XClass::readBinaryObject(int objectId, byte data[], size_t dataMaxLen, s
     while (left > 0) {
         uint16_t chunk     = (left > SE05X_MAX_CHUNK_SIZE) ? SE05X_MAX_CHUNK_SIZE : left;
         size_t max_buffer  = chunk;
-        
+
         status = Se05x_API_ReadObject(&_se05x_session, objectId, offset, chunk, (data + offset), &max_buffer);
         if (status != SM_OK) {
             SMLOG_E("Error in Se05x_API_ReadObject \n");
@@ -621,8 +633,6 @@ int SE05XClass::writeAESKey(int objectId, const byte data[], size_t length)
 {
     smStatus_t      status;
     SE05x_Result_t  result;
-    uint16_t        offset = 0;
-    uint16_t        size;
 
     status = Se05x_API_CheckObjectExists(&_se05x_session, objectId, &result);
     if (status != SM_OK) {
@@ -635,9 +645,7 @@ int SE05XClass::writeAESKey(int objectId, const byte data[], size_t length)
         return 0;
     }
 
-    uint16_t left = length;
-
-    status = Se05x_API_WriteSymmKey(&_se05x_session, NULL, 3, objectId, NULL, data, length, kSE05x_INS_NA, kSE05x_SymmKeyType_AES);
+    status = Se05x_API_WriteSymmKey(&_se05x_session, NULL, 3, objectId, SE05x_KeyID_KEK_NONE, data, length, kSE05x_INS_NA, kSE05x_SymmKeyType_AES);
 
     if (status != SM_OK) {
         SMLOG_E("Error in Se05x_API_WriteSymmKey \n");
@@ -650,9 +658,6 @@ int SE05XClass::writeHMACKey(int objectId, const byte data[], size_t length)
 {
     smStatus_t      status;
     SE05x_Result_t  result;
-    uint8_t         exists = 0;
-    uint16_t        offset = 0;
-    uint16_t        size;
 
     status = Se05x_API_CheckObjectExists(&_se05x_session, objectId, &result);
     if (status != SM_OK) {
@@ -662,7 +667,6 @@ int SE05XClass::writeHMACKey(int objectId, const byte data[], size_t length)
 
     if (result == kSE05x_Result_SUCCESS) {
         SMLOG_E("Object exists \n");
-        exists = 1;
     }
 
     status = Se05x_API_WriteSymmKey(&_se05x_session, NULL, 0, objectId, SE05x_KeyID_KEK_NONE, data, length, kSE05x_INS_NA, kSE05x_SymmKeyType_HMAC);
@@ -784,9 +788,9 @@ int SE05XClass::getECKeyXyValuesFromDER(byte* derKey, size_t derLen, byte* rawKe
     if(*rawLen < SE05X_EC_KEY_RAW_LENGTH) {
         SMLOG_E("Error in getECKeyXyValuesFromDER \n");
         *rawLen = 0;
-        return 0;    
+        return 0;
     }
-    
+
     /* XY values are stored in the last 64 bytes of DER buffer */
     *rawLen = SE05X_EC_KEY_RAW_LENGTH;
     memcpy(rawKey, &derKey[derLen - SE05X_EC_KEY_RAW_LENGTH], SE05X_EC_KEY_RAW_LENGTH);
@@ -799,15 +803,15 @@ int SE05XClass::setECKeyXyVauesInDER(const byte* rawKey, size_t rawLen, byte* de
     if(rawLen != SE05X_EC_KEY_RAW_LENGTH) {
         SMLOG_E("Error in setECKeyXyVauesInDER invalid raw key\n");
         *derLen = 0;
-        return 0;    
+        return 0;
     }
 
     if(*derLen < SE05X_EC_KEY_DER_LENGTH) {
         SMLOG_E("Error in setECKeyXyVauesInDER buffer too small\n");
         *derLen = 0;
-        return 0;    
+        return 0;
     }
-    
+
     /* Copy header byte from 0 to 25 */
     memcpy(&derKey[0], &ecc_der_header_nist256[0], SE05X_EC_KEY_DER_HEADER_LENGTH);
     /* Add format byte */
@@ -827,13 +831,13 @@ int SE05XClass::getECSignatureRsValuesFromDER(byte* derSignature, size_t derLen,
     if ((derLen < SE05X_EC_SIGNATURE_MIN_DER_LENGTH) || (derLen > SE05X_EC_SIGNATURE_MAX_DER_LENGTH)) {
         SMLOG_E("Error in getECSignatureRsValuesFromDER invalid signature\n");
         *rawLen = 0;
-        return 0;  
+        return 0;
     }
 
     if (*rawLen < SE05X_EC_SIGNATURE_RAW_LENGTH) {
         SMLOG_E("Error in getECSignatureRsValuesFromDER buffer too small\n");
         *rawLen = 0;
-        return 0;  
+        return 0;
     }
 
     rLen = derSignature[3];
@@ -868,7 +872,7 @@ int SE05XClass::setECSignatureRsValuesInDER(const byte* rawSignature, size_t raw
 {
     /**
      * Always consider worst case with padding
-     * 
+     *
      * | 0x30 0x46 0x02 0x21 0x00 | R values 32 bytes | 0x02 0x21 0x00 | S values 32 bytes |
      *
      */