/*
Die Spannung eines Potis wird mit 16 abgestuften Spanungswerten 0 -> VCC am PWM-Ausgang ausgegeben;
dazu muß ein RC-Filter ergaenzt werden.
Die Stellung des Potis muß zuvor ueber 80 ms stabil sein und wird mit einer Hysterese ausgewertet, damit
der Ausgangswert nicht 'wackelt'.

Verwendete Hardware: Arduino UNO mit ATmega328

http://www.mino-elektronik.de

Alle Angaben ohne Gewaehr !
2025-10-17
*/

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>

#define BIT(x)  (1<<x)
#define F_CPU           16000000L                 // 16MHz ggf. an eff.Frequenz anpassen
#define T1_VORTEILER    8
#define PRO_SEKUNDE     100                       // alle 10 ms
#define OCR1A_TEILER    (F_CPU / T1_VORTEILER / PRO_SEKUNDE)

#define ADC_SCHRITTE    1024                      // bei 10 Bit
#define ADC_MAX         (ADC_SCHRITTE-1)
#define ADC_KANAL       0                         // PC.0
#define POTI_STUFEN     16
#define EINE_STUFE      (ADC_SCHRITTE / (POTI_STUFEN - 1))  // 15 Bereiche
#define HYS_STUFE       (EINE_STUFE / 4)          // 1/4 als Hysterese
#define WACKEL_HYS      5                         // 5 LSB als Toleranzbereich
#define ADC_MITTEL_N    8                         // acht Werte messen
#define EE_STUFE_ADR    0x10                      // beliebig

#define PWM_AUSGANG     6                         // OC0A an PD.6
#define TEST_AUSGANG    7                         // T1-OCRA an PD.7

int16_t poti_tab[POTI_STUFEN];                    // Bereichsgrenzen
uint32_t ADC_summe;
volatile uint8_t ms10_flag, akt_stufe;
int16_t bereich_oben, bereich_unten;              // inkl. Hysteresen

uint8_t ee_read_byte(int adr)
{
  while(EECR & 2);	                    // abwarten
  EEAR = adr;
  EECR |= 1;		                        // lesebit setzen
  return(EEDR);
}

void ee_write_byte(char data, int adr)
{
  if(data == ee_read_byte(adr)) return;	// wert steht schon dort
  cli();
  EEAR = adr;
  EEDR = data;
  EECR |= 4;		// master schreibbit setzen
  EECR |= 2;		// schreibbit setzen
  sei();
}

uint16_t lese_adc(uint8_t kanal)
{
  ADMUX =  BIT(REFS0)| kanal;       // Vcc als Vref, rechtsbuendig
  ADCSRA = BIT(ADEN) + 0x07;        // ADC einschalten mit Teiler /128
  ADCSRA |= BIT(ADSC);              // starten
  while(ADCSRA & BIT(ADSC));        // warten
  return(ADC);                      // fertig  
}


ISR(TIMER1_COMPA_vect)
{
  PIND = BIT(TEST_AUSGANG);
  ms10_flag = 1;
 }

void init_timer1()
{
  TCCR1B = BIT(WGM12) | BIT(CS11);	// vorteiler /8, compa-clear
  OCR1A = OCR1A_TEILER;	            // fuer 10ms Intervalle @ 2 MHz
  TIMSK1 |= BIT(OCIE1A); 	          // compa-int-enable 
  sei();
}

void warte_10ms(void)
{
  ms10_flag = 0;
  while(!ms10_flag);
}

// Mittelwert aus 8 Werten mit 10 ms Wartezeit bilden
uint16_t hole_adc_mittel(void)
{
  uint32_t ADC_mittelwert;
  uint8_t  ADC_anzahl;
  ADC_mittelwert = 0;
  for(ADC_anzahl = 0; ADC_anzahl < ADC_MITTEL_N; ADC_anzahl++) {
    ADC_mittelwert += lese_adc(ADC_KANAL);
    warte_10ms();
  }
  return(ADC_mittelwert/ADC_MITTEL_N);
}

// 8 Bit sind moeglich
void schreibe_pwm(uint16_t wert)
{
  if(wert > 255) wert = 255;        // hoechsten Wert begrenzen: Ausgang bleibt auf '1'
  OCR0A = wert;                     // aktuellen Wert setzen
  if(wert) {                        // PWM aktivieren, wenn wert != 0
    TCCR0B = 0x01;                  // 1:1 Vorteiler
    TCCR0A = BIT(COM0A1) + BIT(WGM01) + BIT(WGM00);         // Fast PWM einschalten
  } else {                          // sonst PWM abschalten
    TCCR0B = 0x00;                  // Timer0 abschalten
    TCCR0A &= ~(BIT(COM0A1) + BIT(WGM01) + BIT(WGM00));     // Fast PWM abschalten
    PORTB &= ~BIT(PWM_AUSGANG);     // Ausgang auf '0'
  }
}


// Hauptprogramm
// Nach Init auf voherigen Bereich in Dauerschleife akt. Bereich mit Hysteresen festlegen,
// auf stabile Stellung des Potis warten und ggf. neuen Bereich ermitteln und als PWM ausgeben
int main(void)
{
uint8_t n;
volatile int16_t akt_adc, temp;
  CLKPR = 0x80; CLKPR = 0x0;                      // CKDIV auf 0; voller CPU-Takt
  DDRD =  BIT(PWM_AUSGANG) | BIT(TEST_AUSGANG);   // PD.6 als PWM-Ausgang, PD.1 testweise für 10 ms
  init_timer1();                                  // fuer 10 ms Wartezeiten

// Tabelle für Bereiche initialisieren  
  for(n = 0; n < POTI_STUFEN; n++) 
    poti_tab[n] = (n * EINE_STUFE);
  poti_tab[POTI_STUFEN-1] = ADC_SCHRITTE;         // Obergrenze > ADC_MAX

// beim Einschalten letzten Wert holen  
  akt_stufe = ee_read_byte(EE_STUFE_ADR);         // letzten Bereich inkl. Hysteresen wiederherstellen   
  schreibe_pwm((akt_stufe * EINE_STUFE)/4);       // auf 0 - 255 skalieren

  while(1) {
// Bereiche mit Hysterese immer anpassen    
    bereich_oben = poti_tab[akt_stufe] + HYS_STUFE;
    bereich_unten = poti_tab[akt_stufe] - HYS_STUFE;
// letzte Stufe oben begrenzen  
    if(akt_stufe == POTI_STUFEN - 1)
      bereich_oben = ADC_MAX;
// unterste Stufe begrenzen    
    if(akt_stufe == 0)
      bereich_unten = 0;

    temp = hole_adc_mittel();                     // warten, Mittelwert bilden 
    akt_adc = lese_adc(ADC_KANAL);                // und letzten aktuellen Wert holen
    if(temp <= akt_adc + WACKEL_HYS && temp >= akt_adc - WACKEL_HYS) {  // Potiwert ist stabil
      if(akt_adc >= bereich_oben || akt_adc < bereich_unten) {          // wenn ausserhalb des bisherigen Bereiches
         n = 0;                                   // neuen Index auf poti_tab[] suchen
        while(akt_adc > poti_tab[n]) n++;         // bis neuer Bereich gefunden
      
        akt_stufe = n;
        schreibe_pwm((akt_stufe * EINE_STUFE)/4); // auf 0 - 255 skalieren 
        ee_write_byte(akt_stufe, EE_STUFE_ADR);   // fuer Neustart merken
      }
    }
  }
}