#define AT555_DISABLE_OUT // Override the output pin, because FastLED needs it.

#include <FastLED.h>
#include "ATTiny555.h"

#define AT555_OUTPIN PB1
#define NUM_LEDS (24)

CRGB leds[NUM_LEDS];

void setup() {
  AT555_begin();
  FastLED.addLeds<WS2812B, AT555_OUTPIN, GRB>(leds, NUM_LEDS);
  FastLED.setBrightness(16);
}

void loop() {
  // If the 555 is oscillating
  if (ADCH >= AT555_TRIGVAL && ADCH <= AT555_THRESHVAL) {

    // Get how far the analog voltage is between 1/3 vcc and 2/3 vcc
    uint8_t progress = (ADCH - AT555_TRIGVAL) * 3;

    // Find how many leds we need to light to represent the voltage
    uint8_t ledsLit = ((uint16_t)progress * NUM_LEDS) >> 8;

    // Get how far the progress is between two leds (from 0-255)
    uint8_t ledProgress = (uint8_t)((uint16_t)progress - ((uint16_t)ledsLit << 8) / NUM_LEDS) * NUM_LEDS;

    CRGB col = AT555_flipFlop ? CRGB::Green : CRGB::Red; // red when OUT pin is low, green when OUT pin is high

    // Fill the led colors according to the graph
    for (uint8_t i = 0; i < NUM_LEDS; i++) {
      if (i < ledsLit)
        leds[i] = col;
      else if (i == ledsLit) // If the LED is the boundary LED,
        leds[i] = col.scale8(ledProgress); // Scale the colors to anti-alias the line bar.
      else leds[i] = CRGB::Black;
    }

    FastLED.show(); // Display the changes
  }
}


ATTiny555_NeoPixelFade.ino

diagram.json

#ifndef _ATTINY555_H_
#define _ATTINY555_H_

#ifndef AT555_TRIGVAL // if it wasnt defined by the user,
#define AT555_TRIGVAL (85) // reset the flip-flop at 85/255 vcc, which is 1/3 vcc
#endif

#define AT555_ADPS_1MHZ   ((0 << ADPS2) | (0 << ADPS1) | (0 << ADPS0))  // ADC prescaler of 2 (500kHz input clock @ 1MHz)
#define AT555_ADPS_8MHZ   ((0 << ADPS2) | (1 << ADPS1) | (1 << ADPS0))  // ADC prescaler of 8 (1MHz input clock @ 8MHz)
#define AT555_ADPS_16MHZ  ((1 << ADPS2) | (0 << ADPS1) | (0 << ADPS0))  // ADC prescaler of 16 (1MHz input clock @ 16MHz)

#if (F_CPU == 1000000)
#define AT555_ADPS AT555_ADPS_1MHZ
#elif (F_CPU == 8000000)
#define AT555_ADPS AT555_ADPS_8MHZ
#elif (F_CPU == 16000000)
#define AT555_ADPS AT555_ADPS_16MHZ
#else
#error "CPU frequency is not supported!"
#endif

// initializes the ATTiny555 functionality.
void AT555_begin();

#ifdef AT555_ORIGINAL // ATTiny555 Original Layout
#pragma message "Compiling for original layout..."

/*
 *  Pin # | 555 Pin | Type | Function
 * -------+---------+------+-------------------
 *  PB0   | CTRL    | AIN  | analog ref (ignore)
 *  PB1   | THRESH  | AIN  | on above ctrl, start discharge
 *  PB2   | DIS     | OUT  | cap discharge to gnd, otherwise hi-z
 *  PB3   | TRIG    | AIN  | on below AT555_TRIGVAL/255 vcc, start charge
 *  PB4   | OUT     | OUT  | low during discharge
 */

#ifdef AT555_THRESHVAL
#error "AT555_THRESHVAL is not supported when using the original layout, as it relies on an external voltage divider to supply the TRIG voltage."
#endif

// The value of the ATTiny555 output pin 
#define AT555_flipFlop (DDRB & (1 << DDB2))

// The Arduino pin number of the output pin.
#define AT555_OUTPIN (4)

void AT555_begin() {
    cli();            // disable interrupts

    // == init adc ==
    ADMUX = 
        (1 << ADLAR) |  // enable 8-bit mode
        (0 << REFS1) |  // set vref to vcc
        (0 << REFS0) |
        (0 << MUX3)  |  // set ADC mux input to TRIG ADC3/PB3
        (0 << MUX2)  |
        (1 << MUX1)  |
        (1 << MUX0);
    ADCSRA = 
        (1 << ADEN) |   // enable the adc
        (1 << ADSC) |   // start conversion immediately
        (1 << ADIE) |   // enable the adc conversion interrupt
        AT555_ADPS;     // set prescaler

    // == init comparator ==
    // uses AIN0 (CTRL) and AIN1 (THRESH) as the + and - inputs respectively.
    ACSR = 
        (1 << ACIE) |   // enable the analog comparator interrupt
        (1 << ACIS1) |  // set interrupt on falling edge
        (1 << ACIS0);
    // ACO = CTRL > THRESH, therefore we should interrupt on the falling edge

    sei();              	// enable interrupts

    // == init outputs ==
#ifndef AT555_DISABLE_OUT
    DDRB = (1 << DDB4);   // set OUT to output
#endif
    PORTB |= (1 << PB0);  // enable CTRL 35 KOhm pull-up
}

ISR(ANA_COMP_vect) {      // on the falling edge (meaning THRESH is now higher than CTRL)
    // reset the flip-flop
    DDRB |= (1 << DDB2);  // enable discharge (set DIS to gnd)
#ifndef AT555_DISABLE_OUT
    PORTB &= ~(1 << PB4); // disable OUT
#endif
}

ISR(ADC_vect) { // on the adc read complete
    ADCSRA |= (1 << ADSC);  // restart ADC measurement

    // if TRIG is less than AT555_TRIGVAL
    if (ADCH < AT555_TRIGVAL) {
        // set the flip-flop
        DDRB &= ~(1 << DDB2); // disable discharge (set DIS to hi-z)
#ifndef AT555_DISABLE_OUT
        PORTB |= (1 << PB4);  // enable OUT
#endif
    }
}

#else // ATTiny555 Flip Chip Layout
#pragma message "Compiling for flip-chip layout..."

/*
 *  Pin # | 555 Pin | Type | Function
 * -------+---------+------+-------------------
 *  PB1   | DIS     | OUT  | cap discharge to gnd, otherwise hi-z
 *  PB2   | THRESH  | AIN  | on above AT555_THRESHVAL/255, start discharge
 *  PB3   | OUT     | OUT  | low during discharge
 *  PB4   | TRIG    | AIN  | on below AT555_TRIGVAL/255 vcc, start charge
 */

#ifndef AT555_THRESHVAL // if it wasnt defined by the user,
#define AT555_THRESHVAL (170) // set the flip-flop at 170/255 vcc, which is 2/3 vcc
#endif

// The value of the ATTiny555 output pin 
#define AT555_flipFlop (DDRB & (1 << DDB1))

// The Arduino pin number of the output pin.
#define AT555_OUTPIN (3)

void AT555_begin() {
    cli();            // disable interrupts
  
    // == init adc ==
    ADMUX = 
        (1 << ADLAR) |  // enable 8-bit mode
        (0 << REFS1) |  // set vref to vcc
        (0 << REFS0) |
        (0 << MUX3)  |  // set ADC MUX input to ADC1/PB2/THRESH
        (0 << MUX2)  |
        (0 << MUX1)  |
        (1 << MUX0);
    ADCSRA = 
        (1 << ADEN) |   // enable the ADC
        (1 << ADSC) |   // start conversion immediately
        (1 << ADIE) |   // enable the adc conversion interrupt
        AT555_ADPS;     // set prescaler
    
    sei();              	// enable interrupts

    // == init outputs ==
#ifndef AT555_DISABLE_OUT
    DDRB = (1 << DDB3);   // set OUT to output
#endif
}

ISR(ADC_vect) { // on the ADC read complete
    ADCSRA |= (1 << ADSC);  // restart ADC measurement

    // we now have about 20 cycles to do whatever we want. gotta do it fast!

    // flip the ADC MUX 2 LSBs.
    // if MUX is set to 0001 (PB4/ADC2/TRIG), 
    // it will now be 0010 (PB2/ADC1/THRES) and vice versa.
    ADMUX ^=
        (1 << MUX1) |
        (1 << MUX0);

    // if the MUX LSB is now 1, it must have been 0 during the last conversion.
    // because the MUX LSB was 0 when the ADC was measuring PB2/ADC1/THRES,
    // ADCH contains the voltage on THRES.
    // otherwise, ADCH must contain the voltage on TRIG,
    // because the MUX switches between ADC1 and ADC2 each measurement.
    if (ADMUX & (1 << MUX0)) {
        if (ADCH > AT555_THRESHVAL) { // if THRESH is greater than AT555_THRESHVAL,
            // reset the flip-flop
            DDRB |= (1 << DDB1);  // enable discharge (set DIS to gnd)
#ifndef AT555_DISABLE_OUT
            PORTB &= ~(1 << PB3); // disable OUT
#endif
        }
    } else {
        // if TRIG is less than AT555_TRIGVAL
        if (ADCH < AT555_TRIGVAL) {
            // set the flip-flop
            DDRB &= ~(1 << DDB1); // disable discharge (set DIS to hi-z)
#ifndef AT555_DISABLE_OUT
            PORTB |= (1 << PB3);  // enable OUT
#endif
        }
    }
}

#endif

#endif 


ATTiny555.h

# ATTiny555
A single-header 555 timer simulator running on the ATTiny85 :)

For a more detailed description (and build instructions), [check me out on Hackaday!](https://hackaday.io/project/183013-attiny555)

## Overview

By default, the ATTiny555 will do these three functions:

1. When the voltage on THRES rises above two-thirds of the input voltage, the OUT pin is pulled high and the DIS pin is set to sink current.
2. When the voltage on TRIG drops below one-third of the input voltage, the OUT pin is pulled low and the DIS pin is set to high impedance (essentially making it float)
3. When RESET is pulled low, OUT is pulled low and the DIS pin is set to high impedance.

## API Usage

It’s a bit weird to call this an API, because it’s just a thin wrapper over low-level bit hacks. But anyways, here are the main functions of the header:

### Initialization

Just call the `AT555_begin()` function once upon startup.

### Reading the internal flip-flop

The macro `AT555_flipFlop` contains the value of the internal flip-flop. It’s nonzero when the discharge pin is active, and zero when the discharge is inactive.

### Using the “Original Layout”

If you’re using the original layout, define `AT555_ORIGINAL` **before** including `ATTiny555.h`, like so:

```c++
#define AT555_ORIGINAL
#include "ATTiny555.h"
```

Otherwise, the module will compile for the flip-chip layout, messing up your pins.

### Adding custom output pin functionality

Sometimes, your application may require you to add custom functionality for the output pin. If this is needed, simply define `AT555_DISABLE_OUT` **before** including `ATTiny555.h`, like so:

```c++
#define AT555_DISABLE_OUT
#include "ATTiny555.h"
```

Now the output pin is completely in your control!

If you need a macro that expands to the Arduino pin number of the output pin, just use `AT555_OUTPIN`!

### Changing the trigger and threshold values

By default, the trigger value is set to one-third of the VCC and the threshold value is set to two-thirds of VCC. However, these values can be changed. Keep in mind that modifying both is only supported using the flip-chip layout.

| Layout    | Is TRIG value mutable? | Is THRESH value mutable?                    |
| --------- | ---------------------- | ------------------------------------------- |
| Original  | :heavy_check_mark:     | :x: (only through external voltage divider) |
| Flip-Chip | :heavy_check_mark:     | :heavy_check_mark:                          |

They are stored as integers, where `255` is VCC and `0` is zero volts. For example, half of VCC would be expressed as `127` (rounding down).

To change the values, simply define them **before** including `ATTiny555.h`, like so:

```c++
#define AT555_TRIGVAL   (??)
#define AT555_THRESHVAL (??)

#include "ATTiny555.h"
```

> Tip: You can `#define` them as variable names if you need to change them programmatically! Just be sure to define them before including `ATTiny555.h`. Just be aware this requires evil global variables.
>
> ```c++
> #define AT555_TRIGVAL   (myTrigVal)
> #define AT555_THRESHVAL (myThreshVal)
> 
> uint8_t myTrigVal;
> uint8_t myThreshVal;
> 
> #include "ATTiny555.h"
> 
> ...
> ```


#



README.md

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

# Automatically added based on includes:
FastLED
# ---
