/*

* Driver for incremental rotary encoder w/built-in pushbutton and RGB LED.

*

*

* Objective:

*

* This program reads the incoming 2-bit pulses from an incremental rotary

* encoder. The program also detects a 3rd pushbutton input. Finally, the

* program drives 3 PWM outputs connected to an RGB LED. The program was

* developed to work with Sparkfun's COM-10982 encoder.

*

*

* Physical layout and hookup:

*

* The rotary encoder has the following layout:

*

* 1 2 3 4 5

* ^ ^ ^ ^ ^

* | | | | |

* -----------

* | |

* | ,-, |

* <| | | |>

* | '-' |

* | |

* -----------

* | | |

* v v v

* A C B

*

* The pinout is as follows:

*

* A: Rotary encoder bit A

* B: Rotary encoder bit B

* C: Ground (connected to A & B during rotation)

* 1: Red LED cathode

* 2: Green LED cathode

* 3: Pushbutton switch

* 4: Blue LED cathode

* 5: Common anode for LEDs, and pushbutton switch

*

* Arduino hookup:

* - Encoder pin C to GND.

* - Encoder pins A and B to PC0..1 (Arduino pins A0 and A1)

* (rotation code inputs; flip them to swap CW vs. CCW rotation).

* - Encoder pin 5 to Vcc (5V or 3.3V).

* - Encoder pin 3 to PC2 (Arduino pin A2) with a 10K pull-down resistor

* (pushbutton input).

* - Encoder pins 1, 2 and 4 through current limiting resistors and on to

* D5, D6 and B1 (Arduino pins 5, 6 and 9), respectively (PWM outputs

* for RGB LED hooked up to D5/OC0B, D6/OC0A and B1/OC1A, respectively).

*

* Diagram:

*

* Encoder Arduino

* --- -----

* | A|----------|A0 |

* | C|------*---|GND |

* | B|------+---|A1 |

* | | | | |

* | | R4 | |

* | | | | |

* | 1|--R3--+---|5 |

* | 2|--R2--+---|6 |

* | 3|------*---|A2 |

* | 4|--R1------|9 |

* | 5|----------|Vcc |

* --- -----

*

* R1-R3: Current-limiting resistors, e.g. 220Ω

* R4: Pull-down resistor, e.g. 10KΩ

*

*

* Mode of operation:

*

* In the Arduino, the two rotary encoder inputs and the pusbutton input

* trigger a pin change interrupt (PCINT1). The corresponding ISR merely

* forwards the current state of the input pins to the main loop by using

* a simple ring buffer. This keeps the ISR very short and fast, and

* ensures that we miss as few interrupts as possible.

*

* The main loop, and associated functions read the input events from the

* ring buffer, and use them to drive a Controller node in a Remote

* Controller Network. See rcn_common.h in the RCN library for more

* information on RCN. As an RCN Controller, we control 3 different RCN

* Channels, and assign them to each of the R, G and B components of the

* RGB LED on the rotary encoder. The R/G/B components are drive by three

* PWM outputs, which are controlled by analogWrite().

*

* The pusbutton input is used to cycle through the 3 channels, and the

* current Channel is displayed in the corresponding (R, G or B) color on

* the RGB LED. The intensity of the color is proportional to the Level of

* the currently selected Channel. Rotating the knob adjusts the Level for

* the currently selected channel.

*

* Author: Johan Herland <johan@herland.net>

* License: GNU GPL v2 or later

*/

// TODO: Display current color at full intensity while button is pressed.

// TODO: Rotating while pressed should browse through channels.

// TODO: Communicate range from host to controller

// TODO: Dynamic discovery of channels

// TODO: Dynamic discovery of multiple hosts

// TODO: Packet radio collision robustness

// #define DEBUG 1

#if DEBUG

#define LOG Serial.print

#define LOGln Serial.println

#else

#define LOG(...)

#define LOGln(...)

#endif

#define RCN_CTRL_MAX_CHANNELS 7

#include <RF12.h> // Needed by RCN

#include <Ports.h> // Needs Sleepy::*

#include <rcn_controller.h> // Needs RCN_Controller

// Utility macros

#define ARRAY_LENGTH(a) ((sizeof (a)) / (sizeof (a)[0]))

#define MIN(x, y) ((x) < (y) ? (x) : (y))

#define MAX(x, y) ((x) > (y) ? (x) : (y))

#define LIMIT(min, val, max) (min > val ? min : (max < val) ? max : val)

const byte VERSION = 4;

const unsigned long max_idle_time = 10000; // msecs until we go to sleep

const unsigned long long_click_time = 3000; // min msecs for long-click

volatile byte ring_buffer[256] = { 0 };

volatile byte rb_write; // current write position in ring buffer

byte rb_read; // current read position in ringbuffer

byte rot_state = 0;

bool button_state = 0;

bool button_debounce = 0;

byte cur_channel = 0; // Index into above array

enum PWM_PINS { // Arduino PWM pins hooked up to RGB LED

};

unsigned long last_activity = 0;

bool groggy = false; // Set to true, when we've just woken up from sleep

struct color { uint8_t red, green, blue; };

const struct color COLORS[RCN_CTRL_MAX_CHANNELS] = {

{0xff, 0xff, 0xff}, // white

{0xff, 0x00, 0x00}, // red

{0xff, 0x7f, 0x00}, // orange

{0xff, 0xff, 0x00}, // yellow

{0x00, 0xff, 0x00}, // green

{0x00, 0x00, 0xff}, // blue

{0x7f, 0x00, 0xff} // violet

};

enum COLOR { WHITE, RED, ORANGE, YELLOW, GREEN, BLUE, VIOLET };

void fade_pin(int pin, uint8_t value)

}

void display_color(

}

void update_notify(

}

RCN_Controller ctrl(RF12_868MHZ, 123, 16, update_notify);

void setup(void)

}

/*

* PCINT1 interrupt vector

*

* Append the current values of the input pins to the ring buffer.

*/

ISR(PCINT1_vect)

{

ring_buffer[rb_write++] = PINC & B00000111;

}

/*

* TOV2 interrupt vector

*

* Append the current values of the input pins plus a "timer" bit to the

* ring buffer.

*/

ISR(TIMER2_OVF_vect)

{

ring_buffer[rb_write++] = (PINC & B00000111) | B00001000;

}

enum input_events {

};

/*

* Check the ring buffer and return a bitwise-OR combination of the above

* enum values.

*/

int process_inputs(void)

}

void print_state(char event)

}

/*

* Return false immediately if we cannot go to sleep, or go to sleep, and

* return true when it's time to wake up again.

*/

bool go_to_sleep()

}

void wake_up()

}

void loop(void)

}