Aplicações onde microcontroladores podem atuar são praticamente infinitas, não há limites de onde eles podem ser aplicados, basta uma boa ideia e alguém vai pensar "Será que dá pra fazer com Arduino?" e muitas vezes a resposta é: SIM, Dá! São projetos dos mais simples aos mais complexos, utilizando poucos, nenhum ou muitos sensores, shields ou módulos. Se comunicando ou não com outros microcontroladores ou computadores, smartphones, via rádio, via wi-fi, bluetooth... enfim, há uma gama enorme do que um microcontrolador pode fazer. Porém, qualquer projeto que seja, maior ou menor, com mais ou menos recursos, vai inevitavelmente precisar de uma fonte de alimentação, alguns deles irão exigir mais potência, outros nem tanto.
Assim como são amplas as possibilidades de projetos com microcontroladores, consequentemente devem ser amplos também os meios para que consigamos alimentá-los. Felizmente há diversas formas de conseguirmos energia elétrica, seja com baterias, pilhas, energia solar, energia alternada da rede, além de outras.
Mas a questão é, como escolher a forma de alimentar o circuito que seja mais adequada para o projeto pretendido? Pra isso devem ser levadas em considerações questões como, custo, espaço utilizado, peso, potência necessária, autonomia, riscos de falta de energia, segurança... enfim, cada tipo de alimentação possui suas vantagens e desvantagens. Escolher a mais adequada faz parte de qualquer projeto, e por isso, é importante que o projetista tenha conhecimento suficiente sobre as principais fontes de alimentação a serem utilizadas nesses projetos.
Quando se trata de alimentar circuitos através da rede energia de 127/220V-AC, a solução mais simples é sem dúvida comprar um fonte AC-DC de 5V pronta, que irá ser conectada em uma tomada normal e pronto, basta plugar no seu microcontrolador e ser feliz. Mas nem sempre essa alternativa é a melhor, pois a fonte pode ser cara para determinado projeto, ou pode ocupar muito espaço, ou ainda ser muito pesada. Talvez você não queira ter seu projeto com partes separadas, e o melhor seja ter fonte e microcontrolador todo em uma única placa, bastando ser ligada diretamente a rede de energia. Nesses casos talvez seja necessário projetar sua própria fonte e pra isso é preciso saber de antemão qual o consumo que seu projeto terá, espaço que deverá ocupar, quanto você vai querer gastar com componentes, etc.
Em alguns projetos simples, que não utilizam muita potência, uma fonte com alguns mili Amperes pode ser a solução. Uma opção para esses casos, são fontes AC-DC sem transformadores, como fontes capacitivas ou ainda fontes resistivas que em geral tem baixo custo dos componentes utilizados, dependendo de até quantos mA se deseja conseguir.
Há uma gama enorme de tipos de fontes que podem ser montadas a partir desses princípios. Basicamente a ideia é utilizar um resistor ou um capacitor pra diminuir a tensão ou a corrente. depois retificar a corrente e por fim regular e filtrar a tensão. São esses basicamente os componentes mais elementares de uma fonte.
Como não vou abordar todos os tipos de fontes que podem ser utilizados, vou deixar duas dicas de buscas no google: "Fonte sem Transformador" e "Transformerless".
No vídeo abaixo montei uma pequena fonte capacitiva que fornece em torno de 30 mA, suficiente pra alimentar um attiny85. Mas atenção, isso não significa que qualquer projeto que utilize um attiny85 irá rodar com essa fonte, se ele possuir mais sensores, ou outros componentes que demandem mais corrente ao mesmo tempo, esse projeto de fonte pode não ser suficiente, por isso todo o consumo do projeto deve ser muito bem calculado.
Atenção Novamente: Manusear diretamente 110/127V Oferece altos riscos de acidentes. Nunca faça nada que não tenha certeza que irá funcionar. Sem tiver dúvidas peça ajuda pra alguém com mais experiencia.
Para mais detalhes dos cálculos do capacitor utilizado, veja os dois vídeos abaixo, onde fiz uma fonte bem parecida, mas com a intenção de alimentar leds diretamente em uma rede de 127V-AC.
Conclusão:
Fontes de alimentação podem ser a parte mais simples ou mais complexa de um projeto, portanto dependendo do projeto a ser desenvolvido, saber dimensionar e escolher a fonte a ser utilizada pode evitar muita dor de cabeça.
Nesse post vou mostrar como reutilizar uma placa de teclado PS2 de PC para usarmos com um teclado 4x4 no Arduino. Mas qual a vantagem disso? Primeiro que se formos utilizar o teclado 4x4 diretamente no Arduino, precisaríamos de 8 pinos e dependendo da forma de montagem mais alguns resistores e até diodos. Com uma placa de teclado, reduzimos para apenas 2 pinos.
Na imagem abaixo temos a demonstração dos pinos de um conector PS2, tanto macho quanto fêmea.
No exemplo mostrado no vídeo utilizo apenas o conector macho, ligando :
GND-3 ao gnd do Arduino,
4-+5V ao Vcc do Arduino,
CLK-5 ao pino 2 (INT.0); e o
DATA-1 ao pino 3 do Arduino.
Vídeo:
Código-fonte:
/*
2015 - Fabiano A. Arndt
fabianoallex@gmail.com
www.facebook.com/dicasarduino
Alterado para ser utilizado com teclados matriciais 3x4, 4x4 ou outros
originalmente desenvolvida para ser utilizado através de teclado ps2, conforme descrição abaixo:
PS2Keyboard.h - PS2Keyboard library
Copyright (c) 2007 Free Software Foundation. All right reserved.
Written by Christian Weichel <info@32leaves.net>
** Mostly rewritten Paul Stoffregen <paul@pjrc.com>, June 2010
** Modified for use with Arduino 13 by L. Abraham Smith, <n3bah@microcompdesign.com> *
** Modified for easy interrup pin assignement on method begin(datapin,irq_pin). Cuningan <cuninganreset@gmail.com> **
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#define PS2_KEYPAD_BREAK 0x01
#define PS2_KEYPAD_MODIFIER 0x02
#define PS2_KEYPAD_SHIFT_L 0x04
#define PS2_KEYPAD_SHIFT_R 0x08
#define PS2_KEYPAD_ALTGR 0x10
#define PS2_KEYPAD_BUFFER_SIZE 45
#define makeKeymapChar(x) ((char*)x)
#define makeKeymapByte(x) ((byte*)x)
class PS2Keypad {
private:
volatile byte buffer[PS2_KEYPAD_BUFFER_SIZE];
volatile byte head, tail;
byte DataPin;
byte CharBuffer = 0;
byte UTF8next = 0;
char * _chars;
byte * _codes;
byte _cols;
byte _rows;
inline byte get_scan_code(void) {
byte c, i;
i = tail;
if (i == head) { return 0; }
if (++i >= PS2_KEYPAD_BUFFER_SIZE) { i = 0; }
c = buffer[i];
tail = i;
return c;
}
char get_iso8859_code(void) {
static byte state=0;
byte s;
while (1) {
s = get_scan_code();
if (!s) return 0;
if (s == 0xF0) { state |= PS2_KEYPAD_BREAK; } else
if (s == 0xE0) { state |= PS2_KEYPAD_MODIFIER; } else {
if (state & PS2_KEYPAD_BREAK) {
if (s == 0x12) { state &= ~PS2_KEYPAD_SHIFT_L; } else
if (s == 0x59) { state &= ~PS2_KEYPAD_SHIFT_R; } else
if (s == 0x11 && (state & PS2_KEYPAD_MODIFIER)) { state &= ~PS2_KEYPAD_ALTGR; }
state &= ~(PS2_KEYPAD_BREAK | PS2_KEYPAD_MODIFIER); continue;
}
if (s == 0x12) { state |= PS2_KEYPAD_SHIFT_L; continue; } else
if (s == 0x59) { state |= PS2_KEYPAD_SHIFT_R; continue; } else
if (s == 0x11 && (state & PS2_KEYPAD_MODIFIER)) { state |= PS2_KEYPAD_ALTGR; }
return s;
}
}
}
public:
PS2Keypad(byte dataPin, byte rows, byte cols, char * chars, byte * codes) {
DataPin = dataPin;
digitalWrite(DataPin, HIGH);
head = 0;
tail = 0;
_chars = chars;
_codes = codes;
_cols = cols;
_rows = rows;
}
bool available(){
if (CharBuffer || UTF8next) return true;
CharBuffer = get_iso8859_code();
if (CharBuffer) return true;
return false;
}
int read(){
byte result = UTF8next;
if (result) { UTF8next = 0; }
else {
result = CharBuffer;
if (result) { CharBuffer = 0; }
else { result = get_iso8859_code(); }
if (result >= 128) {
UTF8next = (result & 0x3F) | 0x80;
result = ((result >> 6) & 0x1F) | 0xC0;
}
}
if (!result) { return -1; }
return result;
}
char readChar(){
byte code = read();
for (int i=0; i<_rows;i++){
for (int j=0; j<_cols;j++){
if ( *(_codes+ i*_rows + j) == code) { return *(_chars+ i*_rows + j); }
}
}
return ' ';
}
void execInterrupt(void) {
static byte bitcount = 0;
static byte incoming = 0;
static unsigned long prev_ms = 0;
unsigned long now_ms;
byte n, val;
val = digitalRead(DataPin);
now_ms = millis();
if (now_ms - prev_ms > 250) {
bitcount = 0;
incoming = 0;
}
prev_ms = now_ms;
n = bitcount - 1;
if (n <= 7) { incoming |= (val << n); }
bitcount++;
if (bitcount == 11) {
byte i = head + 1;
if (i >= PS2_KEYPAD_BUFFER_SIZE) { i = 0; }
if (i != tail) { buffer[i] = incoming; head = i; }
bitcount = 0;
incoming = 0;
}
}
};
/*****daqui pra baixo é mostrado como usar a classe PS2Keypad***************/
#define PIN_DATA 3
#define ROWS 4
#define COLS 4
char keys_chars[ROWS][COLS] = { {'1','2','3', 'A'}, {'4','5','6','B'}, {'7','8','9', 'C'}, {'*','0','#','D'} };
byte keys_codes[ROWS][COLS] = { {58, 49, 54, 61}, {26, 103,14, 22}, {33, 19, 6, 38}, {34, 100,5, 30} }; //esse código será diferente de acordo com as linhas e colunas escolhidas
PS2Keypad keypad(PIN_DATA, ROWS, COLS, makeKeymapChar(keys_chars), makeKeymapByte(keys_codes));
void interrupt_keypad(){ keypad.execInterrupt(); }
void setup() {
Serial.begin(9600);
Serial.println("Keypad Test:");
attachInterrupt(INT0, interrupt_keypad, FALLING); //atacha a interrupção que trata o recebimento dos dados. SEMPRE FALLING deve ser usado
}
void loop() {
if (keypad.available()) {
//int c = keypad.read();
char c = keypad.readChar();
Serial.print(c);
}
}
Antes de partimos para o código vamos entender como funciona um cartão magnético. Cartões magnéticos, aqueles usados por cartões de crédito, na grande maioria, são cartões que possuem uma banda, geralmente da cor preta (mas podem ser encontrada em outras cores) onde ficam armazenados os dados que são lidos pelos leitores.
Nesses Cartões os dados são divididos em três trilhas de dados medindo aproximadamente 2,5 milimetros cada uma.Existe uma normativa, a ISO/IEC 7811 a qual define o conteúdo e formato de cada uma das trilhas:
Trilha 1: tem formato de 210 bpi (bits por polegar) e contém 79 caracteres cada um composto por 6 bits mais um de paridade. É uma trilha só de leitura.
Trilha 2: tem formato de 75 bpi e contém 40 caracteres cada um composto por 4 bits mais um de paridade.
Trilha 3: tem formato 210 bpi e contém 107 caracteres de 4 bit mais um de paridade.
Em geral a maioria dos cartões de crédito utiliza somente as duas primeiras trilhas. A trilha três contém às vezes PINs, códigos de país, limites autorizados, códigos e números de acordos ou parceiras (milhagens, descontos em lojas), etc. mas o seu uso não é regulado de forma homogênea entre bancos e operadoras. Vale notar que vários dados são repetidos ou duplicados nas trilhas um e dois.
O conteúdo da trilha um ainda não está totalmente padronizado entre as empresas.
O primeiro padrão de escritura da trilha um dos cartões foi desenvolvido pela IATA (Associação Internacional das Empresas Aéreas).
Existe um segundo padrão estabelecido pela ABA (American Bankers Association), que a maioria das empresas de cartões de crédito utiliza, mas podem existir exceções.
As informações que normalmente se encontram na trilha um dos cartões de créditos são as seguintes:
Sinal de Início - um caráter (normalmente "%")
Código de Formato - um caráter alfabético (normalmente "B")
Número de Conta Primário - até 19 caracteres
Separador - um caráter (normalmente "^")
Código de País - três caracteres
Nome - de dois até 26 caracteres
Separador - um caráter
Data de vencimento ou separador - quatro caracteres ou um caráter
Informações livres - número de caracteres até completar a capacidade da trilha (79 caracteres no total)
Sinal de Fim - um caráter (normalmente "?")
Caráter de controle (LRC) - um caráter
A trilha dois foi inicialmente padronizada pela ABA (American Bankers Association).
É a trilha mais padronizada para cartões de crédito e a que todos os sistemas utilizam sempre. Os dados contidos na trilha dois são os seguintes:
Sinal de Início - um caráter (normalmente ";")
Número de Conta Primário - até 19 caracteres
Separador - um caráter (normalmente "=")
Código de País - três caracteres
Data de vencimento ou separador - quatro caracteres ou um caráter
Informações livres - número de caracteres até completar a capacidade da trilha (40 caracteres no total)
Sinal de Fim - um caráter (normalmente "?")
Caráter de controle (LRC) - um caráter
O leitor que estou utilizando para estes testes possui 9 pinos, como pode ser verificado na figura abaixo. Cada uma das trilhas utiliza dois pinos, um pra data e outro pra clock. Além dos pinos Media Detect que é utilizado para indicar que há cartão na leitora e os pinos de vcc e ground. Os Pinos de Data e Clock, devem ser ligados nos pinos de interrupções externas do arduino. A Classe que disponibilizei já faz todo esse trabalho. Apesar de termos 9 pinos, na prática podemos dispensar 4 pinos, pois faremos a leitura de apenas uma trilha, a trilha 1, a trilha 2 ou a trilha 3, o que irá depender do projeto em questão.
Observações: Nos meus testes tentei fazer a leitura simultânea de todos as trilhas mas sem sucesso, por isso disponibilizei a classe de modo que apenas uma trilha seja lida. Basta o programador escolher a trilha que deseja ler.
Vídeo:
código-fonte
o exemplo original foi baseado no código linkado no fim do artigo, a partir do qual criei uma classe, para facilitar o uso do código.
Durante os testes percebi que se passar o cartão apenas até a metade e voltar, o leitor faz uma leitura truncada, não retornando o que realmente está na trilha. A Classe que eu fiz não faz essa validação, ficando a cargo do programador que utilizá-la a tratar desse detalhe, o que irá depender do tipo de projeto ao qual o leitor está sendo usado.
Pra que quiser uma versão que não precise criar vários arquivos separados, fiz algumas alterações no código. A principal delas é que tratei das interrupções fora da classe.
Quem já tentou tratar uma interrupção dentro de uma classe sabe que não é muito simples fazer isso. Nesse vídeo mostro como redefinir a função attachInterrupt para anexar objetos ao invés de funções.
MyInterrupt.h
/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
Part of the Wiring project - http://wiring.uniandes.edu.co
Copyright (c) 2004-05 Hernando Barragan
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General
Public License along with this library; if not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330,
Boston, MA 02111-1307 USA
Modified 24 November 2006 by David A. Mellis
Modified 1 August 2010 by Mark Sproul
*/
#include <inttypes.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <stdio.h>
#include "wiring_private.h"
class Interrupt; //declaracao previa
void attachInterrupt(uint8_t interruptNum, Interrupt * interruptObject, int mode); //declaracao previa
class Interrupt {
public:
void attach(uint8_t interruptNum, int mode) { attachInterrupt(interruptNum, this, mode); };
void volatile virtual execInterrupt(uint8_t interruptNum);
};
Interrupt * interruptObjects[EXTERNAL_NUM_INTERRUPTS];
//static volatile voidFuncPtr intFunc[EXTERNAL_NUM_INTERRUPTS];
// volatile static voidFuncPtr twiIntFunc;
void attachInterrupt(uint8_t interruptNum, Interrupt * interruptObject, int mode) {
if(interruptNum < EXTERNAL_NUM_INTERRUPTS) {
interruptObjects[interruptNum] = interruptObject;
// Configure the interrupt mode (trigger on low input, any change, rising
// edge, or falling edge). The mode constants were chosen to correspond
// to the configuration bits in the hardware register, so we simply shift
// the mode into place.
// Enable the interrupt.
switch (interruptNum) {
#if defined(__AVR_ATmega32U4__)
// I hate doing this, but the register assignment differs between the 1280/2560
// and the 32U4. Since avrlib defines registers PCMSK1 and PCMSK2 that aren't
// even present on the 32U4 this is the only way to distinguish between them.
case 0:
EICRA = (EICRA & ~((1<<ISC00) | (1<<ISC01))) | (mode << ISC00);
EIMSK |= (1<<INT0);
break;
case 1:
EICRA = (EICRA & ~((1<<ISC10) | (1<<ISC11))) | (mode << ISC10);
EIMSK |= (1<<INT1);
break;
case 2:
EICRA = (EICRA & ~((1<<ISC20) | (1<<ISC21))) | (mode << ISC20);
EIMSK |= (1<<INT2);
break;
case 3:
EICRA = (EICRA & ~((1<<ISC30) | (1<<ISC31))) | (mode << ISC30);
EIMSK |= (1<<INT3);
break;
case 4:
EICRB = (EICRB & ~((1<<ISC60) | (1<<ISC61))) | (mode << ISC60);
EIMSK |= (1<<INT6);
break;
#elif defined(EICRA) && defined(EICRB) && defined(EIMSK)
case 2:
EICRA = (EICRA & ~((1 << ISC00) | (1 << ISC01))) | (mode << ISC00);
EIMSK |= (1 << INT0);
break;
case 3:
EICRA = (EICRA & ~((1 << ISC10) | (1 << ISC11))) | (mode << ISC10);
EIMSK |= (1 << INT1);
break;
case 4:
EICRA = (EICRA & ~((1 << ISC20) | (1 << ISC21))) | (mode << ISC20);
EIMSK |= (1 << INT2);
break;
case 5:
EICRA = (EICRA & ~((1 << ISC30) | (1 << ISC31))) | (mode << ISC30);
EIMSK |= (1 << INT3);
break;
case 0:
EICRB = (EICRB & ~((1 << ISC40) | (1 << ISC41))) | (mode << ISC40);
EIMSK |= (1 << INT4);
break;
case 1:
EICRB = (EICRB & ~((1 << ISC50) | (1 << ISC51))) | (mode << ISC50);
EIMSK |= (1 << INT5);
break;
case 6:
EICRB = (EICRB & ~((1 << ISC60) | (1 << ISC61))) | (mode << ISC60);
EIMSK |= (1 << INT6);
break;
case 7:
EICRB = (EICRB & ~((1 << ISC70) | (1 << ISC71))) | (mode << ISC70);
EIMSK |= (1 << INT7);
break;
#else
case 0:
#if defined(EICRA) && defined(ISC00) && defined(EIMSK)
EICRA = (EICRA & ~((1 << ISC00) | (1 << ISC01))) | (mode << ISC00);
EIMSK |= (1 << INT0);
#elif defined(MCUCR) && defined(ISC00) && defined(GICR)
MCUCR = (MCUCR & ~((1 << ISC00) | (1 << ISC01))) | (mode << ISC00);
GICR |= (1 << INT0);
#elif defined(MCUCR) && defined(ISC00) && defined(GIMSK)
MCUCR = (MCUCR & ~((1 << ISC00) | (1 << ISC01))) | (mode << ISC00);
GIMSK |= (1 << INT0);
#else
#error attachInterrupt not finished for this CPU (case 0)
#endif
break;
case 1:
#if defined(EICRA) && defined(ISC10) && defined(ISC11) && defined(EIMSK)
EICRA = (EICRA & ~((1 << ISC10) | (1 << ISC11))) | (mode << ISC10);
EIMSK |= (1 << INT1);
#elif defined(MCUCR) && defined(ISC10) && defined(ISC11) && defined(GICR)
MCUCR = (MCUCR & ~((1 << ISC10) | (1 << ISC11))) | (mode << ISC10);
GICR |= (1 << INT1);
#elif defined(MCUCR) && defined(ISC10) && defined(GIMSK) && defined(GIMSK)
MCUCR = (MCUCR & ~((1 << ISC10) | (1 << ISC11))) | (mode << ISC10);
GIMSK |= (1 << INT1);
#else
#warning attachInterrupt may need some more work for this cpu (case 1)
#endif
break;
case 2:
#if defined(EICRA) && defined(ISC20) && defined(ISC21) && defined(EIMSK)
EICRA = (EICRA & ~((1 << ISC20) | (1 << ISC21))) | (mode << ISC20);
EIMSK |= (1 << INT2);
#elif defined(MCUCR) && defined(ISC20) && defined(ISC21) && defined(GICR)
MCUCR = (MCUCR & ~((1 << ISC20) | (1 << ISC21))) | (mode << ISC20);
GICR |= (1 << INT2);
#elif defined(MCUCR) && defined(ISC20) && defined(GIMSK) && defined(GIMSK)
MCUCR = (MCUCR & ~((1 << ISC20) | (1 << ISC21))) | (mode << ISC20);
GIMSK |= (1 << INT2);
#endif
break;
#endif
}
}
}
void detachInterrupt(uint8_t interruptNum) {
if(interruptNum < EXTERNAL_NUM_INTERRUPTS) {
// Disable the interrupt. (We can't assume that interruptNum is equal
// to the number of the EIMSK bit to clear, as this isn't true on the
// ATmega8. There, INT0 is 6 and INT1 is 7.)
switch (interruptNum) {
#if defined(__AVR_ATmega32U4__)
case 0:
EIMSK &= ~(1<<INT0);
break;
case 1:
EIMSK &= ~(1<<INT1);
break;
case 2:
EIMSK &= ~(1<<INT2);
break;
case 3:
EIMSK &= ~(1<<INT3);
break;
case 4:
EIMSK &= ~(1<<INT6);
break;
#elif defined(EICRA) && defined(EICRB) && defined(EIMSK)
case 2:
EIMSK &= ~(1 << INT0);
break;
case 3:
EIMSK &= ~(1 << INT1);
break;
case 4:
EIMSK &= ~(1 << INT2);
break;
case 5:
EIMSK &= ~(1 << INT3);
break;
case 0:
EIMSK &= ~(1 << INT4);
break;
case 1:
EIMSK &= ~(1 << INT5);
break;
case 6:
EIMSK &= ~(1 << INT6);
break;
case 7:
EIMSK &= ~(1 << INT7);
break;
#else
case 0:
#if defined(EIMSK) && defined(INT0)
EIMSK &= ~(1 << INT0);
#elif defined(GICR) && defined(ISC00)
GICR &= ~(1 << INT0); // atmega32
#elif defined(GIMSK) && defined(INT0)
GIMSK &= ~(1 << INT0);
#else
#error detachInterrupt not finished for this cpu
#endif
break;
case 1:
#if defined(EIMSK) && defined(INT1)
EIMSK &= ~(1 << INT1);
#elif defined(GICR) && defined(INT1)
GICR &= ~(1 << INT1); // atmega32
#elif defined(GIMSK) && defined(INT1)
GIMSK &= ~(1 << INT1);
#else
#warning detachInterrupt may need some more work for this cpu (case 1)
#endif
break;
#endif
}
interruptObjects[interruptNum] = 0;
}
}
/*
void attachInterruptTwi(void (*userFunc)(void) ) {
twiIntFunc = userFunc;
}
*/
#if defined(__AVR_ATmega32U4__)
ISR(INT0_vect) {
if(interruptObjects[EXTERNAL_INT_0])
interruptObjects[EXTERNAL_INT_0]->execInterrupt(EXTERNAL_INT_0);
}
ISR(INT1_vect) {
if(interruptObjects[EXTERNAL_INT_1])
interruptObjects[EXTERNAL_INT_1]->execInterrupt(EXTERNAL_INT_1);
}
ISR(INT2_vect) {
if(interruptObjects[EXTERNAL_INT_2])
interruptObjects[EXTERNAL_INT_2]->execInterrupt(EXTERNAL_INT_2);
}
ISR(INT3_vect) {
if(interruptObjects[EXTERNAL_INT_3])
interruptObjects[EXTERNAL_INT_3]->execInterrupt(EXTERNAL_INT_3);
}
ISR(INT6_vect) {
if(interruptObjects[EXTERNAL_INT_4])
interruptObjects[EXTERNAL_INT_4]->execInterrupt(EXTERNAL_INT_4);
}
#elif defined(EICRA) && defined(EICRB)
ISR(INT0_vect) {
if(interruptObjects[EXTERNAL_INT_2])
interruptObjects[EXTERNAL_INT_2]->execInterrupt(EXTERNAL_INT_2);
}
ISR(INT1_vect) {
if(interruptObjects[EXTERNAL_INT_3])
interruptObjects[EXTERNAL_INT_3]->execInterrupt(EXTERNAL_INT_3);
}
ISR(INT2_vect) {
if(interruptObjects[EXTERNAL_INT_4])
interruptObjects[EXTERNAL_INT_4]->execInterrupt(EXTERNAL_INT_4);
}
ISR(INT3_vect) {
if(interruptObjects[EXTERNAL_INT_5])
interruptObjects[EXTERNAL_INT_5]->execInterrupt(EXTERNAL_INT_5);
}
ISR(INT4_vect) {
if(interruptObjects[EXTERNAL_INT_0])
interruptObjects[EXTERNAL_INT_0]->execInterrupt(EXTERNAL_INT_0);
}
ISR(INT5_vect) {
if(interruptObjects[EXTERNAL_INT_1])
interruptObjects[EXTERNAL_INT_1]->execInterrupt(EXTERNAL_INT_1);
}
ISR(INT6_vect) {
if(interruptObjects[EXTERNAL_INT_6])
interruptObjects[EXTERNAL_INT_6]->execInterrupt(EXTERNAL_INT_6);
}
ISR(INT7_vect) {
if(interruptObjects[EXTERNAL_INT_7])
interruptObjects[EXTERNAL_INT_7]->execInterrupt(EXTERNAL_INT_7);
}
#else
ISR(INT0_vect) {
if(interruptObjects[EXTERNAL_INT_0])
interruptObjects[EXTERNAL_INT_0]->execInterrupt(EXTERNAL_INT_0);
}
ISR(INT1_vect) {
if(interruptObjects[EXTERNAL_INT_1])
interruptObjects[EXTERNAL_INT_1]->execInterrupt(EXTERNAL_INT_1);
}
#if defined(EICRA) && defined(ISC20)
ISR(INT2_vect) {
if(interruptObjects[EXTERNAL_INT_2])
interruptObjects[EXTERNAL_INT_2]->execInterrupt(EXTERNAL_INT_2);
}
#endif
#endif
/*
ISR(TWI_vect) {
if(twiIntFunc)
twiIntFunc();
}
*/
Sketch
#include "MyInterrupt.h"
class Abc : public Interrupt{
private:
public:
Abc(){
attach(0, CHANGE);
attach(1, CHANGE);
}
void volatile execInterrupt(uint8_t interruptNum){
Serial.print("Abc: ");
Serial.print(interruptNum);
Serial.print(" - millis: ");
Serial.println(millis());
}
};
Abc * abc;
void setup() {
Serial.begin(9600);
abc = new Abc();
}
void loop() {
// put your main code here, to run repeatedly:
}
