Interpretando sensores analógicos en ChucK desde Arduino

Montajes

Lectura de Potenciometro

../_images/potenciometer_bb.png

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
/*
 * @file analogSensors.ck
 * @brief Permite capturar dese el puerto serial diferentes lecturas
 *  de sensores analógicos 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);

3 => int MAX_ANALOG_SENSOR; //Cantidad de sensores
3 => int MAX_OSCILATORS; //Cantidad de osciladores simultaneos a usar

//Creación de osciladores
SinOsc osc_a[MAX_OSCILATORS];
[60 ,  61,  62] @=> int midi_a[]; //Corresponde a la cantidad de osciladores a controlar
[0.5, 0.5, 0.5] @=> float volumen_a[]; //Corresponde a la cantidad de osiladores a controlar

//Iniciación de osciladores
for(0 => int i; i< MAX_OSCILATORS; i++)
{
    osc_a[i] => dac;
    midi_a[i] => Std.mtof => osc_a[i].freq;
    0 => osc_a[i].gain;
}

// Variables
string line; // Guarda los valores recogidos por el puerto serial
//el siguiente arreglo debe coincidir con el numbre y la cantidad
//de identificadores para los sensores
["S1", "S2", "S3"]@=> string analogSensors[];
int valueAnalogSensors[MAX_ANALOG_SENSOR]; // Guarda el valor de los sensores
50::ms => dur myTime; // Cada cuanto se actualizarán los sonidos

fun void readSerial()
{
    while(true)
    {
        arduinoCom.onLine() => now;
        arduinoCom.getLine() => line;
        for(0=>int i; i < MAX_ANALOG_SENSOR; i++)
        {
            if(line == analogSensors[i])
            {
                arduinoCom.onLine() => now;
                arduinoCom.getLine() => line;
                Std.atoi(line) => valueAnalogSensors[i];
                break;
            }
        }
    }
}

fun void playSond()
{
    while(true)
    {
        valueAnalogSensors[0] => osc_a[0].freq;
        0.1 => osc_a[0].gain;
        myTime => now;
    }
}

spork ~ readSerial();
spork ~ playSond();

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
/*
 * @file analog_reads.ino
 * @brief Permite hacer diferentes lecturas análogas
 *  enviándolas por puerto serial
 * @author: Johnny Cubides
 * contact: catalejoeducacion@gmail.com, jgcubidesc@gmail.com
 * date: Oct 02, 2018
 * license: GPL
 */
// Máxima cantidad de sensores analógicos a conectar
#define MAX_SENSORS_ANALOG 2 //Poner la cantidad de sensores que usted vaya a usar
#define BAUDRATE 9600 //9600 o 115200
#define DELAY 10 //Tiempo en milisegundos
#define INITIAL 0

// Definición del sensor: nombre, pin, valor análogo
struct Analog_Sensor{
    String sensor_name;
    int pin_number;     //A0, A1, A2...
    int sensitivity;    //sensible [0,1,2,3,4,5,6...]insensible
    int analog_value;
    int analog_value_old;
};

//Punteros
String *sensor_name;
int *analog_sensitivity, *analog_value, *analog_value_old;

// Total de sensores máximo 6 para arduino UNO del A0 al A5
struct Analog_Sensor analog_sensors[MAX_SENSORS_ANALOG] = {
    // La cantidad de sensores a declarar debe coincidir con
    // el número indicado en MAX_SENSORS_ANALOG
    {"S1", A0, 0, INITIAL, INITIAL}, //{"identificador", pin_arduino, senbilidad, valor_inicial, valor_inicial}
    {"S2", A1, 6, INITIAL, INITIAL}, //{"identificador", pin_arduino, senbilidad, valor_inicial, valor_inicial}
};

// Enviar lecturas analogas
void send_analog_readings(void);

void setup()
{
    // Velocidad de comuicación con el PC
    Serial.begin(BAUDRATE);
}

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

void send_analog_readings(void)
{
    // Lectura de sensores analógicos
    for (int i = 0; i < MAX_SENSORS_ANALOG; i++)
    {
       analog_sensors[i].analog_value = analogRead(analog_sensors[i].pin_number);
    }
    // Envío de lecturas analógcas
    for (int i = 0; i < MAX_SENSORS_ANALOG; i++)
    {
        //única búsqueda y direccionamiento a punteros
        sensor_name = &analog_sensors[i].sensor_name;
        analog_value = &analog_sensors[i].analog_value;
        analog_value_old = &analog_sensors[i].analog_value_old;
        analog_sensitivity = &analog_sensors[i].sensitivity;
        //Para manejo de sensibilidad descomente éste if y comente el siguiente if
        if((*analog_value < *analog_value_old-*analog_sensitivity)||(*analog_value > *analog_value_old+*analog_sensitivity))
        //Sin manejo de sensibilidad descomente éste if y comente el anterior if
        //if(*analog_value != *analog_value_old)
        {
            Serial.println(*sensor_name);
            Serial.println(*analog_value);
            *analog_value_old = *analog_value;
        }
    }
    // Fin de transmisión de un paquete
    delay(DELAY);
}