Multitouch musikkontroll (22 / 26 steg)

Steg 22: Firmware

/*
* "ArduinomeFirmware" - Arduino baserat Monome klon av Owen Vallis & Jordan Hochenbaum 2008-06-16
* Reviderad 2008-06-26
* Reviderad 2008-07-20 av Ben Southall
* Omarbetad 2009-03-21 Ben Southall
* Reviderade 01/21/2012 Jordanien Hochenbaum v3.3 rev.a
* Reviderade 06/2012 för 74HC595 av Amanda Ghassaei
* --------------------------------------------------------------------------
* Detta program är fri programvara; Du kan vidaredistribuera det och/eller ändra
* det enligt villkoren i GNU General Public License som offentliggjorts av
* den Free Software Foundation; antingen version 2 av licensen, eller
* (på ditt alternativ) någon senare version.
*
* Detta program är distribuerat i hopp om att det kommer att vara användbar,
* men utan garantier; utan att ens underförstådd garanti om
* SÄLJBARHET eller lämplighet för ett visst ändamål. Se den
* GNU General Public License för mer detaljer.
* --------------------------------------------------------------------------
*
* Denna kod är till stor del en direkt översättning av 40h protokollet designad av Brian Crabtree
* & Joe Lake, och kodad genom Joe sjön. Vi vill uttrycka vårt yttersta tack för att göra
* monome & dess inre-arbetet tillgänglig och öppen källkod. Vi vill också utöka
* Tack till alla som har hjälpt oss få detta långt i att framgångsrikt göra en arduino-
* baserat monome klon, inklusive men inte begränsat till Brad Hill för hans awesome arduino shield,
* och Melka för att visa hur man packa och packa upp seriella.
*
* Ytterligare en kommentar och fördelning 7/20/2008:
* Förändringarna på 7/20/2008 var inspirerade av, och åtminstone i någon del, direkt
* kopieras från 'Octinct' koden skriven av Jonathan M Guberman (upwardnotnorthward.com).
* I synnerhet var användning av timer 2 att köra rutinen avbrott att läsa den seriella porten
* plockat upp från Octinct-projektet, och även ange baudvärde till 57600 tycktes vara
* kritiska för att få allt att fungera tillförlitligt. Mitt tack till Jonathan för att dela hans
* programvara, och för att räkna ut hur att hålla denna följetong buffert i schack.
*
* Ändrar 2009-03-21
*
* Extra ADC stöd för arduino ADCs 0 - 3. Tack vare Josh Lory för det första snittet av koden för
* Detta. Lagt till hantering av ADC aktivera/inaktivera seriell meddelanden och ändrade Josh checkADC kod
* att loopa igenom 4 ADCs snarare än att läsa var och en individuellt. Också, rensade upp ett antal
* oanvända variabler, och flyttade alla PORT pin definitioner till toppen av filen; Detta bör göra det
* lättare för personer som inte använder unsped skölden till ändra maskinvaruanslutningar.
*
* INTE maila monome med tekniska frågor och/eller hjälp när det gäller denna kod eller klon.
* De är på något sätt ansvariga eller anslutna med detta projekt än de var vår inspiration
* och vi använde många av deras metoder och drog från sin kod.
*
* Dessutom medan vi är availble och villig att hjälpa så mycket som möjligt, kan inte vi också hållas
* ansvarig för allt du gör med denna kod. Tveka inte att rapportera eventuella buggar, förslag
* eller förbättringar för oss som de är alla välkomna. Återigen, vi kan inte hållas ansvariga för eventuella skador
* eller skador som orsakas av användning eller missbruk av denna kod eller våra instruktioner. Tack för förståelse.
*
*
*
*
* Ändrar 21/01/2012 & 3.3
* Arduino 1.0 + kompatibilitet (använder .ino tillägg och inte längre anger BYTE typ i Serial.write)
* --------------------------------------------------------------------------
*
* Länkar:
www.monome.org - vår hemsida - klicka på "Arbete/Arduinome" i navigationsmenyn på toppen.
www.monome.org - den "ursprungliga" monome och vår inspiration
www.monome.org
www.monome.org
*
*/

STIFT och porttilldelningar
Om du använder maskinvara än unsped sköld, vill du gå igenom denna del av koden,
och ändra pin-koder och atmega 168 portar som du använder. Vi använder pin/porttilldelningar här,
INTE pin nummer systemet från arduino styrelsen utgångar (e.g. arduino digital stift 8 = PORTB stift 1)
Men i kommentarerna nedan, jag ger motsvarigheterna mellan arduino digital pin-koder och den
ATmega168's PORT/bit numrering.

VIKTIGT - måste du se till att du anger data efter två riktning register-variabler som matchar din
stift.
byte PORTD_Data_Direction = 0x02, //all ingångar utom stift 1 (TX)
byte PORTB_Data_Direction = 0xFF; //all utgångar
byte PORTC_Data_Direction = 0xFC; //A2-A5 finns utgångar, A0, A1 ingångar

Anslutningar till 595 skiftregister
dataPin = A4 = PORTC, lite 4
clockPin = A2 = PORTC, bit 2
latchPin = A3 = PORTC, bit 3
#define DATA_PORT_595 (PORTC)
byte dataPin595 = 4;
byte dataPin595MaskHigh = 1 << dataPin595;
byte dataPin595MaskLow = ~ dataPin595MaskHigh;

#define CLOCK_PORT_595 (PORTC)
byte clockPin595 = 2;
byte clockPin595MaskHigh = 1 << clockPin595;
byte clockPin595MaskLow = ~ clockPin595MaskHigh;

#define LATCH_PORT_595 (PORTC)
byte latchPin595 = 3;
byte latchPin595MaskHigh = 1 << latchPin595;
byte latchPin595MaskLow = ~ latchPin595MaskHigh;

Anslutningar till Max7219 (enheter lysdioder)
dataIn = arduino pin A5 = PORTC, lite 5
Ladda = arduino stift 11 = PORTB bit 4
klockan = arduino stift 12 = PORTB, lite 5
#define LED_DATA_PORT (PORTC)
byte MaxDataPin = 5;
byte DataMaskHigh = 1 << MaxDataPin;
byte DataMaskLow = ~ DataMaskHigh;

#define LED_CLOCK_PORT (PORTB)
byte MaxClockPin = 5;
byte ClockMaskHigh = 1 << MaxClockPin;
byte ClockMaskLow = ~ ClockMaskHigh;

#define LED_LOAD_PORT (PORTB)
byte MaxLoadPin = 4;
byte LoadMaskHigh = 1 << MaxLoadPin;
byte LoadMaskLow = ~ LoadMaskHigh;
avsluta anslutningar till 165 SKIFT register

Använd detta för att fixa spegling
booleska mirrorXLEDs = sant;
booleska mirrorYLEDs = false;
booleska mirrorXButtons = false;
booleska mirrorYButtons = false;

SLUTET pin och porttilldelningar

// ----------------------------

Globala variabler

byte byte0, byte1; lagring för inkommande seriella data

byte WaitingForAddress = 1; 1 när vi förväntar oss den nästa seriella byten vara en adressvärde, 0 annars

byte adress = 0x00; sopor byte att hålla adressen funktionen
byte state = 0x00; sopor byte att hålla staten värde
byte x = 0x00; sopor byte att hålla x position
byte y = 0x00; sopor byte att hålla y-position
byte z = 0x00; sopor byte att iterera över knappar

Följande variabler används för att lagra flaggor som anger om vi har fått ett visst meddelande,
värdet av data i meddelandet. t.ex. IntensityChange = 0 == inget intensitet förändring meddelande tas emot,
IntensityChange = 1 == en intensitet förändring meddelande har tagits emot, och det värdet kommer att vara i IntensityVal
Koden som så småningom fungerar på det inkommande meddelandet återställs variabeln "Förändring" till 0 en gång den
meddelande har hanterats.

byte IntensityChange = 0;
byte IntensityVal = 0;

byte DisplayTestChange = 0;
byte DisplayTestVal = 0;

byte ShutdownModeChange = 0;
byte ShutdownModeVal = 0;

Dessa variabler används för att hantera ADC meddelanden, och butiken vilka portar är för närvarande aktiverade,
och vilka som inte.
byte ADCnum;
byte ADCstate;
byte ADCEnableState [4].

byte ledmem [8]. minne för LED stater - 64 bitar.

byte j = 0; tillfälliga variabeln för knappen looping
int jag = 0; tillfälliga variabeln för looping etc.
int-id = 0; tillfällig förvaring för inkommande meddelande-ID
byte firstRun = 1; 1 när vi har ännu att ta emot ett LED kommando, 0 efter det.
används för att säkerställa att våra led stat minne är korrekt initierad när vi meddelande första LED

int kButtonUpDefaultDebounceCount = 12; Används i knappen debouncing

int kButtonNewEvent = 1; Används för att lagra om tillståndet i en knapp har förändrats eller inte.

byte t = 0; tillfälliga variabeln används i knappen bearbetning

/ * KNAPPEN VEKTORVARIABLER

För 1/0 knapplägen, använda 8 byte (64 bitar)
För knappen debounce counter, använda 8 x 8 matris

*/
byte button_current [8].
byte button_last [8].
byte button_state [8].
byte button_debounce_count [8] [8].
byte button_event [8].
/ * SLUTET AV KNAPPEN VEKTORVARIABLER * /

/ * MAX 7219 INSTRUKTION ADRESSER * /

byte max7219_reg_noop = 0x00; definiera max7219 register (Läs tech doc för förklaring)
byte max7219_reg_digit0 = 0x01;
byte max7219_reg_digit1 = 0x02;
byte max7219_reg_digit2 = 0x03;
byte max7219_reg_digit3 = 0x04;
byte max7219_reg_digit4 = 0x05;
byte max7219_reg_digit5 = 0x06;
byte max7219_reg_digit6 = 0x07;
byte max7219_reg_digit7 = 0x08;
byte max7219_reg_decodeMode = 0x09;
byte max7219_reg_intensity = 0x0a;
byte max7219_reg_scanLimit = 0x0b;
byte max7219_reg_shutdown = 0x0c;
byte max7219_reg_displayTest = 0x0f;

/ * SLUTET AV MAX 7219 INSTRUKTION ADRESSER * /

putByte - helper funktion som skickar en byte till MAX chip
void putByte(byte data)
{
byte jag = 8.
byte mask;

While(i > 0)
{
mask = 0x01 << (i - 1); få bitmask

om (data & mask) / / kontrollera och skicka värdet av denna bit
{
LED_DATA_PORT | = DataMaskHigh;
}
annat
{
LED_DATA_PORT & = DataMaskLow;
}

Puls MAX klockan
LED_CLOCK_PORT & = ClockMaskLow; digitalWrite (klocka, låg); "kryssa" prepeare för lite input
LED_CLOCK_PORT | = ClockMaskHigh; / / digitalWrite (klocka, hög); "tock" input bit

--i; flytta till mindre bitar
}
}

maxSingle är funktionen "lätt" att använda för en enda max7219
gräva är rad samtalet, och seg är kolumnen samtal gräva och seg avse pin namn från tech doc

void maxSingle (byte gräva, byte seg) {

LED_LOAD_PORT & = LoadMaskLow; digitalWrite (belastning, låg); börja

putByte(dig); Ange register
putByte(seg); ((data & 0x01) * 256) + data >> 1); lägga data

LED_LOAD_PORT | = LoadMaskHigh; digitalWrite(load,HIGH);

}

buttonInit - helper funktion som nollor knapplägen
void buttonInit(void) {
byte i.
för (jag = 0; jag < 8; i ++) {
button_current [i] = 0x00;
button_last [i] = 0x00;
button_state [i] = 0x00;
button_event [i] = 0x00;
}
}

buttonCheck - kontrollerar status för en viss knapp.
void buttonCheck (byte rad, byte index)
{
om (((button_current [rad] ^ button_last[row]) & (1 << index)) & & / / om det aktuella fysiska knapp läget skiljer sig från den
((button_current [rad] ^ button_state[row]) & (1 << index))) {/ / last fysisk knapp staten och nuvarande debounced staten

om (button_current [rad] & (1 << index)) {/ / om nuläget fysisk knapp trycks
button_event [rad] = kButtonNewEvent << index; köa upp en ny knapp händelse omedelbart
button_state [rad] | = (1 << index); och ställa in debounced ner.
}
annat {
button_debounce_count [rad] [index] = kButtonUpDefaultDebounceCount;
} / / annars knappen tidigare var deprimerad och nu
har släppts så vi våra debounce counter.
}
annars om (((button_current [rad] ^ button_last[row]) & (1 << index)) == 0 & & / / om det aktuella fysiska knapp läget är samma som
(button_current [rad] ^ button_state[row]) & (1 << index)) {/ / den senaste fysiskt knappen stat men den nuvarande fysiskt
knappläge skiljer sig från den nuvarande debounce
statliga...

om (button_debounce_count [rad] [index] > 0 & &--button_debounce_count [rad] [index] == 0) {/ / om den räknaren debounce har
varit minskas till 0 (menande den
knappen har varit upp i
kButtonUpDefaultDebounceCount
iterationer / / /

button_event [rad] = kButtonNewEvent << index; köa en knapp staten change-händelse

om (button_current [rad] & (1 << index)) {/ / och växla knapparna debounce staten.
button_state [rad] | = (1 << index);
}
annat {
button_state [rad] & = ~ (1 << index);
}
}
}
}

void buttonpress)
{
för (jag = 0; jag < 8; i ++) {
LATCH_PORT_595 & = latchPin595MaskLow; / / Ställ in spärren pin låg så utgångarna inte ändras när du skickar i bitar
för (j = 0; j < 8; j ++) {
CLOCK_PORT_595 & = clockPin595MaskLow;//digitalWrite(clockPin,LOW);
om (j == jag) {//if index lika aktuella jag värde, lågt inställd
DATA_PORT_595 & = dataPin595MaskLow;//digitalWrite(A4,LOW);
}
annat {//set resten av stiften hög
DATA_PORT_595 | = dataPin595MaskHigh;//digitalWrite(A4,HIGH);
}
CLOCK_PORT_595 | = clockPin595MaskHigh;//digitalWrite(clockPin,HIGH);
}

ställa in spärren pin hög-detta skickar data till utgångar
LATCH_PORT_595 | = latchPin595MaskHigh; //digitalWrite (latchPin, hög);

Avmattningen sätts i här slösa bort lite tid medan vi väntar på statligt av produktionen
Pins sedimentera. Utan denna tid slösa slinga, skulle en enda knapptryckning dyka upp som
två pressar (knappen och dess granne)
flyktiga int avmattning = 0;

medan (avmattning < 15) {
Avmattningen ++;
}
button_last [i] = button_current [i];

för (id = 0; id < 8; id ++) {
Växla (id) {
fall 0:
t = digitalRead(A0);
bryta;
fall 1:
t = digitalRead(A1);
bryta;
fall 2:
t = digitalRead(2);
bryta;
fall 3:
t = digitalRead(3);
bryta;
fall 4:
t = digitalRead(4);
bryta;
fall 5:
t = digitalRead(5);
bryta;
fall 6:
t = digitalRead(6);
bryta;
fall 7:
t = digitalRead(7);
bryta;
}
t = (t == 0), //invert t
IF(t) {
button_current [i] | = (1 << id);
}
annat {
button_current [i] & = ~ (1 << id);
}
buttonCheck (i, id);
om (button_event [i] & (1 << id)) {
button_event [i] & = ~ (1 << id); //zero knappen händelse
om (button_state [i] & (1 << id)) {
Serial.write(1);
}
annat {
Serial.write(byte(0));
}

om (mirrorXButtons) {
ID = 7-id;
}
om (mirrorYButtons) {
Jag = 7-i.
}
Serial.write(((ID) << 4) | (i));
}
}
}

Ange alla stift av 595 hög
LATCH_PORT_595 & = latchPin595MaskLow; / / Ställ in spärren pin låg så utgångarna inte ändras när du skickar i bitar

för (j = 0; j < 8; j ++) {
CLOCK_PORT_595 & = clockPin595MaskLow;//digitalWrite(clockPin,LOW);
DATA_PORT_595 | = dataPin595MaskHigh;//digitalWrite(A4,HIGH);
CLOCK_PORT_595 | = clockPin595MaskHigh;//digitalWrite(clockPin,HIGH);
}
ställa in spärren pin hög-detta skickar data till utgångar
LATCH_PORT_595 | = latchPin595MaskHigh; //digitalWrite (latchPin, hög);

}

ISR(TIMER2_COMPA_vect) {

göra
{
om (Serial.available())
{
om (WaitingForAddress == 1)
{
byte0 = Serial.read();

Adress = byte0 >> 4.
WaitingForAddress = 0;
} / / end om (WaitingForAddress == 1);

om (Serial.available())
{
WaitingForAddress = 1;
byte1 = Serial.read();

Switch(Address)
{
fall 2:
State = byte0 & 15.
x = byte1 >> 4.
y = byte1 & 15.

om (statligt == 0) {
ledmem [7-y] & = ~ (1 << x);
}
annat {
ledmem [7-y] | = (1 << x);
}
bryta;
fall 3:
IntensityChange = 1;
IntensityVal = byte1 & 15.
bryta;
fall 4:
DisplayTestChange = 1;
DisplayTestVal = byte1 & 15.
bryta;
fall 5:
State = byte1 & 0x0F;
ADCEnableState [(byte1 >> 4) & 0x03] = staten.
bryta;
fall 6:
ShutdownModeChange = 1;
ShutdownModeVal = byte1 & 15.
bryta;
fall 7:
om (firstRun == 1) {
för (x = 0, x < 8, x ++) {
ledmem [x] = 0;
}

firstRun = 0;
}

x = ((byte0 & 15) & 0x7); maskera detta värde så vi inte skriva till en ogiltig adress.
y = byte1;

om (mirrorYLEDs) {
y = 7-y;
}
om (mirrorXLEDs) {
x=flipByte(x);
}

ledmem [x] = y;
bryta;
mål 8:
om (firstRun == 1)
{
för (x = 0, x < 8, x ++)
{
ledmem [x] = 0;
}

firstRun = 0;
}

x = ((byte0 & 15) & 0x7);
y = byte1;

om (mirrorYLEDs) {
x = 7-x;
}
om (mirrorXLEDs) {
y=flipByte(y);
}
för (z = 0, z < 8, z ++)
{
om (y & (1 << z))
{
ledmem [z] | = 1 << x;
}
annat
{
ledmem [z] & = ~ (1 << x);
}
}
bryta;
} / / end switch(address)
} / / end om (Serial.available()
} / / end om (Serial.available();
} / / end do
medan (Serial.available() > 16);
}

void whoosh(void)
{
återaktivera overflow avbrott för
Timer 1 - är i behov av delay(...)
TIMSK0 | = (1 << TOIE0);

för (int j = 0; j < 9; j ++)
{
för (int jag = 0; jag < 8; i ++)
{
maxSingle (i + 1, 1 << j);
}
Delay(125);
}
och stänga av avbrottet.
TIMSK0 & = ~ (1 << TOIE0);
}

Ogiltiga inställningar () {

DDRD = PORTD_Data_Direction;
DDRB = PORTB_Data_Direction;
DDRC = PORTC_Data_Direction;

Serial.BEGIN(57600);

buttonInit();

inledande av de max 7219
maxSingle (max7219_reg_scanLimit, 0x07);
maxSingle(max7219_reg_intensity,0x0F);
maxSingle (max7219_reg_shutdown, 0x01); inte i Avslutningsläge
maxSingle (max7219_reg_displayTest, 0x00); Töm register, tur alla lysdioder av h

för (jag = 1; jag < = 8; i ++) {
maxSingle(i,0);
ledmem [i-1] = 0;
}

(CLI); //stop avbrott

Ange timer2 avbryta varje 128us
TCCR2A = 0; / / Ställ in hela TCCR2A register till 0
TCCR2B = 0; / / samma för TCCR2B
TCNT2 = 0; //initialize värde till 0
Set jämför match registrera för 7,8 khz steg
OCR2A = 255; / / = (16 * 10 ^ 6) / (7812.5 * 8) - 1 (måste vara < 256)
Aktivera CTC läge
TCCR2A | = (1 << WGM21);
Ange CS11 bit för 8 prescaler
TCCR2B | = (1 << CS11);
Aktivera timern jämför avbrott
TIMSK2 | = (1 << OCIE2A);

SEI (); //allow avbrott

/ / Ställ in 8-bitars räknare 2, utgång jämför avstängd,
/ / normal vågform generation (vad nu det kan betyda)
TCCR2A = 0;
/ / Ställ counter att vara klockad till 16Mhz/8 = 2 Mhz
TCCR2B = 1 << CS21;
//
/ / Ställ avbrott masken så att vi får ett avbrott
/ / på timer 2 spill, dvs efter 256 klockcykler.
/ / Timer 2 avbrott rutin kommer att köra varje
/ / 128 oss.
TIMSK2 = 1 << TOIE2;
//
/ / Obs: I mina ansträngningar att försöka få detta
/ / kod för att fungera tillförlitligt på 115200 baud
/ / jag gick om att inaktivera oanvänd timers som
/ / ställs in av Arduino ramen.
/ / Ramen sätter upp både timer 2 och
/ / timer 1. Vi använder timer 2 att köra den
/ / seriell läsa avbrott, så kan vi bara
/ / Inaktivera timer1 och dess avbrott.
//
/ / VERKLIGEN VIKTIGT OBSERVERA - OM DU VILL ANVÄNDA
/ / ANALOGWRITE
//
/ / Inaktivera timer 1 kommer att stänga av timern
/ / används för PWM, som ligger bakom analogWrite.
/ / Om du vill använda analogWrite, ta bort
/ / raderna nedan.
//
/ / INAKTIVERA PWM COUNTER
TIMSK0 & = ~ (1 << TOIE0);
//
TCCR1B & = ~ (1 << CS12);
TCCR1B & = ~ (1 << CS11);
TCCR1B & = ~ (1 << CS10);
/ / SLUTET INAKTIVERA PWM COUNTER
//
/ / Dessutom inaktiverar avbrotten på timer 0
/ / VERKLIGEN VIKTIGT NOTERA OM DU VILL ANVÄNDA
/ / FÖRDRÖJNING
/ / ta bort den här raden, och även titta på
/ / "SVISCH", som aktiverar och inaktiverar sedan
/ / intterupt på timer 0. Du
/ / för att bli av med dessa rader också.
TIMSK0 & = ~ (1 << TOIE0);

ganska mönster att försäkra mig om att firmware
laddat upp ordentligt.
whoosh();

se till att stänga av belysningen.
för (int jag = 0; jag < 8; i ++)
{
maxSingle(i+1,0);
}
}

void sendADC (int hamn, int värde) {
Serial.write ((1 << 4) | ((port << 2) & 0x0C) | ((värde >> 8) & 0x03));
Serial.write (värde & 0xFF);
//}
//
int nuvarande [4].
int tidigare [4].
int tolerans = 7.

void checkADCs() {
//
för (int adcCounter = 0; adcCounter < 4; adcCounter ++)
// {
//
om (ADCEnableState [adcCounter]! = 0)
// {
aktuella [adcCounter] = analogRead(adcCounter);
//
om (abs(previous[adcCounter]-current[adcCounter]) > tolerans)
// {
föregående [adcCounter] = nuvarande [adcCounter];
sendADC(adcCounter,current[adcCounter]);
// }
//
// }
//
// }
//}

byte flipByte (byte numToFlip) {
byte spegel = 0;
för (int j = 0; j < 8; j ++) {
byte kopia = numToFlip;
spegel | = (kopia >> j) & 1;
om (j < 7) {
spegel spegel = << 1.
}
}
returnera spegel;
}

Ogiltig loop () {

Skicka de LED staterna till ledde matrisen.
för (int jag = 0; jag < 8; i ++)
{
byte ledmemMirror = 0;

om (mirrorXLEDs) {
ledmemMirror=flipByte(ledmem[i]);
} annat {
ledmemMirror = ledmem [i];
}
int y;
om (mirrorYLEDs) {
y =(7-i) + 1;
} annat {
y = i + 1.
}
maxSingle(y,ledmemMirror);
}

om (IntensityChange == 1)
{
IntensityChange = 0;
maxSingle (max7219_reg_intensity, IntensityVal & 15);
}

om (DisplayTestChange == 1)
{
DisplayTestChange = 0;
maxSingle (max7219_reg_displayTest, DisplayTestVal & 15);
}

om (ShutdownModeChange == 1)
{
ShutdownModeChange = 0;
maxSingle (max7219_reg_shutdown, ShutdownModeVal & 15);
}

Kontrollera om knapptryckningar
buttonpress();

/ / Kontrollera tillståndet för att ADC
checkADCs();
}

Du bör se din lysdioder lyser upp en kolumn i taget och rulla över displayen när firmware är klar uppladdning: