Merge branch 'feature_models' of thomas/drumkit into master

3dprint/actuator.scad

+$fa=1/1;
+$fs=1/2;
+bissl=1/2;
+part="spool";//[spool,cap,hammer,all]
+total_length=50;
+wall=0.8;
+air=0.5;
+copper_height=5;
+thick_wall=2*wall; //can be specified
+iron_d=4;
+iron_h=total_length/3; //can be changed, but this seems optimal
+spool_h=iron_h; //according to theory, optimum is a little more
+iron_travel=iron_h; //may be smaller with heavy beaters or returning springs
+extra_hold=iron_h/3;
+spool_id=iron_d+2*air;
+spool_od=spool_id+2*wall;
+cap_od=spool_od+2*copper_height;
+slit=15;
+hole=3;
+hammer_flat=true;
+module spool() {
+  difference() {
+    union() {
+      cylinder(d1=spool_od,d2=cap_od,h=thick_wall+iron_travel);
+      translate([0,0,iron_travel+thick_wall]) cylinder(d=spool_od,h=spool_h+extra_hold);
+    }
+    translate([0,0,thick_wall]) cylinder(d=spool_id,h=spool_h+iron_h+bissl+extra_hold);
+  }
+}
+module cap() {
+difference() {
+union() {
+cylinder(d=cap_od,h=thick_wall);
+translate([0,0,thick_wall])cylinder(d=spool_od+2*wall+2*air,h=extra_hold);
+translate([-cap_od/2,0,0])cube([cap_od,cap_od/2,thick_wall]);
+translate([-cap_od/2,cap_od/2,0])cube([cap_od,thick_wall,2*thick_wall+slit]);
+translate([-thick_wall/2,0,0])cube([thick_wall,cap_od/2,extra_hold+thick_wall]);
+}
+translate([0,0,-bissl])cylinder(d=spool_id,h=extra_hold+thick_wall+2*bissl);
+cylinder(d=spool_od+2*air,h=extra_hold);
+hull() {
+translate([cap_od/2-thick_wall-hole/2,cap_od/2+thick_wall/2,2*thick_wall+hole/2])rotate([90,0,0])cylinder (d=hole, h=thick_wall+bissl,center=true);
+translate([cap_od/2-thick_wall-hole/2,cap_od/2+thick_wall/2,slit])rotate([90,0,0])cylinder (d=hole, h=thick_wall+bissl,center=true);
+}
+hull() {
+translate([-cap_od/2+thick_wall+hole/2,cap_od/2+thick_wall/2,2*thick_wall+hole/2])rotate([90,0,0])cylinder (d=hole, h=thick_wall+bissl,center=true);
+translate([-cap_od/2+thick_wall+hole/2,cap_od/2+thick_wall/2,slit])rotate([90,0,0])cylinder (d=hole, h=thick_wall+bissl,center=true);
+}
+}
+}
+echo (cap_od-thick_wall*2-hole);
+module hammer() {
+if (hammer_flat) {
+cylinder(d=cap_od-2*air,h=thick_wall);
+translate([0,0,thick_wall]) cylinder(d1=cap_od-2*air,d2=iron_d,h=cap_od/2-iron_d/2-air/2);
+}
+else {
+cylinder(d2=cap_od/2,d1=iron_d,h=cap_od/4-iron_d/4);
+translate([0,0,cap_od/4-iron_d/4])cylinder(d=cap_od/2,h=thick_wall);
+translate([0,0,cap_od/4-iron_d/4+thick_wall]) cylinder(d1=cap_od/2,d2=iron_d,h=cap_od/4-iron_d/4);
+}
+translate([0,0,thick_wall+cap_od/2-iron_d/2-air/2]) cylinder(d=iron_d,h=1.5*iron_h);
+}
+if (part=="all") {
+spool();
+translate([0,0,spool_h+iron_h+bissl+air+thick_wall])cap();
+translate([0,0,total_length])mirror([0,0,1])hammer();
+}
+if (part=="spool") spool();
+if (part=="cap") cap();
+if (part=="hammer") hammer();

3dprint/beam.scad

+$fa=1/1;
+$fs=1/2;
+bissl=1/100;
+wall=1.6;//twice nozzle diameter is fine, walls of triangles
+hole=3; //hole for mounting thread inserts
+hd=10; //horizontal distance between mounting points, depends on mounting hole distance in the actuator
+height=40; //dimension of the beam in the direction of tambourine depth
+vd=height-wall; //vertical distance between mounting holes
+segments=14; //number of mounting points, defines the beam length
+radius=1; //rounding of inner corners
+thickness=2*wall+hole; //thickness of the beam, keep some material to properly hold the threaded insert on the side
+offset=wall/2+hole/2;
+difference() {
+  linear_extrude(thickness, convexity=4) difference() {
+    offset(r=-radius)offset(r=radius)union() {
+      for (i=[0:hd:hd*(segments-1)]) translate ([i,0]) {
+        for (tr=[[[hd,0],[0,0]],[[-hd/2,vd],[0,0]],[[hd/2,vd],[0,0]],[[hd/2,vd],[-hd/2,vd]]]) hull() { //diagonals
+          translate(tr[0])circle(d=wall);
+          translate(tr[1]) circle(d=wall);
+        }
+        for (tr=[[hd/2,vd-offset],[-hd/2,vd-offset],[hd,offset],[0,offset]]) translate(tr)circle(d=2*wall+hole); //big circles
+      }
+    
+      //left vertical wall, not generated by the loop
+      for (tr=[[[-hd/2-offset,0],[0,0]],[[-hd/2-offset,0],[-hd/2-offset,vd]],[[-hd/2-offset,vd],[-hd/2,vd]]]) hull() {
+        translate(tr[0])circle(d=wall);
+        translate(tr[1]) circle(d=wall);
+      }
+
+      //solid triangle to jhold threaded inserts
+      hull() for (tr=[[0,0],[-hd/2-offset,0],[-hd/2-offset,vd],[-hd/2,vd]]) translate(tr) circle(d=wall); 
+
+      //right vertical wall, not generated by the loop
+      for (tr=[[[hd*segments+offset,0],[0,0]],
+               [[hd*segments+offset,0],[hd*segments+offset,vd]],
+               [[hd*segments+offset,vd],[hd*(segments-0.5),vd]],
+               [[hd*segments,0],[hd*(segments-0.5),vd]]]) 
+        hull() {
+          translate(tr[0])circle(d=wall);
+          translate(tr[1]) circle(d=wall);
+        }
+    }
+    for (i=[0:segments]) {
+      translate([i*hd,offset]) circle(d=hole);
+      translate([(i-0.5)*hd,vd-offset]) circle(d=hole);
+    }
+  }
+  //mounting holes for threaded inserts, three just in case, it's better to use the middle one
+  translate([-hd/2-offset-wall/2,height/4-wall,thickness/2])rotate([0,90,0])cylinder(d=hole,h=hd-wall);
+  translate([-hd/2-offset-wall/2,height/2-wall/2,thickness/2])rotate([0,90,0])cylinder(d=hole,h=hd-wall);
+  translate([-hd/2-offset-wall/2,height*3/4,thickness/2])rotate([0,90,0])cylinder(d=hole,h=hd-wall);
+}

3dprint/enclosure.scad

+part="bottom";//[bottom,top]

3dprint/tamb_mount.json

             "id_tamb": "239",
             "lip": "3",
             "od_tamb": "251",
-            "part": "outer",
-            "wall": "1.6000000000000001"
+            "part": "outer"
         }
     }
 }

3dprint/tamb_mount.scad

 $fs=1/2;
 bissl=1/100;
 part="inner";//[inner,outer,all_visualize]
-od_tamb=251;
-id_tamb=239;
-wall_tamb=(od_tamb-id_tamb)/2;
-hole_tamb=23;
-lip=3;
-air=1;
-hole=3;
-wall=1.6;
-beam_width=7;
+od_tamb=251;//tambourine rim outer diameter
+id_tamb=239;//tambourine rim inner diameter
+wall_tamb=(od_tamb-id_tamb)/2; //tambourine wall
+hole_tamb=23; //holding hole in the rim
+lip=3; //extra plastic that hols to the hole
+air=1; //wiggle room
+hole=3; //diameter for screw hole
+beam_width=7; //slit in inner part of mount to hod the beam
+wall=1.6;//thinnest part in the mount, namely the slit to tune the beam mounting height
 module inner_mount() {
   difference() {
     union() {
     translate([-beam_width/2-air/2,-hole_tamb/2-lip,-bissl]) cube([beam_width+air,hole_tamb+2*lip,lip]);
   }
 }
-
 module outer_mount() {
   difference() {
     union() {
 if (part=="all_visualize") {
   inner_mount();
   translate([0,0,wall_tamb+3*lip])rotate([180,0,0])outer_mount();
-  }
+}

CMakeLists.txt

 add_executable(drumkit)
 
 target_sources(drumkit PUBLIC
+    src/adc.c
     src/buttons.c
     src/encoder.c
     src/lcd.c

README.md

 
 The code in `src/encoder.c` is derived from [mathertel/RotaryEncoder](https://github.com/mathertel/RotaryEncoder) and therefore licensed as BSD 3-clause.
 
-The PCB design uses `Mini360_step_down_converter` library from [rayvburn/KiCad](https://github.com/rayvburn/KiCad/tree/master/Mini360_step_down_converter).
+~~The PCB design uses `Mini360_step_down_converter` library from [rayvburn/KiCad](https://github.com/rayvburn/KiCad/tree/master/Mini360_step_down_converter).~~
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by

include/adc.h

+/*
+ * adc.h
+ *
+ * Copyright (c) 2022 - 2023 Thomas Buck (thomas@xythobuz.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __ADC_H__
+#define __ADC_H__
+
+void bat_init(void);
+float bat_get(void);
+
+#endif // __ADC_H__

include/buttons.h

 void buttons_run(void);
 
 #endif // __BUTTONS_H__
-

include/encoder.h

 void encoder_run(void);
 
 #endif // __ENCODER_H__
-

include/lcd.h

 #define LCD_HEIGHT 64
 
 void lcd_init(void);
+void lcd_draw(const char *mode, const char *val, const char *bat);
 
 #endif // __LCD_H__

include/sequence.h

 
 #define CH_GPIO_TIMINGS { 42, 42, 42 } // in milliseconds
 
+#define MAX_BEATS 32
+#define MAX_BANKS (MAX_BEATS / NUM_BTNS)
+
 void sequence_init(void);
+
 void sequence_set_bpm(uint32_t new_bpm);
+uint32_t sequence_get_bpm(void);
+
 void sequence_set_beats(uint32_t new_beats);
+uint32_t sequence_get_beats(void);
+
+void sequence_set_bank(uint32_t new_bank);
+uint32_t sequence_get_bank(void);
+
 void sequence_handle_button_loopstation(enum buttons btn, bool rec);
 void sequence_handle_button_drummachine(enum buttons btn);
+
 void sequence_run(void);
 
 #endif // __SEQUENCE_H__

include/ui.h

 
 void ui_init(void);
 void ui_encoder(int32_t val);
+void ui_run(void);
 
 #endif // __UI_H__

src/adc.c

+/*
+ * adc.c
+ *
+ * Copyright (c) 2024 Thomas Buck (thomas@xythobuz.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include "pico/stdlib.h"
+#include "hardware/adc.h"
+
+#include "adc.h"
+
+#define ADC_NUM 2
+#define ADC_PIN (26 + ADC_NUM)
+
+#define ADC_VREF 3.3
+#define ADC_RANGE (1 << 12)
+#define ADC_CONVERT (ADC_VREF / (ADC_RANGE - 1))
+
+#define BAT_R1 10000.0f
+#define BAT_R2 18000.0f
+
+void bat_init(void) {
+    adc_init();
+    adc_gpio_init( ADC_PIN);
+    adc_select_input( ADC_NUM);
+}
+
+float bat_get(void) {
+    float v_adc = adc_read() * ADC_CONVERT;
+
+    // Vadc = Vbat * R2 / (R1 + R2)
+    float v_bat = v_adc / (BAT_R2 / (BAT_R1 + BAT_R2));
+    return v_bat;
+}

src/encoder.c

 #define FOUR0 2 // 4 steps, Latch at position 0 (reverse wirings)
 #define TWO03 3 // 2 steps, Latch at position 0 and 3
 
-#define ENCODER_MODE TWO03
+#define ENCODER_MODE FOUR3
 
 static const uint gpio_num[2] = {
     17, 18
             if (thisState == LATCH3) {
                 // The hardware has 4 steps with a latch on the input state 3
                 positionExt = position >> 2;
+                positionExt = -positionExt;
             }
             break;
 
             if (thisState == LATCH0) {
                 // The hardware has 4 steps with a latch on the input state 0
                 positionExt = position >> 2;
+                positionExt = -positionExt;
             }
             break;
 
             if ((thisState == LATCH0) || (thisState == LATCH3)) {
                 // The hardware has 2 steps with a latch on the input state 0 and 3
                 positionExt = position >> 1;
+                positionExt = -positionExt;
             }
             break;
         }

src/lcd.c

 
     disp.external_vcc = false;
     ssd1306_init(&disp, LCD_WIDTH, LCD_HEIGHT, LCD_ADDR, LCD_I2C);
+    ssd1306_clear(&disp);
+}
+
+void lcd_draw(const char *mode, const char *val, const char *bat) {
+    ssd1306_clear(&disp);
+    ssd1306_draw_string(&disp, 0, 0, 2, mode);
+    ssd1306_draw_string(&disp, 0, 20, 4, val);
+    ssd1306_draw_string(&disp, 0, LCD_HEIGHT - 1 - 10, 1, bat);
+
+    ssd1306_show(&disp);
 }

src/main.c

 #include "pico/stdlib.h"
 #include "hardware/watchdog.h"
 
+#include "adc.h"
 #include "buttons.h"
 #include "encoder.h"
 #include "lcd.h"
 int main(void) {
     watchdog_enable(WATCHDOG_PERIOD_MS, 1);
     stdio_init_all();
+    bat_init();
     buttons_init();
     encoder_init();
     lcd_init();
         encoder_run();
         sequence_run();
         pulse_run();
+        ui_run();
 
         int32_t epos = encoder_pos();
         if (epos != last_epos) {

src/sequence.c

 #include "pulse.h"
 #include "sequence.h"
 
-#define MAX_BEATS 32
 static const uint32_t channel_times[NUM_CHANNELS] = CH_GPIO_TIMINGS;
 
 static uint32_t ms_per_beat = 500;
 static uint32_t beats = 16;
 static uint32_t last_t = 0;
 static uint32_t last_i = 0;
+static uint32_t bank = 0;
 
 static enum channels sequence[MAX_BEATS] = {0};
 
     ms_per_beat = 60000 / new_bpm;
 }
 
+uint32_t sequence_get_bpm(void) {
+    return 60000 / ms_per_beat;
+}
+
 void sequence_set_beats(uint32_t new_beats) {
     beats = (new_beats <= MAX_BEATS) ? new_beats : MAX_BEATS;
+
+    uint32_t max_banks_currently = (beats + (NUM_BTNS - 1)) / NUM_BTNS;
+    bank = (bank < max_banks_currently) ? bank : max_banks_currently;
+}
+
+uint32_t sequence_get_beats(void) {
+    return beats;
+}
+
+void sequence_set_bank(uint32_t new_bank) {
+    uint32_t b = (new_bank < MAX_BANKS) ? new_bank : MAX_BANKS;
+
+    uint32_t max_banks_currently = (beats + (NUM_BTNS - 1)) / NUM_BTNS;
+    bank = (b < max_banks_currently) ? b : max_banks_currently;
+}
+
+uint32_t sequence_get_bank(void) {
+    return bank;
 }
 
 static void sequence_set(uint32_t beat, enum channels ch, bool value) {
 
     switch (btn) {
         case BTN_A: {
+            // TODO kick is wrong here
             bool val = !sequence_get(beat, CH_KICK);
             sequence_set(beat, CH_KICK, val);
             break;
         }
 
         case BTN_B: {
+            // TODO snare is wrong here
             bool val = !sequence_get(beat, CH_SNARE);
             sequence_set(beat, CH_SNARE, val);
             break;
         }
 
         case BTN_C: {
+            // TODO hihat is wrong here
             bool val = !sequence_get(beat, CH_HIHAT);
             sequence_set(beat, CH_HIHAT, val);
             break;

src/ui.c

  */
 
 #include <stdio.h>
+#include <inttypes.h>
 #include "pico/stdlib.h"
 
+#include "adc.h"
 #include "buttons.h"
+#include "lcd.h"
 #include "sequence.h"
 #include "ui.h"
 
+#define REDRAW_MS 2000
+
 static bool rec_held_down = false;
 static enum ui_modes ui_mode = 0;
 static enum machine_modes machine_mode = 0;
+static uint32_t last_redraw = 0;
 
 static void ui_redraw(void) {
+    char mode[64] = {0};
+    char val[64] = {0};
+    char bat[64] = {0};
+
     switch (ui_mode) {
         case UI_BPM: {
-            // TODO
+            snprintf(mode, sizeof(mode) - 1, "BPM:");
+            snprintf(val, sizeof(val) - 1, "%"PRIu32, sequence_get_bpm());
             break;
         }
 
         case UI_MODE: {
-            // TODO
+            snprintf(mode, sizeof(mode) - 1, "Mode:");
+            switch (machine_mode) {
+                case MODE_LOOPSTATION: {
+                    snprintf(val, sizeof(val) - 1, "Loop");
+                    break;
+                }
+
+                case MODE_DRUMMACHINE: {
+                    snprintf(val, sizeof(val) - 1, "Drum");
+                    break;
+                }
+
+                default: {
+                    printf("%s: invalid mode: %d\n", __func__, machine_mode);
+                    machine_mode = 0;
+                    ui_redraw();
+                    return;
+                }
+            }
             break;
         }
 
         case UI_LENGTH: {
-            // TODO
+            snprintf(mode, sizeof(mode) - 1, "Length:");
+            snprintf(val, sizeof(val) - 1, "%"PRIu32, sequence_get_beats());
             break;
         }
 
         case UI_BANK: {
-            // TODO
+            snprintf(mode, sizeof(mode) - 1, "Bank:");
+            snprintf(val, sizeof(val) - 1, "%"PRIu32, sequence_get_bank());
             break;
         }
 
             printf("%s: invalid mode: %d\n", __func__, ui_mode);
             ui_mode = 0;
             ui_redraw();
-            break;
+            return;
         }
     }
+
+    snprintf(bat, sizeof(bat) - 1, "Bat: %.2fV", bat_get());
+    lcd_draw(mode, val, bat);
 }
 
 static void ui_buttons_loopstation(enum buttons btn, bool val) {
 static void ui_buttons(enum buttons btn, bool val) {
     switch (btn) {
         case BTN_CLICK: {
-            ui_mode = (ui_mode + 1) % UI_NUM_MODES;
-            ui_redraw();
+            if (val) {
+                ui_mode = (ui_mode + 1) % UI_NUM_MODES;
+                ui_redraw();
+            }
             break;
         }
 
 
     switch (ui_mode) {
         case UI_BPM: {
-            // TODO
+            sequence_set_bpm(sequence_get_bpm() + val);
             break;
         }
 
         case UI_MODE: {
-            // TODO
+            machine_mode = (machine_mode + val) % MACHINE_NUM_MODES;
             break;
         }
 
         case UI_LENGTH: {
-            // TODO
+            sequence_set_beats(sequence_get_beats() + val);
             break;
         }
 
         case UI_BANK: {
-            // TODO
+            sequence_set_bank(sequence_get_bank() + val);
             break;
         }
 
             printf("%s: invalid mode: %d\n", __func__, ui_mode);
             ui_mode = 0;
             ui_encoder(val);
-            break;
+            return;
         }
     }
+
+    ui_redraw();
 }
 
 void ui_init(void) {
     buttons_callback(ui_buttons);
     ui_redraw();
 }
+
+void ui_run(void) {
+    uint32_t now = to_ms_since_boot(get_absolute_time());
+    if (now >= (last_redraw + REDRAW_MS)) {
+        ui_redraw();
+        last_redraw = now;
+    }
+}