I2C - Funktionsbeschreibung der Lib's

Version 0.3a , Ingo Gerlach , DH1AAD , 28.11.2003

E-Mail bitte an:Ingo Gerlach

Info

Installation

Download

Integration in eigene Programme

Beschreibung der Funktionen

Api's

Info

Die hier zur Verfügung gestellten Librarys sollen das Experementieren mit diesem interessanten Bus vereinfachen. In Verbindung mit dem seriellen oder paralellen Interface, und etwas Perl oder VB Code lassen sich Schaltungen damit sehr schnell Testen.

Die Lib's f�r den seriellen und den parPort sind identisch. Im Header "i2c-fncs.h" sind die "low-level" Funktionen definiert. Je nach Linker-Aufruf, wird dann etweder die serielle Version "i2c_ser.c" oder die paralle Version "i2c_lpt.c" dazugelinkt. Die Device-Funktionen brauchen dann nicht angepasst zu werden.
Um die DLL Aufrufe zu vereinfachen, wurden die Win-Funktionen so gestaltet, das keine Datenstruckturen übergeben werden müssen.
Für die Windows Versionen wahren einige kleine Anpassungen notwendig. Da diese Funktionen "C"-Funktionen "outp" und "inp" basieren, die direkt auf die Hardware zugreifen, funktioniert das so einfach nur unter Windows 95 & Windows 98. Unter Windows NT/ME/2000 geht dies nicht, da hier der direkte Zugriff auf die Hardware mit diesen Funktionen verweigert wird. Unter Linux ist der Zugriff �ber die Funktion "ioperm" m�glich, was aber root Rechte voraussetzt
Ich hatte hier von jemanden einen Link (http://www.zealsoftstudio.com/ntport/) bekommen, wie auch unter NT und W2K der Zugiff erfolgen kann, daher habe ich eine weitere Lib erstellt. Die entsprechende Library kann aber auch hier geladen werden.
  • Port95nt.exe
  • Ich habe diese Lib mal auf einem Notebook mit XP-Professional getestet, hier lief es einwandfrei.
    Unter Linux gibt es neben den C-Funktionen noch ein Perl-Modul sowie einen I2C-Server.

    Der derzeitige Stand der Entwicklung, ist hier einmal schematisch dargestellt:

    Schema




    Installation

    Installation Linux

    Die Linux Installation ist recht einfach, wenn auch noch nicht vollst�ndig automatisiert.
    Vorgehensweise: (als root !)

    1. Verzeichnis anlegen -> mkdir /opt/i2c
    Das Verzeichnis ist in den Scripts fest vorgegeben. (Derzeit noch ... )
    Soll die Software in ein anderes Verzeichnis installiert werden, muss nach dem Auspacken das Makefile angepasst werden.

    2. In dieses Verzeichnis nun das Tar-File kopieren und auspacken.
    gzip -d i2c-0.3.tar.gz
    tar -xvf i2c-0.3.tar

    3. Dann INSTALL eingeben
    Es werden nun die Lib's kompiliert und die Perl-Module erstellt.

    Die man-Pages zu den Perl-Modulen k�nnen mit "man i2c_ser" bzw. "man i2c_par" angezeigt werden. Um auf die definierten Konstanten der Header zugreifen zu können, gibt es
    dort eine weitere Funktion xxxxx_const welchen die Konstanten zurückliefert.
    Sollte ein anderes Verzeichnis als /opt/i2c verwendet werden, ist es erforderlich den Eintrag "HDIR= /opt/i2c/" im Makefile entsprechend anzupassen.

    Das Client Modul muss derzeit noch separat erstellt werden. Dazu in das Verzeichnis /opt/i2c/perl/i2c_client wechseln und dort perl Makefile.PL starten. Danach dann mit "make install" installieren.


    Installation Windows

    Vorgehensweise:

    1. Verzeichnis anlegen und das ZipFile i2c-03.zip dorthin entpacken.

    2. Die DLL's befinden sich im Verzeichnis nt\dll .

    Um sie einsetzen zu k�nnen, ist es erforderlich das die DLL's auch zur Laufzeit gefunden werden.
    Die DLL's müssen daher noch in das Windows System-Verzeichnis kopiert werden.
    Danache port95nt.exe ausf�hren und installieren.
    Die DLL's wurden mit Microsoft Visual C 4.2 erstellt. Die entsprechenden Workspaces sind unter nt\lib\i2c_ser und nt\lib\i2c_par zu finden. Die Quellen dazu unter \i2c_ser , \i2c_par, \src .


    Integration in eigene Programme

    Perl (nur Linux)

    Um unter Perl die Funktionen zu nutzen, muss lediglich am Anfang die Definition
    "use i2c_ser; bzw use i2c_lpt;" eingf�gt werden. z.B.

    use i2c_ser;
    # Serielles Interface
    my $port = i2c_ser::init_iic(0);
    # Interface automatisch suchen 
    
    Wird der I2C-Server verwendet, muss 
    use i2c_client; 
    eingebunden werden.
    

    C

    Binden Sie die include Dateien, aus dem Verzeichnis i2c_ser (i2c_ser.h) bzw. i2c_par (i2c_lpt.h) f�r den paralell Port, in das eigene Projekt mit ein. z.B.

    #include "../i2c_ser/i2c_ser.h"	// i2c Funktionen f�r ser. Schnittstelle
    #include "../lcd/lcd.h"		// LCD Funktionen 
    #include "../pcf8574/pcf8574.h"	// PCF8574 Funktionen
    

    VB

    Da die Funktionen in einer DLL enthalten sind, muss bei VB ein Modul mit den entsprechenenden Definitionen dem eigenen Projekt hinzugefügt werden.
    Eingebunden wird das entsprechende Modul unter VB mit "Projekt / Modul hinzuf�gen ".
    Die Module sind unter WIN\VB\I2C_SER.BAS bzw. WIN\VB\I2C_PAR.BAS zu finden. Die NT Module unter
    NT\VB\I2C_NT_SER.BAS bzw. NT\VB\I2C_NT_PAR.BAS.




    Beschreibung der Funktionen

    Folgende Funktionen sind sowohl f�r das serielle- als auch den paralellen I2C Adapter verf�gbar.

    Low-Level seriell und paralell

    int set_port_delay (int delay)

    Setzt die Wartezeit (delay) f�r Portzugriffe. G�nstige Werte liegen im Bereich von 2-10.
    R�ckgabe delay. Diese Funktion muss vor dem initialiseren aufgerufen werden.
    Sh. Beispiel init_iic.

    int init_iic (int Portnr)

    Initialisert den Port (seriell oder paralell ) f�r die Ein/Ausgabe und �berpr�ft ob ein
    I2C Interface angeschlossen ist. Gibt 0 zur�ck falls das Interface nicht gefunden wird.
    Bei Portnr = 0 wird automatisch gesucht.
    Zur�ckgegeben wird die Adresse (dezimal) bei vorhandensein eines Interfaces ansonsten 0.

    C

    #include "i2c_lpt.h" // i2c Funktionen f�r par. Schnittstelle
    
    int LPT = 0;
    
    set_port_delay(5);	// Portdelay 1-25 25 ..langsam
    iport = init_iic(LPT);	// Init ii2c , Interface automatisch suchen an LPTx
    
    if (iport>0) 
    {
    printf(" gefunden an Port 0x%03xh! \n",iport);
    } else {
    printf("Interface nicht gefunden.\n");
    exit (2);
    }
    ....
    

    VB

    Private Sub Init_Click()
     Dim Port As Integer
     set_port_delay (5)
     Port = init_iic(0)
    End Sub
    

    Perl

    
    use i2c_lpt;
    i2c_lpt::set_port_delay(5);
    # Interface automatisch suchen
    my $iport = i2c_lpt::init_iic(0);
    print "Suche Interface...\n";
    if ($iport > 0) {
     print "I2C-Interface gefunden an $iport \n\n"; 
    } else {
      print "I2C-Interface nicht gefunden. \n"; 
      exit 1;
     }
    ....
    

    int deinit_iic (void)

    Port wieder schliessen. R�ckgabe immer 0.

    int iic_start(void)

    Startbit senden. R�ckgabe immer 0.

    int iic_stop(void)

    Stopbit senden. R�ckgabe immer 0.

    int iic_send_byte(int sbyte)

    Es wird das Byte sbyte �ber den IIC-Bus gesendet.
    R�ckgabe 1 wenn ein ACK vom Slave kam, sonst 0.

    C

    
    int ret;
    int data=0;
    iic_start(); 
    ret = iic_send_byte(114);	# Adresse I2C 
    if (ret)
    {
    ret = iic_send_byte(data);	# Daten ausgeben	
    if (ret) iic_stop();
    } 
    

    VB

    
    Call iic_start
    temp = iic_send_byte(114)
    temp = iic_send_byte(8)
    Call iic_stop
    
    

    Perl

    
    i2c_ser::iic_start()
    i2c_ser::send_byte(114)
    i2c_ser::send_byte(8)
    i2c_ser::iic_stop()	
    
    

    int iic_read_byte(int ack)

    Es wird ein Byte �ber den IIC-Bus eingelesen.
    R�ckgabe empfangenes Byte. Wenn ack = 1 wird abschliessend ein ACK gesendet.

    C

    
     int ret;
     iic_start();
     ret = iic_send_byte(115);	# Adresse I2C 
     if (ret)
     {
       *data = iic_read_byte(0);	# Daten einlesen
     } else *data = 0;
     iic_stop(); 

    VB

    Call iic_start
    temp = iic_send_byte(115)
    data = iic_read_byte(1)
    Call iic_stop
    

    Perl

    
    i2c_ser::iic_start()
    i2c_ser::send_byte(115)
    data = i2c_ser::read_byte(1)
    i2c_ser::iic_stop() 
    



    Low-Level paralell

    Diese Funktionen sind nur für den paralell Port I2C-Adapter verf�gbar!


    int io_enable (void)

    Schaltet den 8 Bit I/O Modus ein.

    int io_disable (void)

    Schaltet den 8 Bit I/O Modus aus.

    int set_strobe (int strobe 1|0 )

    Setz den Strobe Ausgang ( Pin 1 , Ausgangsbuchse) . R�ckgabe strobe.

    int get_status (int status 0)

    Liest den Statusport des paralell Port. R�ckgabe status.

    int byte_in (int status 0)

    Liest ein Byte �ber den 8 Bit I/O Adapter.
    R�ckgabe eingelesenes Byte.

    int byte_out (int sbyte)

    Gibt das Byte sbyte �ber den 8 Bit I/O Adapter aus.
    R�ckgabe sbyte.

    C

    io_enable();
    set_strobe(0);
    MessWert = byte_in(0);
    io_disable(); 
    set_strobe(1);
    
    

    VB

    
    Call io_enable 
    set_strobe (0)
    MessWert = byte_in(0)
    Call io_disable 
    set_strobe (1)
    

    Perl

    
    i2c_lpt::io_enable()
    i2c_lpt::set_strobe(0)
    MessWert = i2c_lpt::byte_in(0)
    i2c_lpt::io_disable()
    i2c_lpt::set_strobe(1)
    

    Low-Level I2C

    Diese Funktionen werden nur intern für die I2C Kommunikation verwendet.

     /* Interne Funktionen i2c_ser & i2c_par	*/
     int iic_ok (void);			// Prueft ob i2c-Interface angeschlossen ist.
     int wait_port(void); 			// Pause fuer Port Zugriff 
     int sda_high (void); 			// Setzt SDA auf high
     int sda_low (void); 			// Setzt SDA auf low
     int scl_high (void); 			// Setzt SCL auf high
     int scl_low (void); 			// Setzt SCL auf high
     int read_sda (void); 			// Liest SDA aus
     int read_scl (void); 			// Liest SCL aus 
    

    PCF8574 , 8 Bit I/O

    Per default wird hier die Startadresse 112 verwendet , ist der PCF
    auf z.B. 114 adressiert, muss adr = 2 sein usw.

    int iic_tx_pcf8574(int data,int adr)

    Sendet das Byte data an einen PCF8574, mit der Adresse adr.

    int iic_rx_pcf8574(int adr)

    Empf�ngt ein Byte data von einen PCF8574, mit der Adresse adr.

    Perl

    
    # Ein Byte senden, (Adresse = 0, dh. 112) 
    $r=i2c_ser::iic_tx_pcf8574(12,0);
    print "PCF8574: Sende #12 an (pcf8574) \n";
    
    # Ein Byte einlesen von Adresse = 2 d.h. 114
    $r=i2c_ser::iic_rx_pcf8574(2);
    print "PCF8574: Empfangenes Byte $r \n";
    

    LCD-Ansteuerung mit PCF8574

    Funktionen zum direkten Ansteuern eines LCDisplay's.
    Verwendet wird hierfür eine Schaltung aus dem Buch Elektor, I2C Bus angewandt, S. 117,
    allerdings mit einer etwas geäderten Anschlussbelegung.

    int lcd_init (void)

    Initialisiert Display , 2 Zeilen 4-BIT-Modus ( default) . Auch hier muss vor der
    eigentlichen Verwendung, der I2C Adapter initialisiert werden.
    sh. init_iic
    Die folgenden Konstanten sind in der C-Lib definiert:

    /* LCD Konstanten */
    #define LCD_IR	0x00	// Instruction Register
    #define LCD_DR	0x01	// Data Register
    #define LCD_BL	0x08	// Backlight
    #define LCD_COF	0x0C	// Cursor Off
    #define	LCD_CON	0x0E	// Cursor On
    #define LCD_CBL	0x0F	// Cursor Blink
    #define LCD_CHM	0x02	// Cursor Home
    #define LCD_CLR	0x01	// Display Clear
    #define LCD_OFF	0x08	// Display Off
    #define	LCD_ADR 0x80	// Adresse setzen
    

    C

    test=lcd_init();
    lcd_backlight(0); // Ausschalten (gibt 1 zur�ck wenn, OK)
    // Text Schreiben 
    lcd_wchar('H');
    lcd_wchar('a');
    lcd_wchar('l');
    lcd_wchar('l');
    lcd_wchar('o');
    // 2. Zeile 
    lcd_instr(LCD_ADR+64);
    lcd_wchar('H');
    lcd_wchar('a');
    lcd_wchar('l');
    lcd_wchar('l');
    lcd_wchar('o');
    printf("\n\nDisplay wird gel�scht....(Enter)\n");
    lcd_instr(LCD_CLR);
    lcd_write_str("Hallo DISPLAY!!");
    

    VB

    Call lcd_init
    lcd_backlight (1)
    lcd_write_str ("Hallo LCD!")
    txt = Space(25)
    temp = lcd_read_str(10, 0, txt)
    

    Perl

    print "LCD : Display Initialisieren..\n";
    i2c_ser::lcd_init();
    $licht = i2c_ser::lcd_backlight(1);
    print "LCD : Licht an \n";
    i2c_ser::lcd_instr(0x0c);
    print "LCD : Cursor Off \n";
    $lcdadr=i2c_ser::lcd_get_adress();
    print "LCD : Der Cursor ist jetzt an Adresse $lcdadr \n";
    i2c_ser::lcd_wchar(ord(H));
    i2c_ser::lcd_wchar(ord(a));
    i2c_ser::lcd_wchar(ord(l));
    i2c_ser::lcd_wchar(ord(l));
    i2c_ser::lcd_wchar(ord(o));
    $lcdadr=i2c_ser::lcd_get_adress();
    print "LCD : Der Cursor ist jetzt an Adresse $lcdadr \n";
    i2c_ser::lcd_instr(0x01);
    i2c_ser::lcd_write_str("Hallo Display");
    print "LCD : Ausgabe mit lcd_write_str  \n";
    

    int lcd_instr (int cmd)

    Sendet das Kommando cmd an das Display.

    int lcd_wchar (int cchar)

    Sendet das Zeichen cchar an das Display.

    int lcd_rchar (int cchar,int pos)

    Liest ein Zeichen cchar vom Display von LCD Position ein.

    C    : lcd_rchar(&cchar,0);
    VB   : lcd_rchar(cchar,0)
    Perl : my $rchar=chr(i2c_ser::lcd_rchar(0));
    

    int lcd_write_str (int *lstr)

    Schreibt einen String *lstr auf das LCD.

    C    : lcd_write_str("Hallo DISPLAY!!");
    VB   : lcd_write_str ("Hallo LCD!")
    Perl : i2c_ser::lcd_write_str("Hallo Display");
    

    char *lcd_read_str (int len,int pos)

    Liest einen String in lstr, von Adresse pos, mit len Anzahl Zeichen vom Display.

    C    : printf("String : %s \n",lcd_read_str(10,0));
    VB   : Dim txt As String
           txt = Space(25)
           temp = lcd_read_str(10, 0, txt)
    Perl : my $rstr=i2c_ser::lcd_read_str(15,0);
    

    int lcd_backlight(int cmd)

    Schaltet, sofern vorhanden, die LCD Beleuchtung ein oder aus.
    0 Licht aus, 1 Licht an.

    int lcd_get_adress(void)

    Liest die aktuelle Adresse aus dem Display. R�ckgabe,
    aktuelle Cursor-Adresse.

    I2C LC Display

    Elektor, I2C Bus angewandt, S. 117, aber andere Anschlussbelegung


    PCF8591 , AD/DA Wandler

    Per default wird hier die Startadresse 144 verwendet , d.h. adr = 0.

    int pcf8591_init(pcf8591 *sp,int ChanMode,float ref)

    Initialisert den PCF. ChanMode kann folgende Werte annehmen:

    #define PCF8591_C4S	  0		// 4 Eing.
    #define PCF8591_C3D	 16		// 3 Dif. Eing.	
    #define PCF8591_C2S	 32		// 2 SE / 2 Dif. Eing.	
    #define PCF8591_C2D	 48		// 2 Dif. Eing.	
    ...
    test = pcf8591_init(&adda,PCF8591_C4S,2.55000); // Daten initialisieren Datenstruktur, ChanMode , REFub
    
    Perl:
    i2c_ser::pcf8591_init($ptr,$pcf8591_mode,$pcf8591_ref_UB);
    # Initialisiert den Wandler.
    # Mode : 0 = 4x Eing. , 16 3x Dif, 32 2 xSE 2xDif, 48 2x Dif
    
    VB:
    Initialiserung Mode , RefUB . RefUB ist bei VB in mV !
    Dim Temp
    Temp = ad_pcf8591_init(0, 2560)
    

    pcf8591_readchan(pcf8591 *sp,int Kanal,int adr)

    Liest einen Wert von Kanal ein. Adr. ist PCF Adresse.

    C
    test  = pcf8591_readchan(&adda,0,adresse);
    
    Perl:
     $chan = i2c_ser::pcf8591_readchan($ptr,$Kanal,$Adr);
     
    VB:
    ' Liest den Wert von AD-Kanal 1, PCF-Adresse = 144
    AD = ad_pcf8591_readchan(1, 0) 
    

    int pcf8591_read4chan(pcf8591 *sp,int adr)

    Liest alle Kanäle.

    C
    test  = pcf8591_read4chan(&adda,adresse);
    printf(" data 0    : %d  \n",adda.data[0]);
    printf(" data 1    : %d  \n",adda.data[1]);
    ...
    
    Perl
    # Liest Alle 4 Kanaele aus. Rueckgabe Array.
    @Kanaele = i2c_ser::pcf8591_read4chan($ptr,adr_of);
          
    VB: nicht vorhanden
    

    pcf8591_setda(pcf8591 *sp, float da_out,int adr)

    Setzt den DA-Wandler auf den Wert da_out.

    C
    ubval = 0.010;  
    test  = pcf8591_setda(&adda,ubval,adresse);
    
    Perl
    # Setzt den Ausgang des DA Wandlers auf $ubval.
    i2c_ser::pcf8591_setda($ptr,$ubval,adr_of);
    
    VB
    ' Ausgang in mV 
    Temp = ad_pcf8591_setda(DaWert, 700)
    

    float pcf8591_aout(pcf8591 *sp,int Kanal)

    Gibt den berechneten Wert in V zurück.

    C
    printf(" data 0    : %d \t    %2.3fV\n",adda.data[0],pcf8591_aout(&adda,0));
    
    Perl
    # Berechnet f�r den $Kanal den Wert in Volt.
    $chan = i2c_ser::pcf8591_aout($ptr,$Kanal)
    
    VB
    aout in mV , nur VB
    aout = ad_pcf8591_aout(1)
    

    PLL TSA5511

    Per default wird hier die Startadresse 192 verwendet , d.h. adr = 0.

    tsa5511_init(tsa_struc *sp,int Mode,long Quarz)

    Initialisert die PLL mit Mode und der QuarzReferenzfrequenz. Mode ist folgenderma�en vordefiniert, kann aber auch beliebige Werte annehmen:

    #define TSA5511_PLL	206	// PLL , CP , Step 100 KHz
    #define TSA5511_DIV	238	// Testmode , Teiler
    test = tsa5511_init(&tsa5511,TSA5511_PLL,4000000);  // Daten initialisieren Datenstruktur,
    
    Perl
    # Initialisiert die PLL.Ist $Quarz = 0 , wird def. 4,00 Mhz sonst $Quarz
    # mode' PLL (206).
    i2c_lpt::tsa5511_init($ptr5511,$tsa5511_mode,$Quarz)
    
    VB
    InitTSA = pll_tsa5511_init(206,0)
    

    tsa5511_calc(tsa_struc *sp,long Freq,int dstep)

    Berechnet die Teilerfaktoren in *sp , R�ckgabe Teiler , dstep = 0 62,5KHz, 1 = 125KHz

    long f = 106900000;
    test  = tsa5511_calc(&tsa5511,f,1);		// Berechnen der Teiler
    printf("Freq: %ld , Teiler n %d , Fres: %d\n",f,test,(test*TSA5511_STEP));
    
    Perl
    # Berechnet fuer $frequenz die Teiler.
    # Bei $double_step = 1 , Schrittweite 125KHz (bei 4 MHz Quarz)
    i2c_lpt::tsa5511_calc($ptr5511,$frequenz,$double_step)
            
    VB
    calc_div = pll_tsa5511_calc(Freq, 0)
    fres = calc_div * 0.0625
    

    tsa5511_send(tsa_struc *sp,int Adr)

    Sendet die Daten an die PLL, Adr 0,2,4,6

    int Adresse = 0;
    tsa5511_send(&tsa5511,Adresse);
    
    Perl
    i2c_lpt::tsa5511_send($ptr5511,$adr)
    
    VB
    pll_tsa5511_send (Adresse)
    
    

    tsa5511_read(int Adr)

    Liest StatusByte, BIT gesetzt PLL locked.


    PLL SDA3302

    Per default wird hier die Startadresse 192 verwendet , d.h. adr = 0.

    sda3302_init(tsa_struc *sp,int Mode)

    Initialisert die PLL mit Mode. Die Funktionen sind ansonsten identisch mit TSA5511.
    Lediglich das auslesen des Statusbytes wird vom SDA nicht unterstützt.


    PLL TSA5523

    Per default wird hier die Startadresse 192 verwendet , d.h. adr = 0.

    tsa5523_init(tsa_struc *sp,int Mode)

    Initialisert die PLL mit Mode.Mit Mode kann neben der Funktion Teiler/PLL auch der Referenz Teiler eingestellt werden. Die Funktionen sind ansonsten identisch mit TSA5511.

    #define TSA5523_PLL	200		// PLL , CP , Step 50 KHz
    #define TSA5523_DIV	238		// Testmode 
    test = tsa5523_init(&tsa5523,TSA5523_PLL);  // Daten initialisieren Datenstruktur,
    

    PLL TSA6057

    Per default wird hier die Startadresse 196 verwendet , d.h. adr = 0.

    int tsa6057_init(tsa6057 *sp,int Raster,int Mode)

    Initialisert die PLL mit Mode und Raster.

    #define TSA6057_AM	16		// AM 
    #define TSA6057_FM	32		// FM
    #define TSA6057_R01	0		// Raster 1 KHz
    #define TSA6057_R10	64		// Raster 10 KHz
    #define TSA6057_R25	128		// Raster 25 KHz
    
    test = tsa6057_init(&tsa,TSA6057_FM,TSA6057_R10); // Daten initialisieren Datenstruktur
    
    Perl
    # Initialisiert die PLL. Raster legt das Raster Fest. Mode AM | FM.
    i2c_ser::tsa6057_init($ptr,$RASTER,$MODE);
    
    VB
    temp = pll_tsa6057_init(Mode,Raster) also z.B. temp = pll_tsa6057_init(32,128)
    

    int tsa6057_calc(tsa6057 *sp,long Freq,int Raster)

    Berechnet die Teilerfaktoren in *sp , R�ckgabe Teiler

    C
    test  = tsa6057_calc(&tsa,f,TSA6057_R10);
    
    Perl
    # Berechnet fuer $frequenz die Teiler.
    $teiler = i2c_ser::tsa6057_calc($ptr,$frequenz,$RASTER);
    
    VB
    teiler = pll_tsa6057_calc(freq,raster)
    

    int tsa6057_send(int Adr)

    Sendet die Daten an die PLL.

    C
    test  = tsa6057_send(&tsa,0);
    
    Perl
    # Sendet die Teiler zur PLL.  adr_offset 0 | 2
    i2c_ser::tsa6057_send($ptr,$adr_offset);
    
    VB
    temp = pll_tsa6057_send(0)
    

    PLL TBB200

    Per default wird hier die Startadresse 196 verwendet, d.h. adr = 0 = SingleModus

    tbb200_init(tbb200 *sp,int Mode,long RefQ,int prescale)

    Initialisert die PLL mit Mode. Mode = 0 ist SingleModulus, = 2 ist DualModulus
    RefFrequenz in Hz ,Vorteiler = 1 wenn SingleMod.

    C
    test = tbb200_init(&tbb2,TBB200_SINGLE,ref,1);  // Daten initialisieren Datenstruktur
    
    Perl
    my $Mode  =  0;	# Single 1 / Dual 2
    my $RefQ  =  6000000;	# 6MHz
    my $Step  =    25000;	# 25 KHz
    my $Freq  = 41000000;	# 43 MHz 
    my $Prescale = 0;	
    my $r=i2c_ser::tbb200_init($ptr,$Mode,$RefQ,$Prescale);
    
    VB
    Step = 25000
    FREF = 6000000#
    prescale = 1
    temp = pll_tbb200_init(Mode, FREF, prescale)
    

    tbb200_calc(tbb200 *sp,long Step,long Freq)

    Berechnet die Teiler.

    tbb200_send_status(tbb200 *sp,int status)

    Sendet das StatusByte status an die PLL.

    tbb200_send_n(tbb200 *sp)

    Sendet den N-Teiler an die PLL. Bei DualModulus Betrieb N&A Teiler.

    tbb200_send_r(tbb200 *sp)

    Sendet den R-Teiler an die PLL.

    
    test = tbb200_calc(&tbb2,step,f);
    test = tbb200_send_status(&tbb2,0);
    test = tbb200_send_r_cnt(&tbb2);
    test = tbb200_send_n_cnt(&tbb2);
    test = tbb200_send_status(&tbb2,248);
    
    Perl
    $r = i2c_ser::tbb200_send_status($ptr,$Status);
    $r = i2c_ser::tbb200_send_r_cnt($ptr);
    $r = i2c_ser::tbb200_send_n_cnt($ptr);
    
    VB
    temp = pll_tbb200_init(Mode, FREF, prescale)
    temp = pll_tbb200_calc(Step, fres)
    temp = pll_tbb200_send_status(Status_Init)
    temp = pll_tbb200_send_r_cnt()
    temp = pll_tbb200_send_n_cnt()
    Status_Init = 248: Rem status
    temp = pll_tbb200_send_status(Status_Init)
    

    © Ingo Gerlach, DH1AAD, 24.05.2002
    E-Mail bitte an:Ingo Gerlach
    website-hit-counters.com
    Provided by website-hit-counters.com site.