Fingers elektrische Welt

Code: Alles auswählen

bool led = 0;

void setup() {

  sei();                      //interupts aus

  pinMode(10, INPUT_PULLUP);  //interrupt eingang

  pinMode(7, OUTPUT);         //tiny pin 6, oc1b
  pinMode(10, OUTPUT);        //tiny pin 2, led

  GIMSK = _BV(INT0);          //ext interupt an int0, pin 5
  MCUCR = _BV(ISC01);         //interupt bei fallender flanke

  sei();                      //interrupts an
}



void loop () {

  TCCR0A = _BV(COM0B1) | _BV(WGM01);  // OC0B = 0 bei match + ctc mode
  TCCR0B = _BV(CS01) | _BV(CS00) ;    //vorteiler =8      
  OCR0A  = 0xff;                      //zählen bis 255
  OCR0B  = 0xff;                      //vergleichswert = 255
  GTCCR = _BV(PSR10) | _BV(TSM);      //timer sync mode + prescaler reset


  while (1) {
    digitalWrite(10, led);
  }  
}



ISR(INT0_vect)
{
  led = !led;             //debug led toggeln
  GTCCR = ~_BV(PSR10);    //start timer
  digitalWrite(7, HIGH);  //ausgang setzen
}

Code: Alles auswählen

asm volatile 
  (
 "ldi r16, 0b00111111 \n"
 "out DDRB, r16 \n")

Code: Alles auswählen

const int buttonPin = 2;     // the number of the pushbutton pin
int buttonState = 0;         // variable for reading the pushbutton status

void setup() {
  // initialize the pushbutton pin as an input:
  pinMode(PB4, INPUT);
  pinMode(PB4, INPUT_PULLUP); //configure pin 2 as an input and enable the internal pull-up resistor

  // initialize the LED pin as an output:
  // DDRB equ 0x17
  asm
  (
    // alternativ: "ldi r16, 0b00001000 \n"
    "ldi r16, 0x08 \n"
    "out 0x17, r16 \n") // DDRB Bit 3 setzen
  ;
}

void loop() {
  // read the state of the pushbutton value:
  buttonState = digitalRead(PB4);

  // check if the pushbutton is pressed. If it is, the buttonState is HIGH:
  if (buttonState == LOW) {
    // turn LED on:
    // PORTB equ 0x18
    asm  (
      "ldi r16, 0b00001000 \n"
      "cbi 0x18, 3 \n" 		//clear Bit PB3
    );

    delay(500);
    // turn LED off:
    //    digitalWrite(PB3, HIGH);
    asm  (
      "ldi r16, 0b00001000 \n"
      "sbi 0x18, 3 \n" 		//set Bit PB3
    );

    delay(100);
  } else {
    // turn LED off:
    digitalWrite(PB3, LOW);
  }
}

Code: Alles auswählen

//DIY Tachometer to Measure Accurate RPM using Arduino
//DIY Tachometer to Measure Accurate RPM using Arduino
//This code is published by https://www.circuitschools.com
//Attribution required to republish.
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //Angabe der erforderlichen Pins

 
// Create the lcd object address 0x27(get it from i2cscanner) and 16 columns x 2 rows 
// LiquidCrystal_I2C lcd (0x27, 16,2); //
float value=0;
float rev=0;
int rpm;
int oldtime=0;
int newtime;
void isr() //interrupt service routine
{
rev++;
}
void setup()
{
lcd.begin(16, 2); // Starten der Programmbibliothek.
// Turn on the backlight on LCD. 
//lcd. backlight ();
attachInterrupt(digitalPinToInterrupt(2),isr,RISING); //attaching the interrupt
}
void loop()
{
 
delay(1000);
detachInterrupt(0); //detaches the interrupt
newtime=millis()-oldtime; //finds the time 
int wings= 1; // no of wings of rotating object, for disc object use 1 with white tape on one side
int RPMnew = rev/wings; //here we used fan which has 3 wings
rpm=(RPMnew/newtime)*60000; //calculates rpm
oldtime=millis(); //saves the current time
rev=0;
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Drehzahl U/Min :");
lcd.setCursor(0,1);
lcd.print( rpm);
lcd.print("");
lcd.print(" ");
attachInterrupt(digitalPinToInterrupt(2),isr,RISING);
}

Code: Alles auswählen

	/////////MotorZustand//////////////////
	tt = millis() - rpmTimeStamp;
	if (tt >= 200) {
		
			rPM = (float) rpmTicks * (float) 30000 / (float) tt;
			rpmTimeStamp = millis();
			rpmTicks = 0;
			blabla....

Code: Alles auswählen

#include <LiquidCrystal.h>
//#include <LiquidCrystal_I2C.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //Angabe der erforderlichen Pins
// LiquidCrystal_I2C lcd (0x27, 16, 2); 

const byte PulsesPerRevolution = 1;
const unsigned long ZeroTimeout = 1000000;
const byte numReadings = 2;

volatile unsigned long LastTimeWeMeasured;
volatile unsigned long PeriodBetweenPulses = ZeroTimeout + 1000;
volatile unsigned long PeriodAverage = ZeroTimeout + 1000;
unsigned long FrequencyRaw;
unsigned long FrequencyReal;
long Frequenz;
unsigned long RPM;
unsigned int PulseCounter = 1;
unsigned long PeriodSum;

unsigned long LastTimeCycleMeasure = LastTimeWeMeasured;
unsigned long CurrentMicros = micros();
unsigned int AmountOfReadings = 1;
unsigned int ZeroDebouncingExtra;
unsigned long readings[numReadings];
unsigned long readIndex;  
unsigned long total; 
unsigned long average;

void setup()
{
lcd.begin(16, 2); // Starten der Programmbibliothek.
lcd.setCursor(0,0); // Angabe des Cursorstartpunktes oben links.
  //lcd.print(""); // Ausgabe des Textes "Nachricht".

  attachInterrupt(digitalPinToInterrupt(2), Pulse_Event, RISING);
  delay(1000);
}
 
void loop()
{
lcd.setCursor(12,1); // Bewegt den Cursor in Zeile 2 (Line0=Zeile1 und Line1=Zeile2) and die Stelle "12".

  LastTimeCycleMeasure = LastTimeWeMeasured;
  CurrentMicros = micros();
  if (CurrentMicros < LastTimeCycleMeasure) {
    LastTimeCycleMeasure = CurrentMicros;
  }
  FrequencyRaw = 10000000000 / PeriodAverage;
  if (PeriodBetweenPulses > ZeroTimeout - ZeroDebouncingExtra || CurrentMicros - LastTimeCycleMeasure > ZeroTimeout - ZeroDebouncingExtra) {
    FrequencyRaw = 0;  // Set frequency as 0.
    ZeroDebouncingExtra = 2000;
  } else {
    ZeroDebouncingExtra = 0;
  }
  FrequencyReal = FrequencyRaw / 10000;

  RPM = FrequencyRaw / PulsesPerRevolution * 60 ;
  RPM = RPM / 10000;
  Frequenz = RPM * 1000 / 60;
//  Frequenz = Frequenz * 1000;
//  Frequenz = 1000000 / Frequenz;
  total = total - readings[readIndex];
  readings[readIndex] = RPM;
  total = total + readings[readIndex];
  readIndex = readIndex + 1;

  if (readIndex >= numReadings) {
    readIndex = 0;
  }
  average = total / numReadings;

  lcd.setCursor(0, 1);
//  lcd.print("Period: ");
//  lcd.print(PeriodBetweenPulses);
//  lcd.print("\tReadings: ");
//  lcd.print(AmountOfReadings);
  lcd.print("\Freq.: ");
//  lcd.print(FrequencyReal);
  lcd.print(Frequenz);
  lcd.print("\mHz        ");
//  lcd.print("\tRPM: ");
//  lcd.print(RPM);
//  lcd.print("\tTachometer: ");
//  lcd.println(average);
  lcd.setCursor(0, 0);
  lcd.print("U/Min: ");
  lcd.print(RPM);
  lcd.print("     ");
}
void Pulse_Event() {
  PeriodBetweenPulses = micros() - LastTimeWeMeasured;
  LastTimeWeMeasured = micros();
  if (PulseCounter >= AmountOfReadings)  {
    PeriodAverage = PeriodSum / AmountOfReadings;
    PulseCounter = 1;
    PeriodSum = PeriodBetweenPulses;

    int RemapedAmountOfReadings = map(PeriodBetweenPulses, 40000, 5000, 1, 10);
    RemapedAmountOfReadings = constrain(RemapedAmountOfReadings, 1, 10);
    AmountOfReadings = RemapedAmountOfReadings;
  } else {
    PulseCounter++;
    PeriodSum = PeriodSum + PeriodBetweenPulses;
  }
}

Code: Alles auswählen

avrdude -v -p t13 -b 1200 -c usbasp -P /dev/ttyS4 -D -F -U flash:w:/home/ich/Technik/Arduino/hex/Z-var-25.hex:i

Code: Alles auswählen

avrdude -v -p t25 -b 1200 -c usbasp -P /dev/ttyS4 -D -F -U flash:w:/home/ich/Technik/Arduino/hex/Z-var-25.hex:i

Code: Alles auswählen

avrdude -v -pattiny25 -cstk500v1 -P/dev/ttyACM2 -b19200 -U flash:w:/home/ich/Technik/Arduino/hex/Z-var-25.hex:i

Code: Alles auswählen

/////////MotorZustand//////////////////
	tt = millis() - rpmTimeStamp;
	if (tt >= 200) {
		//15.000 rpm * 2pulse / 60 = 500 pulse/sec (1/500= 2 mS Puls abstand)
		// 1500 rpm : 20 mS Puls abstand (tt >= 100 = 5 Pulse)
		//rpmTicks ist 8bit!!!-> tt max 500 (ueberlauf) TODO 16?
		//im recording tauchen nur 150er schritte auf,
		//dh. einfangen bei 200 geht zuverlässig, tt wird nie >200

		if (rpmTicks > 0) {
			rPM = (float) rpmTicks * (float) 30000 / (float) tt;

Code: Alles auswählen

rPM = (uint32_t) rpmTicks * 30000 >> 7;

Code: Alles auswählen

ISR(INT0_vect)								// Der Hardware interrupt der ausgelöst wird wenn ein Impuls kommt
{
	AddToFloatAvg(&Dreh,(15000000.0/(TCNT0+256.0*overflow)));	// Drehzahlwert dem Floating Average hinzufügen
	TCNT0=0;							// Timer wieder null setzen
	overflow=0;							// Überlauf wieder null setzen
}

ISR(TIMER0_OVF_vect)							// Interrupt der ausgelöst wird wenn der Timer überläuft(der hat nur 8bit also passiert das recht schnell)
{
	if(overflow<255)
		overflow++;						// Überläufe addieren, wenn 255 mal übergelaufen dann Drehzahl von null in den Floating Average schreiben
	else
		AddToFloatAvg(&Dreh,0);
}