Modified firmware v1
This commit is contained in:
+864
@@ -0,0 +1,864 @@
|
||||
|
||||
|
||||
/* Copyright (c) 2010, Peter Barrett
|
||||
** Sleep/Wakeup support added by Michael Dreher
|
||||
**
|
||||
** Permission to use, copy, modify, and/or distribute this software for
|
||||
** any purpose with or without fee is hereby granted, provided that the
|
||||
** above copyright notice and this permission notice appear in all copies.
|
||||
**
|
||||
** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
|
||||
** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
|
||||
** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
|
||||
** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
|
||||
** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
** SOFTWARE.
|
||||
*/
|
||||
|
||||
//We include our own version of this core USB file with WARBL because it has been modified to remove the CDC serial class to make the device fully class-compliant.
|
||||
//The line below will remove serial communication to make the device fully class-commpliant and not require drivers on any OS.
|
||||
//It can be commented out to use Serial.print and to make it unnecessary to double-click the reset button for programming.
|
||||
|
||||
|
||||
#define CDCCON_DISABLE
|
||||
|
||||
|
||||
#include "USBAPI.h"
|
||||
#include "PluggableUSB.h"
|
||||
#include <stdlib.h>
|
||||
|
||||
#if defined(USBCON)
|
||||
|
||||
/** Pulse generation counters to keep track of the number of milliseconds remaining for each pulse type */
|
||||
#define TX_RX_LED_PULSE_MS 100
|
||||
volatile u8 TxLEDPulse; /**< Milliseconds remaining for data Tx LED pulse */
|
||||
volatile u8 RxLEDPulse; /**< Milliseconds remaining for data Rx LED pulse */
|
||||
|
||||
//==================================================================
|
||||
//==================================================================
|
||||
|
||||
extern const u16 STRING_LANGUAGE[] PROGMEM;
|
||||
extern const u8 STRING_PRODUCT[] PROGMEM;
|
||||
extern const u8 STRING_MANUFACTURER[] PROGMEM;
|
||||
extern const DeviceDescriptor USB_DeviceDescriptorIAD PROGMEM;
|
||||
|
||||
|
||||
const u16 STRING_LANGUAGE[2] = {
|
||||
(3<<8) | (2+2),
|
||||
0x0409 // English
|
||||
};
|
||||
|
||||
#ifndef USB_PRODUCT
|
||||
// If no product is provided, use USB IO Board
|
||||
#define USB_PRODUCT "USB IO Board"
|
||||
#endif
|
||||
|
||||
const u8 STRING_PRODUCT[] PROGMEM = USB_PRODUCT;
|
||||
|
||||
|
||||
# define USB_MANUFACTURER "Mowry Stringed Instruments"
|
||||
|
||||
|
||||
const u8 STRING_MANUFACTURER[] PROGMEM = USB_MANUFACTURER;
|
||||
|
||||
|
||||
#define DEVICE_CLASS 0x02
|
||||
|
||||
|
||||
const DeviceDescriptor USB_DeviceDescriptorIAD =
|
||||
D_DEVICE(0xEF,0x02,0x01,64,USB_VID,USB_PID,0x100,IMANUFACTURER,IPRODUCT,ISERIAL,1);
|
||||
|
||||
|
||||
//==================================================================
|
||||
//==================================================================
|
||||
|
||||
volatile u8 _usbConfiguration = 0;
|
||||
volatile u8 _usbCurrentStatus = 0; // meaning of bits see usb_20.pdf, Figure 9-4. Information Returned by a GetStatus() Request to a Device
|
||||
volatile u8 _usbSuspendState = 0; // copy of UDINT to check SUSPI and WAKEUPI bits
|
||||
|
||||
static inline void WaitIN(void)
|
||||
{
|
||||
while (!(UEINTX & (1<<TXINI)))
|
||||
;
|
||||
}
|
||||
|
||||
static inline void ClearIN(void)
|
||||
{
|
||||
UEINTX = ~(1<<TXINI);
|
||||
}
|
||||
|
||||
static inline void WaitOUT(void)
|
||||
{
|
||||
while (!(UEINTX & (1<<RXOUTI)))
|
||||
;
|
||||
}
|
||||
|
||||
static inline u8 WaitForINOrOUT()
|
||||
{
|
||||
while (!(UEINTX & ((1<<TXINI)|(1<<RXOUTI))))
|
||||
;
|
||||
return (UEINTX & (1<<RXOUTI)) == 0;
|
||||
}
|
||||
|
||||
static inline void ClearOUT(void)
|
||||
{
|
||||
UEINTX = ~(1<<RXOUTI);
|
||||
}
|
||||
|
||||
static inline void Recv(volatile u8* data, u8 count)
|
||||
{
|
||||
while (count--)
|
||||
*data++ = UEDATX;
|
||||
|
||||
//RXLED1; // light the RX LED //not used for WARBL
|
||||
//RxLEDPulse = TX_RX_LED_PULSE_MS;
|
||||
}
|
||||
|
||||
static inline u8 Recv8()
|
||||
{
|
||||
//RXLED1; // light the RX LED //not used for WARBL
|
||||
//RxLEDPulse = TX_RX_LED_PULSE_MS;
|
||||
|
||||
return UEDATX;
|
||||
}
|
||||
|
||||
static inline void Send8(u8 d)
|
||||
{
|
||||
UEDATX = d;
|
||||
}
|
||||
|
||||
static inline void SetEP(u8 ep)
|
||||
{
|
||||
UENUM = ep;
|
||||
}
|
||||
|
||||
static inline u8 FifoByteCount()
|
||||
{
|
||||
return UEBCLX;
|
||||
}
|
||||
|
||||
static inline u8 ReceivedSetupInt()
|
||||
{
|
||||
return UEINTX & (1<<RXSTPI);
|
||||
}
|
||||
|
||||
static inline void ClearSetupInt()
|
||||
{
|
||||
UEINTX = ~((1<<RXSTPI) | (1<<RXOUTI) | (1<<TXINI));
|
||||
}
|
||||
|
||||
static inline void Stall()
|
||||
{
|
||||
UECONX = (1<<STALLRQ) | (1<<EPEN);
|
||||
}
|
||||
|
||||
static inline u8 ReadWriteAllowed()
|
||||
{
|
||||
return UEINTX & (1<<RWAL);
|
||||
}
|
||||
|
||||
static inline u8 Stalled()
|
||||
{
|
||||
return UEINTX & (1<<STALLEDI);
|
||||
}
|
||||
|
||||
static inline u8 FifoFree()
|
||||
{
|
||||
return UEINTX & (1<<FIFOCON);
|
||||
}
|
||||
|
||||
static inline void ReleaseRX()
|
||||
{
|
||||
UEINTX = 0x6B; // FIFOCON=0 NAKINI=1 RWAL=1 NAKOUTI=0 RXSTPI=1 RXOUTI=0 STALLEDI=1 TXINI=1
|
||||
}
|
||||
|
||||
static inline void ReleaseTX()
|
||||
{
|
||||
UEINTX = 0x3A; // FIFOCON=0 NAKINI=0 RWAL=1 NAKOUTI=1 RXSTPI=1 RXOUTI=0 STALLEDI=1 TXINI=0
|
||||
}
|
||||
|
||||
static inline u8 FrameNumber()
|
||||
{
|
||||
return UDFNUML;
|
||||
}
|
||||
|
||||
//==================================================================
|
||||
//==================================================================
|
||||
|
||||
u8 USBGetConfiguration(void)
|
||||
{
|
||||
return _usbConfiguration;
|
||||
}
|
||||
|
||||
#define USB_RECV_TIMEOUT
|
||||
class LockEP
|
||||
{
|
||||
u8 _sreg;
|
||||
public:
|
||||
LockEP(u8 ep) : _sreg(SREG)
|
||||
{
|
||||
cli();
|
||||
SetEP(ep & 7);
|
||||
}
|
||||
~LockEP()
|
||||
{
|
||||
SREG = _sreg;
|
||||
}
|
||||
};
|
||||
|
||||
// Number of bytes, assumes a rx endpoint
|
||||
u8 USB_Available(u8 ep)
|
||||
{
|
||||
LockEP lock(ep);
|
||||
return FifoByteCount();
|
||||
}
|
||||
|
||||
// Non Blocking receive
|
||||
// Return number of bytes read
|
||||
int USB_Recv(u8 ep, void* d, int len)
|
||||
{
|
||||
if (!_usbConfiguration || len < 0)
|
||||
return -1;
|
||||
|
||||
LockEP lock(ep);
|
||||
u8 n = FifoByteCount();
|
||||
len = min(n,len);
|
||||
n = len;
|
||||
u8* dst = (u8*)d;
|
||||
while (n--)
|
||||
*dst++ = Recv8();
|
||||
if (len && !FifoByteCount()) // release empty buffer
|
||||
ReleaseRX();
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
// Recv 1 byte if ready
|
||||
int USB_Recv(u8 ep)
|
||||
{
|
||||
u8 c;
|
||||
if (USB_Recv(ep,&c,1) != 1)
|
||||
return -1;
|
||||
return c;
|
||||
}
|
||||
|
||||
// Space in send EP
|
||||
u8 USB_SendSpace(u8 ep)
|
||||
{
|
||||
LockEP lock(ep);
|
||||
if (!ReadWriteAllowed())
|
||||
return 0;
|
||||
return USB_EP_SIZE - FifoByteCount();
|
||||
}
|
||||
|
||||
// Blocking Send of data to an endpoint
|
||||
int USB_Send(u8 ep, const void* d, int len)
|
||||
{
|
||||
if (!_usbConfiguration)
|
||||
return -1;
|
||||
|
||||
if (_usbSuspendState & (1<<SUSPI)) {
|
||||
//send a remote wakeup
|
||||
UDCON |= (1 << RMWKUP);
|
||||
}
|
||||
|
||||
int r = len;
|
||||
const u8* data = (const u8*)d;
|
||||
u8 timeout = 250; // 250ms timeout on send? TODO
|
||||
bool sendZlp = false;
|
||||
|
||||
while (len || sendZlp)
|
||||
{
|
||||
u8 n = USB_SendSpace(ep);
|
||||
if (n == 0)
|
||||
{
|
||||
if (!(--timeout))
|
||||
return -1;
|
||||
delay(1);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (n > len) {
|
||||
n = len;
|
||||
}
|
||||
|
||||
{
|
||||
LockEP lock(ep);
|
||||
// Frame may have been released by the SOF interrupt handler
|
||||
if (!ReadWriteAllowed())
|
||||
continue;
|
||||
|
||||
len -= n;
|
||||
if (ep & TRANSFER_ZERO)
|
||||
{
|
||||
while (n--)
|
||||
Send8(0);
|
||||
}
|
||||
else if (ep & TRANSFER_PGM)
|
||||
{
|
||||
while (n--)
|
||||
Send8(pgm_read_byte(data++));
|
||||
}
|
||||
else
|
||||
{
|
||||
while (n--)
|
||||
Send8(*data++);
|
||||
}
|
||||
|
||||
if (sendZlp) {
|
||||
ReleaseTX();
|
||||
sendZlp = false;
|
||||
} else if (!ReadWriteAllowed()) { // ...release if buffer is full...
|
||||
ReleaseTX();
|
||||
if (len == 0) sendZlp = true;
|
||||
} else if ((len == 0) && (ep & TRANSFER_RELEASE)) { // ...or if forced with TRANSFER_RELEASE
|
||||
// XXX: TRANSFER_RELEASE is never used can be removed?
|
||||
ReleaseTX();
|
||||
}
|
||||
}
|
||||
}
|
||||
//TXLED1; // light the TX LED
|
||||
//TxLEDPulse = TX_RX_LED_PULSE_MS; //not used for WARBL
|
||||
return r;
|
||||
}
|
||||
|
||||
u8 _initEndpoints[USB_ENDPOINTS] =
|
||||
{
|
||||
0, // Control Endpoint
|
||||
|
||||
//#if !defined(CDCCON_DISABLE)
|
||||
EP_TYPE_INTERRUPT_IN, // CDC_ENDPOINT_ACM
|
||||
EP_TYPE_BULK_OUT, // CDC_ENDPOINT_OUT
|
||||
EP_TYPE_BULK_IN, // CDC_ENDPOINT_IN
|
||||
//#endif
|
||||
// Following endpoints are automatically initialized to 0
|
||||
};
|
||||
|
||||
#define EP_SINGLE_64 0x32 // EP0
|
||||
#define EP_DOUBLE_64 0x36 // Other endpoints
|
||||
#define EP_SINGLE_16 0x12
|
||||
|
||||
static
|
||||
void InitEP(u8 index, u8 type, u8 size)
|
||||
{
|
||||
UENUM = index;
|
||||
UECONX = (1<<EPEN);
|
||||
UECFG0X = type;
|
||||
UECFG1X = size;
|
||||
}
|
||||
|
||||
static
|
||||
void InitEndpoints()
|
||||
{
|
||||
for (u8 i = 1; i < sizeof(_initEndpoints) && _initEndpoints[i] != 0; i++)
|
||||
{
|
||||
UENUM = i;
|
||||
UECONX = (1<<EPEN);
|
||||
UECFG0X = _initEndpoints[i];
|
||||
#if USB_EP_SIZE == 16
|
||||
UECFG1X = EP_SINGLE_16;
|
||||
#elif USB_EP_SIZE == 64
|
||||
UECFG1X = EP_DOUBLE_64;
|
||||
#else
|
||||
#error Unsupported value for USB_EP_SIZE
|
||||
#endif
|
||||
}
|
||||
UERST = 0x7E; // And reset them
|
||||
UERST = 0;
|
||||
}
|
||||
|
||||
// Handle CLASS_INTERFACE requests
|
||||
static
|
||||
bool ClassInterfaceRequest(USBSetup& setup)
|
||||
{
|
||||
u8 i = setup.wIndex;
|
||||
|
||||
#if !defined(CDCCON_DISABLE)
|
||||
if (CDC_ACM_INTERFACE == i)
|
||||
return CDC_Setup(setup);
|
||||
#endif
|
||||
|
||||
#ifdef PLUGGABLE_USB_ENABLED
|
||||
return PluggableUSB().setup(setup);
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
|
||||
static int _cmark;
|
||||
static int _cend;
|
||||
void InitControl(int end)
|
||||
{
|
||||
SetEP(0);
|
||||
_cmark = 0;
|
||||
_cend = end;
|
||||
}
|
||||
|
||||
static
|
||||
bool SendControl(u8 d)
|
||||
{
|
||||
if (_cmark < _cend)
|
||||
{
|
||||
if (!WaitForINOrOUT())
|
||||
return false;
|
||||
Send8(d);
|
||||
if (!((_cmark + 1) & 0x3F))
|
||||
ClearIN(); // Fifo is full, release this packet
|
||||
}
|
||||
_cmark++;
|
||||
return true;
|
||||
}
|
||||
|
||||
// Clipped by _cmark/_cend
|
||||
int USB_SendControl(u8 flags, const void* d, int len)
|
||||
{
|
||||
int sent = len;
|
||||
const u8* data = (const u8*)d;
|
||||
bool pgm = flags & TRANSFER_PGM;
|
||||
while (len--)
|
||||
{
|
||||
u8 c = pgm ? pgm_read_byte(data++) : *data++;
|
||||
if (!SendControl(c))
|
||||
return -1;
|
||||
}
|
||||
return sent;
|
||||
}
|
||||
|
||||
// Send a USB descriptor string. The string is stored in PROGMEM as a
|
||||
// plain ASCII string but is sent out as UTF-16 with the correct 2-byte
|
||||
// prefix
|
||||
static bool USB_SendStringDescriptor(const u8*string_P, u8 string_len, uint8_t flags) {
|
||||
SendControl(2 + string_len * 2);
|
||||
SendControl(3);
|
||||
bool pgm = flags & TRANSFER_PGM;
|
||||
for(u8 i = 0; i < string_len; i++) {
|
||||
bool r = SendControl(pgm ? pgm_read_byte(&string_P[i]) : string_P[i]);
|
||||
r &= SendControl(0); // high byte
|
||||
if(!r) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Does not timeout or cross fifo boundaries
|
||||
int USB_RecvControl(void* d, int len)
|
||||
{
|
||||
auto length = len;
|
||||
while(length)
|
||||
{
|
||||
// Dont receive more than the USB Control EP has to offer
|
||||
// Use fixed 64 because control EP always have 64 bytes even on 16u2.
|
||||
auto recvLength = length;
|
||||
if(recvLength > 64){
|
||||
recvLength = 64;
|
||||
}
|
||||
|
||||
// Write data to fit to the end (not the beginning) of the array
|
||||
WaitOUT();
|
||||
Recv((u8*)d + len - length, recvLength);
|
||||
ClearOUT();
|
||||
length -= recvLength;
|
||||
}
|
||||
return len;
|
||||
}
|
||||
|
||||
static u8 SendInterfaces()
|
||||
{
|
||||
u8 interfaces = 0;
|
||||
|
||||
#if !defined(CDCCON_DISABLE)
|
||||
CDC_GetInterface(&interfaces);
|
||||
#endif
|
||||
|
||||
#ifdef PLUGGABLE_USB_ENABLED
|
||||
PluggableUSB().getInterface(&interfaces);
|
||||
#endif
|
||||
|
||||
return interfaces;
|
||||
}
|
||||
|
||||
// Construct a dynamic configuration descriptor
|
||||
// This really needs dynamic endpoint allocation etc
|
||||
// TODO
|
||||
static
|
||||
bool SendConfiguration(int maxlen)
|
||||
{
|
||||
// Count and measure interfaces
|
||||
InitControl(0);
|
||||
u8 interfaces = SendInterfaces();
|
||||
ConfigDescriptor config = D_CONFIG(_cmark + sizeof(ConfigDescriptor),interfaces);
|
||||
|
||||
// Now send them
|
||||
InitControl(maxlen);
|
||||
USB_SendControl(0,&config,sizeof(ConfigDescriptor));
|
||||
SendInterfaces();
|
||||
return true;
|
||||
}
|
||||
|
||||
static
|
||||
bool SendDescriptor(USBSetup& setup)
|
||||
{
|
||||
int ret;
|
||||
u8 t = setup.wValueH;
|
||||
if (USB_CONFIGURATION_DESCRIPTOR_TYPE == t)
|
||||
return SendConfiguration(setup.wLength);
|
||||
|
||||
InitControl(setup.wLength);
|
||||
#ifdef PLUGGABLE_USB_ENABLED
|
||||
ret = PluggableUSB().getDescriptor(setup);
|
||||
if (ret != 0) {
|
||||
return (ret > 0 ? true : false);
|
||||
}
|
||||
#endif
|
||||
|
||||
const u8* desc_addr = 0;
|
||||
if (USB_DEVICE_DESCRIPTOR_TYPE == t)
|
||||
{
|
||||
desc_addr = (const u8*)&USB_DeviceDescriptorIAD;
|
||||
}
|
||||
else if (USB_STRING_DESCRIPTOR_TYPE == t)
|
||||
{
|
||||
if (setup.wValueL == 0) {
|
||||
desc_addr = (const u8*)&STRING_LANGUAGE;
|
||||
}
|
||||
else if (setup.wValueL == IPRODUCT) {
|
||||
return USB_SendStringDescriptor(STRING_PRODUCT, strlen(USB_PRODUCT), TRANSFER_PGM);
|
||||
}
|
||||
else if (setup.wValueL == IMANUFACTURER) {
|
||||
return USB_SendStringDescriptor(STRING_MANUFACTURER, strlen(USB_MANUFACTURER), TRANSFER_PGM);
|
||||
}
|
||||
else if (setup.wValueL == ISERIAL) {
|
||||
#ifdef PLUGGABLE_USB_ENABLED
|
||||
char name[ISERIAL_MAX_LEN];
|
||||
PluggableUSB().getShortName(name);
|
||||
return USB_SendStringDescriptor((uint8_t*)name, strlen(name), 0);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
if (desc_addr == 0)
|
||||
return false;
|
||||
u8 desc_length = pgm_read_byte(desc_addr);
|
||||
|
||||
USB_SendControl(TRANSFER_PGM,desc_addr,desc_length);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Endpoint 0 interrupt
|
||||
ISR(USB_COM_vect)
|
||||
{
|
||||
SetEP(0);
|
||||
if (!ReceivedSetupInt())
|
||||
return;
|
||||
|
||||
USBSetup setup;
|
||||
Recv((u8*)&setup,8);
|
||||
ClearSetupInt();
|
||||
|
||||
u8 requestType = setup.bmRequestType;
|
||||
if (requestType & REQUEST_DEVICETOHOST)
|
||||
WaitIN();
|
||||
else
|
||||
ClearIN();
|
||||
|
||||
bool ok = true;
|
||||
if (REQUEST_STANDARD == (requestType & REQUEST_TYPE))
|
||||
{
|
||||
// Standard Requests
|
||||
u8 r = setup.bRequest;
|
||||
u16 wValue = setup.wValueL | (setup.wValueH << 8);
|
||||
if (GET_STATUS == r)
|
||||
{
|
||||
if (requestType == (REQUEST_DEVICETOHOST | REQUEST_STANDARD | REQUEST_DEVICE))
|
||||
{
|
||||
Send8(_usbCurrentStatus);
|
||||
Send8(0);
|
||||
}
|
||||
else
|
||||
{
|
||||
// TODO: handle the HALT state of an endpoint here
|
||||
// see "Figure 9-6. Information Returned by a GetStatus() Request to an Endpoint" in usb_20.pdf for more information
|
||||
Send8(0);
|
||||
Send8(0);
|
||||
}
|
||||
}
|
||||
else if (CLEAR_FEATURE == r)
|
||||
{
|
||||
if((requestType == (REQUEST_HOSTTODEVICE | REQUEST_STANDARD | REQUEST_DEVICE))
|
||||
&& (wValue == DEVICE_REMOTE_WAKEUP))
|
||||
{
|
||||
_usbCurrentStatus &= ~FEATURE_REMOTE_WAKEUP_ENABLED;
|
||||
}
|
||||
}
|
||||
else if (SET_FEATURE == r)
|
||||
{
|
||||
if((requestType == (REQUEST_HOSTTODEVICE | REQUEST_STANDARD | REQUEST_DEVICE))
|
||||
&& (wValue == DEVICE_REMOTE_WAKEUP))
|
||||
{
|
||||
_usbCurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED;
|
||||
}
|
||||
}
|
||||
else if (SET_ADDRESS == r)
|
||||
{
|
||||
WaitIN();
|
||||
UDADDR = setup.wValueL | (1<<ADDEN);
|
||||
}
|
||||
else if (GET_DESCRIPTOR == r)
|
||||
{
|
||||
ok = SendDescriptor(setup);
|
||||
}
|
||||
else if (SET_DESCRIPTOR == r)
|
||||
{
|
||||
ok = false;
|
||||
}
|
||||
else if (GET_CONFIGURATION == r)
|
||||
{
|
||||
Send8(1);
|
||||
}
|
||||
else if (SET_CONFIGURATION == r)
|
||||
{
|
||||
if (REQUEST_DEVICE == (requestType & REQUEST_RECIPIENT))
|
||||
{
|
||||
InitEndpoints();
|
||||
_usbConfiguration = setup.wValueL;
|
||||
} else
|
||||
ok = false;
|
||||
}
|
||||
else if (GET_INTERFACE == r)
|
||||
{
|
||||
}
|
||||
else if (SET_INTERFACE == r)
|
||||
{
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
InitControl(setup.wLength); // Max length of transfer
|
||||
ok = ClassInterfaceRequest(setup);
|
||||
}
|
||||
|
||||
if (ok)
|
||||
ClearIN();
|
||||
else
|
||||
{
|
||||
Stall();
|
||||
}
|
||||
}
|
||||
|
||||
void USB_Flush(u8 ep)
|
||||
{
|
||||
SetEP(ep);
|
||||
if (FifoByteCount())
|
||||
ReleaseTX();
|
||||
}
|
||||
|
||||
static inline void USB_ClockDisable()
|
||||
{
|
||||
#if defined(OTGPADE)
|
||||
USBCON = (USBCON & ~(1<<OTGPADE)) | (1<<FRZCLK); // freeze clock and disable VBUS Pad
|
||||
#else // u2 Series
|
||||
USBCON = (1 << FRZCLK); // freeze clock
|
||||
#endif
|
||||
PLLCSR &= ~(1<<PLLE); // stop PLL
|
||||
}
|
||||
|
||||
static inline void USB_ClockEnable()
|
||||
{
|
||||
#if defined(UHWCON)
|
||||
UHWCON |= (1<<UVREGE); // power internal reg
|
||||
#endif
|
||||
USBCON = (1<<USBE) | (1<<FRZCLK); // clock frozen, usb enabled
|
||||
|
||||
// ATmega32U4
|
||||
#if defined(PINDIV)
|
||||
#if F_CPU == 16000000UL
|
||||
PLLCSR |= (1<<PINDIV); // Need 16 MHz xtal
|
||||
#elif F_CPU == 8000000UL
|
||||
PLLCSR &= ~(1<<PINDIV); // Need 8 MHz xtal
|
||||
#else
|
||||
#error "Clock rate of F_CPU not supported"
|
||||
#endif
|
||||
|
||||
#elif defined(__AVR_AT90USB82__) || defined(__AVR_AT90USB162__) || defined(__AVR_ATmega32U2__) || defined(__AVR_ATmega16U2__) || defined(__AVR_ATmega8U2__)
|
||||
// for the u2 Series the datasheet is confusing. On page 40 its called PINDIV and on page 290 its called PLLP0
|
||||
#if F_CPU == 16000000UL
|
||||
// Need 16 MHz xtal
|
||||
PLLCSR |= (1 << PLLP0);
|
||||
#elif F_CPU == 8000000UL
|
||||
// Need 8 MHz xtal
|
||||
PLLCSR &= ~(1 << PLLP0);
|
||||
#endif
|
||||
|
||||
// AT90USB646, AT90USB647, AT90USB1286, AT90USB1287
|
||||
#elif defined(PLLP2)
|
||||
#if F_CPU == 16000000UL
|
||||
#if defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__)
|
||||
// For Atmel AT90USB128x only. Do not use with Atmel AT90USB64x.
|
||||
PLLCSR = (PLLCSR & ~(1<<PLLP1)) | ((1<<PLLP2) | (1<<PLLP0)); // Need 16 MHz xtal
|
||||
#elif defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__)
|
||||
// For AT90USB64x only. Do not use with AT90USB128x.
|
||||
PLLCSR = (PLLCSR & ~(1<<PLLP0)) | ((1<<PLLP2) | (1<<PLLP1)); // Need 16 MHz xtal
|
||||
#else
|
||||
#error "USB Chip not supported, please defined method of USB PLL initialization"
|
||||
#endif
|
||||
#elif F_CPU == 8000000UL
|
||||
// for Atmel AT90USB128x and AT90USB64x
|
||||
PLLCSR = (PLLCSR & ~(1<<PLLP2)) | ((1<<PLLP1) | (1<<PLLP0)); // Need 8 MHz xtal
|
||||
#else
|
||||
#error "Clock rate of F_CPU not supported"
|
||||
#endif
|
||||
#else
|
||||
#error "USB Chip not supported, please defined method of USB PLL initialization"
|
||||
#endif
|
||||
|
||||
PLLCSR |= (1<<PLLE);
|
||||
while (!(PLLCSR & (1<<PLOCK))) // wait for lock pll
|
||||
{
|
||||
}
|
||||
|
||||
// Some tests on specific versions of macosx (10.7.3), reported some
|
||||
// strange behaviors when the board is reset using the serial
|
||||
// port touch at 1200 bps. This delay fixes this behavior.
|
||||
delay(1);
|
||||
#if defined(OTGPADE)
|
||||
USBCON = (USBCON & ~(1<<FRZCLK)) | (1<<OTGPADE); // start USB clock, enable VBUS Pad
|
||||
#else
|
||||
USBCON &= ~(1 << FRZCLK); // start USB clock
|
||||
#endif
|
||||
|
||||
#if defined(RSTCPU)
|
||||
#if defined(LSM)
|
||||
UDCON &= ~((1<<RSTCPU) | (1<<LSM) | (1<<RMWKUP) | (1<<DETACH)); // enable attach resistor, set full speed mode
|
||||
#else // u2 Series
|
||||
UDCON &= ~((1 << RSTCPU) | (1 << RMWKUP) | (1 << DETACH)); // enable attach resistor, set full speed mode
|
||||
#endif
|
||||
#else
|
||||
// AT90USB64x and AT90USB128x don't have RSTCPU
|
||||
UDCON &= ~((1<<LSM) | (1<<RMWKUP) | (1<<DETACH)); // enable attach resistor, set full speed mode
|
||||
#endif
|
||||
}
|
||||
|
||||
// General interrupt
|
||||
ISR(USB_GEN_vect)
|
||||
{
|
||||
u8 udint = UDINT;
|
||||
UDINT &= ~((1<<EORSTI) | (1<<SOFI)); // clear the IRQ flags for the IRQs which are handled here, except WAKEUPI and SUSPI (see below)
|
||||
|
||||
// End of Reset
|
||||
if (udint & (1<<EORSTI))
|
||||
{
|
||||
InitEP(0,EP_TYPE_CONTROL,EP_SINGLE_64); // init ep0
|
||||
_usbConfiguration = 0; // not configured yet
|
||||
UEIENX = 1 << RXSTPE; // Enable interrupts for ep0
|
||||
}
|
||||
|
||||
// Start of Frame - happens every millisecond so we use it for TX and RX LED one-shot timing, too
|
||||
if (udint & (1<<SOFI))
|
||||
{
|
||||
USB_Flush(CDC_TX); // Send a tx frame if found
|
||||
|
||||
// check whether the one-shot period has elapsed. if so, turn off the LED //not used for WARBL
|
||||
// if (TxLEDPulse && !(--TxLEDPulse))
|
||||
// TXLED0;
|
||||
// if (RxLEDPulse && !(--RxLEDPulse))
|
||||
// RXLED0;
|
||||
}
|
||||
|
||||
// the WAKEUPI interrupt is triggered as soon as there are non-idle patterns on the data
|
||||
// lines. Thus, the WAKEUPI interrupt can occur even if the controller is not in the "suspend" mode.
|
||||
// Therefore the we enable it only when USB is suspended
|
||||
if (udint & (1<<WAKEUPI))
|
||||
{
|
||||
UDIEN = (UDIEN & ~(1<<WAKEUPE)) | (1<<SUSPE); // Disable interrupts for WAKEUP and enable interrupts for SUSPEND
|
||||
|
||||
//TODO
|
||||
// WAKEUPI shall be cleared by software (USB clock inputs must be enabled before).
|
||||
//USB_ClockEnable();
|
||||
UDINT &= ~(1<<WAKEUPI);
|
||||
_usbSuspendState = (_usbSuspendState & ~(1<<SUSPI)) | (1<<WAKEUPI);
|
||||
}
|
||||
else if (udint & (1<<SUSPI)) // only one of the WAKEUPI / SUSPI bits can be active at time
|
||||
{
|
||||
UDIEN = (UDIEN & ~(1<<SUSPE)) | (1<<WAKEUPE); // Disable interrupts for SUSPEND and enable interrupts for WAKEUP
|
||||
|
||||
//TODO
|
||||
//USB_ClockDisable();
|
||||
|
||||
UDINT &= ~((1<<WAKEUPI) | (1<<SUSPI)); // clear any already pending WAKEUP IRQs and the SUSPI request
|
||||
_usbSuspendState = (_usbSuspendState & ~(1<<WAKEUPI)) | (1<<SUSPI);
|
||||
}
|
||||
}
|
||||
|
||||
// VBUS or counting frames
|
||||
// Any frame counting?
|
||||
u8 USBConnected()
|
||||
{
|
||||
u8 f = UDFNUML;
|
||||
delay(3);
|
||||
return f != UDFNUML;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//=======================================================================
|
||||
|
||||
USBDevice_ USBDevice;
|
||||
|
||||
USBDevice_::USBDevice_()
|
||||
{
|
||||
}
|
||||
|
||||
void USBDevice_::attach()
|
||||
{
|
||||
_usbConfiguration = 0;
|
||||
_usbCurrentStatus = 0;
|
||||
_usbSuspendState = 0;
|
||||
USB_ClockEnable();
|
||||
|
||||
UDINT &= ~((1<<WAKEUPI) | (1<<SUSPI)); // clear already pending WAKEUP / SUSPEND requests
|
||||
UDIEN = (1<<EORSTE) | (1<<SOFE) | (1<<SUSPE); // Enable interrupts for EOR (End of Reset), SOF (start of frame) and SUSPEND
|
||||
|
||||
//TX_RX_LED_INIT; //not used for WARBL
|
||||
|
||||
|
||||
}
|
||||
|
||||
void USBDevice_::detach()
|
||||
{
|
||||
}
|
||||
|
||||
// Check for interrupts
|
||||
// TODO: VBUS detection
|
||||
bool USBDevice_::configured()
|
||||
{
|
||||
return _usbConfiguration;
|
||||
}
|
||||
|
||||
void USBDevice_::poll()
|
||||
{
|
||||
}
|
||||
|
||||
bool USBDevice_::wakeupHost()
|
||||
{
|
||||
// clear any previous wakeup request which might have been set but could be processed at that time
|
||||
// e.g. because the host was not suspended at that time
|
||||
UDCON &= ~(1 << RMWKUP);
|
||||
|
||||
if(!(UDCON & (1 << RMWKUP))
|
||||
&& (_usbSuspendState & (1<<SUSPI))
|
||||
&& (_usbCurrentStatus & FEATURE_REMOTE_WAKEUP_ENABLED))
|
||||
{
|
||||
// This short version will only work, when the device has not been suspended. Currently the
|
||||
// Arduino core doesn't handle SUSPEND at all, so this is ok.
|
||||
USB_ClockEnable();
|
||||
UDCON |= (1 << RMWKUP); // send the wakeup request
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
#endif /* if defined(USBCON) */
|
||||
File diff suppressed because it is too large
Load Diff
+2231
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,677 @@
|
||||
|
||||
/*
|
||||
Copyright (C) 2018-2021 Andrew Mowry warbl.xyz
|
||||
|
||||
Many thanks to Michael Eskin and Jesse Chappell for their additions and debugging help.
|
||||
|
||||
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.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see http://www.gnu.org/licenses/
|
||||
*/
|
||||
|
||||
|
||||
|
||||
//#include <MemoryUsage.h> //can be used to show free RAM
|
||||
#include <avr/wdt.h> //for resetting with watchdog
|
||||
#include <TimerOne.h> //for timer interrupt for reading sensors at a regular interval
|
||||
#include <DIO2.h> //fast digitalWrite library used for toggling IR LEDs
|
||||
#include <MIDIUSB.h>
|
||||
#include <EEPROM.h>
|
||||
#include <avr/pgmspace.h> // for using PROGMEM for fingering chart storage
|
||||
|
||||
#define GPIO2_PREFER_SPEED 1 //digitalread speed, see: https://github.com/Locoduino/DIO2/blob/master/examples/standard_outputs/standard_outputs.ino
|
||||
|
||||
#define DEBOUNCE_TIME 0.02 //debounce time, in seconds---Integrating debouncing algorithm is taken from debounce.c, written by Kenneth A. Kuhn:http://www.kennethkuhn.com/electronics/debounce.c
|
||||
#define SAMPLE_FREQUENCY 200 //button sample frequency, in Hz
|
||||
|
||||
#define MAXIMUM (DEBOUNCE_TIME * SAMPLE_FREQUENCY) //the integrator value required to register a button press
|
||||
|
||||
#define VERSION 20 //software version number (without decimal point)
|
||||
|
||||
//MIDI commands
|
||||
#define NOTE_OFF 0x80 //127
|
||||
#define NOTE_ON 0x90 // 144
|
||||
#define KEY_PRESSURE 0xA0 // 160
|
||||
#define CC 0xB0 // 176
|
||||
#define PROGRAM_CHANGE 0xC0 // 192
|
||||
#define CHANNEL_PRESSURE 0xD0 // 208
|
||||
#define PITCH_BEND 0xE0 // 224
|
||||
|
||||
// Fingering Patterns
|
||||
#define kModeWhistle 0
|
||||
#define kModeUilleann 1
|
||||
#define kModeGHB 2
|
||||
#define kModeNorthumbrian 3
|
||||
#define kModeChromatic 4
|
||||
#define kModeGaita 5
|
||||
#define kModeNAF 6
|
||||
#define kModeKaval 7
|
||||
#define kModeRecorder 8
|
||||
#define kModeRegulators 9 //only used for a custom regulators implementation, not the "official" software
|
||||
#define kModeUilleannStandard 10 //contains no accidentals
|
||||
#define kModeXiao 11
|
||||
#define kModeSax 12
|
||||
#define kModeGaitaExtended 13
|
||||
#define kModeSaxBasic 14
|
||||
#define kModeEVI 15
|
||||
#define kModeShakuhachi 16
|
||||
#define kModeSackpipaMajor 17
|
||||
#define kModeSackpipaMinor 18
|
||||
#define kModeCustom 19
|
||||
#define kModeNModes 20
|
||||
#define kModeBoha 21
|
||||
|
||||
// Pitch bend modes
|
||||
#define kPitchBendSlideVibrato 0
|
||||
#define kPitchBendVibrato 1
|
||||
#define kPitchBendNone 2
|
||||
#define kPitchBendLegatoSlideVibrato 3
|
||||
#define kPitchBendNModes 4
|
||||
|
||||
// Register control modes
|
||||
#define kPressureSingle 0
|
||||
#define kPressureBreath 1
|
||||
#define kPressureThumb 2
|
||||
#define kPressureBell 3
|
||||
#define kPressureNModes 4
|
||||
|
||||
// Secret function drone control MIDI parameters
|
||||
#define kDroneVelocity 36
|
||||
#define kLynchDroneMIDINote 50
|
||||
#define kCrowleyDroneMIDINote 51
|
||||
|
||||
// Drones control mode
|
||||
#define kNoDroneControl 0
|
||||
#define kSecretDroneControl 1
|
||||
#define kBaglessDroneControl 2
|
||||
#define kPressureDroneControl 3
|
||||
#define kDroneNModes 4
|
||||
|
||||
//Variables in the switches array (settings for the swiches in the slide/vibrato and register control panels)
|
||||
#define VENTED 0
|
||||
#define BAGLESS 1
|
||||
#define SECRET 2
|
||||
#define INVERT 3
|
||||
#define CUSTOM 4
|
||||
#define SEND_VELOCITY 5
|
||||
#define SEND_AFTERTOUCH 6 //second bit of this one is used for poly
|
||||
#define FORCE_MAX_VELOCITY 7
|
||||
#define IMMEDIATE_PB 8
|
||||
#define LEGATO 9
|
||||
#define OVERRIDE 10
|
||||
#define THUMB_AND_OVERBLOW 11
|
||||
#define R4_FLATTEN 12
|
||||
#define kSWITCHESnVariables 13
|
||||
|
||||
//Variables in the ED array (all the settings for the Expression and Drones panels)
|
||||
#define EXPRESSION_ON 0
|
||||
#define EXPRESSION_DEPTH 1
|
||||
#define SEND_PRESSURE 2
|
||||
#define CURVE 3 // (0 is linear, 1 and 2 are power curves)
|
||||
#define PRESSURE_CHANNEL 4
|
||||
#define PRESSURE_CC 5
|
||||
#define INPUT_PRESSURE_MIN 6
|
||||
#define INPUT_PRESSURE_MAX 7
|
||||
#define OUTPUT_PRESSURE_MIN 8
|
||||
#define OUTPUT_PRESSURE_MAX 9
|
||||
#define DRONES_ON_COMMAND 10
|
||||
#define DRONES_ON_CHANNEL 11
|
||||
#define DRONES_ON_BYTE2 12
|
||||
#define DRONES_ON_BYTE3 13
|
||||
#define DRONES_OFF_COMMAND 14
|
||||
#define DRONES_OFF_CHANNEL 15
|
||||
#define DRONES_OFF_BYTE2 16
|
||||
#define DRONES_OFF_BYTE3 17
|
||||
#define DRONES_CONTROL_MODE 18
|
||||
#define DRONES_PRESSURE_LOW_BYTE 19
|
||||
#define DRONES_PRESSURE_HIGH_BYTE 20
|
||||
#define VELOCITY_INPUT_PRESSURE_MIN 21
|
||||
#define VELOCITY_INPUT_PRESSURE_MAX 22
|
||||
#define VELOCITY_OUTPUT_PRESSURE_MIN 23
|
||||
#define VELOCITY_OUTPUT_PRESSURE_MAX 24
|
||||
#define AFTERTOUCH_INPUT_PRESSURE_MIN 25
|
||||
#define AFTERTOUCH_INPUT_PRESSURE_MAX 26
|
||||
#define AFTERTOUCH_OUTPUT_PRESSURE_MIN 27
|
||||
#define AFTERTOUCH_OUTPUT_PRESSURE_MAX 28
|
||||
#define POLY_INPUT_PRESSURE_MIN 29
|
||||
#define POLY_INPUT_PRESSURE_MAX 30
|
||||
#define POLY_OUTPUT_PRESSURE_MIN 31
|
||||
#define POLY_OUTPUT_PRESSURE_MAX 32
|
||||
#define VELOCITY_CURVE 33
|
||||
#define AFTERTOUCH_CURVE 34
|
||||
#define POLY_CURVE 35
|
||||
#define EXPRESSION_MIN 36
|
||||
#define EXPRESSION_MAX 37
|
||||
#define CUSTOM_FINGERING_1 38
|
||||
#define CUSTOM_FINGERING_2 39
|
||||
#define CUSTOM_FINGERING_3 40
|
||||
#define CUSTOM_FINGERING_4 41
|
||||
#define CUSTOM_FINGERING_5 42
|
||||
#define CUSTOM_FINGERING_6 43
|
||||
#define CUSTOM_FINGERING_7 44
|
||||
#define CUSTOM_FINGERING_8 45
|
||||
#define CUSTOM_FINGERING_9 46
|
||||
#define CUSTOM_FINGERING_10 47
|
||||
#define CUSTOM_FINGERING_11 48
|
||||
#define kEXPRESSIONnVariables 49
|
||||
|
||||
//GPIO constants
|
||||
const uint8_t ledPin = 13;
|
||||
const uint8_t holeTrans[] = {5, 9, 10, 0, 1, 2, 3, 11, 6}; //the analog pins used for the tone hole phototransistors, in the following order: Bell,R4,R3,R2,R1,L3,L2,L1,Lthumb
|
||||
const GPIO_pin_t pins[] = {DP11, DP6, DP8, DP5, DP7, DP1, DP0, DP3, DP2}; //the digital pins used for the tone hole leds, in the following order: Bell,R4,R3,R2,R1,L3,L2,L1,Lthumb. Uses a special declaration format for the GPIO library.
|
||||
const GPIO_pin_t buttons[] = {DP15, DP14, DP16}; //the pins used for the buttons
|
||||
|
||||
//instrument
|
||||
byte mode = 0; // The current mode (instrument), from 0-2.
|
||||
byte defaultMode = 0; // The default mode, from 0-2.
|
||||
|
||||
//variables that can change according to instrument.
|
||||
int8_t octaveShift = 0; //octave transposition
|
||||
int8_t noteShift = 0; //note transposition, for changing keys. All fingering patterns are initially based on the key of D, and transposed with this variable to the desired key.
|
||||
byte pitchBendMode = kPitchBendSlideVibrato; //0 means slide and vibrato are on. 1 means only vibrato is on. 2 is all pitchbend off, 3 is legato slide/vibrato.
|
||||
byte senseDistance = 10; //the sensor value above which the finger is sensed for bending notes. Needs to be higher than the baseline sensor readings, otherwise vibrato will be turned on erroneously.
|
||||
byte breathMode = kPressureBreath; //the desired presure sensor behavior: single register, overblow, thumb register control, bell register control.
|
||||
unsigned int vibratoDepth = 1024; //vibrato depth from 0 (no vibrato) to 8191 (one semitone)
|
||||
bool useLearnedPressure = 0; //whether we use learned pressure for note on threshold, or we use calibration pressure from startup
|
||||
byte midiBendRange = 2; // +/- semitones that the midi bend range represents
|
||||
byte mainMidiChannel = 1; // current MIDI channel to send notes on
|
||||
|
||||
//These are containers for the above variables, storing the value used by the three different instruments. First variable in array is for instrument 0, etc.
|
||||
byte modeSelector[] = {kModeBoha, kModeUilleann, kModeGHB}; //the fingering patterns chosen in the configuration tool, for the three instruments.
|
||||
int8_t octaveShiftSelector[] = {0, 0, 0};
|
||||
int8_t noteShiftSelector[] = {0, 0, 8};
|
||||
byte pitchBendModeSelector[] = {1, 1, 1};
|
||||
byte senseDistanceSelector[] = {10, 10, 10};
|
||||
byte breathModeSelector[] = {1, 1, 0};
|
||||
byte useLearnedPressureSelector[] = {0, 0, 0};
|
||||
int learnedPressureSelector[] = {0, 0, 0};
|
||||
byte LSBlearnedPressure; //used to reconstruct learned pressure from two MIDI bytes.
|
||||
unsigned int vibratoHolesSelector[] = {0b011111111, 0b011111111, 0b011111111};
|
||||
unsigned int vibratoDepthSelector[] = {1024, 1024, 1024};
|
||||
byte midiBendRangeSelector[] = {2, 2, 2};
|
||||
byte midiChannelSelector[] = {1, 1, 1};
|
||||
|
||||
bool momentary[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}} ; //whether momentary click behavior is desired for MIDI on/off message sent with a button. Dimension 0 is mode (instrument), dimension 1 is button 0,1,2.
|
||||
|
||||
byte switches[3][13] = //the settings for the five switches in the vibrato/slide and register control panels
|
||||
//instrument 0
|
||||
{
|
||||
{
|
||||
1, // vented mouthpiece on or off (there are different pressure settings for the vented mouthpiece)
|
||||
0, // bagless mode off or on
|
||||
0, // secret button command mode off or on
|
||||
0, // whether the functionality for using the right thumb or the bell sensor for increasing the register is inverted.
|
||||
0, // off/on for Michael Eskin's custom vibrato approach
|
||||
0, // send pressure as NoteOn velocity off or on
|
||||
0, // send pressure as aftertouch (channel pressure) off or on, and/or poly aftertouch (2nd bit)
|
||||
1, // force maximum velocity (127)
|
||||
0, // send pitchbend immediately before Note On (recommnded for MPE)
|
||||
1, // send legato (Note On message before Note Off for previous note)
|
||||
0, //override pitch expression pressure range
|
||||
0, //use both thumb and overblowing for register control with custom fingering chart
|
||||
0 //use R4 finger to flatten any note one semitone with custom fingering chart
|
||||
},
|
||||
|
||||
//same for instrument 1
|
||||
{0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0},
|
||||
|
||||
//same for instrument 2
|
||||
{0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0}
|
||||
};
|
||||
|
||||
byte ED[3][49] = //an array that holds all the settings for the Expression and Drones Control panels in the Configuration Tool.
|
||||
//instrument 0
|
||||
{
|
||||
{
|
||||
0, //EXPRESSION_ON
|
||||
3, //EXPRESSION_DEPTH (can have a value of 1-8)
|
||||
0, //SEND_PRESSURE
|
||||
0, //CURVE (0 is linear)
|
||||
1, //PRESSURE_CHANNEL
|
||||
7, //PRESSURE_CC
|
||||
0, //INPUT_PRESSURE_MIN range is from 0-100, to be scaled later up to maximum input values
|
||||
100, //INPUT_PRESSURE_MAX range is from 0-100, to be scaled later
|
||||
0, //OUTPUT_PRESSURE_MIN range is from 0-127, to be scaled later
|
||||
127, //OUTPUT_PRESSURE_MAX range is from 0-127, to be scaled later
|
||||
0, //DRONES_ON_COMMAND
|
||||
1, //DRONES_ON_CHANNEL
|
||||
51, //DRONES_ON_BYTE2
|
||||
36, //DRONES_ON_BYTE3
|
||||
0, //DRONES_OFF_COMMAND
|
||||
1, //DRONES_OFF_CHANNEL
|
||||
51, //DRONES_OFF_BYTE2
|
||||
36, //DRONES_OFF_BYTE3
|
||||
0, //DRONES_CONTROL_MODE (0 is no drone control, 1 is use secret button, 2 is use bagless button, 3 is use pressure.
|
||||
0, //DRONES_PRESSURE_LOW_BYTE
|
||||
0, //DRONES_PRESSURE_HIGH_BYTE
|
||||
0, //VELOCITY_INPUT_PRESSURE_MIN
|
||||
100, //VELOCITY_INPUT_PRESSURE_MAX
|
||||
0, //VELOCITY_OUTPUT_PRESSURE_MIN
|
||||
127, //VELOCITY_OUTPUT_PRESSURE_MAX
|
||||
0, //AFTERTOUCH_INPUT_PRESSURE_MIN
|
||||
100, //AFTERTOUCH_INPUT_PRESSURE_MAX
|
||||
0, //AFTERTOUCH_OUTPUT_PRESSURE_MIN
|
||||
127, //AFTERTOUCH_OUTPUT_PRESSURE_MAX
|
||||
0, //POLY_INPUT_PRESSURE_MIN
|
||||
100, //POLY_INPUT_PRESSURE_MAX
|
||||
0, //POLY_OUTPUT_PRESSURE_MIN
|
||||
127, //POLY_OUTPUT_PRESSURE_MAX
|
||||
0, //VELOCITY_CURVE
|
||||
0, //AFTERTOUCH_CURVE
|
||||
0, //POLY_CURVE
|
||||
0, //EXPRESSION_MIN
|
||||
100, //EXPRESSION_MAX
|
||||
0, //CUSTOM_FINGERING_1
|
||||
74, //CUSTOM_FINGERING_2
|
||||
73, //CUSTOM_FINGERING_3
|
||||
72, //CUSTOM_FINGERING_4
|
||||
71, //CUSTOM_FINGERING_5
|
||||
69, //CUSTOM_FINGERING_6
|
||||
67, //CUSTOM_FINGERING_7
|
||||
66, //CUSTOM_FINGERING_8
|
||||
64, //CUSTOM_FINGERING_9
|
||||
62, //CUSTOM_FINGERING_10
|
||||
61 //CUSTOM_FINGERING_11
|
||||
},
|
||||
|
||||
//same for instrument 1
|
||||
{0, 3, 0, 0, 1, 7, 0, 100, 0, 127, 0, 1, 51, 36, 0, 1, 51, 36, 0, 0, 0, 0, 127, 0, 127, 0, 127, 0, 127, 0, 127, 0, 127, 0, 0, 0, 0, 100, 0, 74, 73, 72, 71, 69, 67, 66, 64, 62, 61},
|
||||
|
||||
//same for instrument 2
|
||||
{0, 3, 0, 0, 1, 7, 0, 100, 0, 127, 0, 1, 51, 36, 0, 1, 51, 36, 0, 0, 0, 0, 127, 0, 127, 0, 127, 0, 127, 0, 127, 0, 127, 0, 0, 0, 0, 100, 0, 74, 73, 72, 71, 69, 67, 66, 64, 62, 61}
|
||||
};
|
||||
|
||||
byte pressureSelector[3][12] = //a selector array for all the register control variables that can be changed in the Configuration Tool
|
||||
//instrument 0
|
||||
{
|
||||
{
|
||||
15, 15, 15, 15, 30, 30, //closed mouthpiece: offset, multiplier, jump, drop, jump time, drop time
|
||||
3, 7, 100, 7, 9, 9
|
||||
}, //vented mouthpiece: offset, multiplier, jump, drop, jump time, drop time
|
||||
//instrument 1
|
||||
{
|
||||
15, 15, 15, 15, 30, 30,
|
||||
3, 7, 10, 7, 9, 9
|
||||
},
|
||||
//instrument 2
|
||||
{
|
||||
15, 15, 15, 15, 30, 30,
|
||||
3, 7, 10, 7, 9, 9
|
||||
}
|
||||
};
|
||||
|
||||
uint8_t buttonPrefs[3][8][5] = //The button configuration settings. Dimension 1 is the three instruments. Dimension 2 is the button combination: click 1, click 2, click3, hold 2 click 1, hold 2 click 3, longpress 1, longpress2, longpress3
|
||||
//Dimension 3 is the desired action: Action, MIDI command type (noteon/off, CC, PC), MIDI channel, MIDI byte 2, MIDI byte 3.
|
||||
//instrument 0 //the actions are: 0 none, 1 send MIDI message, 2 change pitchbend mode, 3 instrument, 4 play/stop (bagless mode), 5 octave shift up, 6 octave shift down, 7 MIDI panic, 8 change register control mode, 9 drones on/off, 10 semitone shift up, 11 semitone shift down
|
||||
{ { {2, 0, 0, 0, 0}, //for example, this means that clicking button 0 will send a CC message, channel 1, byte 2 = 0, byte 3 = 0.
|
||||
{8, 0, 0, 0, 0}, //for example, this means that clicking button 1 will change pitchbend mode.
|
||||
{0, 0, 0, 0, 0},
|
||||
{5, 0, 0, 0, 0},
|
||||
{6, 0, 0, 0, 0},
|
||||
{0, 0, 0, 0, 0},
|
||||
{0, 0, 0, 0, 0},
|
||||
{0, 0, 0, 0, 0}
|
||||
},
|
||||
|
||||
//same for instrument 1
|
||||
{{2, 0, 0, 0, 0}, {8, 0, 0, 0, 0}, {9, 0, 0, 0, 0}, {5, 0, 0, 0, 0}, {6, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}},
|
||||
|
||||
//same for instrument 2
|
||||
{{2, 0, 0, 0, 0}, {8, 0, 0, 0, 0}, {9, 0, 0, 0, 0}, {5, 0, 0, 0, 0}, {6, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}}
|
||||
};
|
||||
|
||||
//other misc. variables
|
||||
byte hardwareRevision = 30;
|
||||
unsigned long ledTimer = 0; //for blinking LED
|
||||
byte blinkNumber = 1; //the number of remaining blinks when blinking LED to indicate control changes
|
||||
bool LEDon = 0; //whether the LED is currently on
|
||||
bool play = 0; //turns sound off and on (with the use of a button action) when in bagless mode
|
||||
bool bellSensor = 0; //whether the bell sensor is plugged in
|
||||
bool prevBellSensor = 0; //the previous reading of the bell sensor detection pin
|
||||
unsigned long initialTime = 0; //for testing
|
||||
unsigned long finalTime = 0; //for testing
|
||||
unsigned long cycles = 0; //for testing
|
||||
byte program = 0; //current MIDI program change value. This always starts at 0 but can be increased/decreased with assigned buttons.
|
||||
bool dronesState = 0; //keeps track of whether we're above or below the pressure threshold for turning drones on.
|
||||
|
||||
//variables for reading pressure sensor
|
||||
volatile unsigned int tempSensorValue = 0; //for holding the pressure sensor value inside the ISR
|
||||
int sensorValue = 0; // first value read from the pressure sensor
|
||||
int sensorValue2 = 0; // second value read from the pressure sensor, for measuring rate of change in pressure
|
||||
int prevSensorValue = 0; // previous sensor reading, used to tell if the pressure has changed and should be sent.
|
||||
int pressureChangeRate = 0; //the difference between current and previous sensor readings
|
||||
int sensorCalibration = 0; //the sensor reading at startup, used as a base value
|
||||
byte offset = 15;
|
||||
byte customScalePosition; //used to indicate the position of the current note on the custom chart scale (needed for state calculation)
|
||||
int sensorThreshold[] = {260, 0}; //the pressure sensor thresholds for initial note on and shift from register 1 to register 2, before some transformations.
|
||||
int upperBound = 255; //this represents the pressure transition between the first and second registers. It is calculated on the fly as: (sensorThreshold[1] + ((newNote - 60) * multiplier))
|
||||
byte newState; //the note/octave state based on the sensor readings (1=not enough force to sound note, 2=enough force to sound first octave, 3 = enough force to sound second octave)
|
||||
byte prevState = 1; //the previous state, used to monitor change necessary for adding a small delay when a note is turned on from silence and we're sending not on velocity based on pressure.
|
||||
boolean sensorDataReady = 0; //tells us that pressure data is available
|
||||
boolean velocityDelay = 0; //whether we are currently waiting for the pressure to rise after crossing the threshold from having no note playing to have a note playing. This is only used if we're sending velocity based on pressure.
|
||||
unsigned long velocityDelayTimer = 0; //a timer for the above delay.
|
||||
bool jump = 0; //whether we jumped directly to second octave from note off because of rapidly increasing pressure.
|
||||
unsigned long jumpTimer = 0; //records time when we dropped to note off.
|
||||
int jumpTime = 15; //the amount of time to wait before dropping back down from an octave jump to first octave because of insufficient pressure
|
||||
bool drop = 0; //whether we dropped directly from second octave to note off
|
||||
unsigned long dropTimer = 0; //time when we jumped to second octave.
|
||||
int dropTime = 15 ; //the amount of time to wait (ms) before turning a note back on after dropping directly from second octave to note off
|
||||
byte jumpValue = 15;
|
||||
byte dropValue = 15;
|
||||
byte multiplier = 15; //controls how much more difficult it is to jump to second octave from higher first-octave notes than from lower first-octave notes. Increasing this makes playing with a bag more forgiving but requires more force to reach highest second-octave notes. Can be set according to fingering mode and breath mode (i.e. a higher jump factor may be used for playing with a bag). Array indices 1-3 are for breath mode jump factor, indices 4-6 are for bag mode jump factor.
|
||||
byte soundTriggerOffset = 3; //the number of sensor values above the calibration setting at which a note on will be triggered (first octave)
|
||||
int learnedPressure = 0; //the learned pressure reading, used as a base value
|
||||
|
||||
unsigned int inputPressureBounds[4][4] = { //for mapping pressure input range to output range. Dimension 1 is CC, velocity, aftertouch, poly. Dimension 2 is minIn, maxIn, scaledMinIn, mappedPressure
|
||||
{100, 800, 0, 0},
|
||||
{100, 800, 0, 0},
|
||||
{100, 800, 0, 0},
|
||||
{100, 800, 0, 0},
|
||||
};
|
||||
|
||||
unsigned long pressureInputScale[4] = // precalculated scale factor for mapping the input pressure range, for CC, velocity, aftertouch, and poly.
|
||||
{0, 0, 0, 0};
|
||||
|
||||
byte outputBounds[4][2] = { // container for ED output pressure range variables (CC, velocity, aftertouch, poly)-- the ED variables will be copied here so they're in a more logical order. This is a fix for variables that were added later.
|
||||
{0, 127},
|
||||
{0, 127},
|
||||
{0, 127},
|
||||
{0, 127}
|
||||
};
|
||||
|
||||
byte curve[4] = {0, 0, 0, 0}; //similar to above-- more logical odering for the pressure curve variable
|
||||
|
||||
|
||||
//variables for reading tonehole sensors
|
||||
volatile byte lastRead = 0; //the transistor that was last read, so we know which to read the next time around the loop.
|
||||
unsigned int toneholeCovered[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; //covered hole tonehole sensor readings for calibration
|
||||
int toneholeBaseline[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; //baseline (uncovered) hole tonehole sensor readings
|
||||
volatile int tempToneholeRead[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; //temporary storage for tonehole sensor readings with IR LED on, written during the timer ISR
|
||||
int toneholeRead[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; //storage for tonehole sensor readings, transferred from the above volatile variable
|
||||
volatile int tempToneholeReadA[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; //temporary storage for ambient light tonehole sensor readings, written during the timer ISR
|
||||
unsigned int holeCovered = 0; //whether each hole is covered-- each bit corresponds to a tonehole.
|
||||
uint8_t tempCovered = 0; //used when masking holeCovered to ignore certain holes depending on the fingering pattern.
|
||||
bool fingersChanged = 1; //keeps track of when the fingering pattern has changed.
|
||||
unsigned int prevHoleCovered = 1; //so we can track changes.
|
||||
volatile int tempNewNote = 0;
|
||||
byte prevNote;
|
||||
byte newNote = -1; //the next note to be played, based on the fingering chart (does not include transposition).
|
||||
byte notePlaying; //the actual MIDI note being played, which we remember so we can turn it off again.
|
||||
volatile bool firstTime = 1; // we have the LEDs off ~50% of the time. This bool keeps track of whether each LED is off or on at the end of each timer cycle
|
||||
volatile byte timerCycle = 0; //the number of times we've entered the timer ISR with the new sensors.
|
||||
byte newDroneNote;
|
||||
//byte prevDroneNote; // Has no use for now
|
||||
byte droneNotePlaying;
|
||||
|
||||
//pitchbend variables
|
||||
unsigned long pitchBendTimer = 0; //to keep track of the last time we sent a pitchbend message
|
||||
byte pitchBendOn[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; //whether pitchbend is currently turned for for a specific hole
|
||||
int pitchBend = 8192; //total current pitchbend value
|
||||
int prevPitchBend = 8192; //a record of the previous pitchBend value, so we don't send the same one twice
|
||||
int iPitchBend[] = {8192, 8192, 8192, 8192, 8192, 8192, 8192, 8192, 8192}; //current pitchbend value for each tonehole
|
||||
int pitchBendPerSemi = 4096;
|
||||
int prevChanPressure = 0;
|
||||
int prevCCPressure = 0;
|
||||
int prevPolyPressure = 0;
|
||||
unsigned long pressureTimer = 0; //to keep track of the last time we sent a pressure message
|
||||
unsigned long noteOnTimestamp = 0; // ms timestamp the note was activated
|
||||
byte slideHole; //the hole above the current highest uncovered hole. Used for detecting slides between notes.
|
||||
byte stepsDown = 1; //the number of half steps down from the slideHole to the next lowest note on the scale, used for calculating pitchbend values.
|
||||
byte vibratoEnable = 0; // if non-zero, send vibrato pitch bend
|
||||
unsigned int holeLatched = 0b000000000; //holes that are disabled for vibrato because they were covered when the note was triggered. They become unlatched (0) when the finger is removed all the way.
|
||||
unsigned int vibratoHoles = 0b111111111; //holes to be used for vibrato, left thumb on left, bell sensor far right.
|
||||
unsigned int toneholeScale[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; //a scale for normalizing the range of each sensor, for sliding
|
||||
unsigned int vibratoScale[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; //same as above but for vibrato
|
||||
int expression = 0; //pitchbend up or down from current note based on pressure
|
||||
bool customEnabled = 0; //Whether the custom vibrato above is currently enabled based on fingering pattern and pitchbend mode.
|
||||
int adjvibdepth; //vibrato depth scaled to MIDI bend range.
|
||||
|
||||
//variables for managing MIDI note output
|
||||
bool noteon = 0; //whether a note is currently turned on
|
||||
bool shiftState = 0; //whether the octave is shifted (could be combined with octaveShift)
|
||||
int8_t shift = 0; //the total amount of shift up or down from the base note 62 (D). This takes into account octave shift and note shift.
|
||||
byte velocity = 127;//default MIDI note velocity
|
||||
|
||||
//tonehole calibration variables
|
||||
byte calibration = 0; //whether we're currently calibrating. 1 is for calibrating all sensors, 2 is for calibrating bell sensor only, 3 is for calibrating all sensors plus baseline calibration (normally only done once, in the "factory").
|
||||
unsigned long calibrationTimer = 0;
|
||||
|
||||
//variables for reading buttons
|
||||
unsigned long buttonReadTimer = 0; //for telling when it's time to read the buttons
|
||||
byte integrator[] = {0, 0, 0}; //stores integration of button readings. When this reaches MAXIMUM, a button press is registered. When it reaches 0, a release is registered.
|
||||
bool pressed[] = {0, 0, 0}; //whether a button is currently presed (this it the output from the integrator)
|
||||
bool released[] = {0, 0, 0}; //if a button has just been released
|
||||
bool justPressed[] = {0, 0, 0}; //if a button has just been pressed
|
||||
bool prevOutput[] = {0, 0, 0}; //previous state of button, to track state through time
|
||||
bool longPress[] = {0, 0, 0}; //long button press
|
||||
unsigned int longPressCounter[] = {0, 0, 0}; //for counting how many readings each button has been held, to indicate a long button press
|
||||
bool noteOnOffToggle[] = {0, 0, 0}; //if using a button to toggle a noteOn/noteOff command, keep track of state.
|
||||
bool longPressUsed[] = {0, 0, 0}; //if we used a long button press, we set a flag so we don't use it again unless the button has been released first.
|
||||
bool buttonUsed = 0; //flags any button activity, so we know to handle it.
|
||||
bool specialPressUsed[] = {0, 0, 0};
|
||||
bool dronesOn = 0; //used to monitor drones on/off.
|
||||
|
||||
//variables for communication with the WARBL Configuration Tool
|
||||
bool communicationMode = 0; //whether we are currently communicating with the tool.
|
||||
byte buttonReceiveMode = 100; //which row in the button configuration matrix for which we're currently receiving data.
|
||||
byte pressureReceiveMode = 100; //which pressure variable we're currently receiving date for. From 1-12: Closed: offset, multiplier, jump, drop, jump time, drop time, Vented: offset, multiplier, jump, drop, jump time, drop time
|
||||
byte counter = 0; // We use this to know when to send a new pressure reading to the configuration tool. We increment it every time we send a pitchBend message, to use as a simple timer wihout needing to set another actual timer.
|
||||
byte fingeringReceiveMode = 0; // indicates the mode (instrument) for which a fingering pattern is going to be sent
|
||||
|
||||
void setup()
|
||||
{
|
||||
|
||||
DIDR0 = 0xff; // disable digital input circuits for analog pins
|
||||
DIDR2 = 0xf3;
|
||||
|
||||
pinMode2(ledPin, OUTPUT); // Initialize the LED pin as an output (using the fast DIO2 library).
|
||||
pinMode2(17, INPUT_PULLUP); //this pin is used to detect when the bell sensor is plugged in (high when plugged in).
|
||||
|
||||
for (byte i = 0; i < 9; i++) { //Initialize the tonehole sensor IR LEDs.
|
||||
pinMode2f(pins[i], OUTPUT);
|
||||
}
|
||||
|
||||
pinMode2f(DP15, INPUT_PULLUP); //set buttons as inputs and enable internal pullup
|
||||
pinMode2f(DP16, INPUT_PULLUP);
|
||||
pinMode2f(DP14, INPUT_PULLUP);
|
||||
|
||||
//EEPROM.update(44,255); //can be uncommented to force factory settings to be resaved for debugging (after making changes to factory settings). Needs to be recommented again after.
|
||||
|
||||
|
||||
if (EEPROM.read(44) != 3 || EEPROM.read(1011) != VERSION) {
|
||||
EEPROM.update(1011, VERSION); //update the stored software version
|
||||
saveFactorySettings(); //If we're running the software for the first time, if a factory reset has been requested, or if the software version has changed, copy all settings to EEPROM.
|
||||
}
|
||||
|
||||
if (EEPROM.read(37) == 3) {
|
||||
loadCalibration(); //If there has been a calibration saved, reload it at startup.
|
||||
}
|
||||
|
||||
loadFingering();
|
||||
loadSettingsForAllModes();
|
||||
mode = defaultMode; //set the startup instrument
|
||||
|
||||
analogRead(A4); // the first analog readings are sometimes nonsense, so we read a few times and throw them away.
|
||||
analogRead(A4);
|
||||
sensorCalibration = analogRead(A4);
|
||||
sensorValue = sensorCalibration; //an initial reading to "seed" subsequent pressure readings
|
||||
|
||||
loadPrefs(); //load the correct user settings based on current instrument.
|
||||
|
||||
//prepare sensors
|
||||
Timer1.initialize(100); //this timer is only used to add some additional time after reading all sensors, for power savings.
|
||||
Timer1.attachInterrupt(timerDelay);
|
||||
Timer1.stop(); //stop the timer because we don't need it until we've read all the sensors once.
|
||||
ADC_init(); //initialize the ADC and start conversions
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
void loop()
|
||||
{
|
||||
|
||||
//cycles ++; //for testing
|
||||
|
||||
receiveMIDI();
|
||||
|
||||
if ((millis() - buttonReadTimer) >= 5) { //read the state of the control buttons every so often
|
||||
checkButtons();
|
||||
buttonReadTimer = millis();
|
||||
}
|
||||
|
||||
if (buttonUsed) {
|
||||
handleButtons(); //if a button had been used, process the command. We only do this when we need to, so we're not wasting time.
|
||||
}
|
||||
|
||||
if (blinkNumber > 0) {
|
||||
blink(); //blink the LED if necessary (indicating control changes, etc.)
|
||||
}
|
||||
|
||||
if (calibration > 0) {
|
||||
calibrate(); //calibrate/continue calibrating if the command has been received.
|
||||
}
|
||||
|
||||
noInterrupts();
|
||||
for (byte i = 0; i < 9; i++) {
|
||||
toneholeRead[i] = tempToneholeRead[i]; //transfer sensor readings to a variable that won't get modified in the ISR
|
||||
}
|
||||
interrupts();
|
||||
|
||||
|
||||
for (byte i = 0; i < 9; i++) {
|
||||
if (calibration == 0) { //if we're not calibrating, compensate for baseline sensor offset (the stored sensor reading with the hole completely uncovered)
|
||||
toneholeRead[i] = toneholeRead[i] - toneholeBaseline[i];
|
||||
}
|
||||
if (toneholeRead[i] < 0) { //in rare cases the adjusted readings can end up being negative.
|
||||
toneholeRead[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
get_fingers(); //find which holes are covered
|
||||
|
||||
|
||||
if (prevHoleCovered != holeCovered) {
|
||||
fingersChanged = 1;
|
||||
|
||||
tempNewNote = get_note(holeCovered); //get the next MIDI note from the fingering pattern if it has changed
|
||||
send_fingers(); //send new fingering pattern to the Configuration Tool
|
||||
prevHoleCovered = holeCovered;
|
||||
if (pitchBendMode == kPitchBendSlideVibrato || pitchBendMode == kPitchBendLegatoSlideVibrato) {
|
||||
findStepsDown();
|
||||
}
|
||||
|
||||
|
||||
if (tempNewNote != -1 && newNote != tempNewNote) { //If a new note has been triggered
|
||||
if (pitchBendMode != kPitchBendNone) {
|
||||
holeLatched = holeCovered; //remember the pattern that triggered it (it will be used later for vibrato)
|
||||
for (byte i = 0; i < 9; i++) {
|
||||
iPitchBend[i] = 0; //and reset pitchbend
|
||||
pitchBendOn[i] = 0;
|
||||
}
|
||||
}
|
||||
newNote = tempNewNote; //update the next note if the fingering pattern is valid
|
||||
}
|
||||
|
||||
// CHANGES: I moved the line that was here before inside previous if block, otherwise it does not seem to be actually checked for validity
|
||||
// Plus, it has no use to update newNote if it is equal to tempNewNote.
|
||||
|
||||
// Handle Drone notes in Boha mode
|
||||
if (modeSelector[mode] == kModeBoha) {
|
||||
// Get the drone note
|
||||
tempNewNote = get_noteDrone(holeCovered);
|
||||
if (tempNewNote != -1 && newDroneNote != tempNewNote) {
|
||||
newDroneNote = tempNewNote;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (sensorDataReady) {
|
||||
get_state();//get the breath state from the pressure sensor if there's been a reading.
|
||||
}
|
||||
|
||||
unsigned long nowtime = millis();
|
||||
|
||||
if (switches[mode][SEND_VELOCITY]) { //if we're sending NoteOn velocity based on pressure
|
||||
if (prevState == 1 && newState != 1) {
|
||||
velocityDelayTimer = nowtime; //reset the delay timer used for calculating velocity when a note is turned on after silence.
|
||||
}
|
||||
prevState = newState;
|
||||
}
|
||||
|
||||
get_shift(); //shift the next note up or down based on register, key, and characteristics of the current fingering pattern.
|
||||
|
||||
if ((nowtime - pressureTimer) >= ((nowtime - noteOnTimestamp) < 20 ? 2 : 5)) {
|
||||
pressureTimer = nowtime;
|
||||
if (abs(prevSensorValue - sensorValue) > 1) { //if pressure has changed more than a little, send it.
|
||||
if (ED[mode][SEND_PRESSURE]) {
|
||||
calculatePressure(0);
|
||||
}
|
||||
if (switches[mode][SEND_VELOCITY]) {
|
||||
calculatePressure(1);
|
||||
}
|
||||
if (switches[mode][SEND_AFTERTOUCH] & 1) {
|
||||
calculatePressure(2);
|
||||
}
|
||||
if (switches[mode][SEND_AFTERTOUCH] & 2) {
|
||||
calculatePressure(3);
|
||||
}
|
||||
|
||||
sendPressure(false);
|
||||
|
||||
if (communicationMode) {
|
||||
sendUSBMIDI(CC, 7, 116, sensorValue & 0x7F); //send LSB of current pressure to configuration tool
|
||||
sendUSBMIDI(CC, 7, 118, sensorValue >> 7); //send MSB of current pressure
|
||||
}
|
||||
prevSensorValue = sensorValue;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if ((nowtime - pitchBendTimer) >= 9) { //check pitchbend and send pressure data every so often
|
||||
pitchBendTimer = nowtime;
|
||||
|
||||
calculateAndSendPitchbend();
|
||||
|
||||
|
||||
counter++;
|
||||
|
||||
if (counter == 10) { //we check every 10 ticks to see if the bell sensor has been plugged/unplugged.
|
||||
|
||||
counter = 0;
|
||||
bellSensor = (digitalRead2(17)); //check if the bell sensor is plugged in
|
||||
if (prevBellSensor != bellSensor) {
|
||||
prevBellSensor = bellSensor;
|
||||
if (communicationMode) {
|
||||
sendUSBMIDI(CC, 7, 102, 120 + bellSensor); //if it's changed, tell the configuration tool.
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//Serial.println(newState);
|
||||
//Serial.println(ED[mode][VELOCITY_INPUT_PRESSURE_MIN]);
|
||||
//Serial.println(outputBounds[0][0]);
|
||||
//Serial.println(inputPressureBounds[0][3]);
|
||||
//FREERAM_PRINT
|
||||
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
sendNote(); //send the MIDI note
|
||||
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user