The Digital Signal Generator, based on an AVR16EB28, generates a square wave of from 2Hz
to approximately 33.5MHz in precise steps of 2Hz.

The project takes advantage of the new Numerical Controller Oscillator (NCO) mode available in the timer/counter TCF in the AVR EB-series microcontrollers. It uses an AVR16EB28, a crystal, an OLED display, a rotary encoder, a keypad, and a small number of other components.

Introduction

When Microchip released their AVR EB-series chips at the end of 2023 I was intrigued by one particular feature: the timer/counter TCF that works differently from all previous AVR timer/counters. Typically timer/counters divide the clock by a divisor in a compare register. This gives a range of frequencies with unequal steps. For example, with divisors of 1, 2, 3, 4 … a 20MHz clock gives you 20MHz, 10MHz, 6.67MHz, 5MHz … where the steps are getting progressively smaller.

The TCF timer/counter, by comparison, provides a mode called Numerical Controller Oscillator (NCO) which adds a value from a register to the count value on each clock cycle, and takes the output from the overflow ^[1]. For values of 1, 2, 3, 4 … and a 24-bit counter a 20MHz clock gives you frequencies of 1.192Hz, 2.384Hz, 3.576Hz, 4.768Hz … where the steps are equal.

Phase-Locked Loop (PLL)

Another feature of the AVR EB series is a PLL (Phase-Locked Loop) that can be used to multiply a clock of 2.2MHz to 5.5MHz by a factor of 8 or 16 to drive the TCF timer/counter with up to 80MHz, way beyond the processor's maximum 20MHz clock rate. These two features of the AVR EB series led to the idea of this simple wide-range digital signal generator.

Crystal

I wanted to generate frequencies with round numbers of Hz, and better accuracy than the processor's built-in oscillator, so I decided to use a crystal clock. I calculated that the value of crystal clock that would be needed to give round-number frequencies is 2²²Hz or 4.194304MHz, and I was pleased to find that this is a commonly available value.

The NCO oscillator can either produce an asymmetrical square-wave output with a pulse width of one clock cycle, or a symmetrical square wave of half the frequency; I chose the second option.

The frequency range

In this mode the output frequency f  in Hz is given by:

where clk is the clock input to the NCO and inc is the increment value in the compare register. With a crystal of 2²²Hz and a x16 PLL this becomes:

Because inc can take the values 1 to 2²⁴–1 the result is a range of 2Hz to 33554430Hz in steps of exactly 2Hz. For alternative options see Further suggestions below.

Operation

The Digital Signal Generator works as follows: you enter the frequency you want, in Hz, on the numeric keypad as a sequence of up to eight digits, and press *. The display then shows the actual frequency that will be generated, and generates the square waves on the outputs. You can then adjust the frequency up or down in steps of 2Hz using the rotary encoder. Pressing # clears the current input.

The waveform outputs are taken from pins 1 and 28 on the AVR16EB14. For example, here are the two waveforms generated for a frequency of 100000Hz:

Jitter

I should mention one characteristic of the NCO which is that the output will have jitter when the value being added to the counter isn't an exact divisor of the maximum count. For example, with a 24-bit counter and an increment value of 3, which is not an exact divisor of 2²⁴, a 20MHz clock will give a square wave with a wavelength alternating between 0.419 secs and 0.210 secs. However, this is the worst case, and at higher frequencies the jitter rapidly becomes a negligible proportion of the wavelength. Note that, despite the jitter, the average frequency of the output is precise, and so even at low frequencies the jitter is not a problem for applications such as timing or clock generation.

The circuit

Here's the circuit of the Digital Signal Generator:

The circuit of the Digital Signal Generator, based on an AVR16EB28.

The processor

I initially thought about designing the circuit based on a 14-pin AVR16EB14, but this has the limitation that the timer/counter waveform output WO0 is on the same pin as the EXTCLK external clock pin needed for the input to the PLL. A 20-pin package would solve this problem, but I went to the 28-pin AVR16EB28 because it's available in a DIP package, and so could be fitted on the breadboard without needing a breakout board. The extra I/O pins might come in useful in a future expansion. You could of course also use the AVR32EB28.

The display

For the display I used an I2C 128x32 0.91" OLED display, available at low cost from a variety of vendors on AliExpress ^[2]. Note that the display is 3.3V only, so don't power the circuit from 5V.

Numeric keypad

For the numeric keypad I used the PCB keypad I designed in an earlier article; see One-Input Numeric Keypad. It fits neatly on the breadboard, and connects to a single analogue input, PD6. Alternatively you could build the keypad on a piece of Veroboard.

The crystal

The crystal I used is a 4.194304MHz through-hole type with a 0.2" lead spacing, an accuracy of 20ppm, and a load capacitance of 18pF ^[3]. To calculate the capacitor values I used the formula C = 2(C_L - C_S), where C_L is the published load capacitance 18pF, and C_S is the stray capacitance. On a breadboard there is probably close to 18pF of stray capacitance, so additional capacitors are probably not necessary, but if you're designing a PCB version of the circuit you should leave space for the capacitors.

Unlike the earlier ATmega processors the new AVR series don't support an external high-frequency crystal, so it's necessary to provide an external crystal oscillator with its output connected to the EXTCLK input. One possible crystal oscillator design uses an inverter across the crystal:

To avoid the need for an external inverter I used the Event System to construct an inverter as follows:

• Define PC2 as an event output, EVOUTC.
• Define PC3 as an event generator on channel 2
• Configure PC3 to invert the input.

The crystal is connected between PC3 and PC2, and the inverter output PC2 is then connected to the EXTCLK input on PA0.

Rotary encoder

For the rotary encoder I used a Bourns rotary encoder with 16 pulses per rotation ^[4] because the wire terminations fit neatly into a breadboard, but you could use any suitable rotary encoder, such as Adafruit's which includes a knob ^[5].

Construction

I built the whole circuit on a 360 hole breadboard ^[6], using pre-cut colour-coded jumper wires to make the interconnections easier ^[7].

I constructed a right-angle adapter from a 4-way pin header to mount the display horizontally, while plugging it into four consecutive breadboard columns; see the photograph at the start of the article.

The program

Here's a description of the main parts of the program:

Crystal oscillator

The routine SetupCrystal() uses the Event System to configure PC3 and PC2 as an inverter, with the crystal connected across it:

void SetupCrystal () {
  PORTC.EVGENCTRLA = PORT_EVGEN0SEL_PIN3_gc;              // Use PC3 as EVGEN0
  EVSYS.CHANNEL2 = EVSYS_CHANNEL_PORTC_EV0_gc;            // Link EVGEN0 to CHANNEL2
  EVSYS.USEREVSYSEVOUTC = EVSYS_USER_CHANNEL2_gc;         // Link CHANNEL2 to PC2
  PORTC.PIN3CTRL = PORT_INVEN_bm;                         // Invert input PC3
}

The output on PC2 is connected to the input of the Phase-Locked Loop at EXTCLK on PA0.

Phase-Locked Loop (PLL)

The routine SetupPLL() sets up the PLL to multiply the frequency on EXTCLK by 16:

void SetupPLL () {
  uint8_t pllctrla = CLKCTRL_SOURCE_EXTCLK_gc | CLKCTRL_MULFAC_16X_gc;
  _PROTECTED_WRITE(CLKCTRL.PLLCTRLA, pllctrla);           // EXTCLK and x16
}

The built-in macro _PROTECTED_WRITE() must be used because the Clock Controller registers are protected from being changed by a runaway program using Configuration Change Protection.

Numerically Controlled Oscillator (NCO)

The next step is to set up the NCO in the routine SetupNCO(). I found the Microchip application note TB3341 ^[8] helpful in writing this part of the program:

void SetupNCO () {
  PORTMUX.TCFROUTEA = PORTMUX_TCF0_ALT1_gc;               // WO0,WO1 on PA6,PA7

  // Enable WO0 and WO1 and invert WO1 polarity
  while((TCF0.STATUS & TCF_CTRLABUSY_bm) != 0);
  TCF0.CTRLC = TCF_WO0EN_bm | TCF_WO1EN_bm | TCF_WO1POL_bm;
  
  // Configure NCO Pulse-Frequency mode
  TCF0.CTRLB = TCF_CLKSEL_PLL_gc | TCF_WGMODE_NCOFDC_gc;  // Use PLL as clock
}

This first selects the alternative positions for the waveform outputs WO0 and WO1 because the default positions conflict with EXTCLK.

It then enables the waveform outputs and inverts WO1, to give two out of phase square waves.

Finally it selects NCO Pulse-Frequency mode, which gives a symmetrical square wave, and specifies the PLL as the clock source.

Setting the frequency

The function SetFrequency() is called each time the frequency changes:

void SetFrequency () {
  while((TCF0.STATUS & TCF_CMP0BUSY_bm) != 0);
  TCF0.CMP = Input>>1;
}

Starting and stopping the NCO

Finally, these two functions are called to start and stop the square-wave output:

void StartNCO () {
  while((TCF0.STATUS & TCF_CTRLABUSY_bm) != 0);
  TCF0.CTRLA |= TCF_ENABLE_bm; 
}

void StopNCO () {
  while((TCF0.STATUS & TCF_CTRLABUSY_bm) != 0);
  TCF0.CTRLA &= ~TCF_ENABLE_bm;
}

Numeric keypad

The numeric keypad is read by the function ReadKeypad(), which returns the number of the key, or -1 if no key is being pressed. For more details see One-Input Numeric Keypad.

Display driver

The functions for driving the 128x32 OLED display are based on earlier projects. The frequency is plotted using double-sized characters, using smoothing as described in Smooth Big Text.

Rotary encoder

The rotary encoder uses a pin-change interrupt to update the frequency, based on my earlier project Bounce-Free Rotary Encoder.

Main loop

Finally the main loop polls the numeric keypad and updates the display until * is pressed, and then sets the output frequency to the entered value.

Installing the program

First install Spence Konde's DxCore from GitHub: see DxCore - Installation. I used version 1.6.2.

Then, in the Arduino IDE:

• Choose the AVR EB-series (no bootloader) option under the DxCore heading on the Board menu.
• Check that the subsequent options are set as follows (ignore any other options):

Board: "AVR EB-series (no bootloader)"
Chip: "AVR16EB28"
Clock Speed: "20 MHz internal"

You can leave the other options at their defaults, the first option on each submenu.

• Connect a UPDI programmer to the UPDI, GND, and VDD pins.

The recommended way to upload the program is to use a 3.3V Serial board, such as the SparkFun FTDI Basic board ^[9] connected with a Schottky diode as follows. You can substitute a 4.7kΩ resistor for the Schottky diode:

• Set Programmer to the "SerialUPDI - Normal: 230400 baud (recommended)" option.
• Select the USB port corresponding to the USB to Serial board in the Port menu.

• Select Burn Bootloader to reset the fuses (in case they were changed for an earlier project).
• Click Upload to upload the program to the AVR16EB28.

Resources

Here's the program for the Digital Signal Generator: Digital Signal Generator Program.

Get details of the One-Input Numeric Keypad here: One-Input Numeric Keypad.

Further suggestions

• If you prefer an output adjustable in steps of exactly 1Hz you can use the 4.194304MHz crystal divided by 2 to give a range of 1Hz to 16777215Hz in steps of 1Hz, with a symmetrical square-wave output. Note that the AVR EB-series Errata states that in NCO mode the prescaler in TCF0 CTRLA is non-functional, but you can divide the input to the PLL by 2 instead.
• If you want a higher maximum frequency you can change the NCO mode from NCOFDC (fixed duty-cycle) to NCOPF (pulse-frequency) to give a range of 4Hz to 67108860Hz in steps of 4Hz with an asymmetrical square-wave output one clock period wide.
• If your rotary encoder includes a switch you could add a pin-change interrupt on PD2 to toggle between these options, or to change the frequency step size of the rotary encoder.

Updates

7th July 2026: Fixed a problem that meant that the Digital Signal Generator Program source code was password protected.

1. ^ This is like the phase accumulator used in DDS (Direct Digital Synthesis), except that the TCF timer/counter only has a one-bit output.
2. ^ 0.91" 128x32 OLED Display Module White on AliExpress.
3. ^ QCL4.194304F18B23B on Farnell.
4. ^ Bourns Incremental Encoder on Halltronics.
5. ^ Rotary Encoder + Extras on Adafruit.
6. ^ AD-100 Advanced Solderless Breadboard on Rapid Electronics.
7. ^ Jumper Wire Kit on The Pi Hut.
8. ^ Getting Started with Timer/Counter Type F (TCF) on Microchip.
9. ^ SparkFun FTDI Basic Breakout - 3.3V on Sparkfun.

The 12-key Numeric Keypad that interfaces to a single analogue input.

It's on a small 1.2 x 1.6" (30 x 40mm) PCB, and I've also built a demo circuit to show how to use it.

Introduction

Microcontroller projects often need a numeric keypad, and a typical approach is to arrange the keys in a matrix of rows and columns; so for a 3 x 4 numeric keypad you might need to scan seven I/O pins.

This keypad works differently; each key generates a different analogue voltage, and you only need a single analogue input to interface it. I wrote about the idea some time ago in the article One Input Keypad Interface, and I've incorporated keypads using this approach in several projects, such as Walkie-Textie Wireless Communicator and Digital Signal Generator, but I've never published a PCB to allow you to create a stand-alone keypad. However, recently I wanted to prototype a project on a breadboard using a keypad, and I wished I had a PCB version. So here it is.

The circuit

This is the circuit of the keypad:

The circuit of the One-Input Numeric Keypad, which uses a network of six resistors.

The buttons are widely available 6 x 6mm tactile buttons ^[1]. It uses a network of six 0805 surface-mount E6 resistors, arranged as a voltage divider, so each keypress generates a different voltage. It's also designed to draw no current unless a key is pressed. The resistor values are calculated to give the best spread of voltages in the available range from GND to VDD.

The '*' and '#' keys generate the values 10 and 11 respectively; they are useful for functions such as Enter and Delete. The surface-mount resistors are mounted on the back of the board, and the three connections are brought out to a five-way pin header at the top of the board (only three of the pins are used):

The back of the One-Input Numeric Keypad PCB showing the six 0805 surface-mount resistors.

The program

Here's the ReadKeypad() function that interrogates the keypad:

const int Keypad = PIN_PC0;
const int SmallestGap = 40;
int Values[] =  {1023,680,640,590,547,507,464,411,351,273,180,133, 0,-100};
int Buttons[] = {  -1, 11,  9,  6,  3,  0, 10,  8,  7,  5,  4,  2, 1};

int ReadKeypad () {
  int val, lastval=0, count = 0;
  do {
    val = analogRead(Keypad);
    if (abs(val-lastval)<2) count++;
    else { lastval = val; count = 0; }
  } while (count < 3);
  int i = 0;
  val = val - SmallestGap/2;
  while (val < Values[i]) { i++; }
  return Buttons[i - 1];
}

The constant Keypad specifies the analogue input that the keypad is connected to. The program uses two arrays: Values[] stores the analogue values given by each pin, in descending order, and Buttons[] stores the corresponding button for each voltage. The ReadKeypad() routine reads the analogue input, and then checks the value against each value in Values[] until it's larger; it then returns the corresponding button from Buttons[]. If no key is pressed it returns -1.

Demo circuit

I built a simple circuit to demonstrate the keypad by displaying the key pressed on a seven-segment LED display:

The demonstration circuit for the One-Input Numeric Keypad, based on an AVR32EB14,
displays the key pressed on a seven-segment LED display.

I built the demo circuit on a 360 hole breadboard ^[2], using pre-cut colour-coded jumper wires to make the interconnections easier ^[3]. I used an AVR32EB14 in a TSSOP-14 package, mounted on a breakout board ^[4] and a 0.56" single-digit seven-segment display ^[5]. The display is driven directly from the eight I/O pins PA0 to PA1, PC2 to PC3, and PD4 to PD7, with a 220Ω current-limiting resistor from the common cathode to GND. PC0 is used for the analogue keypad input.

Resources

Get Eagle and Gerber files for the keypad: https://github.com/technoblogy/one-input-numeric-keypad.

Or order PCBs from OSH Park here: One-Input Numeric Keypad.

Here's the demo program: One-Input Numeric Keypad Demo.

1. ^ FSM4JH Through-Hole Tactile Switch on Farnell.
2. ^ AD-100 Advanced Solderless Breadboard on Rapid Electronics.
3. ^ Jumper Wire Kit on The Pi Hut.
4. ^ SMT Breakout PCB for SOIC-14 or TSSOP-14 on Adafruit.
5. ^ 0.56" Seven Segment Display on Switch Electronics.

The IR NeoPixel Controller, based on an AVR64DD14, controlling a high-power NeoPixel RGB LED.

It lets you control the hue, saturation, and brightness of each RGB LED independently, or alternatively set them all to the same settings. You can also switch off and on all the LEDs, or animate the LEDs with slowly-changing hue. It's based on an AVR64DD14 and a TSOP38238 IR receiver.

Introduction

I recently bought some smart colour bulbs, thinking it would be nice to be able to adjust the colour of the illumination in my living room. However it turned out that I also needed to buy a compatible smart hub, install a control app, create an account, and control the bulbs using my smartphone.

This is fine if you want to automate your home, but for a single light it was far more complicated than I really wanted. I therefore thought about building my own solution based on a NeoPixel interface, using an infrared remote control to control the brightness and colour of the LEDs. The advantage of using NeoPixel LEDs over dumb high-power RGB LEDs is that you can chain multiple lights together with just three wires.

This IR NeoPixel Controller will support up to nine lights, a number I chose because the IR remote provides keys 0 to 9. However, the main constraint will be how much power your power supply can handle. A typical USB-C output can provide 5V at 1.5A, which is enough for two or possibly three high-power 3W LEDs.

The IR NeoPixel Controller lets you control the hue, saturation, and brightness of each RGB LED independently, or alternatively set them all to the same settings. You can also switch off and on all the lights, or animate the lights with slowly-changing hue. The settings are stored in EEPROM, so if you disconnect and reconnect the power the LEDs remember their previous settings.

Components

The circuit consists of three components: the NeoPixel LEDs, the NeoPixel driver, and the IR remote control receiver.

High-power NeoPixel LEDs

For the LEDs I chose Adafruit's 3 watt chainable NeoPixel LEDs, that use WS2811 NeoPixel-protocol controllers to drive a high-power RGB LED mounted on an aluminium heatsink ^[1]. To use these set the #define at the start of the program to RGB.

Alternatively you can use the 4 watt RGBW versions ^[2], which are available in warm white, natural white, or cool white. To use these set the #define at the start of the program to RGBW:

The IR NeoPixel Controller controlling a high-power NeoPixel RGBW LED.

Warning! These high-power NeoPixel LEDs are extremely bright, so when testing the IR NeoPixel Controller I covered them with translucent bottle tops. When using it for room illumination I recommend using a reflector to direct it at the ceiling, or put it into a translucent globe light fitting ^[3]:

A high-power NeoPixel RGB LED in a translucent globe light fitting.

The high-power LEDs should be mounted on a heatsink to avoid overheating at maximum brightness. I used a square 40 x 40 x 11mm black ^[4] or silver ^[5] finned heatsink.

Note that although the high-power modules use the same connectors as Adafruit's LED strips, the polarity of the +5V and GND connections is reversed, so check before plugging them in!

This circuit will also drive standard WS2812 or WS2812B NeoPixel LEDs daisy-chained together, but these are each only about 0.3 watts. However, because perception of brightness is non linear they will look only about a third of the brightness of the high-power LEDs.

NeoPixel driver

To drive the LED modules I used my NeoPixel driver based on an AVR64DD14: NeoPixel Driver Program 3. This uses a Timer/Counter in the AVR processor to generate the waveforms needed by the NeoPixel protocol, and the SPI peripheral to output them as a serial stream, rather than the software approach used by many other NeoPixel interfaces.

IR remote control receiver

The IR remote control receiver is designed to work with remote controls that use the NEC protocol, like many low cost infrared remotes available from the Far East. The remote control I used is available from Adafruit ^[6], or their distributors such as The Pi Hut in the UK ^[7]. The NEC protocol is also used by the Apple Remote ^[8], so if you have one of those you could use it. If you want to use a different remote control you can find its key codes as described below: Finding the codes for an IR remote.

Using the IR NeoPixel Controller

The following diagram shows the function of each key on the Adafruit remote control:

Initially all the LEDs will be off, at minimum brightness, the saturation will be at maximum, and the remote control will control the first LED.

• To control an individual LED press the corresponding number key, 1 to 9. To control all the LEDs press 0.
• To control the brightness press or hold down ▲ or ▼.
• To change the hue (colour) press or hold down ◀ or ▶. The hue goes in the sequence: red, yellow, green, cyan, blue, magenta, and back to red.
• To change the saturation press or hold down VOL- or VOL+. Reducing the saturation dilutes the colour with white.
• To turn off all the LEDs press STOP. Press it again to revert to their previous settings.

The settings are saved automatically every 10 seconds.

The circuit

Here's the circuit of the IR NeoPixel Controller:

Circuit for the IR NeoPixel Controller.

Infrared receiver

The circuit uses the popular TSOP38238 38kHz infrared receiver module in a 3-pin through-hole package, and available from Adafruit ^[9] or most component suppliers.

Because I am planning to build a surface mount version of the circuit on a PCB I also tested the circuit with a surface-mount equivalent, the TSOP36138, mounted on a SOIC-12 breakout board ^[10] (it wouldn't fit on an SOIC-8 breakout board):

A version of the circuit using a TSOP36138 surface-mount infrared receiver module
mounted on a breadboard.

Microcontroller

The project is controlled by a 14-pin AVR processor, the AVR64DD14. This has just enough I/O pins to perform all the functions, including an error light, provided you configure PF6 as an input to receive the IR signals from the IR receiver.

The program is small enough to fit on an AVR32DD14 or even an AVR16DD14, although I haven't tested them.

Error light

The error light flashes if a complex pattern cannot be evaluated in the 20ms between updates of the NeoPixels, but given the small number of LEDs in this application this will probably never happen, so I've also made it flash once to show that the IR remote control has set maximum or minimum brightness or saturation.

Construction

I built the circuit on a mini breadboard, available from SparkFun ^[11] or The Pi Hut in the UK ^[12]. Pre-cut colour-coded jumper wires make the interconnections easier ^[13]. 

The AVR64DD14 isn't available in a dual in-line package, so I mounted it on an SOIC-14 breakout board ^[14].

The program

IR remote control format

The NEC format was originally developed by the consumer electronics firm NEC. The data is encoded using pulse distance encoding. Each bit starts with 562.5µs of carrier. A zero has a total width of 1.125ms before the start of the next bit, and a one has a total width of 2.25ms before the next bit:

The carrier pulse consists of 21 cycles at 38kHz. The pulses usually have a mark/space ratio of 1:4, to reduce the current consumption:

Each code sequence starts with a 9ms pulse, known as the AGC pulse. This is followed by a 4.5ms silence:

The data consists of 32 bits: a command field consisting of an 8-bit id and an 8-bit key code, and a 16-bit address field:

The bits are transmitted low-order bit first and high-order bit last. Note that there needs to be one extra pulse at the end to terminate the last bit.

The address identifies the equipment being controlled, and the key identifies the key pressed.

In the original version of the NEC protocol the 8-bit id was just an inverted version of the key. The Apple Remote uses the full 16-bits of the address and command fields; the address is 0x87EE, and the id is used to allow a remote to be paired to a particular product.

IR receiver

The IR remote control receiver code is based on my earlier IR Remote Control Receiver, which is designed to work with the NEC protocol.

The timing of each component of the NEC protocol can conveniently be expressed in multiples of 112.5µs. The multiples are defined by the following constants:

const int ZeroBit = 10;                                   // 10 * 112.5us = 1.125ms
const int OneBit  = 20;                                   // 20 * 112.5us = 2.25ms
const int RepeatPulse = 100;                              // 100 * 112.5us = 11.25ms
const int AGCPulse = 120;                                 // 120 * 112.5us = 13.5ms

I used Timer/Counter TCB to do the timing. First, it is configured to count in units of 112.5µs:

  TCB0.CCMP = 2700-1;                                     // 112.5us
  TCB0.CTRLA = TCB_CLKSEL_DIV1_gc | TCB_ENABLE_bm;        // Divide timer by 1
  TCB0.CTRLB = 0;                                         // Periodic Interrupt mode
  TCB0.INTCTRL = TCB_CAPT_bm;                             // Overflow interrupt 

Note that this assumes a 24MHz clock, and you will need to change the divisor for a different clock rate.

Next, the TCB interrupt service routine simply counts interrupts in the global variable Ticks:

ISR(TCB0_INT_vect) {
  TCB0.INTFLAGS = TCB_CAPT_bm;                            // Clear interrupt flag
  if (Ticks < 255) Ticks++;
}

The output from the IR receiver goes to input PF6, and a pin-change interrupt is set on this pin:

  PORTF.PIN6CTRL = PORT_PULLUPEN_bm | PORT_ISC_FALLING_gc;// Interrupt falling edge

The PORTF interrupt service routine is called on each falling edge of the IR input:

ISR (PORTF_PORT_vect) {
  static uint32_t RecdData;
  // Waiting for AGC pulse and gap
  int Time = Ticks;
  if (NextBit == -1) {                                    // Waiting for AGC pulse
    if ((Time > AGCPulse-10) && (Time <= AGCPulse+10)) {  // Got AGC pulse
      RecdData = 0; NextBit = 0;
    } else if ((Time > RepeatPulse-10) && (Time <= RepeatPulse+10)) {
      ProcessCode(RecdData, true);                        // Repeat code
    }
  } else {                                                // Data bit
    if ((Time > OneBit+5) || (Time == 255)) NextBit = -1; // Fail - restart
    else {
      if (Time > OneBit-5) {                              // Bit = '1'
        RecdData = RecdData | ((unsigned long) 1<<NextBit);
      }
      NextBit++;
      if (NextBit == 32) {                                // Got complete code
        ProcessCode(RecdData, false);                     // Normal code                     
        NextBit = -1;                                     // Go back to waiting
      }
    }
  }
  Ticks = 0;                                              // Clear counter
  PORTF.INTFLAGS = PIN6_bm;                               // Clear interrupt flag
}

This uses the global variable NextBit to keep track of the progress of the decoding. Initially NextBit is set to -1, to indicate that the routine is waiting for the AGC start pulse. As the bits are received they are shifted into RecdData, and NextBit is incremented. When NextBit reaches 32 the complete IR code has been received, and the routine calls ProcessCode() to perform the required action.

The routine checks that the length of the AGC pulse and gap is within 10 ticks of the required 13.5ms, and if so sets NextBit to 0 to start reading the code. It also checks whether the AGC pulse and gap is within 10 ticks of the 11.25ms width of a repeat code, and if so calls ProcessCode() with the same code and the second parameter set to true.

For each bit the routine checks its length. If it is within 5 ticks of 2.25ms it is taken as a 1-bit. If shorter than this it is taken as a 0-bit. If the bit is too long, or Time = 255, it indicates that the code hasn't been received correctly, so the processing of the code is abandoned and the routine returns to the waiting state.

Processing the IR remote key codes

The IR remote key presses are processed by the routine ProcessCode(), which takes the 32-bit code and a flag to specify whether it is a repeat code; ie the key is being held down.

The code is first separated into the address, key, and id components, and the address is checked to ensure that the code is from the Adafruit remote:

void ProcessCode (uint32_t code, bool repeat) {
  uint16_t address = code & 0xffff;
  uint8_t key = code >> 16 & 0xff;
  uint8_t id = code >> 24 & 0xff;
  
  if (address != IRAddress) return;                        // Check for remote
  uint8_t n = State.LED;
  
  switch (key) {
    case UP:    if (State.Control[n][VALUE] <= 253) State.Control[n][VALUE]+=2;
                else Error(true); break;
    ...
  }
}

The routine then uses a switch statement to perform the appropriate action for each key. In most cases this involves incrementing or decrementing one of the elements of the array State.Control[][]. The first array index is the number of the LED, from 1 to 9, or 0 to set all LEDs to the same value. The second array index is the parameter being controlled: hue, saturation, or value (brightness). For simplicity I've only shown the processing for the UP key, which increases the brightness.

An earlier version of the program used a NeedsSaving flag to indicate whether the data had changed and needed to be saved to EPROM, but I realised that this was unnecessary because the Arduino EEPROM library EEPROM.update() function, and its wrapper EEPROM.put(), only write to the EEPROM if the value to be written is different from what's already there, so there's no wear on the EEPROM if the data hasn't changed.

NeoPixel driver

The NeoPixel driver code is identical to the program described in my earlier project A NeoPixel Driver using AVR Hardware [3]. The main change is that the number of channels is specified by a global variable Channels, to allow for RGBW or GRBW NeoPixels.

Actually, there is one other change. In my first prototype I found that the NeoPixels sometimes flickered when operating the IR remote. I tracked the problem down to the pin-change interrupt interfering with the timing of the SPI0 interrupt. The solution is to give the SPI0 interrupt priority by defining it as a level 1 high priority vector, with the statement:

  CPUINT.LVL1VEC = 20;                                    // Give SPI0_INT priority

The value 20 is the SPI0_INT vector number, which you can find in the datasheet Interrupt Vector Mapping table.

Pattern functions

My earlier Light Lab project provided 22 alternative patterns which included both static and animated displays that you could control with three potentiometers, and it supported strips of up 160 LEDs. To achieve this the pattern functions used fixed-point arithmetic, because floating point wasn't fast enough to support that number of LEDs.

This IR Controlled NeoPixel application has more modest ambitions: it only allows up to nine LEDs, and there is essentially one pattern which allows you to adjust the hue, saturation, and brightness of each or all LEDs with the remote control. The pattern functions are written using floating-point calculations, which is fast enough with this number of LEDs, and this makes them simpler than their equivalents in Light Lab.

For example, here's the main hsv() function for RGB or GRB displays:

float hsv (int k, float h, float s, float v) {
  return clamp(2.0 - (3.0 * tri(h - k/3.0))) * v * s + v * (1 - s);
}

It takes an integer channel number k, from 0 to 2 for red, green, and blue, and floating-point values of hue, saturation, and value (brightness), of 0.0 to 1.0. It returns the intensity of that channel, from 0.0 to 1.0.

It uses the functions fract(), fractional part, clamp(), which clamps its parameter to the range 0.0 to 1.0, and dist(), which returns the the shortest distance around a circle between two points on a circle of circumference 1.0. 

For RGBW or GRBW LEDs the additional channel number 3 indicates the white channel, and the function becomes:

float hsv (int k, float h, float s, float v) {
  if (k == 3) return v * (1 - s);                         // White channel
  else return clamp(2.0 - (3.0 * tri(h - k/3.0))) * v * s;
}

For an explanation of how these hsv() functions work see A Single-Line HSV Function.

Saving the state in EEPROM

After setting the LEDs to the colour settings you want to use, if you switch off and on again they are restores to the same settings. To do this the settings are saved in a struct called State:

struct {
  uint8_t flag = NumPixels;                               // Check if changed
  uint8_t Control[NumPixels+1][3];                        // Control values
  uint8_t LED = 1;                                        // 1 to 9 or 0 = all
  bool Animate = false;                                   // Changing display
  bool On = true;                                         // Switch LEDs on/off
} State;

On startup the settings are loaded from EEPROM with the following statement in setup():

  if (EEPROM.read(0) == NumPixels) EEPROM.get(0, State);  // Only read if valid

The first time you run the program, or if the number of LEDs, NumPixels, has changed, the settings are initialised to their defaults by calling ResetState().

The settings are saved automatically every 10 seconds in the Refresh() loop.

Installing the program

First install Spence Konde's DxCore from GitHub: see DxCore - Installation. I used version 1.5.11 ^[15].

Then, in the Arduino IDE:

• Choose the AVR DD-series (no bootloader) option under the DxCore heading on the Board menu.
• Check that the subsequent options are set as follows (ignore any other options):

Board: "AVR DD-series (no bootloader)"
Chip: "AVR64DD14"
Clock Speed: "24 MHz internal"
Reset and UPDI: "PF6: Input & PF7: UPDI (no reset pin, safe.)" 

You can leave the other options at their defaults, the first option on each submenu.

• Connect a UPDI programmer to the UPDI, GND, and VDD pins.

To program the processor the recommended option is to use a 5V or 3.3V USB to Serial board, such as the SparkFun FTDI Basic board ^[16], or a USB to Serial cable ^[17], connected with a Schottky diode as follows. You can substitute a 4.7kΩ resistor for the Schottky diode:

• Set Programmer to the "SerialUPDI - Normal: 230400 baud (recommended)" option.
• Select the USB port corresponding to the USB to Serial board in the Port menu.

• Select Burn Bootloader to configure the fuse to make PF6 an input.
• Click Upload to upload the program to the AVR64DD14.

If the IR remote control doesn't work, check that you remembered to set the Reset and UPDI option to make PF6 an input.

Finding the codes for an IR remote

The following procedure allows you to use the IR NeoPixel Controller to display the address and key codes for any NEC-protocol IR remote control.

Connect a NeoPixel strip with at least 8 LEDs to the +5V, Data, and GND pins. I used an Adafruit eight NeoPixel strip ^[18].

Then modify the IR NeoPixel Controller program as follows:

• Set the #define FORMAT line to the NeoPixel format appropriate to the type of strip you are using.
• Comment out the following line in the ProcessCode() function, as shown, to respond to any address:

// if (address != 0xbf00) return;

• Replace the switch block below it by the lines:

ResetState();
for (int i=0; i<8; i++) State.Control[i+1][VALUE] = (key>>i & 1) * 16;

• Upload the program.

Now when you press any key on the remote control, its code will be displayed in binary on the eight LEDs.

Finding the remote control address

• To display the bottom eight bits of the remote control address when you press a key, change the second line to:

for (int i=0; i<8; i++) State.Control[i+1][VALUE] = (address>>i & 1) * 16;

• To display the top eight bits of the remote control address change the line to:

for (int i=0; i<8; i++) State.Control[i+1][VALUE] = (address>>(i+8) & 1) * 16;

Resources

Here's the IR NeoPixel Controller program: IR NeoPixel Controller Program

1. ^ Ultra Bright 3 Watt Chainable NeoPixel LED on Adafruit.
2. ^ Ultra Bright 4 Watt RGBW NeoPixel LED on Adafruit.
3. ^ Firstlight Sphere 15cm Flush Ceiling Light on Lightbulbs Direct.
4. ^ Aluminium Heatsink - Black on The Pi Hut.
5. ^ Aluminium Heatsink - Silver on The Pi Hut.
6. ^ Mini Remote Control on Adafruit.
7. ^ Mini IR Remote Control on The Pi Hut.
8. ^ Apple Remote on Wikipedia.
9. ^ IR (Infrared) Receiver Sensor on Adafruit.
10. ^ SMT Breakout PCB for SOIC-12 or TSSOP-12 on Adafruit.
11. ^ Breadboard - Mini Modular (White) on SparkFun.
12. ^ Mini Breadboard - White on The Pi Hut.
13. ^ Jumper Wire Kit on The Pi Hut.
14. ^ SMT Breakout PCB for SOIC-14 or TSSOP-14 on Adafruit.
15. ^ There is a problem programming the AVR64DD14 with DxCore 1.6.2.
16. ^ SparkFun FTDI Basic Breakout - 5V on Sparkfun.
17. ^ FTDI Serial TTL-232 USB Cable on Adafruit.
18. ^ NeoPixel Stick - 8 x 5050 RGB LED on Adafruit.