Seite 2 von 31

Re: Der AVR-/ARDUINO-Faden

Verfasst: Mi 5. Aug 2015, 15:43
von Sir_Death
die belgische Post hat als Absender dann aber trotzdem eine Adresse in Shenzen...

Re: Der AVR-/ARDUINO-Faden

Verfasst: Mi 5. Aug 2015, 15:54
von zauberkopf
Hi !


Ich überlege mir gerade den hier zu Samplen : http://www.atmel.com/devices/ATA8515.aspx?tab=documents
AVR + ISM Tranceiver.

Das teilchen wird interessant : das package habe ich noch nie verlötet.. und ich weis bis dato auch noch nicht, wie ich den Programmieren soll.
AVRDUDE kennt den nämlich nicht.
Digikey hat lieferschwierigkeiten...
Und überhaupt.. ich erkenne aus dem Datenblatt gar nicht, wie ich die PLL programmieren soll !
Probleme über Probleme..

vielleicht ist der TH72011 + tiny doch die bessere wahl..

Re: Der AVR-/ARDUINO-Faden

Verfasst: Mi 5. Aug 2015, 15:55
von BMS
Als Programmer eignet sich ein USBASP (meiner von Fischl).
Software: Programmierung in C mit WinAVR/avrgcc
Hardware: ATmegaXYZ auf Lochraster.
Fertige Boards habe ich auch bei eHaJo, EleConT und chip45 gesehen, kann preislich natürlich nicht mit Chinaboards mithalten, haben dafür teils mehr Peripherie an Bord. Starter-Teilesets gibts bei it-wns.
Wer's ganz klein braucht kann sich mal die Digisparks ansehen, z.B. bei cboden.

Re: Der AVR-/ARDUINO-Faden

Verfasst: Mi 5. Aug 2015, 21:48
von Fritzler
@Jan
so wies aussieht ist der ATA8515 auch garnicht User Programmierbar, der hat kein user Flash, sondern nurn Firmware Flash, hä was?
In the Atmel ATA8510 the internal microcontroller with 20Kbyte user flash can be used to add custom extensions to the
Atmel firmware. The Atmel ATA8515 embeds only the firmware ROM without user memory.
Und dann steht da was von SPI Commands, der 8515 is also nur als SPI Slave nutzbar?

Siehe auch im Datenblatt unter:
1.4.1 Typical 3V Application with External Microcontroller

Unter 1.4.2 Typical 3V Stand-Alone Application steht dann auch nurnoch der ATA8510

Ansonsten wenn du doch den 10er meinst (Im Link steht nur der 15er).
avrdude hat ne configdatei und die kannste einfach erweitern.
Musst eben "nur" im Datenblatt gucken welche Signatur der hat und mit welchem anderen AVR die Fusebits gleich sind.
Dann nen configeintrag zusammenkopieren :mrgreen:
Speicherpagegrüße steht jas auch im DB.

Zur PLL: kein Plan!

Bei Atmel sampeln ist übrigens auch nicht, im Atmel store gibts genau 0 Stück :mrgreen:

Aber da gibts doch was nettes von Texas Instruments mit Zigbee oder WLAN uder Bluetooth (je nach Baureihe) mit ARM Kern drinne :mrgreen:
http://www.ti.com/product/cc3200

Oder guck dir hier was ab:
https://rad1o.badge.events.ccc.de/

Re: Der AVR-/ARDUINO-Faden

Verfasst: Mi 5. Aug 2015, 22:21
von zauberkopf
Ich brauch aber 433MHZ..

Hintergrund ist der : Also die Suse, für die ich mal die Wanze gebaut habe,
die will eventuell ne richtige Austellung daraus machen.
So oder so ähnlich..
Jedenfalls denkt die über Wanzen nach, die gleichzeitig senden sollen...

Also brauch ich nen Sender mit ner PLL, und das ganze am besten Programmierbar, damit ich 10 unterschiedliche Frequenzen habe.
Die eigentliche idee ist also einen TH72011 + attiny zu verwenden.
Das quarz kann ich mittels capazitätsdiode modulieren..
Dann nur noch die einstellbare PA auf geringste stufe (1mW) stellen.. und fertig ist die Wanze für den Kunstbedarf.
Und so einen FM Mini-TX kann man auch für Mini-Ballonmissionen nehmen.

Der Atmel hatt aber sender,rx, und proz augenscheinlich in einem Chip untergebracht. Solche Chips gibs viele ( auch von Microshit).
Und das interessiert mich, weil weniger bauteile.

Aber wenn Atmel nicht verkaufen will.. zur not werden es halt 2 Chips..

Re: Der AVR-/ARDUINO-Faden

Verfasst: Do 6. Aug 2015, 08:18
von duese
Kann man die Arduino Nano und Micro eigentlich direkt über den USB programmieren oder ist der nur für USB-Anwendungen und programmieren wie beim Mini per seriell (und dranhängendem USB-seriell-Wandler-Kabel)?

Re: Der AVR-/ARDUINO-Faden

Verfasst: Do 6. Aug 2015, 09:26
von Duffman
Der (originale) Nano hat auf der Rückseite einen FT232RL USB-Seriell Wandler.
Auf dem (origanelen) Mikro werkelt ein Atmega32U4; der hat also schon USB-Kommunkation on-Chip.

Es ist bei beiden also kein USB-Seriell Wandler notwendig.

BAD_INTERRUPT

Verfasst: So 30. Aug 2015, 22:03
von ferdimh
Gibt es eine möglichkeit, in einem Interrupt-Handler die Nummer des auslösenden Interrupts rauszufinden?
Ich habe hier meine Waschmaschine, die gelegentlich (=ca alle 3 Waschvorgänge) spontane Resets macht. Mittlerweile habe ich einen default-Interrupt-Handler eingerichtet und außerdem das Register, was die Resetursache anzeigt ausgegeben.
Ich weiß seit eben: Es wird ein Interrupt ausgelöst, der nicht behandelt wird.
Durch Codestudium finde ich den aber nicht.
Also daher die Frage:
Wie kriege ich heraus (und kriege ich es überhaupt heraus), welcher Interrupt eine ISR ausgelöst hat?
Oder muss ich für jeden möglichen Interrupt einen eigenen Handler installieren?
CPU delicti ist ein Atmega64.

Re: Der AVR-/ARDUINO-Faden

Verfasst: So 30. Aug 2015, 22:13
von Bastelbruder
Die Interrupt-Hauptroutine sollte nach Aufruf alle Flagbytes abklappern, die gefundenen Flags nacheinander bearbeiten und zurücksetzen, dann das global Interruptflag zurücksetzen und nochmal alle flags prüfen. Wenn keine flags mehr gesetzt sind, ist die Aufgabe erledigt. Das sollte auch glitches auf dem global flag sauber ignorieren wenn nicht zu viel spam kommt.

Re: Der AVR-/ARDUINO-Faden

Verfasst: So 30. Aug 2015, 22:39
von ferdimh
Das Abklappern ALLER bei der Kiste weit verstreuten Flags versuche ich gerade zu vermeiden. Für einige gibt es nicht mal Flags.
Ich weiß halt nur, dass irgendein Interrupt einschlägt, den ich nicht haben möchte und auch nicht bestellt habe. Um ihn zu finden wäre ausgesprochen hilfreich, welcher der 0x44 möglichen es denn nun ist.

Re: Der AVR-/ARDUINO-Faden

Verfasst: Mi 2. Sep 2015, 23:40
von Jch
Hallo,

Ich wollte euch mal auf mein Problem hinweisen.

Und zwar habe ich noch einen Arduino Uno R3 welcher über I2C mit einem EA DOGM240-6 verbunden ist.

Das Display bekommt die Spannung vom Display und wenn ich beim Arduino die Spannung anmache, dann zeigt das Display für 2 Sekunden "Hello World" an und dieser Text verschwindet dann. Erst nach erneutem Spannung an kommt der Text wieder.

Das war die Kurzfassung.

Hier der Link zum Problem

Nun ist die Frage, ost es ein Software oder ein Hardwareproblem?
Wie kann ich es herausfinden und beheben?
Oszilloskop ist vorhanden.

Die Ladungspumpe geht aus wenn der Text verschwindet bzw deswegen verschwindet der Text.

Ich bin für jede Idee dankbar.

Grüße

Re: Der AVR-/ARDUINO-Faden

Verfasst: Do 3. Sep 2015, 00:53
von Anse
Push doch einfach Deinen Faden.
In diesem Forum mit so vielen Beiträgen pro Tag kann es sein das ein Thema komplett an einem vorbei geht weil man nur einmal am Tag rein schauen konnte. Wenn es dann erst mal im unteren Bereich verschwunden ist, fällt es nicht mehr auf. Eine Erinnerung nach einer angemessenen Wartezeit finde ich schon OK.

Re: Der AVR-/ARDUINO-Faden

Verfasst: Fr 18. Sep 2015, 14:01
von ando
Moin,

ich schreib jetzt doch nen Beitrag, obwohl ich aufgrund der Trivialität lange gezögert hab!

Plottermeier hat mich ja letztens an den Arduino herangeführt, und jetzt liegt die Uno Platine vor mir und blinkt!

Ich will nen Dämmerungsschalter bauen. Funktioniert auch schon aber:

Ich hätte gerne, das
a) Nei Verzögerung, sprich- wenn der SchwellWert(x) in einer Minute(y) mehr als 30(z) mal erreicht wird geschaltet wird.
b) Nice to Have: Einstellbarer Schwellwert über Poti und LED die an oder ausgeht, wenn Schwellwert erreicht.

Edith: Teil b) hab ich shcon hinbekommen!

Bisher sieht das so aus:

Code: Alles auswählen

// Konstanten
const int abfrageZahl = 5;      // Je mehr abfragen, desto stabiler isr das Ergebnis
const int ldr = A1;             // Pin für den Fotowiederstand
const int led = 12;
const int led2=11;

// Variablen
int helligkeit = 0;            // Variable für die Helligkeit  
int abfrage[abfrageZahl];      // Array Variable für das Mitteln der Temperatur
float durchschnitt = 0;        // Variable für das Mitteln der Temperatur


void setup()
{  
  Serial.begin(9600);       // Baudrate für die Ausgabe am Serial Monitor
  pinMode(ldr, INPUT);      // Pin des NTC Wiederstands als Eingang
  pinMode(led, OUTPUT);
  pinMode(led2, OUTPUT);
}


void loop()
{
  // Nimmt N Abfragen in einer Reihe, mit einem kurzen delay
  for (int i=0; i < abfrageZahl; i++)
  {
    abfrage[i] = analogRead(ldr);
    delay(10);
  }
  
  // Mittelt alle Abfragen
  durchschnitt = 0;
  for (int i=0; i < abfrageZahl; i++)
  {
    durchschnitt += abfrage[i];
  }
  helligkeit = durchschnitt/abfrageZahl;
  
  // Ausgabe an den Seriellen Monitor
  Serial.print("LDR ");
  Serial.println(helligkeit);
  
  // Schalte bei Dunkelheit die LED an
  if(helligkeit > 600)
  {
    digitalWrite(led, HIGH);
    delay(1000);
    digitalWrite(led2, LOW);
  }  
  else
  {
    digitalWrite(led, LOW);
    digitalWrite(led2, HIGH);
  }  
}
Also ich mach das seit gestern zum erstenmal- für euch isses villeicht nen Zeitverteib in der Mittagspause.

Bin mal gespannt, wie wir es lösen-

Ando

Re: Der AVR-/ARDUINO-Faden

Verfasst: Fr 18. Sep 2015, 19:27
von phettsack
Kleiner USB-Tiny: Klick.

Hab einen hier und der lässt sich sehr einfach programmieren.
Einfach in den USB rein und los gehts.

Re: Der AVR-/ARDUINO-Faden

Verfasst: Fr 18. Sep 2015, 20:18
von ando
Hi,

also ich hab ja jetzt eigentlich damit gerechnet, haufenweise Tipps zu bekommen.

Is das denn so kompliziert? Hab natürlich mal gegoogelt, um vllt nen ähnliches Programm zu finden, aber die gefundenen Lösungen war sehr kompliziert gelöst worden.

Mir geht es nun hauptsächlich darum, das der Eingangs Port 30 sec abgefragt wird, die Werte gespeichert, und wenn genug über dem Schwellwert liegen, dann eine Schaltfunktion ausgeführt wird.

Das muss doch einfach machbar sein, oder?

Re: Der AVR-/ARDUINO-Faden

Verfasst: Fr 18. Sep 2015, 21:05
von xoexlepox
ando hat geschrieben:Is das denn so kompliziert?
Einerseits ist das Problem trivial, andererseits hat es (aufgrund deiner Definition) auch "seine Tücken". Das ist aber eher ein "Kommunikationsproblem", wie es häufig bei solchen Fragestellungen auftritt. In der Definition steht z.b. "innerhalb einer Zeitspanne" -> Wie wird die bestimmt? Kontinuierlich laufenden Timer abfragen? Oder (einfacher zu realisieren) "innerhalb einer gewissen Anzahl von Aufrufen einer Funktion", wobei der Nutzer der Funktion dafür verantwortlich ist, diese Funktion in gewissen Zeitabständen regelmäßig aufzurufen. Ich würde mir dafür erst einmal eine Funktion schreiben, die feststellt, ob der Wert über dem Schwellwert liegt, oder nicht, und eine 0 oder 1 liefert. Dann einen gleitenden Mittelwert darüber bilden, und wieder eine Schwellwertfunktion über dessen Ergebnis. Haken dabei: Der "originale/exakte" gleitende Mittelwert braucht eine Menge Speicher. Wenn einige Einschränkungen in Kauf genommen werden können, lässt sich das auch "speichersparender" lösen. Aber das ist dann wieder eine Sache der "Definition der Anforderung" ;)

Edith meint: Ganz primitive Lösung (die allerdings ihre Einschränkungen hat): Werte der Schwellwertüberschreitungen (0 oder 1) jede Sekunde aufaddieren, jede zweite Sekunde eins abziehen, und den Additionswert auf (0-60) limitieren. Liegt die Summe über 30, Ausgang aktivieren. Im "Grenzbereich" könnte das jedoch etwas "flackern" ;) Aber dagegen lässt sich wieder eine Hysterese einbauen... Es gibt etliche Möglichkeiten, dieses Problem zu lösen, welche davon "brauchbar" ist, hängt von der Anwendung ab ;)

Re: Der AVR-/ARDUINO-Faden

Verfasst: Fr 18. Sep 2015, 21:47
von Sunset
Nettes Programm, Ando und ein interessantes Übungsprojekt.

Lass uns doch mal schauen, was Dein Programm genau macht und was Du genau haben möchtest.

Fangen wir mit der Aufgabenstellung an:
Du möchtest eine Verzögerung über 30 Sekunden, die in Abhängigkeit von einem Schwellwert als Ergebnis einen Ausgang ein- oder aus schaltet.
Der Teufel liegt im Detail: Ist die Aufgabe, alle 30 Sekunden zu prüfen, ob der Schwellwert über- oder unterschritten wird?
Oder soll jede Sekunde überprüft werden, ob ein Schwellwert der letzten 30 Sekunden über- oder unterschritten wird?

Lass uns mal in das Programm schauen:
1. Konstanten und Variablen deklarieren
2. Setup: Pins als Ein- und Ausgang definieren
3. Eine Tabelle mit N Abfragen füllen
4. Durchschnitt der Tabelle berechnen
5. Schwellwert prüfen und Ausgang schalten
6. Zürück zu 3.

Schade, nicht ganz die Logik, die gewünscht ist. Was kann verbessert werden?

Vor dem Loop brauchen wir eine Tabelle mit 30 Messwerten, die könnte man je nach gewünschtem Ausgangszustand auch am Anfang definieren auf kleiner oder größer als der Schwellwert.
Dann soll jede Sekunde einmal der erste Wert in der Tabelle vergessen werden, alle anderen Tabellenwerte wandern 1 nach vorne, der letzte Tabellenwerte soll durch den aktuellen Messwert ersetzt werden.
Danach den Mittelwert berechnen, mit dem Schwellwert vergleichen und entsprechend den Ausgang schalten.

Ein Programm habe ich jetzt bewußt nicht geschrieben, aber ich hoffe mit dem skizzierten Ablauf doch ein bisschen weiter geholfen zu haben.
Viel Spaß beim frickeln! :mrgreen:

Re: Der AVR-/ARDUINO-Faden

Verfasst: Fr 18. Sep 2015, 22:56
von xanakind
Ich hab endlich mal wieder meinen kleinen Arduino aus der Schublade gezogen und mal wieder abgeschlossen.

Als Basis dient das Kotzprogramm mit der fetten RGB LED, ich möchte aber 2 weitere Funktionen hinzufügen.
WHITE-->Alle 3 Farben immer volle Pulle (also Weisses Licht)
COLOR--> 3 Potis an 3 Eingängen werden abgefragt und dessen Werte dann jeweils als PWM auf die 3 Farben gegeben.

Die 2 weitreren Modis hinzufügen war kein Problem, das geht und bei White und Color macht der Controller momentan halt nix.
Aber dann geht´s auch schon wieder los.
Ich möchte erstmal nur die Weiss Funktion (im Code ganz unten) zum laufen bringen und es meckert rum, weil es irgendwelche Klammern vermisst.
Arduino markiert dann ganz oben

Code: Alles auswählen

#define DAZZLE 2
Wo fehlt da denn bitteschön noch eine Klammer?!
ich stehe gerade auf voll dem Schlauch :(
Hier mal der Komplette Code, wäre echt super wenn ihr mir auf die Sprünge helfen könntet :)

Code: Alles auswählen

// Bedazzler! A good multiple LED PWM project, by Limor Fried
// Public domain 2009
#include <util/delay.h>
int value;
int redpin1 = 5, redpin2 = 6;                           
int greenpin1 = 3, greenpin2 = 11;                           
int bluepin1 = 9, bluepin2 = 10;                           
int ledmax;
#define GLITTER 0
#define SWIRL 1
#define DAZZLE 2
#define WHITE 3
#define COLOR 4
volatile int mode = DAZZLE;
// we use a button on pin 2 (interrupt pin) to detect mode changes
void modechange(void)
{
  // debounce it
  if (digitalRead(2) == LOW) {
   _delay_ms(10);
   if (digitalRead(2) != LOW)
        return;
   Serial.println("button");
   mode++;
   if (mode > 4)
     mode = 0;
  Serial.print("new mode! ");
  Serial.println(mode, DEC);
  
  }
}
void setup() 
{ 
  pinMode(2, INPUT);
  digitalWrite(2, HIGH);   // pullup on mode button
  attachInterrupt(0, modechange, CHANGE);
  
  Serial.begin(9600);
  
  randomSeed(analogRead(0));
  // nothing for setup 
    analogWrite(redpin1, 0);
    analogWrite(redpin2, 0);
     analogWrite(greenpin1, 0);
    analogWrite(greenpin2, 0);
    analogWrite(bluepin1, 0);
    analogWrite(bluepin2, 0);
    
    ledmax = 250; // change this value to adjust the maximum brightness
}
void loop() 
{ 
  switch(mode) {
    case SWIRL:
      //Serial.println("swirl");
      ckswirl(ledmax, 10);
      break;
    case GLITTER:
      //Serial.println("glimmer");
      glimmertest(ledmax, ledmax/10, 30); 
      break;
    case DAZZLE:
      //Serial.println("dazzle");
      bedazzle(ledmax, 10, 7, 11); 
      break;
  }
   
}
void bedazzle(int ledmax, int pulselensec, int freqmin, int freqmax) {
  long pulses;
  
  
  analogWrite(redpin1, 0);
  analogWrite(redpin2, 0);
  analogWrite(greenpin1, 0);
  analogWrite(greenpin2, 0);
  analogWrite(bluepin1, 0);
  analogWrite(bluepin2, 0);
  
  // note we dont use red LEDs in this
  int freq = random(freqmin, freqmax+1);
  int pulsedelay = 1000/freq;
  pulsedelay /= 2;
  
  pulses = pulselensec;
  pulses *= 1000;
  pulses /= 2*pulsedelay;
  /*
  Serial.print("pulsing at ");
  Serial.print(freq, DEC);
  Serial.print(" Hz (");
  Serial.print(pulsedelay, DEC);
  Serial.println(" ms on/off)");
  Serial.print(pulses);
  Serial.println(" pulses");
*/
  while (pulses--) {
    analogWrite(greenpin1, ledmax);
    analogWrite(greenpin2, ledmax);
    analogWrite(bluepin1, ledmax);
    analogWrite(bluepin2, ledmax);
    analogWrite(redpin1, ledmax);
    analogWrite(redpin2, ledmax);
    _delay_ms(pulsedelay);
    analogWrite(greenpin1, 0);
    analogWrite(greenpin2, 0);
    analogWrite(bluepin1, 0);
    analogWrite(bluepin2, 0);
    analogWrite(redpin1, 0);
    analogWrite(redpin2, 0);
    _delay_ms(pulsedelay); 
   if (mode != DAZZLE) return; 
  }
  
}
void ckswirl(int ledmax, uint8_t z) {
  int r, g, b;
  
  // fade from red to orange to yellow to green
  for (g=0; g<255; g++) { // turn red down
    analogWrite(redpin1, ledmax-g); 
    analogWrite(redpin2, ledmax-g);
    analogWrite(greenpin1, g);           // sets the value (range from 0 to 255) 
    analogWrite(greenpin2, g);           // sets the value (range from 0 to 255) 
    delay(z);
    
    if (mode != SWIRL) return;
  }
  // fade from green to blue
  for (b=0; b<255; b++) { // turn red down
    analogWrite(bluepin1, b); 
    analogWrite(bluepin2, b);
    analogWrite(greenpin1, ledmax-b);           // sets the value (range from 0 to 255) 
    analogWrite(greenpin2,  ledmax-b);           // sets the value (range from 0 to 255) 
    delay(z);
    if (mode != SWIRL) return;
  }
  // from blue to red
  for (r=0; r<255; r++) { // turn red down
    analogWrite(redpin1, r); 
    analogWrite(redpin2, r);
    analogWrite(bluepin1, ledmax-r);           // sets the value (range from 0 to 255) 
    analogWrite(bluepin2,  ledmax-r);           // sets the value (range from 0 to 255) 
    delay(z);
    if (mode != SWIRL) return;
  }
}
void glimmertest(int maxvalue, int incr, int z) {
  
   for(value = 0 ; value <= maxvalue; value+=incr) 
  { 
    analogWrite(greenpin1, value);           // sets the value (range from 0 to 255) 
    analogWrite(greenpin2,  maxvalue-value);           // sets the value (range from 0 to 255) 
    analogWrite(bluepin1, value); 
    analogWrite(bluepin2,  maxvalue-value);           // sets the value (range from 0 to 255) 
    analogWrite(redpin1, value); 
    analogWrite(redpin2, maxvalue-value);           // sets the value (range from 0 to 255) 
    delay(z);                            // waits for 30 milli seconds to see the dimming effect 
    if (mode != GLITTER) return;
  } 
  for(value =  maxvalue; value >=0; value-=incr)   // fade out (from max to min) 
  { 
    analogWrite(greenpin1, value); 
    analogWrite(greenpin2 , maxvalue-value);           // sets the value (range from 0 to 255) 
    analogWrite(bluepin1, value); 
    analogWrite(bluepin2,  maxvalue-value);           // sets the value (range from 0 to 255) 
    analogWrite(redpin1, value); 
    analogWrite(redpin2,  maxvalue-value);           // sets the value (range from 0 to 255) 
    delay(z); 
    if (mode != GLITTER) return;
  }  
}
void WHITE (int ledmax, ) {
digitalWrite (redpin1, HIGH);
digitalWrite (redpin2, HIGH);
digitalWrite (greenpin1, HIGH);
digitalWrite (greenpin2, HIGH);
digitalWrite (bluepin1, HIGH);
digitalWrite (bluepin2, HIGH);
  }

Re: Der AVR-/ARDUINO-Faden

Verfasst: Sa 19. Sep 2015, 00:03
von Anse
Schau mal das an :

Code: Alles auswählen

void WHITE (int ledmax, ) {
Der Compiler erwartet da noch was. Mach mal das Komma weg.
Tipp am Rand zum Programmierstil: Variablennamen klein, Defines groß schreiben, Funktionsnamen auch klein.

Re: Der AVR-/ARDUINO-Faden

Verfasst: Sa 19. Sep 2015, 20:48
von xanakind
Danke für den Hinweis, hab das grade mal probiert(Komma weg), nun meints bei:

Code: Alles auswählen

void WHITE (int ledmax ) {
error: expected declaration before '}' token
:roll:

Erwartet es noch irgendwelche Klammern die ich vergessen hab?

Re: Der AVR-/ARDUINO-Faden

Verfasst: Sa 19. Sep 2015, 21:05
von xoexlepox
Entferne mal das Leerzeichen zwischen Funktionsnamen und Parameterliste. Vielleicht reicht das schon.

Re: Der AVR-/ARDUINO-Faden

Verfasst: Sa 19. Sep 2015, 23:10
von Sven
Öhm das kann so nicht funktionieren ;)
WHITE ist einerseits ein define (ganz oben in der Datei) und andererseits ist es eine Funktion. Die müssen schon anders heißen, für den C Compiler reicht da auch schon Groß/Kleinschreibung.
(Wobei das kein guter Stil wäre)

Re: Der AVR-/ARDUINO-Faden

Verfasst: So 20. Sep 2015, 00:14
von xanakind
Ah!
Danke Sven!
Das war die Lösung!
Das Kompilieren klappt nun.
Die portpin´s werden im entsprechenden Modus noch nicht auf High gezogen, da fehlt noch was in der void loop.
Aber da gucke ich morgen nach :D

Re: Der AVR-/ARDUINO-Faden

Verfasst: So 20. Sep 2015, 12:16
von ando
Hi,
also nochmal zu meinem Dämmerungs Schalter und evtueller Kommunikationsproblemen:

Die "For" Schleife hab ich mir nich selbst ausgedacht. Die hab ich aus nem Beispielprogramm geklaut.

Mir geht es bei der Aufgabenstellung einfach dadrum, das der Ausgang ( zb die Lampe) später nicht ständig an und aus geht, wenn mal ein dunkles Wölkchen am Himmel ist.

Ich hab mir das jez so überlegt:

Ich nehm meinen Helligkeitswert- Wenn der über dem Schwellwert ist, addiere ich zu einer Variable x "1" dazu.
Dann mache ich einen Delay, von zb 5000ms und prüfe wieder.
Das ganze dann 6 mal hintereinander.
Wenn x = 6 , dann schaltet mein Ausgang. ( digital High)
Wenn nicht, (digital LoW)

Sollte gehn, oder?
Jez müsste ich nur noch wissen, wie ich die Variable addiere....
Ando

Re: Der AVR-/ARDUINO-Faden

Verfasst: So 20. Sep 2015, 12:38
von xoexlepox
ando hat geschrieben:Sollte gehn, oder?
Prinzipiell ja, führt aber zum "klappern", wenn die Helligkeit in der Nähe des Schwellwertes (der Summe) liegt -> Ist einmal einer der sechs Messwerte darunter, schaltet das Teil schon wieder aus. Deshalb ist es empfehlenswert, eine Hysterese einzubauen: Bei >5 (6+) wird eingeschaltet, ist die Lampe jedoch schon an, wird erst bei <5 (4-) wieder abgeschaltet. Du verwendest also zwei Schwellwerte abhängig vom Zustand des "Ausgangs" -> einen zum Einschalten, einen zum Ausschalten.
ando hat geschrieben:Jez müsste ich nur noch wissen, wie ich die Variable addiere....
Summe = Summe + 1; ? Oder einfacher "Summe++;" Und nicht vergessen, am Anfang die Summe auf Null zu setzen ;)

Re: Der AVR-/ARDUINO-Faden

Verfasst: So 20. Sep 2015, 14:41
von Sunset
ando hat geschrieben:Die "For" Schleife hab ich mir nich selbst ausgedacht. Die hab ich aus nem Beispielprogramm geklaut.
Ist doch ok. Ich habe ein bisschen das Gefühl, das Du zwar weißt, was die FOR Schleife macht, aber über die dahinterstehende Logik an dieser Stelle des Programms könnte ein Missverständnis entstanden sein.

Ich möchte noch einmal versuchen, das anders zu erklären:

Nachfolgend soll ein Zeitstrahl sein, dabei sollen die Sybole darstellen:
+ über dem Schwellwert
- unter dem Schwellwert
0 der Schwellwert
P die Messung
V der Vergleich ob der Schwellwert über oder unterschritten ist
. Füllzeichen, macht nix

Die FOR Schleife macht jetzt folgendes:
Zeit -> 000000+++++++0+++0-000----------00---00000++++++++
Loop 1: PPPPPV.........................................................
Loop 2: ........PPPPPPV.................................................
Loop 3: .................PPPPPV.......................................
Loop 4: ..........................PPPPPPV...............................
Loop 5: .....................................PPPPPV..................

Alternativ, wenn man mit einer Tabelle arbeitet, die den jeweils 1. Messwert vergisst und die neue Messung am Ende zufügt, dann wandert der Messbereich anstatt zu springen:

Zeit -> 000000+++++++0+++0-000----------00---00000++++++++
Loop 1: PPPPPV.........................................................
Loop 2: .PPPPPV........................................................
Loop 3: ..PPPPPV.......................................................
Loop 4: ...PPPPPV......................................................
Loop 5: ....PPPPPV.....................................................
Loop 6: .....PPPPPV....................................................
Usw.

Ich glaube, so wird der Unterschied besser deutlich, oder?
Beide Methoden sind valide, weder ist die erste falsch, noch die 2. richtiger, es kommt halt nur drauf an, was man erreichen bzw. machen und messen möchte.
ando hat geschrieben:
Ich nehm meinen Helligkeitswert- Wenn der über dem Schwellwert ist, addiere ich zu einer Variable x "1" dazu.
Dann mache ich einen Delay, von zb 5000ms und prüfe wieder.
Das ganze dann 6 mal hintereinander.
Wenn x = 6 , dann schaltet mein Ausgang. ( digital High)
Wenn nicht, (digital LoW)

Sollte gehn, oder?
Was macht das Programm denn, wenn ein Messwert kleiner oder gleich dem Schwellwert ist?
Die Variable x muss doch auch irgendwie wieder kleiner werden können, oder?

Das addieren von Variablen hat xexplox schon erklärt, subtrahieren geht genauso: x = x - 1 oder abgekürzt x--

Viel Spaß beim frickeln ;-)

Re: Der AVR-/ARDUINO-Faden

Verfasst: So 20. Sep 2015, 14:59
von ando
So,
die Hysterese habe ich hinbekommen.

Code: Alles auswählen

void loop()
{
  // Nimmt N Abfragen in einer Reihe, mit einem kurzen delay
  for (int i=0; i < abfrageZahl; i++)
  {
    abfrage[i] = analogRead(ldr);
    delay(400);
  }
  
  // Mittelt alle Abfragen
  durchschnitt = 0;
  for (int i=0; i < abfrageZahl; i++)
  {
    durchschnitt += abfrage[i];
  }
  helligkeit = durchschnitt/abfrageZahl;
  
  // Ausgabe an den Seriellen Monitor
  Serial.print("LDR ");
  Serial.println(helligkeit);
  
  // Schalte bei Dunkelheit die LED an
  if ((helligkeit < 300) && (digitalRead (led) == LOW))  // grüne LED oder Relais
  {
    digitalWrite(led, HIGH);
  }
  else {
    if ((helligkeit > 600) && (digitalRead(led) == HIGH))
    {
      digitalWrite(led,LOW);
    }
  }
}
Jetzt will ich natürlich den Helligekitswert mit nem Poti einstellen können.
So wie ich das sehe, brauche ich nun aber 2 Potis, für die obere und die untere Stellung.

Boah, ich hab langsam nen Knoten im Hirn. Leider sollte die ganze Sache bis morgen am laufen sein.

Edith: ICh stell meinen Dämmerungswert jetzt analog ein, indem ich nen Poti in Reihe zum LDR schalte. ( Da war ohnehin nen 1K Ohm R , der mit dem LDR nen Spnnungsteiler gebildet hat.
damit funktioniert es ersteinmal einigermassen.

Ando

Re: Der AVR-/ARDUINO-Faden

Verfasst: So 20. Sep 2015, 15:44
von Sunset
ando hat geschrieben:Jetzt will ich natürlich den Helligekitswert mit nem Poti einstellen können.
So wie ich das sehe, brauche ich nun aber 2 Potis, für die obere und die untere Stellung.
Das Poti liest Du genau so ein wie den Ldr, nur halt von einem anderen Pin.
Danach berechnest Du den oberen und unteren Grenzwert und anstelle der festen Werte vergleichst Du mit den berechneten Werten.

Code: Alles auswählen

const int poti = A2;
const hysterese = 50;

int grenze=0;
int oGrenze=0;
int uGrenze=0;

pinMode (poti, INPUT);

grenze = analogRead(poti);
oGrenze = grenze + hysterese;
uGrenze = grenze - hysterese;
So in etwa, dann die Werte 300 und 600 aus Deinem Programm durch oGrenze und uGrenze ersetzen.
Der Code oben ist natürlich für sich alleine so nicht lauffähig... :geek:

Re: Der AVR-/ARDUINO-Faden

Verfasst: Mo 21. Sep 2015, 07:52
von ando
Hi,

das ist ne super Idee, die ich auch direkt umgesetzt habe.

Code: Alles auswählen

// Konstanten
const int abfrageZahl = 2;      // Je mehr abfragen, desto stabiler isr das Ergebnis
const int ldr = A1;             // Pin für den Fotowiederstand
const int led = 12;
const int led2=11; 
const int hysterese = 50;

// Variablen
int helligkeit = 0;            // Variable für die Helligkeit  
int abfrage[abfrageZahl];      // Array Variable für das Mitteln der Temperatur
float durchschnitt = 0;        // Variable für das Mitteln der Temperatur
int grenze = 0;
int oGrenze = 0;
int uGrenze = 0;
int poti = A2;

void setup()
{  
  Serial.begin(9600);       // Baudrate für die Ausgabe am Serial Monitor
  pinMode(ldr, INPUT);      // Pin des NTC Wiederstands als Eingang
  pinMode(led, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode (poti, INPUT);   // Schwellwertpoti

}


void loop()
{
grenze = analogRead (poti);
}

oGrenze = grenze + hysterese;

uGrenze = grenze - hysterese;

{
  // Nimmt N Abfragen in einer Reihe, mit einem kurzen delay
  for (int i=0; i < abfrageZahl; i++)
  {
    abfrage[i] = analogRead(ldr);
    delay(400);
  }
  
  // Mittelt alle Abfragen
  durchschnitt = 0;
  for (int i=0; i < abfrageZahl; i++)
  {
    durchschnitt += abfrage[i];
  }
  helligkeit = durchschnitt/abfrageZahl;
  
  // Ausgabe an den Seriellen Monitor
  Serial.print("LDR ");
  Serial.println(helligkeit);
  
  // Schalte bei Dunkelheit die LED an
  if ((helligkeit < 40) && (digitalRead (led) == LOW))  // grüne LED oder Relais
  {
    digitalWrite(led, HIGH);  // einschalten
  }
  else {
    if ((helligkeit > 160) && (digitalRead(led) == HIGH))
    {
      digitalWrite(led,LOW);
    }
  }
}
Läuft aber nicht:

am_hys.cpp:36:1: error: †˜oGrenze†™ does not name a type
dam_hys.cpp:38:1: error: †˜uGrenze†™ does not name a type
dam_hys.cpp:40:1: error: expected unqualified-id before †˜{†™ token

ÄH- ich hab die Fehlermeldung gegoggelt- stack overflow?? bzw soll es an irgendwelchen dateien liegen? kanndochncisein, oder?


Ich hab ja zwischenzeitlich noch ne weitere Idee: Wenn ich die Hysterese so wie im Beispiel als Konstant angebe, könnt eich die ja auch mit nem zweiten Poti einstellen, und zb als Blinkende LED ausgeben lassen: Shcnell blinken: kleine Hysterese, langsam Blinken, große Hysterese.
Das wäre nahezuperfekt- nur leider scheiterts grade eher an der Programm Syntax *grumel*

Ando

Re: Der AVR-/ARDUINO-Faden

Verfasst: Mo 21. Sep 2015, 08:02
von Sunset
Überprüfe bitte mal Deine Klammern }{.

Ich glaube unter grenze ist eine } zu viel und unter uGrenze eine { zu viel.
So besteht die Funktion loop() nur aus einer Zeile.

Selbstverständlich kannst Du den Wert von hysterese auch von einem Poti einlesen und damit einstellbar machen.

Re: Der AVR-/ARDUINO-Faden

Verfasst: Mo 21. Sep 2015, 15:46
von Raider
Genau, da sind zwei Klammern zu viel.

Code: Alles auswählen

// Konstanten
const int abfrageZahl = 2;      // Je mehr abfragen, desto stabiler isr das Ergebnis
const int ldr = A1;             // Pin für den Fotowiederstand
const int led = 12;
const int led2=11; 
const int hysterese = 50;

// Variablen
int helligkeit = 0;            // Variable für die Helligkeit  
int abfrage[abfrageZahl];      // Array Variable für das Mitteln der Temperatur
float durchschnitt = 0;        // Variable für das Mitteln der Temperatur
int grenze = 0;
int oGrenze = 0;
int uGrenze = 0;
int poti = A2;

void setup()
{  
  Serial.begin(9600);       // Baudrate für die Ausgabe am Serial Monitor
  pinMode(ldr, INPUT);      // Pin des NTC Wiederstands als Eingang
  pinMode(led, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode (poti, INPUT);   // Schwellwertpoti

}


void loop()
{
grenze = analogRead (poti);


oGrenze = grenze + hysterese;

uGrenze = grenze - hysterese;


  // Nimmt N Abfragen in einer Reihe, mit einem kurzen delay
  for (int i=0; i < abfrageZahl; i++)
  {
    abfrage[i] = analogRead(ldr);
    delay(400);
  }
  
  // Mittelt alle Abfragen
  durchschnitt = 0;
  for (int i=0; i < abfrageZahl; i++)
  {
    durchschnitt += abfrage[i];
  }
  helligkeit = durchschnitt/abfrageZahl;
  
  // Ausgabe an den Seriellen Monitor
  Serial.print("LDR ");
  Serial.println(helligkeit);
  
  // Schalte bei Dunkelheit die LED an
  if ((helligkeit < 40) && (digitalRead (led) == LOW))  // grüne LED oder Relais
  {
    digitalWrite(led, HIGH);  // einschalten
  }
  else {
    if ((helligkeit > 160) && (digitalRead(led) == HIGH))
    {
      digitalWrite(led,LOW);
    }
  }
}
So macht Arduino bei mir keine Fehlermeldung mehr....

Re: Der AVR-/ARDUINO-Faden

Verfasst: Di 22. Sep 2015, 00:14
von xoexlepox
Aus einem anderen Thread hierher kopiert, damit es dort nicht zu sehr OT wird:
zauberkopf hat geschrieben:Der nachteil : Zeitkritische Dinge.. also im ms bereich.. würde ich sein lassen.
Stimmt! An so Etwas klemptnere ich gerade herum (da kommt es auf 10µs an). Nachdem ich dem "Framework" durch Patchen eines Files den Timer0-Interrupt klauen konnte (trommle direkt auf den Registern herum), funktionierte es zwar so halbwegs, aber es tauchten sehr seltsame Effekte auf. Nun versuche ich es (durch Umstricken der Makefiles) mit "pure gcc", was soeben zur Folge hatte, daß das Nano-Board nun überhaupt nix mehr macht :(
Andere Idee : Arduino-Board und ASM oder GCC Compiler. Dazu ein Makefile von ozonisator und virtex.. und man hat die volle kontrolle über das teil.
Ok, den Weg sind auch schon Andere gegangen... Sind Erfahrungen (bzw. Makefiles) dazu hier verfügbar?

Re: Der AVR-/ARDUINO-Faden

Verfasst: Di 22. Sep 2015, 07:35
von zauberkopf
Also, das klappt eigentlich ganz gut..
Ich brauchte das auch mal, also ein paar signale in us Bereich.. das habe ich dann mit Assembler gelöst, ohne Timer.
Der effekt, das der Arduino nicht reagiert habe ich auch.
Aber dann im Betrieb. Beim einschalten oder reset, kann ich ihn für ein paar sek lang ansprechen.. dann beginnt mein Programm.
Es sei denn, Du hast die Serielle Leitung für Deine Zwecke angezapft..

Re: Der AVR-/ARDUINO-Faden

Verfasst: Di 22. Sep 2015, 09:24
von xoexlepox
zauberkopf hat geschrieben:Es sei denn, Du hast die Serielle Leitung für Deine Zwecke angezapft..
Jau, auf den USART-Registern trommele ich auch rum ;) Mit dem Arduino-Make läuft das Programm, mit "pure-gcc" nicht. Ich vermute mal, da fehlt noch ein ganz klein wenig von dem Gebimsel, was das Arduino-Make da noch einbindet. Momentan habe ich die Interrupt-Vektorliste im Verdacht...

Re: Der AVR-/ARDUINO-Faden

Verfasst: Di 22. Sep 2015, 09:35
von zauberkopf
Denk dran.. sobald Du die Arduino IDE verwendest, wird auch der komischer timer.. etc.. gestartet.
Und dann beginnt der ganze mist..

Ich halte es so : Zeitkritisch = gcc und Makefile = Normaler AVR halt mit Bootloader....
Nicht Zeitkritisch und andere Anfänger sollen auch damit rumspielen können : Arduino IDE.
Ich sehe das so : Mit dem 8051er AH Basic konnte ich schon damals nicht alles machen, was in Assembler ging.
Aber das Basic hat mir schon ein wenig damals die Lust am Controller gegeben.
Obwohl ich damals schon am C64 Assembler konnte.

Re: Der AVR-/ARDUINO-Faden

Verfasst: Di 22. Sep 2015, 11:58
von xoexlepox
zauberkopf hat geschrieben:Denk dran.. sobald Du die Arduino IDE verwendest, wird auch der komischer timer.. etc.. gestartet.
Die (Java) IDE benutze ich zwar nicht, aber das Zeugs, was "darunter" werkelt, also die Arduino-Klassen (das "Arduino.mk"). Und die versuche ich gerade loszuwerden, indem ich mir ein eigens entsprechendes Makefile erzeuge ;)

Re: Der AVR-/ARDUINO-Faden

Verfasst: Di 22. Sep 2015, 13:13
von ozonisator

Re: Der AVR-/ARDUINO-Faden

Verfasst: Di 22. Sep 2015, 13:57
von xoexlepox
Danke für den Link! Das sieht (auf den ersten Blick) genau nach so etwas aus, was ich suche :D Ich probiere es mal aus.

Re: Der AVR-/ARDUINO-Faden

Verfasst: Di 22. Sep 2015, 14:31
von Fritzler
Besorgt euch WinAVR, da is nen makefile Editor bei und das Linkerscript auch.

Re: Der AVR-/ARDUINO-Faden

Verfasst: Di 22. Sep 2015, 15:49
von xoexlepox
Fritzler hat geschrieben:Besorgt euch WinAVR, da is nen makefile Editor bei und das Linkerscript auch.
Ich bin mir nicht so sicher, daß das einem Linux-Nutzer irgendeinen Vorteil bringen könnte ;)

Re: Der AVR-/ARDUINO-Faden

Verfasst: Di 22. Sep 2015, 16:15
von Fritzler
Denn nimmste det hier: (Programmierung in C)
https://wiki.ubuntuusers.de/AVR
Ist quasi das WinAVR für Linux, das makefile sieht auch 1zu1 gleich aus.
Musst ja nichtmal geany nutzen, das Makefile lässt sich ja kopieren.

Ansonsten eben avr-gcc selber nageln :mrgreen:
hab ich jetz erstmal alles für MIPS durch:
gcc nageln
Linkerscript mit .data von flash nach RAM kopieren etc.
Makefile dazu
kann ich ja mal Anleitungen heute Abend hochladen, gibt aber keinen Support, hab zu wenig Zeit :P

Re: Der AVR-/ARDUINO-Faden

Verfasst: Di 22. Sep 2015, 19:09
von xoexlepox
Fritzler hat geschrieben: gibt aber keinen Support, hab zu wenig Zeit :P
Das ist ja wohl klar -> Durch so etwas muss sich jeder selbst durchwurschteln ;) Aber ich habe den Fehler an meinem Makefile gerade gefunden: Es wurde keinerlei Interrupt ausgelöst, da das globale "interrupt enable" bei dem Arduino-Zeugs aktiv ist, bei meinem Kram aber nicht :oops: -> ein "sei()" wirkt Wunder...

Re: Der AVR-/ARDUINO-Faden

Verfasst: Di 22. Sep 2015, 19:45
von Fritzler
Trotzdem gibts etwas Hirninput, da man sich sowas sonst immer zusammensuchen muss:
Doku_GCC_nageln_ff.pdf
(11.22 KiB) 151-mal heruntergeladen
Doku_Startup_Linker_Make_ff.pdf
(54.42 KiB) 140-mal heruntergeladen
Das Linkerscript muss antürlich an die Adressen im AVR angepasst werdn und andere libc Funbktionen werden im Startup benötigt, da flash/RAM andere Speicherbusse haben.

Re: Der AVR-/ARDUINO-Faden

Verfasst: Di 22. Sep 2015, 20:07
von xoexlepox
Fritzler hat geschrieben:...an die Adressen im AVR angepasst werdn und andere libc Funbktionen...
Genau deshalb habe ich das "Arduino.mk" als "Ausgangsmaterial" genommen ;)

Re: Der AVR-/ARDUINO-Faden

Verfasst: Di 22. Sep 2015, 20:12
von Fritzler
*würg* *röchel*

Re: Der AVR-/ARDUINO-Faden

Verfasst: Di 22. Sep 2015, 20:54
von xoexlepox
Fritzler hat geschrieben:*würg*
Und genau das möchte ich mit der Aktion entfernen ;)

Re: Der AVR-/ARDUINO-Faden

Verfasst: Di 22. Sep 2015, 22:19
von zauberkopf
Fritzler : *kicher*..

Aber ozonisator und virtex : Ich muss noch mal danke sagen für Euer Makefile !
Ich stand ja immer schon mit Makefiles irgendwie auf Kriegsfuß.. keine Ahnung warum.
Aber das Makefile hat mir echt den spass wiedergegeben !
Keine Fuses mehr... Und ich kann mit meiner geliebiten Kate (Editor) weiterarbeiten.
(ich habs gern puritanisch.. zwar nicht so puritanisch.. wie die vi leute.. aber .. )
Wie doch ein paar Bytes manchmal freude bereiten können..

Re: Der AVR-/ARDUINO-Faden

Verfasst: Di 22. Sep 2015, 22:47
von xoexlepox
zauberkopf hat geschrieben:Ich stand ja immer schon mit Makefiles irgendwie auf Kriegsfuß.. keine Ahnung warum
Ich vermute mal, daß du dir nie die Mühe gemacht hast, in diese (zugegebenermaßen etwas kryptische) "Sprache" weiter einzusteigen. Iirc gibt es sogar ein eigenes "Handbuch" (aus der Serie mit den lustigen Viechern drauf) dafür ;)
zauberkopf hat geschrieben:Wie doch ein paar Bytes manchmal freude bereiten können..
Tja, auch ohne "bunt und hübsch anzusehen" lassen sich u.U. "kleine, unscheinbare, aber funktionale Meisterwerke" schaffen ;)

Re: Der AVR-/ARDUINO-Faden

Verfasst: Mi 30. Sep 2015, 23:51
von felixh
Hi!

nutze AVR-GCC (Winavr-2010) und Code::Blocks.

Versuche gerade das eeprom von nem Mega128 zu lesen.
Soweit ich verstanden habe, wird ein eeprom_read_dword zu einem __eerd_dword_m128 "umdefined", um dann eine fehlermeldung 'undefined reference to "__eerd_dword_m128"' zu werfen.
wenn ich die build-optionen auf nen mega32 umstelle klappt alles...

ich nehme mal an, dass da irgendwo ne library falsch eingebunden ist?

Jemand nen Tipp?

Im ganzen web scheint sonst keiner diese problem zu haben, mit google bin ich jedenfalls nicht schlauer geworden

//edit: ich hab versucht, an das makefile zu kommen, aber das wird von Codeblocks wohl on the fly erzeugt.
Linker-optionen sind jedenfalls:

Code: Alles auswählen

-mmcu=atmega128
-Wl,-Map=$(TARGET_OUTPUT_DIR)$(TARGET_OUTPUT_BASENAME).map,--cref
sorry, ich kann einigermassen akzeptabel Programmieren, aber sobald ich das Wort "makefile" usw höre, setzt es bei mir aus ;-)
(ich hab also nicht die leiseste ahnung, was die Zeile da oben macht. ich kann gerade noch mittels -l weitere librarys linken)

//edit: OK, das linken von /avr/lib/avr51/libc.a hat geholfen! Kompiliert jetzt. Obs geht zeigt die Zukunft.

Re: Der AVR-/ARDUINO-Faden

Verfasst: So 4. Okt 2015, 23:02
von xanakind
Kurze Info:Ich hab mich diesen Abend nun mal in ruhe an mein Kotzlampenprogramm gesetzt und es funktioniert nun alles so wie ich es will!

Modus Weiss und sogar RGB (mit Potiauswertung) funktioniert!
Ich fasse es nicht! :D

Dann kann der ganze Kram endlich mal in ein Gehäuse und dann geht´s an die Lepton.... :?