cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/faust/gui/Esp32ControlUI.h

@@ -0,0 +1,341 @@
+/************************** BEGIN Esp32ControlUI.h ************************
+ FAUST Architecture File
+ Copyright (C) 2003-2022 GRAME, Centre National de Creation Musicale
+ ---------------------------------------------------------------------
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+ 
+ You should have received a copy of the GNU Lesser General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ 
+ EXCEPTION : As a special exception, you may create a larger work
+ that contains this FAUST architecture section and distribute
+ that work under terms of your choice, so long as this FAUST
+ architecture section is not modified.
+ *************************************************************************/
+
+#ifndef FAUST_ESP32CONTROL_H
+#define FAUST_ESP32CONTROL_H
+
+#include <string>
+#include <stdio.h>
+#include <vector>
+#include <string.h>
+
+#include "driver/uart.h"
+
+#include "faust/gui/DecoratorUI.h"
+#include "faust/gui/ValueConverter.h"
+
+/*******************************************************************************
+ * Esp32ControlUI : Faust User Interface
+ * This class handles Gramophone controllers
+ ******************************************************************************/
+
+// Value converter using a low-pass filter
+class FilteredConverter : public ConverterZoneControl
+{
+    
+    private:
+    
+        /*
+         Generated with:
+         
+            process = si.smooth(tau2pole(T60))
+            with {
+                SR = 100;   // Control rate is 100 Hz
+                T60 = hslider("T60", 0.2, 0, 1, 0.01);
+                tau2pole(tau) = exp(-1.0/(tau*SR));
+            };
+        */
+    
+        // Template used to specialize double parameters expressed as NUM/DENOM
+        template <int NUM, int DENOM>
+        struct Double {
+            static constexpr double value() { return double(NUM)/double(DENOM); }
+        };
+
+        /*
+        // Templated filter with T60 expressed as NUM/DENOM
+        template <class fVslider0, typename REAL>
+        struct CtrlFilter {
+            
+            float fRec0[2];
+            
+            CtrlFilter()
+            {
+                for (int l0 = 0; (l0 < 2); l0 = (l0 + 1)) {
+                    fRec0[l0] = 0.0f;
+                }
+            }
+            
+            FAUSTFLOAT compute(FAUSTFLOAT input0)
+            {
+                // Computed at compile time
+                REAL fSlow0 = std::exp((0.0f - (0.00999999978f / REAL(fVslider0::value()))));
+                REAL fSlow1 = (1.0f - fSlow0);
+                // Computed at runtime
+                fRec0[0] = ((fSlow0 * fRec0[1]) + (fSlow1 * REAL(input0)));
+                FAUSTFLOAT output0 = FAUSTFLOAT(fRec0[0]);
+                fRec0[1] = fRec0[0];
+                return output0;
+            }
+            
+        };
+    
+        // T60 = 2/10 = 0.2s
+        CtrlFilter<Double<2,10>, double> fFilter;
+        */
+    
+    
+        /*
+         Generated with:
+         process = _ <: (_,@(delay)) : - : + ~ _ : /(delay);
+         */
+    
+        template <int fHslider0>
+        struct CtrlFilter {
+            
+            int IOTA;
+            float fVec0[128];
+            float fRec0[2];
+            
+            CtrlFilter()
+            {
+                IOTA = 0;
+                for (int l0 = 0; (l0 < 128); l0 = (l0 + 1)) {
+                    fVec0[l0] = 0.0f;
+                }
+                for (int l1 = 0; (l1 < 2); l1 = (l1 + 1)) {
+                    fRec0[l1] = 0.0f;
+                }
+            }
+            
+            FAUSTFLOAT compute(FAUSTFLOAT input0)
+            {
+                float fSlow0 = float(fHslider0);
+                float fSlow1 = (1.0f / fSlow0);
+                int iSlow2 = int(fSlow0);
+                float fTemp0 = float(input0);
+                fVec0[(IOTA & 127)] = fTemp0;
+                fRec0[0] = ((fTemp0 + fRec0[1]) - fVec0[((IOTA - iSlow2) & 127)]);
+                FAUSTFLOAT output0 = FAUSTFLOAT((fSlow1 * fRec0[0]));
+                IOTA = (IOTA + 1);
+                fRec0[1] = fRec0[0];
+                return output0;
+            }
+            
+        };
+
+        CtrlFilter<10> fFilter;
+    
+    public:
+    
+        FilteredConverter(FAUSTFLOAT* zone,
+                          ValueConverter* converter)
+        : ConverterZoneControl(zone, converter) {}
+        virtual ~FilteredConverter() {}
+    
+        void update(double v)
+        {
+            *fZone = fValueConverter->ui2faust(fFilter.compute(FAUSTFLOAT(v)));
+        }
+    
+};
+
+// To be used with Gramophone
+class Esp32ControlUI : public GenericUI
+{
+    
+    private:
+    
+        std::vector<FilteredConverter*> fKnob1Converter;
+        std::vector<FilteredConverter*> fKnob2Converter;
+        std::vector<FilteredConverter*> fKnob3Converter;
+    
+        std::vector<FAUSTFLOAT*> fPushButton;
+        std::vector<FAUSTFLOAT*> fCheckButton;
+        int fLastButton;
+    
+        std::string fKey, fValue;
+    
+        TaskHandle_t fProcessHandle;
+    
+        void update()
+        {
+            while (true) {
+                
+                // Knob 1
+                if (fKnob1Converter.size() > 0) {
+                    int val = adc1_get_raw(ADC1_CHANNEL_7);
+                    for (int i = 0; i < fKnob1Converter.size(); i++) {
+                        fKnob1Converter[i]->update(double(val));
+                    }
+                }
+                
+                // Knob 2
+                if (fKnob2Converter.size() > 0) {
+                    int val = adc1_get_raw(ADC1_CHANNEL_4);
+                    for (int i = 0; i < fKnob2Converter.size(); i++) {
+                        fKnob2Converter[i]->update(double(val));
+                    }
+                }
+                
+                // Photores
+                if (fKnob3Converter.size() > 0) {
+                    int val = adc1_get_raw(ADC1_CHANNEL_6);
+                    for (int i = 0; i < fKnob3Converter.size(); i++) {
+                        fKnob3Converter[i]->update(double(val));
+                    }
+                }
+                
+                // Button considered as a push button
+                if (fPushButton.size() > 0) {
+                    int button = gpio_get_level(GPIO_NUM_14);
+                    for (int i = 0; i < fPushButton.size(); i++) {
+                        *fPushButton[i] = FAUSTFLOAT(button);
+                    }
+                }
+                
+                // Button considered as a checkbox
+                if (fCheckButton.size() > 0) {
+                    int button = gpio_get_level(GPIO_NUM_14);
+                    for (int i = 0; i < fCheckButton.size(); i++) {
+                        if ((button == 1) && (button != fLastButton)) {
+                            // Upfront detected
+                            *fCheckButton[i] = !(*fCheckButton[i]);
+                        }
+                        fLastButton = button;
+                    }
+                }
+                
+                /*
+                int encoder_button = gpio_get_level(GPIO_NUM_15);
+                int encoder_dt = gpio_get_level(GPIO_NUM_4);
+                int encoder_clk = gpio_get_level(GPIO_NUM_13);
+                
+                int encoder_status;
+                if (encoder_button == 0) {
+                    encoder_status = encoder_dt;
+                } else {
+                    encoder_status = encoder_clk;
+                }
+                
+                std::cout << "encoder_button " << encoder_button << std::endl;
+                std::cout << "encoder_dt " << encoder_dt << std::endl;
+                std::cout << "encoder_clk " << encoder_clk << std::endl;
+                std::cout << "encoder_status " << encoder_status << std::endl;
+                */
+                
+                vTaskDelay(10 / portTICK_PERIOD_MS);
+            }
+        }
+    
+        static void updateHandler(void* arg)
+        {
+            static_cast<Esp32ControlUI*>(arg)->update();
+        }
+    
+    public:
+        
+        Esp32ControlUI():fLastButton(0), fProcessHandle(nullptr)
+        {
+            adc1_config_width(ADC_WIDTH_BIT_12);
+            adc1_config_channel_atten(ADC1_CHANNEL_7,ADC_ATTEN_DB_11);
+            adc1_config_channel_atten(ADC1_CHANNEL_4,ADC_ATTEN_DB_11);
+            adc1_config_channel_atten(ADC1_CHANNEL_6,ADC_ATTEN_DB_11);
+            gpio_config_t io_conf;
+            io_conf.intr_type = (gpio_int_type_t) GPIO_PIN_INTR_POSEDGE;
+            io_conf.pin_bit_mask = ((1ULL<<4) | (1ULL<<13) | (1ULL<<14) | (1ULL<<15));
+            io_conf.mode = GPIO_MODE_INPUT;
+            io_conf.pull_up_en = (gpio_pullup_t)1;
+            gpio_config(&io_conf);
+        }
+    
+        virtual ~Esp32ControlUI()
+        {
+            for (const auto& it : fKnob1Converter) delete it;
+            for (const auto& it : fKnob2Converter) delete it;
+            for (const auto& it : fKnob3Converter) delete it;
+            stop();
+        }
+    
+        bool start()
+        {
+            // Start Controller receive task
+            return (xTaskCreatePinnedToCore(updateHandler, "Faust Controller Task", 4096, (void*)this, 5, &fProcessHandle, 1) == pdPASS);
+        }
+    
+        void stop()
+        {
+            if (fProcessHandle != nullptr) {
+                vTaskDelete(fProcessHandle);
+                fProcessHandle = nullptr;
+            }
+        }
+    
+        // -- active widgets
+        void addButton(const char* label, FAUSTFLOAT* zone)
+        {
+            if (fKey == "switch") {
+                fprintf(stdout, "addButton\n");
+                fPushButton.push_back(zone);
+            }
+            fValue = fKey = "";
+        }
+        void addCheckButton(const char* label, FAUSTFLOAT* zone)
+        {
+            if (fKey == "switch") {
+                fprintf(stdout, "addCheckButton\n");
+                fCheckButton.push_back(zone);
+            }
+            fValue = fKey = "";
+        }
+        void addVerticalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+        {
+            addNumEntry(label, zone, init, min, max, step);
+        }
+        void addHorizontalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+        {
+            addNumEntry(label, zone, init, min, max, step);
+        }
+        void addNumEntry(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+        {
+            if (fKey == "knob") {
+                if (fValue == "1") {
+                    fprintf(stdout, "knob1 %f %f\n", min, max);
+                    fKnob1Converter.push_back(new FilteredConverter(zone, new LinearValueConverter(0., 4095., min, max)));
+                } else if (fValue == "2") {
+                    fprintf(stdout, "knob2 %f %f\n", min, max);
+                    fKnob2Converter.push_back(new FilteredConverter(zone, new LinearValueConverter(0., 4095., min, max)));
+                } else if (fValue == "3") {
+                    fprintf(stdout, "knob3 %f %f\n", min, max);
+                    // This control does not use the full range of [0 4095]
+                    fKnob3Converter.push_back(new FilteredConverter(zone, new LinearValueConverter(2700., 4095., min, max)));
+                }
+            }
+            fValue = fKey = "";
+        }
+    
+        // -- metadata declarations
+        void declare(FAUSTFLOAT* zone, const char* key, const char* val)
+        {
+            if (strcmp(key, "switch") == 0 || strcmp(key, "knob") == 0) {
+                fprintf(stdout, "key %s val %s\n", key, val);
+                fKey = key;
+                fValue = val;
+            }
+        }
+    
+};
+
+#endif // FAUST_ESP32CONTROL_H
+/**************************  END  Esp32ControlUI.h **************************/

cyfaust/resources/architecture/faust/gui/Esp32Reader.h

@@ -0,0 +1,102 @@
+/************************** BEGIN Esp32Reader.h **************************
+ FAUST Architecture File
+ Copyright (C) 2003-2022 GRAME, Centre National de Creation Musicale
+ ---------------------------------------------------------------------
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+ 
+ You should have received a copy of the GNU Lesser General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ 
+ EXCEPTION : As a special exception, you may create a larger work
+ that contains this FAUST architecture section and distribute
+ that work under terms of your choice, so long as this FAUST
+ architecture section is not modified.
+ *************************************************************************/
+
+#ifndef FAUST_ESP32READER_H
+#define FAUST_ESP32READER_H
+
+#include <stdio.h>
+#include "esp_err.h"
+#include "esp_log.h"
+#include "esp_spi_flash.h"
+#include "esp_vfs_fat.h"
+#include "driver/sdspi_host.h"
+#include "sdmmc_cmd.h"
+
+#include "faust/gui/WaveReader.h"
+
+#define TAG "Esp32Reader"
+
+#define SD_PIN_NUM_MISO GPIO_NUM_2
+#define SD_PIN_NUM_MOSI GPIO_NUM_15
+#define SD_PIN_NUM_CLK  GPIO_NUM_14
+#define SD_PIN_NUM_CS   GPIO_NUM_13
+
+struct Esp32Reader : public WaveReader {
+    
+    void sdcard_init()
+    {
+        ESP_LOGI(TAG, "Initializing SD card");
+        ESP_LOGI(TAG, "Using SPI peripheral");
+        
+        sdmmc_host_t host = SDSPI_HOST_DEFAULT();
+        sdspi_slot_config_t slot_config = SDSPI_SLOT_CONFIG_DEFAULT();
+        slot_config.gpio_miso = SD_PIN_NUM_MISO;
+        slot_config.gpio_mosi = SD_PIN_NUM_MOSI;
+        slot_config.gpio_sck  = SD_PIN_NUM_CLK;
+        slot_config.gpio_cs   = SD_PIN_NUM_CS;
+        // This initializes the slot without card detect (CD) and write protect (WP) signals.
+        // Modify slot_config.gpio_cd and slot_config.gpio_wp if your board has these signals.
+        
+        // Options for mounting the filesystem.
+        // If format_if_mount_failed is set to true, SD card will be partitioned and
+        // formatted in case when mounting fails.
+        esp_vfs_fat_sdmmc_mount_config_t mount_config = {
+            .format_if_mount_failed = false,
+            .max_files = 5,
+            .allocation_unit_size = 16 * 1024
+        };
+        
+        // Use settings defined above to initialize SD card and mount FAT filesystem.
+        // Note: esp_vfs_fat_sdmmc_mount is an all-in-one convenience function.
+        // Please check its source code and implement error recovery when developing
+        // production applications.
+        sdmmc_card_t* card;
+        esp_err_t ret = esp_vfs_fat_sdmmc_mount("/sdcard", &host, &slot_config, &mount_config, &card);
+        
+        if (ret != ESP_OK) {
+            if (ret == ESP_FAIL) {
+                ESP_LOGE(TAG, "Failed to mount filesystem. "
+                         "If you want the card to be formatted, set format_if_mount_failed = true.");
+            } else {
+                ESP_LOGE(TAG, "Failed to initialize the card (%s). "
+                         "Make sure SD card lines have pull-up resistors in place.", esp_err_to_name(ret));
+            }
+            return;
+        }
+        
+        // Card has been initialized, print its properties
+        sdmmc_card_print_info(stdout, card);
+        ESP_LOGI(TAG, "SD card initialized");
+    }
+    
+    Esp32Reader()
+    {
+        sdcard_init();
+    }
+   
+    // Access methods inherited from WaveReader
+};
+
+#endif // FAUST_ESP32READER_H
+/**************************  END  Esp32Reader.h **************************/

cyfaust/resources/architecture/faust/gui/Esp32SensorUI.h

@@ -0,0 +1,137 @@
+/************************** BEGIN Esp32SensorUI.h ************************
+ FAUST Architecture File
+ Copyright (C) 2003-2022 GRAME, Centre National de Creation Musicale
+ ---------------------------------------------------------------------
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+ 
+ You should have received a copy of the GNU Lesser General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ 
+ EXCEPTION : As a special exception, you may create a larger work
+ that contains this FAUST architecture section and distribute
+ that work under terms of your choice, so long as this FAUST
+ architecture section is not modified.
+ *************************************************************************/
+
+
+#ifndef FAUST_ESP32SENSOR_H
+#define FAUST_ESP32SENSOR_H
+
+#include <string>
+#include <stdio.h>
+#include <string.h>
+
+#include "driver/uart.h"
+#include "MPU9250.h"
+
+#include "faust/gui/APIUI.h"
+
+#define ONE_G 9.81
+
+// To be used with Gramophone for accelerometer, gyroscope and magnetometer
+class Esp32SensorUI : public APIUI
+{
+    private:
+    
+        TaskHandle_t fProcessHandle;
+        MPU9250 fMPU9250;
+        bool fHasAcc, fHasGyr, fHasMag;
+    
+        void sensor()
+        {
+            while (true) {
+                
+                if (fHasAcc) {
+                    fMPU9250.accelUpdate();
+                    propagateAcc(0, fMPU9250.accelX() * ONE_G);
+                    propagateAcc(1, fMPU9250.accelY() * ONE_G);
+                    propagateAcc(2, fMPU9250.accelZ() * ONE_G);
+                    /*
+                    std::cout << "======================" << std::endl;
+                    std::cout << "accelX " << fMPU9250.accelX() << std::endl;
+                    std::cout << "accelY " << fMPU9250.accelX() << std::endl;
+                    std::cout << "accelZ " << fMPU9250.accelZ() << std::endl;
+                    */
+                }
+                
+                if (fHasGyr) {
+                    fMPU9250.gyroUpdate();
+                    propagateGyr(0, fMPU9250.gyroX());
+                    propagateGyr(1, fMPU9250.gyroY());
+                    propagateGyr(2, fMPU9250.gyroZ());
+                    /*
+                    std::cout << "======================" << std::endl;
+                    std::cout << "gyroX " << fMPU9250.gyroX() << std::endl;
+                    std::cout << "gyroY " << fMPU9250.gyroY() << std::endl;
+                    std::cout << "gyroZ " << fMPU9250.gyroZ() << std::endl;
+                    */
+                }
+                
+                /*
+                if (fHasMag) {
+                    fMPU9250.magUpdate();
+                    propagateMag(0, fMPU9250.magX());
+                    propagateMag(1, fMPU9250.magY());
+                    propagateMag(2, fMPU9250.magZ());
+                    propagateMag(2, fMPU9250.magHorizDirection());
+                }
+                */
+                
+                vTaskDelay(5 / portTICK_PERIOD_MS);
+            }
+        }
+    
+        static void sensorHandler(void* arg)
+        {
+            static_cast<Esp32SensorUI*>(arg)->sensor();
+        }
+    
+    public:
+    
+        Esp32SensorUI():fProcessHandle(nullptr),
+        fMPU9250(MPU9250_ADDRESS_AD0_HIGH),
+        fHasAcc(false),
+        fHasGyr(false),
+        fHasMag(false)
+        {}
+    
+        bool start()
+        {
+            fHasAcc = (getAccCount(0) > 0) || (getAccCount(1) > 0) || (getAccCount(2) > 0);
+            fHasGyr = (getGyrCount(0) > 0) || (getGyrCount(1) > 0) || (getGyrCount(2) > 0);
+            
+            fprintf(stdout, "fHasAcc %d\n", fHasAcc);
+            fprintf(stdout, "fHasGyr %d\n", fHasGyr);
+            
+            if (fHasAcc) fMPU9250.beginAccel();
+            if (fHasGyr) fMPU9250.beginGyro();
+            if (fHasMag) fMPU9250.beginMag();
+            if (fHasAcc || fHasGyr || fHasMag) {
+                // Start Sensor receive task
+                return (xTaskCreatePinnedToCore(sensorHandler, "Faust Sensor Task", 10240, (void*)this, 5, &fProcessHandle, 1) == pdPASS);
+            } else {
+                return true;
+            }
+        }
+    
+        void stop()
+        {
+            if (fProcessHandle != nullptr) {
+                vTaskDelete(fProcessHandle);
+                fProcessHandle = nullptr;
+            }
+        }
+    
+};
+
+#endif // FAUST_ESP32CONTROL_H
+/**************************  END  Esp32SensorUI.h **************************/