Ciao e grazie per le dritte, sono andato un po' avanti ed al 70% ho otttenuto quello che volevo. per il restante 25% torno a chiedervi un aiuto, cosi poi da potervi mostrare il lavoro finito anche dal punto di vista dell'Hardware.
Ora riesco ad inviare quello che voglio con un pulsante , scegliendo COSA mandare nei due stati del pulsante(pressione e rilascio) fin qui tutto straordianriamente benissimo.
Ora sto cercando di applicare la stessa logica/procedura per gestire, attraverso dei potenziomentri, dei faders all'interno del mio software luci, e questo non mi funziona; ora esistono giĂ degli sketch che fanno questo in maniera eccellete, ma facendo il "merge" di questi sketch con il mio, non funzionano bene.
Per cui avevo pensato di gestire questi fader digitali facendo mandare un messaggio osc dal potenziometro hardware. Ovviamente non ci sono ancora riuscito.
Se qualcuno potesse darmi qualche dritta vi sarei molto grato.
di seguito trovate lo sketch ed anche un commento sull'errore nella procedura della lettura analogRead.
/**************************************************************************************************************
Includes
*************************************************************************************************************/
int Pin_A7 = 54;
int Pin_A8 = 55;
int Pin_A9 = 56;
int Pin_A10 = 57;
int Pin_A11 = 58;
int Pin_A12 = 59;
int Pin_A13 = 60;
int Pin_A14 = 61;
int Pin_A15 = 62;
#include <OSCBoards.h>
//#include "Arduino.h"
#include <OSCBundle.h>
#include <OSCData.h>
#include <OSCMatch.h>
#include <OSCMessage.h>
#include <OSCTiming.h>
#ifdef BOARD_HAS_USB_SERIAL
#include <SLIPEncodedUSBSerial.h>
SLIPEncodedUSBSerial SLIPSerial(thisBoardsSerialUSB);
#else
#include <SLIPEncodedSerial.h>
SLIPEncodedSerial SLIPSerial(Serial);
#endif
#include <string.h>
/**************************************************************************************************************
Macro e Costanti
*************************************************************************************************************/
#define PING_AFTER_IDLE_INTERVAL 2500
#define TIMEOUT_AFTER_IDLE_INTERVAL 5000
const String HANDSHAKE_QUERY = "ETCOSC?";
const String HANDSHAKE_REPLY = "OK";
/**************************************************************************************************************
Variabili Globali
**************************************************************************************************************/
bool connectedToEos = false;
unsigned long lastMessageRxTime = 0;
bool timeoutPingSent = false;
/**************************************************************************************************************
Setup Pin digitali Arduino creiamo array secondo l'ordine in cui li vogliamo, non confondere il numero del
"pin" con il numero totale dei pin da definire
*************************************************************************************************************/
int faderpins[7] = {
A0, A1, A2, A3, A4, A5, A6,
};
int buttonPins[21] =
{
2, // SUB 751
3, // SUB 752
4, // SUB 753
5, // SUB 754
6, // SUB 755
7, // SUB 756
8, // SUB 757
9, 22, // Q22/1 - Q22/2
10, 21, // Q22/9 - Q22/10
11, 20, // Q22/4 - Q22/13
12, 19, // Q22/1 - Q22/18
13, 18, // 3
14, 17, // 4
15, 16, // 5
};
/**************************************************************************************************************
Stato Pin (la quantitĂ deve corrispondere al numero dei pin)
inizializza tutti gli stati dei pulsanti come up con un array(si poteva scrivere anche true al posto di 1)
*************************************************************************************************************/
bool faderState[7] =
{
0, 0, 0, 0, 0, 0, 0,
};
bool buttonState[21] =
{
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1,
};
/**************************************************************************************************************
Scriviamo i messaggi OSC che vogliamo mandare alla pressione del pulsante, stesso ordine in cui abbiamo
elencato i pin.
*************************************************************************************************************/
const String faderMove[7] = {
"eos/fader/1/1",
"eos/fader/1/2",
"eos/fader/1/3",
"eos/fader/1/3",
"eos/fader/1/4",
"eos/fader/1/5",
"eos/fader/1/6",
};
const String buttonDowns[21] =
{
/*SUB 751*/"eos/sub/751/full",
/*SUB 752*/"eos/sub/752/full",
/*SUB 753*/"eos/sub/753/full",
/*SUB 754*/"eos/sub/754/full",
/*SUB 755*/"eos/sub/755/full",
/*SUB 756*/"eos/sub/756/full",
/*SUB 757*/"eos/sub/757/full",
/*Q22/1 */"/eos/cue/22/1/fire",
/*Q22/2 */"/eos/cue/22/2/fire",
/*Q22/9 */"/eos/cue/22/9/fire",
/*Q22/10*/"/eos/cue/22/10/fire",
/*Q22/4 */"/eos/cue/22/4/fire",
/*Q22/13*/"/eos/cue/22/13/fire",
/*Q22/11*/"/eos/cue/22/11/fire",
/*Q22/18*/"/eos/cue/22/18/fire",
/*N*/"/eos/cue/50/9/fire",
/*J*/"eos/sub/755/full",
/*Q*/"eos/sub/756/full",
/*K*/"eos/sub/757/full",
/*s1*/"eos/macro/9101/fire", //macro in background con snapshot
/*s2*/"eos/macro/9102/fire",
};
/**************************************************************************************************************
Scriviamo i messaggi OSC che/se vogliamo mandare al rilascio dei pulsanti, nello stesso ordine dei pin
per l'OUt dei submaster in time zero, impostare lo sneak a zero in setup.
*************************************************************************************************************/
const String buttonUps[21]
{
/*SUB 751*/"eos/sub/751/out",
/*SUB 752*/"eos/sub/752/out",
/*SUB 753*/"eos/sub/753/out",
/*SUB 754*/"eos/sub/754/out",
/*SUB 755*/"eos/sub/755/out",
/*SUB 756*/"eos/sub/756/out",
/*SUB 757*/"eos/sub/757/out",
/*Q22/1 */"/eos/cue/22/0/fire",
/*Q22/2 */"/eos/cue/22/0/fire",
/*Q22/9 */"/eos/cue/22/0/fire",
/*Q22/10*/"/eos/cue/22/0/fire",
/*Q22/4 */"/eos/cue/22/0/fire",
/*Q22/13*/"/eos/cue/22/0/fire",
/*Q22/11*/"/eos/cue/22/0/fire",
/*Q22/18*/"/eos/cue/22/0/fire",
/*M*/"eos/cue/50/0/fire",
/*N*/"eos/cue/50/0/fire",
/*J*/"eos/sub/755/out",
/*Q*/"eos/sub/756/out",
/*K*/"eos/sub/757/out",
/*s1*/"",
};
/**************************************************************************************************************
Funzione di Handshake per fader e bottoni
**************************************************************************************************************/
void parseOSCMessage(String& msg) {
// controlla se questa è la stringa di handshake
if (msg.indexOf(HANDSHAKE_QUERY) != -1) {
// String di handshake trovata!
connectedToEos = true;
// initEOS();
}
SLIPSerial.beginPacket();
SLIPSerial.write((const uint8_t*)HANDSHAKE_REPLY.c_str(), (size_t)HANDSHAKE_REPLY.length());
SLIPSerial.endPacket();
}
/*******************************************************************************
Qui ci prepariamo a comunicare OSC con Eos configurando SLIPSerial. Una volta
abbiamo finito con setup() passiamo il controllo a loop() e non chiamiamo mai
setup() di nuovo.
Parametri: nessuno
Valore di ritorno: void
******************************************************************************/
void setup()
{
pinMode(Pin_A7, OUTPUT);
pinMode(Pin_A8, OUTPUT);
pinMode(Pin_A9, OUTPUT);
pinMode(Pin_A10, OUTPUT);
pinMode(Pin_A11, OUTPUT);
pinMode(Pin_A12, OUTPUT);
pinMode(Pin_A13, OUTPUT);
pinMode(Pin_A14, OUTPUT);
pinMode(Pin_A15, OUTPUT);
SLIPSerial.begin(115200);
// This is a hack around an Arduino bug. It was taken from the OSC library
// examples
#ifdef BOARD_HAS_USB_SERIAL
while (!SerialUSB);
#else
while (!Serial);
#endif
/*questo è necessario per ricollegare un dispositivo perché richiede un po' di tempo
per l'apertura della porta seriale, ma nel frattempo il messaggio di handshake era
inviato da Eos*/
SLIPSerial.beginPacket();
SLIPSerial.write((const uint8_t*)HANDSHAKE_REPLY.c_str(), (size_t)HANDSHAKE_REPLY.length());
SLIPSerial.endPacket();
// Inizializzazione di tutti i pulsanti input PULLUP mode
for (int i = 0; i < 21; i++) pinMode(buttonPins[i], INPUT_PULLUP);
//while (NoHandshake) HandShake();
//initEOS();
}
/*******************************************************************************
Main loop: manage OSC I/O. Send a ping command to Eos every second.
Parameters: none
Return Value: void
******************************************************************************/
void loop()
{
for (int i = 0; i < 21; i++)
{
if (digitalRead(buttonPins[i]) != buttonState[i])
{
//Se cambia lo stato del pulsante invia messaggio della pressione bottone verso il basso
if (buttonState[i]) sendOSCString(buttonDowns[i]);
else sendOSCString(buttonUps[i]);
buttonState[i] = !buttonState[i];//capovolge lo stato della variabile
//buttonTimers[i] = millis(); millis/debouncing disattivato , messo condensatore 100nf
}
//qui mi da errore!!!
if (analogRead(faderPins[i]) != faderState[i])
{
if (faderState[i]) sendOSCString (faderMove[i]);
}
}
static String curMsg;
static unsigned long lastTimeSent;
static int32_t pingNum;
unsigned long curTime;
int size;
// Check to see if any OSC commands have come from Eos that we need to respond to.
size = SLIPSerial.available();
if (size > 0)
{
// Fill the msg with all of the available bytes
while (size--) curMsg += (char)(SLIPSerial.read());
}
if (SLIPSerial.endofPacket())
{
parseOSCMessage(curMsg);
lastMessageRxTime = millis();//
timeoutPingSent = false;//
curMsg = String();
}
if (lastMessageRxTime > 0) {
unsigned long diff = millis() - lastMessageRxTime;
}
// Send a ping every second.
curTime = millis();
if (curTime - lastTimeSent > 1000)
{
OSCMessage ping("/eos/ping");
ping.add(pingNum++);
SLIPSerial.beginPacket();
ping.send(SLIPSerial);
SLIPSerial.endPacket();
lastTimeSent = curTime;
}
}
void sendOSCString(String buttonMessage)
{
OSCMessage buttonMsg(buttonMessage.c_str());//Cambia la stringa in un messaggio OSC
SLIPSerial.beginPacket(); // Processo per iniziare un messaggio OSc
buttonMsg.send(SLIPSerial); // invia il nostro messaggio OSC
SLIPSerial.endPacket(); // invia il nostro messaggio OSC
}
/*
void sendOSCString(String faderMessage)
{
OSCMessage faderMsg(faderMessage.c_str());//Cambia la stringa in un messaggio OSC
SLIPSerial.beginPacket(); // Processo per iniziare un messaggio OSc
faderMsg.send(SLIPSerial); // invia il nostro messaggio OSC
SLIPSerial.endPacket(); // invia il nostro messaggio OSC
}
*/
,
che si trova in basso del tuo post
