µC als Funktionsgenerator

[Hannes K. (chgruber)]

Kann ich meinen µC (LPC936) als Funktionsgenerator mit externer 
Versorgung verwenden?
D.h. ich legen an einen Pin 9V und schalte, mittels Timer oder 
ext.Interrupt die 9V am Eingangspin auf einen anderen Ausgangspin.


Ungefähr so:



#include <REG936.h>

#define AUS 0x00;


sbit Ausgang = 0xA0;
sbit Eingang = 0xA1;





void main()
{

 P2M1 &= 0xFE;
 P2M2 |= 0x01;

 TH0 = 0x00;
 TL0 = 0x05;

 TH1 = 0x00;
 TL1 = 0x0A;

 TMOD=0x11;

 ET0 = 1;
 ET1 = 1;
 EA = 1;

 TR0 = 1;


   while(1)
  {}

}


void SpannungAUS () interrupt 1
{

 Ausgang = AUS;

 TH0 = 0x00;
 TL0 = 0x05;
 TR0 = 0;
 TR1 = 1;
}


void SpannungEIN () interrupt 3
{

 Ausgang = Eingang;

 TH1=0x00;
 TL1=0x0A;
 TR1 = 0;
 TR0 = 1;

}

[KST (Gast)]

Hä???

[holger (Gast)]

>D.h. ich legen an einen Pin 9V und schalte, mittels Timer oder
>ext.Interrupt die 9V am Eingangspin auf einen anderen Ausgangspin.

Jo, mach mal. Und dreh ein Video von den Rauchwolken.

[Hannes K. (chgruber)]

Ja deswegen frag ich ja...ich bin ganz neu im µC-Business.

[Michael A. (Gast)]

Christian Gruber schrieb:
> D.h. ich legen an einen Pin 9V und schalte, mittels Timer oder
> ext.Interrupt die 9V am Eingangspin auf einen anderen Ausgangspin.

Hört sich spannend an. GUck mal in Abschnitt 10 des Datenblatts

[Harald W. (wilhelms)]

Christian Gruber schrieb:

> Kann ich meinen µC als Funktionsgenerator verwenden?

http://de.wikipedia.org/wiki/Funktionsgenerator
Gruss
Harald

[Hannes K. (chgruber)]

Dann schalte ich eben mit dem µC einen Transistor und über diesen dann 
die 9V

[ich (Gast)]

Dann hast Du aber bestenfalls einen Rechteck-Generator

[Hannes K. (chgruber)]

ich schrieb:
> Dann hast Du aber bestenfalls einen Rechteck-Generator

So soll es auch sein. ;-)

[Wastl F. (rescuetigerchen)]

Benutz doch einfach einen Timer-Overflow (Interrupt). Da kannst du ganz 
bequem die Frequenz vorgeben, an und ausschalten kannst du bei Bedarf 
auch. Bei Atmel hat man zumindest diese Option.

[Helmut S. (helmuts)]

Hallo Christian,
Ein Funktionsgenerator kann z. B. Sinus, Dreieck, Rampe, Rechteck und 
eventuell auch beliebige Kurvenformen.
Was du suchst nennt sich Pulsgenerator.

[Philk (Gast)]

Wozu einen µC für so eine primitive Aufgabe nehmen?

nimm einen NE555 und beschalte ihn als Astabile Kippstufe:

http://de.wikipedia.org/wiki/NE555#Astabile_Kippstufe

[Hannes K. (chgruber)]

Philk schrieb:
> Wozu einen µC für so eine primitive Aufgabe nehmen?
>
> nimm einen NE555 und beschalte ihn als Astabile Kippstufe:

Das ist natürlich die eleganteste Lösung, nur brauche ich diesen 
Pulsgenerator nur kurz für einen Test. Und NE555 hab ich keinen bei der 
Hand.

[Thomas E. (thomase)]

Philk schrieb:
> Wozu einen µC für so eine primitive Aufgabe nehmen?
Weil dem Controller das sowas von egal ist.

> nimm einen NE555 und beschalte ihn als Astabile Kippstufe:
Grauenhaft. Mit einem µC braucht man gar keine externe Beschaltung.

mfg.

[Bernhard S. (b_spitzer)]

Also zu allererst sollte Dir klar sein, dass dein Controller Spannungen 
über 5V weder am Eingang mag noch am Ausgang erzeugen kann. Ich habe mal 
vor einiger Zeit einen per serieller Schnittstelle steuerbaren 
Impulsgenerator programmiert. Nach Übertragung eines Textstrings erzeugt 
er das gewünschte Signal.
Ohne Gewähr: (die LCD-Funktionen kann man ganz weglassen oder du musst 
sie anpassen)

/*  Pulsgenerator
   Erzeugen eines unsymmetrischen Rechtecksignals am Ausgang
   Die Puls- und Pausendauer kann per serieller Schnittstelle 
  in Schritten von 100us-100ms konfiguriert werden.
  Protokoll dazu mit 9600Baud:
  Piiii.pppp z.B. P0015:0200 erzeugt ein Servo-Signal mit 1,5ms/20ms
*/
#include <stdio.h>            //  für sprintf                          
#include <intrins.h>            //  Intrinsische Funktionen z.B._nop_()                  

#include <defines.h>            // Abkürzungen

#include <at89c5131.h>          //  Registeradressen  
//#include <at89s4051.h>          //  Registeradressen  

#include "..\..\lcd.h"

/****************   Definitionen *********************************************/
/* Zustände der Zeichenprüfung */
#define  Idle      0
#define  Start      1
#define  Puls1      2
#define  Puls2      3
#define  Puls3      4
#define  Puls4      5
#define  Separator  6
#define  Pause1    7
#define  Pause2    8
#define  Pause3    9
#define  Pause4    10
#define  Ende      11
#define  Fehler    99

/****************   Globale Variablen ****************************************/
data at 0x7E uI16  Ticks;
data uI16 Puls, Pause, Periode;
 
sbit Ausgang1 = P2^0;      // Signalausgang 1

//****************   Funktionen ***********************************************
void init(void);
void Timer0_Tick(void) interrupt 1;
void Timer_init(uC8 Timer, uC8 Mode, uC8 High, uC8 Low);

// Ausgabe einer 4-Stelligen Zahl ab Pos
void myprintf40(uC8 Pos, uI16 Zahl);
// Ausgabe einer 3.1-Stelligen Zahl ab Pos      
void myprintf31(uC8 Pos, uI16 Zahl);
//****************  Hauptprogramm  *******************************************

void main(void)
{  uC8 Zeichen, Zustand=Idle, Buf[20];
  //uC8 Tausender, Hunderter, Zehner, Einer, Zehntel;
  uI16 Temp;

  init();
  Periode=0;
  
  while(1)
  {
    if(RI)
    {
      RI = 0;
      Zeichen = SBUF;
      switch (Zustand)
      {
        case Idle  : if(Zeichen == 'P') Zustand=Puls1; break;
        /* Pulsdauer aus 4 ASCII-Zeichen zusammensetzen */
        case Puls1  : Temp = Zeichen - 0x30; Zustand=Puls2; break;
        case Puls2  : Temp = Temp * 10 + (Zeichen - 0x30); Zustand=Puls3; break;
        case Puls3  : Temp = Temp * 10 + (Zeichen - 0x30); Zustand=Puls4; break;
        case Puls4  : Temp = Temp * 10 + (Zeichen - 0x30); Zustand=Separator; break;
        /* Separator : prüfen */
        case Separator  :   if(Zeichen == ':')
                     {   Puls = Temp;       // Korrekt, Puls übernehmen
                       Zustand=Pause1;     // danach Pause lesen
                        break;
                      }
                      else 
                      {  Zustand = Fehler;
                        break;                      
                      }
        case Pause1  : Temp = Zeichen - 0x30; Zustand=Pause2; break;
        case Pause2  : Temp = Temp * 10 + (Zeichen - 0x30); Zustand=Pause3; break;
        case Pause3  : Temp = Temp * 10 + (Zeichen - 0x30); Zustand=Pause4; break;
        case Pause4  : Temp = Temp * 10 + (Zeichen - 0x30); Zustand=Ende; break;
        /* Ende CR: prüfen */
        case Ende  :   if(Zeichen == ' ')        // Zeilenschaltung
                     {   Pause = Temp;       // Korrekt, Puls übernehmen
                       Periode = Puls + Pause;
                       Zustand=Idle;       // fertig
                       //sprintf(Buf,"ti:%4d, tp:%4d",Puls, Pause);
                       sprintf(Buf,"%4d+%4d=%4d",Puls, Pause,Periode);
                       textlcd(Buf, 2);
                        break;
                      }
                      else 
                      {  Zustand = Fehler;
                        break;                      
                      }
        case Fehler  :   Zustand=Idle; textlcd("Formatfehler", 2); break;
        default: break;
      }
    }
  }
}


/* System-Ticks alle 100us
  Puls wird bei Beginn der Periode gesetzt, nach Pulsdauer wieder gelöscht */
void  Timer0_Tick(void) interrupt 1
{  Ticks++; 
  if(Ticks>=Periode)
  {  Ticks=0;
    Ausgang1 = 1;      // Ausgang setzen, 1 Periode ist vorbei
  }
  if(Ticks==Puls)
  {
    Ausgang1 = 0;      // Pulsdauer vorbei
  }
}

/* Initialiserung für Timer 0 oder 1
  Übergabe von Timernummer, Mode und Startwerten */
void  Timer_init(uC8 Timer, uC8 Mode, uC8 High, uC8 Low)
{
  if (Timer==1) 
  {
    TMOD |= (Mode & 0x0F) << 4;
    TH1 = High;
    TL1 = Low;
    TR1 = 1;
  }
  else
  {
    TMOD |= (Mode & 0x0F);
    TH0 = High;
    TL0 = Low;
    TR0 = 1;
  }
}

/* Initialiserung serielle Schnittstelle
  nutzt den Baudratengenerator des AT89C5131 */
void  init_seriell(void)
{
  PCON|= 0x80;      // SMOD setzen
  BDRCON = 0x1F;      // Baudratengenerator nutzen
  BRL = 236;        // 217: 9600 Baud 236: 19200
  SCON = 0x52;      // 8Bit UART, TI gesetzt
}

/* Ausgabe einer 4-Stelligen Zahl ab Pos*/
void myprintf40(uC8 Pos, uI16 Zahl)
{        
  cursorpos(Pos);
  // Tausender
  charlcd(0x30 + Zahl/1000);
  Zahl = Zahl%1000;
  // Hunderter
  charlcd(0x30 + Zahl/100);
  Zahl = Zahl % 100;
  // Zehner
  charlcd(0x30 + Zahl /10);
  // Einer
  charlcd(0x30 + Zahl % 10);
}

/* Ausgabe einer 3.1-Stelligen Zahl ab Pos */
void myprintf31(uC8 Pos, uI16 Zahl)
{
  cursorpos(Pos);
  // Hunderter
  charlcd(0x30 + Zahl/1000);
  Zahl = Zahl % 1000;
  // Zehner
  charlcd(0x30 + Zahl /100);
  Zahl = Zahl % 100;
  // Einer
  charlcd(0x30 + Zahl / 10);
  charlcd(',');
  charlcd(0x30 + Zahl % 10);
}

/* Init-Funktion, wird für Konfiguration der Peripherie verwendet */
void init(void)
{
  initlcd();
  textlcd("Pulsgenerator   ",1);
  textlcd("V 1.0           ",2);
  init_seriell();
  // Timer 0, Mode 2, 100us Reload = (256-100)
  Timer_init(0,2,156,156);
  ET0 = 1;    // Timer-Interrupt
  EA = 1;    // Gloable Freigabe
}

tschuessle
Bernhard