Add Tunes tab.

Author: AlkaMotors

SerialPortConnector.pro

@@ -4,6 +4,12 @@ QT += serialport
 
 CONFIG += c++11
 
+CONFIG += release
+
+CONFIG(release, debug|release) {
+    CONFIG += static
+}
+
 # The following define makes your compiler emit warnings if you use
 # any Qt feature that has been marked deprecated (the exact warnings
 # depend on your compiler). Please consult the documentation of the
@@ -20,13 +26,15 @@ SOURCES += \
     bluejaymelody.cpp \
     fourwayif.cpp \
     main.cpp \
+    music.cpp \
     widget.cpp
 
 HEADERS += \
     BF_ROOTLOADER.h \
     bluejaymelody.h \
     defaults.h \
     fourwayif.h \
+    music.h \
     widget.h
 
 FORMS += \

SerialPortConnector.pro.user

@@ -50,7 +50,7 @@ uint8_t air_starteeprom[48] ={
     0x66,      // current protection level (value x 2) above 100 disables, default 102 (204 degrees) (byte 44)
     0x06,      // sine mode strength 1-10 default 6 byte 45
     //eeprom version 2 or later
-    0x01,      // input type selector 1)Auto 2)Dshot only 3)Servo only 4)PWM 5)Serial 6)BetaFlight Safe Arming
+    0x00,      // input type selector 1)Auto 2)Dshot only 3)Servo only 4)PWM 5)Serial 6)BetaFlight Safe Arming
     0x00,      // auto_timing
 };
 

defaults.h

@@ -184,7 +184,7 @@ void FourWayIF::set_Ack_req(char ackreq){
 }
 
 bool FourWayIF::ACK_received(){
-    return ack_received;
+
 }
 
 

fourwayif.cpp

@@ -0,0 +1,328 @@
+#include "music.h"
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#include <ctype.h>
+
+/* ═══════════════════════════════════════════════════════════════════════
+ * Frequency table
+ * Matches Python: freq = round(440 * 2^((midi-69)/12), 1)
+ *                 where midi = (octave+1)*12 + semitone
+ * This is the actual frequency used for BOTH T3 encoding AND pulse counting.
+ * ═══════════════════════════════════════════════════════════════════════ */
+
+static double note_actual_freq(int semitone, int octave)
+{
+    int midi = (octave + 1) * 12 + semitone;
+    double freq = 440.0 * pow(2.0, (midi - 69) / 12.0);
+    /* Round to 1 decimal place to match Python's round(..., 1) */
+    return round(freq * 10.0) / 10.0;
+}
+
+/* ═══════════════════════════════════════════════════════════════════════
+ * MIDI → T3 lookup table
+ * Covers MIDI notes 60-107 (C4–B7).
+ * midi = (octave+1)*12 + semitone, so:
+ *   octave 4: midi 60-71
+ *   octave 5: midi 72-83  ← verified hard-coded values
+ *   octave 6: midi 84-95  ← verified hard-coded values
+ *   octave 7: midi 96-107
+ * ═══════════════════════════════════════════════════════════════════════ */
+
+#define MIDI_T3_MIN  60
+#define MIDI_T3_MAX  107
+
+static uint8_t midi_t3_table[MIDI_T3_MAX - MIDI_T3_MIN + 1];
+static int     table_built = 0;
+
+
+static void limit_bluejay_pitch(int *semitone, int *octave)
+{
+    /* Bluejay max frequency ≈ 2290 Hz (T3 = 1) */
+    const double MAX_FREQ = 2200.0;
+
+    double freq = note_actual_freq(*semitone, *octave);
+
+    if (freq > MAX_FREQ)
+    {
+        /* Drop one octave */
+        (*octave)--;
+
+        /* Safety clamp so we never go below valid range */
+        if (*octave < 4)
+            *octave = 4;
+    }
+}
+
+
+
+static uint8_t midi_to_t3_precise(int midi)
+{
+    /* exact frequency from MIDI note */
+    double freq = 440.0 * pow(2.0, (midi - 69) / 12.0);
+
+    /* Bluejay timing formula */
+    double t3f = 41000.0 / freq - 16.9;
+
+    int t3 = (int)lround(t3f);
+
+    if (t3 < 1)   t3 = 1;
+    if (t3 > 255) t3 = 255;
+
+    return (uint8_t)t3;
+}
+
+
+static void build_midi_t3_table(void)
+{
+    if (table_built) return;
+
+    static const uint8_t oct5[12] = { 61,57,53,49,45,42,39,35,32,30,27,25 };
+    static const uint8_t oct6[12] = { 23,20,18,16,15,12,11,10,8,7,5,4 };
+
+    for (int midi = MIDI_T3_MIN; midi <= MIDI_T3_MAX; midi++)
+    {
+        int semitone = midi % 12;
+
+        if (midi >= 72 && midi <= 83)
+            midi_t3_table[midi - MIDI_T3_MIN] = oct5[semitone];
+
+        else if (midi >= 84 && midi <= 95)
+            midi_t3_table[midi - MIDI_T3_MIN] = oct6[semitone];
+
+        else
+            midi_t3_table[midi - MIDI_T3_MIN] = midi_to_t3_precise(midi);
+    }
+
+    table_built = 1;
+}
+
+/* semitone 0=C..11=B, octave 4-7 → T3 byte */
+static uint8_t note_to_t3(int semitone, int octave)
+{
+    build_midi_t3_table();
+    int midi = (octave + 1) * 12 + semitone;
+    if (midi >= MIDI_T3_MIN && midi <= MIDI_T3_MAX)
+        return midi_t3_table[midi - MIDI_T3_MIN];
+    /* Fallback for out-of-range octaves */
+    return midi_to_t3_precise(note_actual_freq(semitone, octave));
+}
+
+/* ═══════════════════════════════════════════════════════════════════════
+ * Note name parsing
+ * ═══════════════════════════════════════════════════════════════════════ */
+
+static const char *NOTE_NAMES[12] = {
+    "C","C#","D","D#","E","F","F#","G","G#","A","A#","B"
+};
+
+static const struct { const char *flat; const char *sharp; } FLAT_MAP[] = {
+    {"DB","C#"}, {"EB","D#"}, {"FB","E"}, {"GB","F#"},
+    {"AB","G#"}, {"BB","A#"}, {"CB","B"}, {NULL, NULL}
+};
+
+/* Advances *p past the note name. Returns semitone 0-11, or -1 on failure. */
+static int parse_note_name(const char **p)
+{
+    char name[4] = {0};
+    int  len = 0;
+
+    if (!isalpha((unsigned char)**p)) return -1;
+    name[len++] = (char)toupper((unsigned char)**p);
+    (*p)++;
+
+    if (**p == '#' || **p == 'b') {
+        name[len++] = (char)toupper((unsigned char)**p);
+        (*p)++;
+    }
+
+    for (int i = 0; FLAT_MAP[i].flat; i++)
+        if (strcmp(name, FLAT_MAP[i].flat) == 0)
+        { strcpy(name, FLAT_MAP[i].sharp); break; }
+
+    for (int i = 0; i < 12; i++)
+        if (strcmp(name, NOTE_NAMES[i]) == 0) return i;
+
+    return -1;
+}
+
+/* ═══════════════════════════════════════════════════════════════════════
+ * Duration string → divisor integer
+ * Accepts "8", "4", "1/8", "1/4" etc.
+ * ═══════════════════════════════════════════════════════════════════════ */
+static int parse_duration_str(const char *s)
+{
+    const char *slash = strchr(s, '/');
+    if (slash)
+        return atoi(slash + 1);   /* "1/8" → 8 */
+    return atoi(s);               /* "8"   → 8 */
+}
+
+/* ═══════════════════════════════════════════════════════════════════════
+ * Internal encoder — operates on const char*
+ * ═══════════════════════════════════════════════════════════════════════ */
+
+static int encode_notation(const char *notation, int bpm, uint8_t out[BLUEJAY_ARRAY_SIZE])
+{
+    memset(out, 0, BLUEJAY_ARRAY_SIZE);
+
+    /* Tokenise — work on a mutable copy */
+    char buf[2048];
+    strncpy(buf, notation, sizeof(buf) - 1);
+    buf[sizeof(buf) - 1] = '\0';
+    for (char *c = buf; *c; c++) if (*c == ',') *c = ' ';
+
+    char  *raw_toks[512];
+    int    ntok = 0;
+    char  *tok  = strtok(buf, " \t\r\n");
+    while (tok && ntok < (int)(sizeof(raw_toks)/sizeof(raw_toks[0]))) {
+        raw_toks[ntok++] = tok;
+        tok = strtok(NULL, " \t\r\n");
+    }
+
+    /* Parse tokens into events */
+    typedef struct { int semitone; int octave; int dur_div; } Event;
+    Event events[512];
+    int   nevents = 0;
+
+    int dur_counts[33] = {0};
+    int oct_counts[9]  = {0};
+
+    int i = 0;
+    while (i < ntok) {
+        const char *t = raw_toks[i];
+
+        if (t[0] == 'P' || t[0] == 'p') {
+            int d = parse_duration_str(t + 1);
+            if (d <= 0) return -1;
+            events[nevents].semitone = -1;
+            events[nevents].octave   = 0;
+            events[nevents].dur_div  = d;
+            nevents++;
+            if (d <= 32) dur_counts[d]++;
+            i++;
+        } else {
+            const char *p = t;
+            int semi = parse_note_name(&p);
+            if (semi < 0) return -1;
+
+            int octave = 5;
+            if (*p >= '4' && *p <= '7') { octave = *p - '0'; p++; }
+
+            if (i + 1 >= ntok) return -1;
+            int d = parse_duration_str(raw_toks[i + 1]);
+            if (d <= 0) return -1;
+
+            events[nevents].semitone = semi;
+            events[nevents].octave   = octave;
+            events[nevents].dur_div  = d;
+            nevents++;
+            if (d <= 32)  dur_counts[d]++;
+            if (octave >= 0 && octave <= 8) oct_counts[octave]++;
+            i += 2;
+        }
+    }
+
+    if (nevents == 0) return -1;
+
+    /* Determine default duration and octave (most common) */
+    int default_dur = 4, best_dur_cnt = 0;
+    for (int d = 1; d <= 32; d++)
+        if (dur_counts[d] > best_dur_cnt) { best_dur_cnt = dur_counts[d]; default_dur = d; }
+
+    int default_oct = 5, best_oct_cnt = 0;
+    for (int o = 4; o <= 7; o++)
+        if (oct_counts[o] > best_oct_cnt) { best_oct_cnt = oct_counts[o]; default_oct = o; }
+
+    /* Build (T4, T3) pairs */
+    double ms_per_beat = 60000.0 / bpm;
+    uint8_t pairs[BLUEJAY_MAX_PAIRS * 2];
+    int     npairs = 0;
+
+    for (int e = 0; e < nevents && npairs < BLUEJAY_MAX_PAIRS; e++) {
+        double dur_ms = ms_per_beat * 4.0 / events[e].dur_div;
+
+        if (events[e].semitone < 0) {
+            /* Pause: T3=0, T4=ms clamped 1-255 */
+            int t4 = (int)round(dur_ms);
+            if (t4 < 1)   t4 = 1;
+            if (t4 > 255) t4 = 255;
+            pairs[npairs * 2]     = (uint8_t)t4;
+            pairs[npairs * 2 + 1] = 0;
+            npairs++;
+        } else {
+            int semi = events[e].semitone;
+            int oct  = events[e].octave;
+
+            /* Automatically lower notes above C#7 */
+            limit_bluejay_pitch(&semi, &oct);
+
+            uint8_t t3 = note_to_t3(semi, oct);
+
+            /*
+             * FIX: use the actual note frequency for pulse counting,
+             * NOT the inverse of the T3 byte (41000/(t3+16.9)).
+             * The T3-inverse introduces rounding error that produces
+             * wrong pair counts, especially for higher-octave notes.
+             * This matches the Python reference tool exactly.
+             */
+            double actual_freq = note_actual_freq(semi, oct);
+           // double actual_freq = note_actual_freq(events[e].semitone, events[e].octave);
+            double pulses_remaining = dur_ms / 1000.0 * actual_freq;
+
+            while (pulses_remaining > 0.5 && npairs < BLUEJAY_MAX_PAIRS) {
+                int chunk = (pulses_remaining >= 255.0)
+                ? 255
+                : (int)round(pulses_remaining);
+                if (chunk < 1) chunk = 1;
+                pairs[npairs * 2]     = (uint8_t)chunk;
+                pairs[npairs * 2 + 1] = t3;
+                npairs++;
+                pulses_remaining -= chunk;
+            }
+        }
+    }
+
+    /* Write 128-byte header + pairs */
+    out[0] = 0;
+    out[1] = (uint8_t)(bpm > 255 ? 255 : bpm);
+    out[2] = (uint8_t)default_oct;
+    out[3] = (uint8_t)default_dur;
+    for (int p = 0; p < npairs; p++) {
+        out[4 + p * 2]     = pairs[p * 2];
+        out[4 + p * 2 + 1] = pairs[p * 2 + 1];
+    }
+
+    return npairs;
+}
+
+
+int blheli32_to_bluejay_array(const QString &notation, int bpm, uint8_t out[BLUEJAY_ARRAY_SIZE])
+{
+    QByteArray utf8 = notation.toUtf8();
+    return encode_notation(utf8.constData(), bpm, out);
+}
+
+void bluejay_array_to_c_literal(const uint8_t arr[BLUEJAY_ARRAY_SIZE],
+                                const char *var_name)
+{
+    printf("uint8_t %s[%d] = {\n", var_name, BLUEJAY_ARRAY_SIZE);
+    printf("    /* [0]  reserved */ 0x%02X,\n",  arr[0]);
+    printf("    /* [1]  BPM      */ 0x%02X,  // %d BPM\n", arr[1], arr[1]);
+    printf("    /* [2]  def oct  */ 0x%02X,  // octave %d\n", arr[2], arr[2]);
+    printf("    /* [3]  def dur  */ 0x%02X,  // 1/%d\n", arr[3], arr[3]);
+    printf("\n    /* [4..127] (T4, T3) note pairs */\n");
+    for (int i = 4; i < BLUEJAY_ARRAY_SIZE; i += 2) {
+        uint8_t t4 = arr[i], t3 = arr[i + 1];
+        if (t4 == 0 && t3 == 0)
+            printf("    0x00, 0x00,  // (unused)\n");
+        else if (t3 == 0)
+            printf("    0x%02X, 0x00,  // pause %d ms\n", t4, t4);
+        else
+            printf("    0x%02X, 0x%02X,  // T3=0x%02X (~%.0f Hz), %d pulses\n",
+                   t4, t3, t3, 41000.0 / (t3 + 16.9), t4);
+    }
+    printf("};\n");
+}
+