Swadge Hero

components/hdw-led/hdw-led.c

@@ -21,10 +21,10 @@
 // Variables
 //==============================================================================
 
-static rmt_channel_handle_t led_chan        = NULL;
-static rmt_encoder_handle_t led_encoder     = NULL;
-static uint8_t ledBrightness                = 0;
-static led_t localLeds[CONFIG_NUM_LEDS + 1] = {0};
+static rmt_channel_handle_t led_chan    = NULL;
+static rmt_encoder_handle_t led_encoder = NULL;
+static uint8_t ledBrightness            = 0;
+static led_t localLeds[CONFIG_NUM_LEDS] = {0};
 
 //==============================================================================
 // Functions
@@ -111,9 +111,9 @@ esp_err_t setLeds(led_t* leds, uint8_t numLeds)
     };
 
     // Make sure to not overflow
-    if (numLeds > CONFIG_NUM_LEDS + 1)
+    if (numLeds > CONFIG_NUM_LEDS)
     {
-        numLeds = CONFIG_NUM_LEDS + 1;
+        numLeds = CONFIG_NUM_LEDS;
     }
 
     // Fill a local copy of LEDs with brightness applied
@@ -124,27 +124,6 @@ esp_err_t setLeds(led_t* leds, uint8_t numLeds)
         localLeds[i].b = (leds[i].b >> ledBrightness);
     }
 
-    // If all eight LEDs are being set, but not the 9th
-    if (CONFIG_NUM_LEDS == numLeds)
-    {
-        // Set the 9th LED to the average of the 6th, 7th, and 8th
-        int32_t avgR = 0;
-        int32_t avgG = 0;
-        int32_t avgB = 0;
-        for (int32_t lIdx = 5; lIdx < 8; lIdx++)
-        {
-            avgR += leds[lIdx].r;
-            avgG += leds[lIdx].g;
-            avgB += leds[lIdx].b;
-        }
-        localLeds[CONFIG_NUM_LEDS].r = (avgR / 3) >> ledBrightness;
-        localLeds[CONFIG_NUM_LEDS].g = (avgG / 3) >> ledBrightness;
-        localLeds[CONFIG_NUM_LEDS].b = (avgB / 3) >> ledBrightness;
-
-        // Set the 9th LED too
-        numLeds = CONFIG_NUM_LEDS + 1;
-    }
-
     // Write RGB values to LEDs
     return rmt_transmit(led_chan, led_encoder, (uint8_t*)localLeds, numLeds * sizeof(led_t), &tx_config);
 }
@@ -160,9 +139,9 @@ uint8_t getLedState(led_t* leds, uint8_t numLeds)
 {
     if (NULL != leds && numLeds > 0)
     {
-        if (numLeds > CONFIG_NUM_LEDS + 1)
+        if (numLeds > CONFIG_NUM_LEDS)
         {
-            numLeds = CONFIG_NUM_LEDS + 1;
+            numLeds = CONFIG_NUM_LEDS;
         }
 
         memcpy(leds, localLeds, sizeof(led_t) * numLeds);

components/hdw-led/include/hdw-led.h

@@ -30,10 +30,6 @@
  * must be flushed before entering light sleep. If they are not, garbage data may be sent after light sleep begins,
  * resulting in indeterminate LED behavior.
  *
- * Even though \c CONFIG_NUM_LEDS declares eight LEDs, there is a ninth LED which is controllable. By default, setting
- * \c CONFIG_NUM_LEDS LEDs will automatically set the ninth to the average of the sixth, seventh, and eighth, which
- * surround it on the PCB. To set the ninth LED, set `CONFIG_NUM_LEDS + 1` LEDs.
- *
  * \section led_example Example
  *
  * Set the LEDs to a rough rainbow:

emulator/src/components/hdw-led/hdw-led.c

@@ -11,8 +11,8 @@
 // Variables
 //==============================================================================
 
-static led_t rdLeds[CONFIG_NUM_LEDS + 1] = {0};
-static uint8_t ledBrightness             = 0;
+static led_t rdLeds[CONFIG_NUM_LEDS] = {0};
+static uint8_t ledBrightness         = 0;
 
 //==============================================================================
 // Functions
@@ -82,9 +82,9 @@ uint8_t getLedState(led_t* leds, uint8_t numLeds)
 {
     if (NULL != leds && numLeds > 0)
     {
-        if (numLeds > CONFIG_NUM_LEDS + 1)
+        if (numLeds > CONFIG_NUM_LEDS)
         {
-            numLeds = CONFIG_NUM_LEDS + 1;
+            numLeds = CONFIG_NUM_LEDS;
         }
 
         memcpy(leds, rdLeds, sizeof(led_t) * numLeds);

emulator/src/extensions/leds/ext_leds.c

@@ -3,14 +3,15 @@
 #include "hdw-led.h"
 #include "hdw-led_emu.h"
 #include "macros.h"
+#include "vector2d.h"
 
 #include "rawdraw_sf.h"
 
 //==============================================================================
 // Defines
 //==============================================================================
 
-#define MIN_LED_WIDTH 64
+#define MIN_LED_HEIGHT 64
 
 //==============================================================================
 // Static Function Prototypes
@@ -37,17 +38,17 @@ emuExtension_t ledEmuExtension = {
 // Where LEDs are drawn, kinda
 // first value is the LED column (top-to-bottom(?))
 // second value is the row
-static const int16_t ledOffsets[8][2] = {
-    {1, 2}, {0, 3}, {0, 1}, {1, 0}, // Left side LEDs
-    {2, 0}, {3, 1}, {3, 3}, {2, 2}, // Right side LEDs
+static const vec_t ledOffsets[CONFIG_NUM_LEDS] = {
+    {.x = 4, .y = 1}, {.x = 5, .y = 0}, {.x = 3, .y = 0}, {.x = 1, .y = 0}, {.x = 2, .y = 1},
+    {.x = 0, .y = 2}, {.x = 2, .y = 2}, {.x = 4, .y = 2}, {.x = 6, .y = 2},
 };
 
 //==============================================================================
 // Functions
 //==============================================================================
 
 /**
- * @brief Initializes the
+ * @brief Initializes the LED panes
  *
  * @param args
  * @return true if the extension is enabled
@@ -57,8 +58,8 @@ static bool ledsExtInit(emuArgs_t* args)
 {
     if (!args->hideLeds)
     {
-        requestPane(&ledEmuExtension, PANE_LEFT, MIN_LED_WIDTH * 2, 1);
-        requestPane(&ledEmuExtension, PANE_RIGHT, MIN_LED_WIDTH * 2, 1);
+        requestPane(&ledEmuExtension, PANE_TOP, 1, MIN_LED_HEIGHT);
+        requestPane(&ledEmuExtension, PANE_BOTTOM, 1, MIN_LED_HEIGHT * 2);
         return true;
     }
 
@@ -91,17 +92,26 @@ static void drawLeds(uint32_t winW, uint32_t winH, const emuPane_t* panes, uint8
     {
         for (int i = 0; i < MIN(numLeds, ARRAY_SIZE(ledOffsets)); i++)
         {
-            // Use left pane for offsets 0 and 1, right for offsets 2 and 3
-            const emuPane_t* pane = (ledOffsets[i][0] < 2) ? (panes + 0) : (panes + 1);
-
-            int16_t ledH = pane->paneH / (numLeds / 2);
-            int16_t ledW = pane->paneW / 2;
-
-            int16_t xOffset = pane->paneX + (ledOffsets[i][0] % 2) * (ledW / 2);
-            int16_t yOffset = ledOffsets[i][1] * ledH;
-
+            int16_t xOffset, yOffset, ledW, ledH;
+            // Use top pane for offset 0, bottom for offsets 1 & 2
+            if (0 == ledOffsets[i].y)
+            {
+                ledH = panes[0].paneH;
+                ledW = panes[0].paneW / 4;
+
+                xOffset = panes[0].paneX + (ledOffsets[i].x * ledW) / 2;
+                yOffset = panes[0].paneY + (ledOffsets[i].y * ledH);
+            }
+            else
+            {
+                ledH = panes[1].paneH / 2;
+                ledW = panes[1].paneW / 4;
+
+                xOffset = panes[1].paneX + (ledOffsets[i].x * ledW) / 2;
+                yOffset = panes[1].paneY + ((ledOffsets[i].y - 1) * ledH);
+            }
             CNFGColor((leds[i].r << 24) | (leds[i].g << 16) | (leds[i].b << 8) | 0xFF);
-            CNFGTackRectangle(xOffset, yOffset, xOffset + ledW * 3 / 2, yOffset + ledH);
+            CNFGTackRectangle(xOffset, yOffset, xOffset + ledW, yOffset + ledH);
         }
     }
 }

main/menu/menuManiaRenderer.c

@@ -93,6 +93,12 @@ menuManiaRenderer_t* initMenuManiaRenderer(font_t* titleFont, font_t* titleFontO
     renderer->shadowColors     = defaultShadowColors;
     renderer->shadowColorsLen  = ARRAY_SIZE(defaultShadowColors);
 
+    // LED color
+    uint32_t ledColor        = paletteToRGB(renderer->bgColor);
+    renderer->baseLedColor.r = ((ledColor >> 16) & 0xFF) / 2;
+    renderer->baseLedColor.g = ((ledColor >> 8) & 0xFF) / 2;
+    renderer->baseLedColor.b = ((ledColor >> 0) & 0xFF) / 2;
+
     // Save or allocate title font
     if (NULL == titleFont)
     {
@@ -379,14 +385,11 @@ void drawMenuMania(menu_t* menu, menuManiaRenderer_t* renderer, int64_t elapsedU
     {
         // Run timer for LED excitation
         renderer->ledExciteTimer += elapsedUs;
-        while (renderer->ledExciteTimer >= 40000 * 8)
+        while (renderer->ledExciteTimer >= 40000 * CONFIG_NUM_LEDS)
         {
-            renderer->ledExciteTimer -= 40000 * 8;
-            uint32_t ledColor                      = paletteToRGB(renderer->bgColor);
-            renderer->leds[renderer->currentLed].r = ((ledColor >> 16) & 0xFF) / 2;
-            renderer->leds[renderer->currentLed].g = ((ledColor >> 8) & 0xFF) / 2;
-            renderer->leds[renderer->currentLed].b = ((ledColor >> 0) & 0xFF) / 2;
-            renderer->currentLed                   = (renderer->currentLed + 1) % CONFIG_NUM_LEDS;
+            renderer->ledExciteTimer -= 40000 * CONFIG_NUM_LEDS;
+            renderer->leds[renderer->currentLed] = renderer->baseLedColor;
+            renderer->currentLed                 = (renderer->currentLed + 1) % CONFIG_NUM_LEDS;
         }
 
         // Run timer for LED decay
@@ -662,11 +665,12 @@ void setManiaLedsOn(menuManiaRenderer_t* renderer, bool ledsOn)
  * @param rowTextColor The color of the row text
  * @param shadowColors The colors cycled through as the selected shadow
  * @param shadowColorsLen The number of selected shadow colors to cycle through
+ * @param baseLedColor The color of the LED illumination
  */
 void recolorMenuManiaRenderer(menuManiaRenderer_t* renderer, paletteColor_t titleBgColor, paletteColor_t titleTextColor,
                               paletteColor_t textOutlineColor, paletteColor_t bgColor, paletteColor_t outerRingColor,
                               paletteColor_t innerRingColor, paletteColor_t rowColor, paletteColor_t rowTextColor,
-                              const paletteColor_t* shadowColors, int32_t shadowColorsLen)
+                              const paletteColor_t* shadowColors, int32_t shadowColorsLen, led_t baseLedColor)
 {
     renderer->titleBgColor      = titleBgColor;
     renderer->titleTextColor    = titleTextColor;
@@ -681,4 +685,5 @@ void recolorMenuManiaRenderer(menuManiaRenderer_t* renderer, paletteColor_t titl
     renderer->shadowColors      = shadowColors;
     renderer->shadowColorsLen   = shadowColorsLen;
     renderer->selectedShadowIdx = 0;
+    renderer->baseLedColor      = baseLedColor;
 }

main/menu/menuManiaRenderer.h

@@ -94,6 +94,7 @@ typedef struct
     paletteColor_t rowTextColor;        ///< The color of the row text
     const paletteColor_t* shadowColors; ///< The colors cycled through as the selected shadow
     int32_t shadowColorsLen;            ///< The number of selected shadow colors to cycle through
+    led_t baseLedColor;                 ///< The base color of the LED rotation
 } menuManiaRenderer_t;
 
 menuManiaRenderer_t* initMenuManiaRenderer(font_t* titleFont, font_t* titleFontOutline, font_t* menuFont);
@@ -103,6 +104,6 @@ void setManiaLedsOn(menuManiaRenderer_t* renderer, bool ledsOn);
 void recolorMenuManiaRenderer(menuManiaRenderer_t* renderer, paletteColor_t titleBgColor, paletteColor_t titleTextColor,
                               paletteColor_t textOutlineColor, paletteColor_t bgColor, paletteColor_t outerRingColor,
                               paletteColor_t innerRingColor, paletteColor_t rowColor, paletteColor_t rowTextColor,
-                              const paletteColor_t* shadowColors, int32_t shadowColorsLen);
+                              const paletteColor_t* shadowColors, int32_t shadowColorsLen, led_t baseLedColor);
 
 #endif

main/modes/games/swadgeHero/mode_swadgeHero.c

@@ -81,6 +81,7 @@ static void shEnterMode(void)
     {
         loadWsg(icons[i], &shv->icons[i], true);
     }
+    loadWsg("star.wsg", &shv->star, true);
 
     // Show initial menu
     shChangeScreen(shv, SH_MENU);
@@ -103,6 +104,7 @@ static void shExitMode(void)
     {
         freeWsg(&shv->icons[i]);
     }
+    freeWsg(&shv->star);
 
     // Free mode memory
     free(shv);
@@ -226,6 +228,10 @@ void shChangeScreen(shVars_t* sh, shScreen_t newScreen)
             {
                 free(val);
             }
+            while ((val = pop(&shv->starList)))
+            {
+                free(val);
+            }
             break;
         }
         case SH_GAME_END:

main/modes/games/swadgeHero/mode_swadgeHero.h

@@ -122,6 +122,13 @@ typedef struct
     list_t fretLines;
     int32_t lastFretLineUs;
 
+    // LED data
+    int32_t nextBlinkUs;
+    int8_t ledBaseVal;
+    int32_t ledDecayTimer;
+    int32_t usPerLedDecay;
+    led_t ledHitVal;
+
     // Drawing data
     list_t gameNotes;
     buttonBit_t btnState;
@@ -130,6 +137,8 @@ typedef struct
     const char* timingText;
     int32_t textTimerUs;
     wsg_t icons[6];
+    wsg_t star;
+    list_t starList;
 
     // High score display
     list_t hsStrs;