Wenn in der Schaltung ein Atmega Kontroller laufen würde, könntest du doch mit dem Takt von 25 MHz und dem Timer 0 und Timer 1 die 5 MHz erzeugen. Gutes Tool:  http://www.et06.dk/atmega_timers/

Ansonsten müsste man sich mal genau anschauen, wie das die 32 Bit Kontroller von Atmel mit der PLL Unit machen. Dort wird der Takt geteilt und multipliziert. http://www.atmel.com/Images/doc32072.pdf Seite 42 - 44

Eine andere Möglichkeit wäre beide Takte, die 25 MHz und 5 MHz, von einem CPLD oder einem FPGA generieren zu lassen. Dieser würde mit einem Grundtakt von ca. 50 MHz laufen, oder beliebig schneller und kann dann die beiden anderen Taktraten erzeugen. Die Programmierung erfolgt in VHDL z.B. mit  Xilinx ISE Webpack

Mehr Möglichkeiten fallen mir gerade so nicht ein.

Also ein bisschen musst du auch selbst machen.

PDF Dokument Seite 17ff
 - Ein Takt Signal für die Infrarot Diode Vorwiderstand 90 Ohm, Signal wird vom Arduino generiert
 - Empfänger: TSOP 31238  mit 5V Versorgen dazu noch eine Diode, ein Kondensator für die Spannungsstabilisierung und zwei Widerstände
 - Ausgangs Signal direkt am Arduino anschließen

Quellcode:

Code:

/* Eine Klasse die den Timer 1 des Atmega 328P kontrolliert
 * Die Prescaler Werte sowie andere Register müssen nicht mehr direkt beschrieben werden
 * Quelle: http://www.arduino.cc/playground/Code/Timer1
 */
  #include <TimerOne.h>

// Frequenz Status für die IR Dioden
  unsigned char Frequenz_38kHz_state;  
  unsigned char Light_Mode_State;

 void generateFrequenz_38kHz()
  {
    /* PIN 9 togglen
     * Hier wird mit absicht auf die vereinfachten Arduino Funktionen verzichtet, da diese Funktion
     * sehr schnell ablaufen muss. (Interrupt)
     * Die orginal Arduino funktion (digitalWrite(9, state)) braucht die doppelte Ausführzeit.
     */
    /* Toggle State */    
    Frequenz_38kHz_state = !Frequenz_38kHz_state;
    /* Set Port */
    PORTB |= (Frequenz_38kHz_state<<PORTB1);        
  }

void Lichtschranke_active(void)
{
  //Verarbeitung des Signals

}

 void setup()
  {
 /* TIMER1 wird zur Frequenzgenerierung für die Lichtschranken verwendet
  * Generiert 38 kHz Signal für die Lichtschrank
  * Timer 1 initialisieren mit:
  * 1 / 38kHz = 26.32 µs
  * 26.32µs = 38,76 kHz)
  */
    Timer1.initialize(26);

 /* Ausgangs Pin Festlegen (PIN 9) und Duty Cycle Wert einstellen
  * Duty Cycle = 50%  (10bit = 1023 => 100%,   512 => 50%)
  */
 Timer1.pwm(9, 512, 26);
 /* Beim Timer Überlauf wird ein Interrupt ausgelöst.
  * Hier wird die Funktion festgelegt, die aufgerufen wird, wenn der Interrupt ausgelöst wird
  */
    Timer1.attachInterrupt(generateFrequenz_38kHz, 26);

   Frequenz_38kHz_state = 0;

    /* Interrupts Definieren */
    // du musst das signal vom empfänger direkt hier anschließen:  an interrupt pin 0  siehe datenblatt deines kontrollers
    // sobald das signal den status wechselt, wird die funktion Lichtschranke_active aufgerufen, den rest der Verarbeitung musst du selbst machen
    // nicht jede Lösung ist Umsonst im Internet ... ein bisschen Aufwand musst du selbst leisten.
    attachInterrupt(0, Lichtschranke_active, CHANGE);
}

void loop()
{
   /

}

Dann geht das sogar alles noch einfacher und sogar gegen Fremdlicht geschützt.
Ich habe so eine Lichtschranke mit dem Arduino schon einmal gebaut um die Geschwindigkeit eines Kickerball zu messen.

Schau dir mal das Projekt an, im rar Archive im Anhang findest du die Schaltpläne und den Source Code:
Die Theorie steht im PDF Dokument. Das Unnütze kannst du einfach überspringen.

Projektvorstellung: Geschwindigkeitsanzeige am Kicker / Tischfussball

Du sagtest doch selber das es über eine größere Entfernung funktionieren soll, daher haben wir hier IR (ungenau und nicht weitreichend) ausgeschlossen. Es gibt bestimmt fertige Empfänger. Hier wäre mal ein Schaltplan, wobei man das Relais nicht benötigt. Wenn man die Widerstände anders auslegt sollte man auch mit 5V klar kommen.

http://mic.hit-karlsruhe.de/projekte/WS07_FT_Lap_Control/data/Datenblatt_lichtschranke.pdf

Benutz doch die Google Suche, die ist sogar schneller ;-)

[nicht]

Ich würde nicht den Nano nehmen, der ist zu Teuer:
http://www.watterott.com/de/Arduino-Nano   (40 €)

Nimm lieber diese Komponenten, mit denen bist du auf Dauer, deutlich günstiger:
http://www.watterott.com/de/Wattuino-pro-mini-5V-16MHz  (10 €)
http://www.watterott.com/de/FTDI-Basic-Breakout-5V (Programieradapter) (11 €)

Bei jedem weiteren Projekt kann man dann den Wattuino nehmen und spart ordentlich Geld


Der Vorteil bei einem Uhren Modul liegt darin, das du eine feste Uhrzeit hast, und damit dein Projekt steuern kannst. Wenn du immer nur alle 12 Stunden dein Event auslöst, kannst du nach einem längerem Stromausfall die Zeit, wann die 12 Stunden um sind nicht mehr genau bestimmen. Entweder startet die Wartezeit dann von neuem, oder deine Relais ziehen mitten in der Nacht an, da du den Zeitpunkt nur relative bestimmen kannst, aber nicht absolute. Dies geht nur mit einer Uhr.

Ein Tree (Nested-Set-Model) wurde hier im Forum schon in verschiedenen Libs verwendet. Aber diese Libs sind darauf ausgelegt mit statischen Objekten zu arbeiten und so wenig wie möglich im Ram zu belegen. Du könntest diese Libs umschreiben so das sie auch mit dynamischen Objekten umgehen können. Dies kostet so wie Uwe schon gesagt sehr viel Ram. Effektiv könntest du vielleicht 10 Ordner mit 10 Dateien darstellen, anschließend hast du zu wenig Speicher.

Die andere Frage ist, wie viel Zeit willst du in das Projekt stecken, ich schätze wenn du die Lib selbst schreiben musst, bist du wohl 20-40 Stunden am Programmieren und weißt anschließend erst ob es auch mit mehr als 10 Ordnern und Dateien funktioniert.

Globale Variablen sind Variablen die Außerhalb von Funktionen deklariert werden. Lokale Variablen sind die, die innerhalb von Funktionen verwendet werden.

Code:

//global
int x=0;

void add(unsigned int add_num)
{
  x += add_num;
}

void sub(unsigned int sub_num)
{
  x -= sub_num;
}

void reset()
{
  x = 0;
}

void setup(void)
{   
  Serial.begin(9600);
}

void loop(void)
{
  Serial.println(x);  // ausgabe x = 0
 
  add(3); 
  Serial.println(x);  // ausgabe x = 3

  sub(6);
  Serial.println(x);  // ausgabe x = -3

  reset(x);

  delay(1000);
}

Dieses Beispiel stellt die Grundfunktionen eines Taschenrechners dar. Wenn du dieses Beispiel auf deinen Arduino läds, siehst du das Ergebnis im Seriellen Monitor.
   

Hi, solange die Methode test()  nicht in einer Lib verwendet wird, nennt man diese auch einfach nur Funktion.

Wenn die Variable die gleiche sein soll, kannst du mit Referenzen arbeiten. Beispiel:

Code:

int x=10;

void test(int &variable)
{
  variable = 20;
}

//aufruf
test(x);
// x beinhaltet nun den wert 20.

Oder du deklarierst die Variable global, so wie du es gemacht hast, dann wird die Variable auch am Ende den Wert 20 haben.

Code:

int x = 10;

void test()
{
  x = 20;
}

test(); //x hat nun den wert 20

Ich hoffe das hilft dir weiter, ansonsten muss du dein Problem genauer erklären.

Ok, in meinen Beispielen zu den Threads wird ja auch mit globalen Variablen gearbeitet die auch ankommen, daher wundere ich mich ein wenig.

Im Prinzip sollte es laufen. Ich habe da nun wieder ein paar Fragen, da ich das Programm so nicht testen kann:

- Welche Arduino Version verwendest du ? Da du an vielen Stellen noch den Type byte verwendest, vermute ich das es nicht die neuste ist, da es den Type da nicht mehr gibt. Ich habe die Lib nur mit der Arduino Version 1.04 getestet.

- Auf meiner Projektseite gibt es noch eine neuere Version der Lib, dort wurde die Initialisierung und der Aufruf der Funktionen weiter vereinfacht. Verwende doch bitte die Version.  

- Läuft der Thread denn, also kommen die Ausgaben das er gestartet wurde und das er danach in der Loop läuft ?

- Kannst du, dass noch mit einer globalen Variable testen die nur ein Integer beinhaltet ? Wenn es dann nicht funktioniert liegt irgendwo anders der Fehler.

Wenn ich dein Beispiel bei mir nur mit einer Seriellen Schnittstelle teste, kann ich den Wert aus der Loop an den Thread übergeben.

Hmm, schlauer werde ich dadurch auch nicht:

- Wo wird der Thread aufgerufen ? In der Loop kann ich den Eintrag __simpleThread_run  nicht finden.
- Werden die Ausgaben vom Thread ausgegeben, also über die Serielle Schnittstelle ?
- Geben die Zeilen: Serial.println("wrtGlobe on ThreadPage: "); Serial.println(wrtGlobe); etwas aus, oder ist der Inhalt hier schon nicht mehr vorhanden ?
- Wenn du anstatt des Threads eine neue Funktion erstellst und versuchst in dieser auf die globale Variable zuzugreifen, ist der Inhalt noch vorhanden ?
- Wird der Thread in der setup Funktion mit  __simpleThread_start(thread_name) gestartet ? In deinem Beispiel Code ist das nicht der fall.


Ich kann nur raten. Häng doch einfach dein Projekt unten als Zip File an deinen nächsten Beitrag oder stell den kompletten Quellcode zur Verfügung.

Die Threads laufen völlig unabhängig von den Variablen die du festlegst oder anlegst. Die Threads können auch keine Variablen löschen. Eine mögliche Fehlerquelle liegt darin, wenn man bei  __simpleThread_init (  xxx )  die falsche Anzahl angibt, dann laufen die Threads nicht, da die Speicherbelegung nicht richtig funktioniert.

Wo wird die Variable den eingelesen ?
Im Thread findet im Moment nur die Ausgabe statt und wenn die Variable leer ist, dann liegt das vermutlich nicht am Thread. Stell mal bitte mehr Quellcode von deiner Software zur Verfügung.

Das funktioniert genauso wie eine normale Scroll Funktion auf dem Display.
Da ich so etwas bisher noch nicht gebraucht habe, existiert dafür keine fertige Funktion.
Du könntest aber mit  if(CTR_check_button()) {
und   if(g_button_up > 0) {  und  if(g_button_down > 0) {  die Scroll Funktion steuern.

Vielleicht gibt es hier ja irgendwo schon eine Lib im Forum die sich mit dem Scrollen durch längere Texte beschäftigt.

Hi, die Lib wurde soeben nochmal aktualisiert.

Du kannst an einen Thread keine Parameter übergeben. Es ist genau so wie bei der setup() {} und loop() {} Funktion des Arduinos. Es können innerhalb des Threads lokale Variablen angelegt werden, ansonsten ist die Kommunikation nur über globale Variablen möglich.