8bit PWM w. n SRs (fehlerbereinigt)

/*
 * pwm8.c
 *
 *  Created on: 10.03.2019
 *      Author: harry
 */

#include "avr/io.h"
#include <avr/interrupt.h>
#include "pwm8.h"

/*
 * User adjustable
 */
#define LED_NUM     8               // must be a multiple of 8
                                    // limited by amount of RAM
#define DEBUG                       // enable scope-trigger-signal-pin

#ifdef DEBUG
#define TRIGGER_PIN PD2             // Debug-pin for scope-triggering
#define ACTIVE_PIN  PD3
#define DEBUG_DIR   DDRD
#define DEBUG_PORT  PORTD
#endif

#define LATCH_PIN   PB1             // STCP
#define OE_PIN      PB2             // OE
#define MOSI_PIN    PB3             // Din
#define CLK_PIN     PB5             // SHCP

#define PORT_DIR    DDRB
#define LED_PORT    PORTB

/*
 * timingg-setting
 */
#define DEADTIME    24              // increase value, if you have other more time
                                    // consuming interrupts and the shortest pulses gets doubled
/*
 * don't change anything below this line!
 * except, you know, what are you going to do!
 */
#define LATCH()     LED_PORT |= (1 << LATCH_PIN),LED_PORT &= ~(1 << LATCH_PIN)

#ifdef DEBUG
#define TRIGGER()   DEBUG_PORT ^= (1 << TRIGGER_PIN) //,PULSE_PORT &= ~(1 << TRIGGER_PIN)
#define LEAVE_INT()     DEBUG_PORT |= (1 << ACTIVE_PIN)
#define ENTER_INT()     DEBUG_PORT &= ~(1 << ACTIVE_PIN)
#endif

#define SR_NUM      (LED_NUM / 8)

#define TIM_BSY()   tim_bsy = TRUE
#define TIM_RDY()   tim_bsy = FALSE
#define SPI_BSY()   spi_bsy = TRUE
#define SPI_RDY()   spi_bsy = FALSE

static volatile uint8_t pwm_buf[SR_NUM][8];

static volatile uint8_t tim_bsy = FALSE;
static volatile uint8_t spi_bsy = FALSE;
static volatile uint8_t bit_cnt = 0;
static volatile uint8_t sr_cnt;
static volatile uint8_t dummy;

/*
 * Public Functions
 */
void pwm8Init(void)
{
    // Initialize GPIOs
    PORT_DIR |= ((1 << LATCH_PIN) | (1 << OE_PIN)
             | (1 << MOSI_PIN) | (1 << CLK_PIN));   // define Outputs
    LED_PORT &= ~((1 << LATCH_PIN) | (1 << OE_PIN));    // Reset Latch and OE

#ifdef DEBUG
    DEBUG_DIR |= ((1 << TRIGGER_PIN) | (1 << ACTIVE_PIN));
#endif

    // Initialize SPI
    SPCR = (1 << SPIE) | (1 << SPE) | (1 << MSTR);  // enable SPI
    dummy = SPSR;   // clear pending interrupts
    dummy = SPDR;

    // Initialize Timer
    TCCR1A = (1 << COM1B1) | (1 << WGM11);
    TCCR1B = (1 << WGM12) | (1 << WGM13)
            | (1 << CS11);      // fast PWM-Mode
    TCNT1 = 0;
    GTCCR = ((1 << PSRSYNC) | (1 << TSM) | (1 << PSRASY));  // disable & synchronize prescaler

    TIFR1 = (1 << OCF1B);   // clear any pending interrupt
    TIMSK1 = (1 << ICIE1);  // enable OC0A interrupt
    sei();

    // Start first SPI-transfer
    sr_cnt = 0;
    SPDR = pwm_buf[sr_cnt][bit_cnt];
    SPI_BSY();
}

/*
 * Set LED Nr. lednr
 * to PWM-Value pwm_val
 */
void pwm8SetLED(uint16_t lednr, uint8_t pwm_val)
{
uint8_t pwm_mask, led_mask;
uint8_t sr;

    sr = lednr >> 3;
    pwm_mask = 1;
    led_mask = 1 << (lednr & 0b00000111);
    for (uint8_t i = 0; i < 8; i++)
    {
        if ((pwm_val & pwm_mask) == 0)
        {
            pwm_buf[sr][i] = pwm_buf[sr][i] | led_mask;
        }
        else
        {
            pwm_buf[sr][i] = pwm_buf[sr][i] & ~led_mask;
        }
        pwm_mask <<= 1;
    }
}

/*
 * Private Functions
 */
    // stat next Cycle
static void pwm8KickCycle(void)
{

    LATCH();    // enable new data
#ifdef DEBUG
    if (bit_cnt == 0)
        TRIGGER();
#endif

    // setup one-pulse-timer
    ICR1 = (1 << bit_cnt) + DEADTIME;
    OCR1B = DEADTIME;

    TCNT1 = 0;
    GTCCR = 0;              // enable Prescaler and start Timer
    TIM_BSY();              // timer running

    bit_cnt = (bit_cnt +1) & 0b00000111; // advance to next cycle
    SPDR = pwm_buf[0][bit_cnt]; // send next pattern in advance
    SPI_BSY();              // SPI running
    LEAVE_INT();
}

/*
 * Interrupts
 *
 */
    // SPI-Interrupt
ISR( SPI_STC_vect )
{
    ENTER_INT();
    dummy = SPDR;
    if (++sr_cnt == SR_NUM)
    {
        SPI_RDY();
        sr_cnt = 0;
        if (tim_bsy == FALSE)
            pwm8KickCycle();        // this is a special case, where the
                                    // SPI-transfer takes longer than the timer-cycle
    }
    else
    {
        SPDR = pwm_buf[sr_cnt][bit_cnt];
    }
    LEAVE_INT();
}

     // Timer Interrupt
ISR( TIMER1_CAPT_vect )
{
    ENTER_INT();
    GTCCR = (1<<TSM) | (1<<PSRASY) | (1<<PSRSYNC); // halt all timers
    TIM_RDY();
    if (spi_bsy == FALSE)
        pwm8KickCycle();
    LEAVE_INT();
}