Beiträge von Henne

Der DMX-Bereich sollte in drei Felder aufgeteilt werden: Aus, normal, Einzelblitz
Zusätzlich wollen wir kein Blinken sondern ein kurzes Flashen.
Deshalb nehme ich das zweite Vergleichsregister (OCR1B) und nutze es, um kurz vor dem anderen Interrupt mit dem Blitz zu beginnen. Über das alte Vergleichsregister (OCR1A) wird dann der Blitz nur noch abgeschlossen.

/* DMX Stroboskop Interface
Version: 0.1
Datum: 21.06.09
Autor: H.Hölscher (www.hoelscher-hi.de)
Target: DMX Transceiver @8MHz
Lizenz: GPLv2
*/




#include "lib_dmx_in.h"
#include <avr/wdt.h>
#include <avr/pgmspace.h>







uint8_t	DmxBuf;







const uint16_t FreqTable[] PROGMEM = {
29206, 27412, 25826, 24414, 23148, 22007, 20973, 20032, 19172, 18382, 17655, 16984, 16361, 15783, 15244,
14741, 14269, 13827, 13412, 13021, 12652, 12303, 11973, 11660, 11364, 11082, 10813, 10557, 10314, 10081,
9858, 9645, 9441, 9246, 9058, 8878, 8705, 8538, 8378, 8224, 8075, 7931, 7793, 7659, 7530, 7405, 7284,
7167, 7054, 6944, 6838, 6735, 6635, 6538, 6443, 6352, 6263, 6176, 6092, 6010, 5930, 5852, 5776, 5703,
5631, 5560, 5492, 5425, 5360, 5297, 5235, 5174, 5115, 5057, 5000, 4945, 4890, 4837, 4786, 4735, 4685,
4636, 4589, 4542, 4496, 4452, 4408, 4365, 4322, 4281, 4240, 4200, 4161, 4123, 4085, 4048, 4012, 3976,
3941, 3906, 3872, 3839, 3806, 3774, 3743, 3711, 3681, 3651, 3621, 3592, 3563, 3535, 3507, 3480, 3453,
3427, 3400, 3375, 3349, 3324, 3300, 3276, 3252, 3228, 3205, 3182, 3160, 3138, 3116, 3094, 3073, 3052,
3031, 3011, 2990, 2971, 2951, 2932, 2912, 2894, 2875, 2856, 2838, 2820, 2803, 2785, 2768, 2751, 2734,
2717, 2701, 2685, 2669, 2653, 2637, 2622, 2606, 2591, 2576, 2561, 2547, 2532, 2518, 2504, 2490, 2476,
2463, 2449, 2436, 2422, 2409, 2396, 2384, 2371, 2358, 2346, 2334, 2322, 2310, 2298, 2286, 2274, 2263,
2251, 2240, 2229, 2218, 2207, 2196, 2185, 2175, 2164, 2154, 2143, 2133, 2123, 2113, 2103, 2093, 2083
};







void init_system(void)
{
DDRA=   0xFF;                 	//low outputs
PORTA=  0;
DDRD=   0b10000110;       		//DMX, spare, LED1
PORTD=  0b01111010;
DDRE=	0b001;




TCCR1B = (1<<CS12)|(1<<WGM12);	//set T1 @clk/256, CTC mode
TIMSK  = (1<<OCIE1A);
OCR1A  = 5000;




init_DMX();          			//initialisiere DMX-Empfang
} 













int main(void)
{
cli();
init_system();
sei();
for(;;)
{
wdt_reset();  								//reset watchdog (evtl durch Fuse Bits aktiv)
get_dips();
if (DmxRxField[0] != DmxBuf)
    {

	if (DmxRxField[0] < 11)
		{
		TIMSK &= ~(1<<OCIE1B);				//disable firing ISR
		}
	else if (DmxRxField[0] < 211 )
    	{
		uint16_t TimeBuf;
		TimeBuf= pgm_read_word(&FreqTable[DmxRxField[0] -11]);
		if (TCNT1 >= (TimeBuf -310)) TCNT1= TimeBuf -310; 
		cli();
		OCR1A= TimeBuf;						//set quench time
		OCR1B= TimeBuf -300;				//set time to start firing
		sei();
		if (!(TIMSK &(1<<OCIE1B)))
			{
			TIFR   = (1<<OCF1B);
			TIMSK |= (1<<OCIE1B);			//enable firing ISR
			TCNT1= 0;
			}
		}
	else
		{
		if (DmxBuf < 211)
			{
			TIMSK &= ~(1<<OCIE1B);			//disable firing ISR
			TCNT1  = 0;
			PORTD &= ~(1<<PD7);				//enable strobe
			PORTA |= (1<<PA0);
			OCR1A  = 300;					//set on time
			}
		}
	DmxBuf= DmxRxField[0]; 
	}
}
} 
















ISR (TIMER1_COMPA_vect)
{
PORTD |= (1<<PD7);							//disable strobe
PORTA &= ~(1<<PA0);
}







ISR (TIMER1_COMPB_vect)
{
PORTD &= ~(1<<PD7);							//enable strobe
PORTA |= (1<<PA0);
}

Wenn sich unser DMX-Wert geändert hat, lade ich die neue Frequenz aus der Tabelle.
Wenn der Timer schon weiter gezählt hat, als unser Vergleichswert groß ist, müssten wir für den nächsten Blitz so lange warten, bis der Timer nach dem Überlauf das nächste Mal wieder vorbeikommt. Da wir solche Aussetzer nicht wollen, setzen wir in diesem Fall den Timer kurz vor unseren Vergleichswert.
Abschließend aktualisieren wir den Vergleichswert. Da dieser eine Größe von 16bit hat, müssen wir darauf achten, dass keine ISR dazwischen funken kann und sperren deshalb kurz alle Interrupts.

Die Timer-ISR selbst lässt nur die rote LED blinken.

Nun zur neuen main:

Wir möchten Werte direkt aus dem Flash lesen und benötigen dafür die Lib:
#include <avr/pgmspace.h>

Wir brauchen eine neue globale Variable:
uint8_t DmxBuf;

Der Code lautet:

int main(void)
{
cli();
init_system();
sei();
for(;;)
{
wdt_reset();  					//reset watchdog (evtl durch Fuse Bits aktiv)
get_dips();
if (DmxRxField[0] != DmxBuf)
    {
	DmxBuf= DmxRxField[0];
    uint16_t TimeBuf;
	TimeBuf= pgm_read_word(&FreqTable[DmxBuf]);
	if (TCNT1 >= TimeBuf) TCNT1= TimeBuf -5; 
	cli();
	OCR1A= TimeBuf;
	sei(); 
	}
}
}

Kann mir jemand erklären, was ich wohl gemacht habe?

ach ja:
Die Interrupt Service Routine (ISR) zum Blinken lautet:

ISR (TIMER1_COMPA_vect)
{
PORTD ^= (1<<PD7);
}

Hier mein derzeitiges Projekt:
http://www.hoelscher-hi.de/hendrik/forum/anastrobe.zip

so...

Sorry für die Verzögerung - ich hatte aus Versehen das falsche Universum angestöpselt und habe mich bis eben gewundert, warum nichts funktionierte...

Da wir Timer1 als Frequenzgenerator nutzen und möglichst genau arbeiten wollen, nutzen wir ihn im CTC mode. Das bedeutet, dass wir ihn automatisch bei Erreichen von unserem Zielwert (abgelegt im Vergleichsregister OCR1A) zurücksetzen.

Die Initialisierung gehört in die Funktion init_system() und lautet:

TCCR1B = (1<<CS12)|(1<<WGM12);	//set T1 @clk/256, CTC mode
TIMSK  = (1<<OCIE1A);
OCR1A  = 5000;

Die erste Zeile setzt Prescaler und mode. Die Zweite aktiviert einen Interrupt bei Erreichen des Zielwertes und die dritte lädt schon einmal eine Dummy-Frequenz, damit was blinkt...

@PMN:
Die Formel ist richtig umgestellt ->
8*10^6/(1Hz*2^16)= 122

also Vorteiler 256 (s.o.)

Eigentlich habt Ihr Recht: Umstellen ist doch besser...

Edit:
Ich bereite jetzt mal den Code vor...

Eure Herangehensweise ist super, wenn man den Prescaler beliebig aussuchen kann.
Wenn man sich auf einen von 6 (?) möglichen Werten festlegen muss, geht ausprobieren schneller

Ach ja: Wenn ich die Formel durch Matlab jage, erhalte ich folgende Tabelle:

const uint16_t FreqTable[] PROGMEM = {
29206, 27412, 25826, 24414, 23148, 22007, 20973, 20032, 19172, 18382, 17655, 16984, 16361, 15783, 15244,
14741, 14269, 13827, 13412, 13021, 12652, 12303, 11973, 11660, 11364, 11082, 10813, 10557, 10314, 10081,
9858, 9645, 9441, 9246, 9058, 8878, 8705, 8538, 8378, 8224, 8075, 7931, 7793, 7659, 7530, 7405, 7284,
7167, 7054, 6944, 6838, 6735, 6635, 6538, 6443, 6352, 6263, 6176, 6092, 6010, 5930, 5852, 5776, 5703,
5631, 5560, 5492, 5425, 5360, 5297, 5235, 5174, 5115, 5057, 5000, 4945, 4890, 4837, 4786, 4735, 4685,
4636, 4589, 4542, 4496, 4452, 4408, 4365, 4322, 4281, 4240, 4200, 4161, 4123, 4085, 4048, 4012, 3976,
3941, 3906, 3872, 3839, 3806, 3774, 3743, 3711, 3681, 3651, 3621, 3592, 3563, 3535, 3507, 3480, 3453,
3427, 3400, 3375, 3349, 3324, 3300, 3276, 3252, 3228, 3205, 3182, 3160, 3138, 3116, 3094, 3073, 3052,
3031, 3011, 2990, 2971, 2951, 2932, 2912, 2894, 2875, 2856, 2838, 2820, 2803, 2785, 2768, 2751, 2734,
2717, 2701, 2685, 2669, 2653, 2637, 2622, 2606, 2591, 2576, 2561, 2547, 2532, 2518, 2504, 2490, 2476,
2463, 2449, 2436, 2422, 2409, 2396, 2384, 2371, 2358, 2346, 2334, 2322, 2310, 2298, 2286, 2274, 2263,
2251, 2240, 2229, 2218, 2207, 2196, 2185, 2175, 2164, 2154, 2143, 2133, 2123, 2113, 2103, 2093, 2083
};

Diese Tabelle wird als Konstante direkt im Flash (PROGMEM) abgelegt und belastet so nicht das RAM.

Wenn Ihr das datenblatt nicht habt:

Zur Auswahl stehen: 1; 8; 64; 256; 1024

Keiner eine Idee? :wink:

Auflösung: Wir müssen bei der langsamsten Frequenz am weitesten zählen -> 1Hz interessant

also: Y_max= 8*10^6/Prescale, wobei Y_max < 65536 und Prescale möglichst klein

-> 64 reicht nicht, 256 passt.

Somit lautet die Formel für den Timer, um auf PMNs Frequenzen zu kommen:
Y= 8*10^6/(256*f_pmn), wobei f_pmn= 1..15Hz.

@PMN: inverse Multiplikation wird nichts. Unser Problem ist vom Typ 1/n - also Tabelle...

Um eine schöne hohe Auflösung zu bekommen, wollen wir für die Strobes den 16bit-Timer (T1) nutzen.
Dieser zählt von 0 bis 2^16 und fängt dann wieder von vorn an. Jeder Timer eines AVRs hat einen eigenen Vorteiler (Prescaler), um den Zähltakt dem Systemtakt anzupassen.

Nun zur Berechnung:

PMN möchte einen Frequenzbereich von 1..15Hz.
Wir wollen nun herausfinden, wie weit der Timer von 0 an zählen muss, um auf 1Hz oder 15Hz zu kommen. (Nach Erreichen der Zahl resetten wir den Timer und zählen erneut...)

Die Formel lautet:
Y= f_quarz/(f_pmn * Prescale)

Unser Quarz hat 8MHz. Die möglichen Vorteiler findet Ihr auf S.122 im Datenblatt. Was ist der kleinste Vorteiler, damit wir mit unserem Wertebereich (2^16 = 65536) hinkommen?

Daniel, Jaegermeister:
Warten oder weitermachen?

@PMN: Hat denn die LED vorher mit ~16Hz geblinkt. Wenn nicht, hast Du die Fuse Bits vergessen.

Hier mein derzeitiges Projekt:
http://www.hoelscher-hi.de/hendrik/forum/anastrobe.zip

@all:
In der letzten Version der Lib habe ich folgendes geändert:
DmxField -> DmxRxField
init_DMX -> init_DMX_RX

In einem Projekt benötigte ich sowohl Tx und Rx Lib, was die Änderung notwendig mache.

Also einfach die Namen in main.c anpassen...

EDIT:
Wenn Euch sowas mal bei einem Update eines größeren Projektes passieren sollte, kann man das Ersetzen einfach über Cntrl+H automatisieren.

====
Vorschläge zum Frequenzbereich?

@PMN: Hast Du die Header-Datei eingebunden? Wird in der Header-Datei DmxField oder etwas anderes deklariert?

Wenn Ihr soweit seid, brauchen wir zunächst eine wichtige Angabe für das Projekt:

Welcher Frequenzbereich soll für das Stroboskop einstellbar sein? (25Hz-100Hz wären wahrscheinlich suboptimal )

...und haltet schon mal das Datenblatt für den mega8515 bereit. Tipp: ab S.97 wird es spannend

<ich habe in dem vorigen Post noch etwas zum Beobachten von Variablen editiert>

Zunächst fügt Ihr meine "lib_dmx_in.c" und die "lib_dmx_in.h" aus dem Archiv "rxd.zip" in Euer Projektverzeichnis (bei mir: AnaStrobe ) ein.

Dann geht Ihr links im AVR-Studio auf den Reiter "AVR GCC" und fügt die lib_dmx_in.c zu den source files und die lib_dmx_in.h zu den Header Files.

Nun möchten wir ja mit unserem Hauptprogramm Funktionen aus der Lib nutzen können. Dazu müssen wir die Header Datei oben in Eurem Code bekannt machen:

#include "lib_dmx_in.h"

(Die io.h und stdint.h können wieder entfernt werden, da ich sie in der Header Datei der Lib einbinde...)

Damit die Initialisierung etwas strukturierter aussieht, bekommt sie eine eigene Prozedur:

void init_system(void)
{
DDRA=  0xFF;                 //low outputs
PORTA= 0;
DDRD=  0b10000110;	    //DMX, spare, LED1
PORTD= 0b01111010;




init_DMX();		    //initialisiere DMX-Empfang
}

Über init_DMX () rufe ich den Initialisierungscode aus der Lib auf und muss mich nicht weiter darum kümmern.

Nun zum Hauptprogramm:

int main(void)
{
cli();
init_system();
sei();
for(;;)
{
wdt_reset();  //reset watchdog (evtl durch Fuse Bits aktiv)
get_dips();
if (DmxField[0]>127)
      {
      PORTD &= ~(1<<PD7);	//LED an
      }
else
      {
      PORTD |= (1<<PD7);	//LED aus
      }
}
}

Mit cli sperre ich zunächst die Interrupts, damit mir kein Ereignis dazwischenfunkt. Dann initialisiere ich den Transceiver und gebe die Interrupts wieder frei.
Mit get_dips() lese ich die Startadresse ein.
Und danach schau ich nur noch, ob mein erster Kanal >50% ist. Falls ja, knipse ich die rote LED an.

========

Bis hierhin laufen alle Projekte gleich. Deshalb konnte ich einen Großteil der anfänglichen Posts der alten DMXC-Tuts wiederverwenden

Wenn Ihr bis hierhin gekommen seid, wird es auch für mich spannend

Nach dem Abspeichern drückt Ihr Strg+F7 und kompiliert damit das Programm und startet den Simulator.

Das Nachrichtenfenster sollte nun zeigen, dass die Geschichte erfolgreich war und 180byte Programmcode erzeugt wurde.

Das ist ziemlich viel für die paar Zeilen - deshalb klicken wir auf das Zahnrad-Icon (von mir aus auch Schnecke - auf jeden Fall neben dem blauen X) und wählen als Optimization "-0s" und kompilieren noch mal.

Siehe da: 130bytes

BTW:
-0o: keine Optimierung
-01..-03: Optimierung der Geschwindigkeit
-0s: Optimierung der Codegröße. (Wenig Code geht auch schneller

Nun klickt Ihr bei "Debug" auf "AVR Simulator Options" und wählt 8MHz als Frequenz.

Nochmal kompilieren.

Nun kann mit Tippen von F11 Schritt für Schritt der Code durchlaufen werden.

Das Ergebnis seht Ihr links, wenn Ihr den I/O-View Reiter anwählt.
Variablen (wie count) können Ihr durch Eingabe von Alt+4 beobachten. (Wenn der Compiler schlau ist, merkt er, dass wir count nur in der Funktion main einsetzen und sonst keine globalen Variablen haben. In diesem Fall findet Ihr count in den Registern...)

Das Hex-File findet Ihr in dem default-Ordner innerhalb Eures Projekt-Ordners. Wenn Ihr es mit PonyProg auf den Transceiver überspielt, flackert die rote LED mit 16-20Hz.

===

Ich schlage vor, wir warten bis 15.30h und beginnen dann mit dem DMX-Empfang.
Vielleicht ist bis dann mehr los...

Dann deklarieren wir unsere erste Variable:

uint16_t count;

Dies ist eine nicht-negative (unsigned) Variable mit 16bit, die wir "count" nennen.
Count kann also einen Wert von 0 bis 2^16, also 65535, annehmen.

Jetzt fehlt eigentlich nur noch der erste spektakuläre Code:

int main(void)
{




DDRA=  0xFF;	   //low outputs
PORTA= 0;




DDRD=  0b10000110;	   //DMX, spare, LED1
PORTD= 0b01111010;




for(;;)
    {
    wdt_reset();	  //reset watchdog (evtl durch Fuse Bits aktiv)
    if (--count == 0)
         {
         PORTD ^= (1<<PD7);     //toggle LED
         }
     }
}

Das Hauptprogramme lautet immer:
int main(void)
{
}
Es heißt also main, bekommt beim Aufruf keine Werte mit und gibt einen Integer (beim Absturz...) zurück.

Zunächst initialisieren wir PortA sicherheitshalber als Ausgang, indem wir das Datenregister auf 0b11111111 (also 0xFF) setzen und machen alle Pins LOW.

Dann initialisieren wir PortD in ähnlicher Weise. (Schaut mal in den Schaltplan auf meiner Seite - dann seht Ihr den Sinn der Werte

Nun kommt eine for-Endlosschleife, damit wir nicht den Code ein Mal abarbeiten und dann abstürzen.
Darin setzen wir zunächst den Watchdog zurück.
Dann ziehen wir 1 von count ab (count= count -1 und schauen anschließend, ob wir 0 erreicht haben.
Wenn ja, läuft count über und wir wechseln den Status der LED an PortD, Pin7. (Wer mit dem Exklusiv-Oder Probleme hat, sollte noch mal in das C-Tut auf mikrocontroller.net linsen...)

EDIT: Gibt es hier eigentlich eine Möglichkeit, Dateien anzuhängen?

Nun beginnen wir mal mit dem ersten Programm:

Zunächst ein paar Kommentare, damit man in ein paar Jahren noch durchsteigt:

/* DMX Stroboskop Interface
Version: 0.1
Datum: 21.06.09
Autor: H.Hölscher (http://www.hoelscher-hi.de)
Target: DMX Transceiver @8MHz
Lizenz: GPLv2
*/

Dann binden wir ein paar Definitionen ein, mit denen wir später arbeiten wollen:

#include <avr/io.h>
#include <stdint.h>
#include <avr/wdt.h>

Die "io.h" sagt dem Kompiler, was wir mit typischen Peripherienamen, etc. meinen und übersetzt sie in die physikalische Adresse. So können wir zum Beispiel schreiben:
"PORTA= 0xFF;" und nicht "0x23= 0xFF"
Natürlich sind die physikalischen Adressen bei jedem AVR-Typ anders - aber deshalb haben wir ja bereits festgelegt, dass wir mit einem mega8515 arbeiten.

Die "stdint.h" erklärt dem Compiler was wir mit verschiedenen Variablentypen meinen. Andernfalls kann der GCC nichts mit "char", "integer" oder "short" anfangen und wirft Fehlermeldungen.

Die "wdt.h" läst uns auf den Watchdog zugreifen.
Wenn dieser Wachhund nicht alle paar ms von uns zurückgerufen wird, startet er den AVR neu. Somit stehen wir bei einem Absturz des AVRs nicht im Dunkeln sondern sind nach <1s wieder dabei
Da ich ihn sicherheitshalber gern schon mit den fuses aktiviere, rufen wir ihn einfach sicherheitshalber einfach zurück - auch wenn wir ihn zunächst gar nicht initialisieren...

Nun öffnet sich die eigentliche Entwicklungsumgebung:

In der Mitte befindet sich die jeweils aktive Datei mit dem Quellcode.

Links findet Ihr ein Panel mit verschiedenen Funktionen:
Durch Klicken auf den unteren Reiter "AVR GCC" könnt Ihr verschiedene Dateien in das Proekt einbauen bzw. entfernen.
Es gibt dabei verschiedene Dateiarten:
"Source Files" haben die Endung .c, .cpp oder .s und beinhalten die eigentlichen Funktionen.
In "Header Files" (Endung .h) stehen Vereinbahrungen, die in mehreren Source Files bekannt sein müssen. Beispiele dafür sind gemeinsame Variablen oder Pinbelegungen und andere Konstanten.

Der Reiter "I/O View" wird später bei der Simulation des Codes interessant, da wir hier sehen, wie sich der AVR später durch das Programm verhalten wird.

Unten befindet sich schließlich noch ein Panel mit verschiedenen Logs und Compiler-Ausgaben. Falls es beim Kompilieren der Quelltexte Probleme gibt, werden hier Hinweise dazu gegeben.

Durch Klicken auf "Next" kommen wir zu den Degugger-Einstellungen:
Wählt als Debug Platform den "AVR Simulator" und als Device den "ATmega8515"

Beendet den Wizard mit "Finish".

Startet dazu das AVR-Studio.

Es öffnet sich der Startup-Wizard (Welcome to AVR Studio 4).
Beginnt ein neues Projekt mit "New Project".

Wählt dann unter Project type "AVR GCC", da wir unsere Firmware in C schreiben wollen.
Gebt nun den Pfad unter Location an, wo der Ordner mit allen zu dem Projekt gehörenden Daten abgelegt werden soll. (Bei mir lautet er bspw.: C:\eigene Programme\Rev3_0\)
Als Projektnamen wähle ich AnaStrobe, da wir ein Interface für analoge Strobes schreiben wollen.
Das initial file nenne ich wie üblich main.c
(create folder und create initial file bleiben gewählt)