Sonidos en formato wav, sensores análógicos y digitales

Código de ejemplo

Código ChucK

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/*
 * @file digitalSensors.ck
 * @brief Permite capturar dese el puerto serial diferentes lecturas
 *  de sensores digitales e interpretar desde ChucK.
 * @author: Johnny Cubides
 * contact: catalejoeducacion@gmail.com, jgcubidesc@gmail.com
 * date: Oct 03, 2018
 * license: GPL
 */
//*********** CONFIGURACION PUERTO SERIAL *****************
<<<"Listando puertos seriales">>>;
SerialIO.list() @=> string list[];
for(int i; i < list.size(); i++){
   <<< i, ":", list[i] >>>;
}
<<<"Iniciando puerto serial">>>;
SerialIO arduinoCom;
//Seleccionar el puerto serial de interés
//con el índice de la lista anterior
arduinoCom.open(0, SerialIO.B9600, SerialIO.ASCII);

Gain master => dac;

//*********** CONFIGURACION INSTRUMENTO NOTAS MIDI *******
3 => int MAX_DIGITAL_SENSOR;
SinOsc osc[MAX_DIGITAL_SENSOR];
//Los siguientes 2 arregos corresponden a la posición decada sensor,
//en éste ejemplo son tres sensores que tienen asociadas 3 notas con
//su respectivo volumen.
[60 ,  61,  62] @=> int midi[];
[0.5, 0.5, 0.5] @=> float volumen[];

for(0 => int i; i< MAX_DIGITAL_SENSOR; i++)
{
    osc[i] => master;
    midi[i] => Std.mtof => osc[i].freq;
    0 => osc[i].gain;
}
50::ms => dur myTime; // Cada cuanto se actualizarán los sonidos

//********** CONFIGURACION DE SONIDOS WAV *****************
2 => int MAX_PUSH_SENSOR;
SndBuf wav[MAX_PUSH_SENSOR];
[
"kick_1.wav",
"acoustic_ride_cymbal.wav"
] @=> string audios[];
for(0 => int i; i< MAX_PUSH_SENSOR; i++)
{
    me.dir()+audios[i] => wav[i].read;
    wav[i] => master;
}
1000::ms => dur myTimeWav; // Cada cuanto se actualizarán los sonidos

// Variables
string line; // Guarda los valores recogidos por el puerto serial
0 => int valueDigital; // Guarda el valor de los sensores digitales
0 => int valuePush; //Elementos a presionar

fun void readSerial()
{

    <<<"ok">>>;
    while(true)
    {
        arduinoCom.onLine() => now;
        arduinoCom.getLine() => line;
        //<<<line>>>;
        if(line == "D")
        {
            arduinoCom.onLine() => now;
            arduinoCom.getLine() => line;
            while(line == ""){
                arduinoCom.onLine() => now;
                arduinoCom.getLine() => line;
            }
            Std.atoi(line) => valueDigital;
            //<<<line>>>;
        }else if(line == "P")
        {
            arduinoCom.onLine() => now;
            arduinoCom.getLine() => line;
            while(line == ""){
                arduinoCom.onLine() => now;
                arduinoCom.getLine() => line;
            }
            Std.atoi(line) => valuePush;
            //<<<line>>>;
        }
    }
}

fun void playDigitalSond()
{
    while(true)
    {
        for(0 => int i; i< MAX_DIGITAL_SENSOR; i++)
        {
            volumen[i]*(valueDigital & (1 << i)) => osc[i].gain;
        }
        myTime => now;
    }
}

fun void playWavSond()
{
    while(true)
    {
        for(0 => int i; i< MAX_PUSH_SENSOR; i++)
        {
            if(valuePush & (1 << i))
                0 => wav[i].pos;
        }
        myTimeWav => now;
    }
}

spork ~ readSerial();
spork ~ playDigitalSond();
spork ~ playWavSond();

while(true) 1::second => now;

Código Arduino

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
/*
 * @file digital_reads.ino
 * @brief Permite hacer diferentes lecturas digitales optimizandolas y
 *  enviándolas por puerto serial
 * @author: Johnny Cubides
 * contact: catalejoeducacion@gmail.com, jgcubidesc@gmail.com
 * date: Oct 02, 2018
 * license: GPL
 *
 * Peso dado a cada sensor
 * 128
 * |64
 * ||32
 * |||16
 * ||||8421
 * ||||||||
 * 76543210 --> Posición de cada sensor
 * ||||||||_ primer sensor
 * |||||||__ segundo sensor
 * ||||||___ tercer sensor
 * |||||____ Cuarto sensor
 * ||||_____ Quinto sensor
 * |||______ Sexto sensor
 * ||_______ Séptimo sensor
 * |________ Octavo sensor
 *
 * Por cada sensor actico, (un uno lógico), al digital_value se suma un peso.
 * Ejemplo:
 *  pimer sensor activo         --> digital_value = 1
 *  segundo sensor activo       --> digital_value = 2
 *  tercer sensor activo        --> digital_value = 4
 *  los tres sensores activos   --> digital_value = 4+2+1 = 7
 *  Ocho sensores activos       --> digital_value = 128+64+32+16+8+4+2+1 = 255
 * Nota:
 *  No hay ninguna combinación que permita obtener el mismo resultado, es así
 *  que se puede distinguir qué sensor o qué sensores están activos.
 */
// Máxima cantidad de sensores analógicos a conectar
#define MAX_DIGITAL_SENSOR 3 //Poner la cantidad que usted vaya a usar
// Máxima cantidad de sensores analógicos a conectar
#define MAX_ANALOG_SENSORS 2 //Poner la cantidad de sensores que usted vaya a usar
#define BAUDRATE 9600 //9600 o 115200
#define DELAY 1 //Tiempo en milisegundos
#define INITIAL 0

//
struct Analog2Digital_Sensor{
    unsigned int pin_number[MAX_ANALOG_SENSORS]; //A0, A1, A2...
    unsigned int value_analog[MAX_ANALOG_SENSORS];
    bool logic[MAX_ANALOG_SENSORS]; //Lógica del sensor 0->Positiva, 1->Negativa
    unsigned int threshold[MAX_ANALOG_SENSORS];
    unsigned int digital_value; //All array
    unsigned int digital_value_old; // All array
};

struct Analog2Digital_Sensor analog2digital_sensor = {
    {A0, A1},
    {INITIAL, INITIAL},
    {0,  0}, // 0->lógica positiva, 1-> lógica negativa
    {100, 200}, // umbral[0, 1023]
    INITIAL,
    INITIAL
};

bool *logic;
unsigned int *threshold, *digital_value, *digital_value_old, *value_analog;

// Definición de sensores: pin, valor digital, valor digital antiguo
struct Digital_Sensor{
    int pin_number[MAX_DIGITAL_SENSOR];
    bool logic[MAX_DIGITAL_SENSOR];
    int digital_value;
    int digital_value_old;
};

// Creación de sensores digitales; tenga en cuenta la lógica del sensor
struct Digital_Sensor digital_sensors = {
    // Poner el número de pin de los sensores según el orden que usted haya
    // establecido; la cantidad de pines debe coincidir con el MAX_DIGITAL_SENSOR.
    {2, 3, 4}, //ejemplo:{pin_arduino, pin_arduino, pin_number
    {0, 0, 0}, //Lógica de cada pin ↑ : 0 -> positiva; 1 -> negativa, la posición corresponde al pin_arduino
    INITIAL, //Puede siempre iniciar en 0
    INITIAL  //Puede siempre iniciar en 0
};



// Convierte analogo a digital y envía dato
// el switch, se refiere a que debe ser pulsado para
// intercambiar estado, si no se hace, permanece en el último estado
void send_analog_2_digital_push_button(void);

// Enviar lecturas digitales
void send_digital_readings(void);

void setup()
{
    // Configuración de pines como entradas de información de sensores
    for(int i=0; i < MAX_DIGITAL_SENSOR; i++)
    {
        pinMode(digital_sensors.pin_number[i], INPUT);
    }
    // Velocidad de comunicación con el PC
    Serial.begin(BAUDRATE);
}

// Ejecución de programa principal
void loop()
{
    send_digital_readings();
    send_analog_2_digital_push_button();
}

void send_digital_readings(void)
{
    // Lectura de sensores digitales
    for (int i = 0; i < MAX_DIGITAL_SENSOR; i++)
    {
       digital_sensors.digital_value |= ((int)(digital_sensors.logic[i]^digitalRead(digital_sensors.pin_number[i])))<<i;
    }
    // Envío de lectura digital
    if(digital_sensors.digital_value != digital_sensors.digital_value_old){
        // Si tiene solo éstas entradas digitales, puede omitir la siguiente línea comentandola
        Serial.println("D");
        // Enviando el valor de los sensores digitales
        Serial.println(digital_sensors.digital_value);
        digital_sensors.digital_value_old = digital_sensors.digital_value;
    }
    // Fin de transmisión de un paquete
    digital_sensors.digital_value = 0;
    delay(DELAY);
}

void send_analog_2_digital_push_button(void)
{
    for (int i = 0; i < MAX_ANALOG_SENSORS; i++)
    {
        analog2digital_sensor.value_analog[i] = analogRead(analog2digital_sensor.pin_number[i]);
    }
    for (int i = 0; i < MAX_ANALOG_SENSORS; i++)
    {
        logic = &analog2digital_sensor.logic[i];
        threshold = &analog2digital_sensor.threshold[i];
        value_analog = &analog2digital_sensor.value_analog[i];
        analog2digital_sensor.digital_value |= ((int)(*logic^((*value_analog > *threshold)?1:0)))<<i;
    }
    // Envío de lectura digital
    if(analog2digital_sensor.digital_value != analog2digital_sensor.digital_value_old){
        // Si tiene solo éstas entradas digitales, puede omitir la siguiente línea comentandola
        Serial.println("P");
        // Enviando el valor de los sensores digitales
        Serial.println(analog2digital_sensor.digital_value);
        analog2digital_sensor.digital_value_old = analog2digital_sensor.digital_value;
    }
    // Fin de transmisión de un paquete
    analog2digital_sensor.digital_value = 0;
    delay(DELAY);
}