GPIB Speisung

[Rebi (Gast)]

Hallo ich möchte Spannungswerte zu folgender Speisung schicken.

https://www.ntecusa.com/docs/xantrex_xhr_xfr_xfr3_users.pdf

Dort steht mit VSET 3.0 setzt man die Spannung auf 3V.
Schreibe ich das auf die Datenleitungen? und wenn ja reicht das?

[m.n. (Gast)]

Rebi schrieb:
> Schreibe ich das auf die Datenleitungen?

Woran dachtest Du denn? Mit einem Filzstift?

[Pandur S. (jetztnicht)]

Wenn du keine Ahnung von GPIB hast, auch nicht die noetigen 500 Euro 
fuer einen Adapter hast, dich auch nicht einarbeiten willst, empfehle 
ich ein modernes Powersupply mit einem anderen Interface.
Oder gibt es einen speziellen Grund dieses zu verwenden ?

[Rebi (Gast)]

Jetzt Nicht schrieb:
> Wenn du keine Ahnung von GPIB hast, auch nicht die noetigen 500 Euro
> fuer einen Adapter hast, dich auch nicht einarbeiten willst, empfehle
> ich ein modernes Powersupply mit einem anderen Interface.
> Oder gibt es einen speziellen Grund dieses zu verwenden ?

Wir haben einen Adapter mit dem man Speisungen einstellen kann. Also 
z.B. ein Rechteck von 10V/7s erzeugen. Jedoch geht dies aktuell nur für 
eine Speisung ich möchte die Software jetzt erweitern das auch die oben 
angegeben Speisung angesteuert werden kann.

[Rebi (Gast)]

Ich hab bis jetzt diesen Code hier:
Zuerst will ich die Adresse erkennen, dann die Speisung einstellen und 
die 3V ausgeben, doch beim Einschalten der Speisung kommt ein Fehler. 
Beim Handshake wird NDAC nicht auf 0 gezogen. Dankbar über jeden Tipp.

uchar GPIB_Command[40]= ("OUT 1\n");
uchar GPIB_gucDevice_Address[40] = ("GPIB0::1::INSTR\n");
uchar GPIB_VSET[40] = ("VSET 3V\n");

G_ATN = OUTPUT_PUSHPULL; // Bit runterziehen
        P_SIGNAL_OUT &=~ ATN;
        G_EOI = INPUT_NO_PULL; // Bit loslassen
        
          uebergeben = 1;
        for(int x = 0; uebergeben!= 0; x++)
        {
           uebergeben = GPIB_gucDevice_Address[x];
           test = gpib_write_data(uebergeben);
           if(test == ERROR)
           {
             Write_String(0,1,(uchar*)"Fehler");
             break;
           }
           else
           {
             Write_String(0,1,(uchar*)"Okey");
           }
        }

        G_ATN = OUTPUT_PUSHPULL; // Bit runterziehen
        P_SIGNAL_OUT |= ATN;

        uebergeben = 1;

         for(int x = 0; uebergeben!= 0; x++)
         {
           uebergeben = GPIB_Command[x];
           if (uebergeben != 0)
           {
           test = gpib_write_data(uebergeben);
           if(test == ERROR)
           {
             Write_String(0,2,(uchar*)"Fehler");
             break;
           }
           else
           {
             Write_String(0,2,(uchar*)"Okey");
           }
           }
         }


        uchar ucLength = 0;
        uchar i = 0;
            ucLength = 0xFF;
            for (i = 0; ucLength == 0xFF; i ++)
            {
              uebergeben = GPIB_VSET[i];
                if (uebergeben == 0)
                {
                    ucLength = i;
                }
            }

            for (i = 0; ucLength != 0; ucLength -- )
            {

              uebergeben = GPIB_VSET[i] ;
                test = gpib_write_data(uebergeben);
                if(test == ERROR)
                {
                    Write_String(0,3,(uchar*)"Fehler");
                    break;
                }
                i ++;
            }
            //Bei letztem Byte EOI = 0
            G_EOI = OUTPUT_PUSHPULL; // Bit runterziehen
            P_SIGNAL_OUT &=~EOI;

            //letztes Bit schreiben
            i ++;
            uebergeben = GPIB_VSET[i] ;
            test = gpib_write_data(uebergeben);
            if(test == ERROR)
            {
              Write_String(0,3,(uchar*)"Fehler");
            }
            else
            {
                Write_String(0,3,(uchar*)"Okey");
            }
}

uchar gpib_write_data(uchar c)
{
    uchar ucHandshakeValue;

    Variabel = c;
    //PORT3 - Datenleitungen - Alle INPUT
    G_DIO1 = INPUT_NO_PULL;
    G_DIO2 = INPUT_NO_PULL;
    G_DIO3 = INPUT_NO_PULL;
    G_DIO4 = INPUT_NO_PULL;
    G_DIO5 = INPUT_NO_PULL;
    G_DIO6 = INPUT_NO_PULL;
    G_DIO7 = INPUT_NO_PULL;
    G_DIO8 = INPUT_NO_PULL;

    if ((c&0x01))
    {
        G_DIO1 = OUTPUT_PUSHPULL; // Bit runterziehen
        P_DATA_OUT &=~ DIO1;
    } else
    {
        G_DIO1 = INPUT_NO_PULL; // Bit loslassen
    }

    if ((c&0x02))
    {
        G_DIO2 = OUTPUT_PUSHPULL;// Bit runterziehen
        P_DATA_OUT &=~ DIO2;
    }
    else
    {
        G_DIO2 = INPUT_NO_PULL; // Bit loslassen
    }

    if ((c&0x04))
    {
        G_DIO3 = OUTPUT_PUSHPULL; // Bit runterziehen
        P_DATA_OUT &=~ DIO3;
    } else
    {
        G_DIO3 = INPUT_NO_PULL; // Bit loslassen
    }

    if ((c&0x08))
    {
        G_DIO4 = OUTPUT_PUSHPULL; // Bit runterziehen
        P_DATA_OUT &=~ DIO4;
    } else
    {
        G_DIO4 = INPUT_NO_PULL; // Bit loslassen
    }

    if ((c&0x10))
    {
        G_DIO5 = OUTPUT_PUSHPULL; // Bit runterziehen
        P_DATA_OUT &=~ DIO5;
    } else
    {
        G_DIO5 = INPUT_NO_PULL; // Bit loslassen
    }

    if ((c&0x20))
    {
        G_DIO6 = OUTPUT_PUSHPULL; // Bit runterziehen
        P_DATA_OUT &=~ DIO6;
    } else
    {
        G_DIO6 = INPUT_NO_PULL; // Bit loslassen
    }

    if ((c&0x40))
    {
        G_DIO7 = OUTPUT_PUSHPULL; // Bit runterziehen
        P_DATA_OUT &=~ DIO7;
    }
    else
    {
        G_DIO7 = INPUT_NO_PULL; // Bit loslassen
    }

    if ((c&0x80))
    {
        G_DIO8 = OUTPUT_PUSHPULL; // Bit runterziehen
        P_DATA_OUT &=~ DIO8;
    }
    else
    {
        G_DIO8 = INPUT_NO_PULL; // Bit loslassen
    }

    G_NRFD = INPUT_NO_PULL; // Bit loslassen

    G_NDAC = INPUT_NO_PULL; // Bit loslassen

    //Datenauf Buschreiben
    Datenrichtung |= Write_data; // Datenrichtung = Daten schreiben

    ucHandshakeValue = 0;
    uiErrorCounter = 0;
    ui10msCounter = guiTimer_10ms + 1;
    // Warten bis Gerät bereit ist für neue Daten - NRFD = 1
    while ((ucHandshakeValue == 0) && (uiErrorCounter <= 100))
    {
    //  Wenn NRFD laenger als 1 Sekunde nicht = 0, dann Error
        ucHandshakeValue = ((P_SIGNAL >> 0x02) & 0x01);
        if (guiTimer_10ms  >= ui10msCounter)
        {
      uiErrorCounter ++;
      ui10msCounter = guiTimer_10ms + 1;
      if (uiErrorCounter >= 100 )
      {
        return ERROR;
      }
        }
    }
    //DAV = 1
    G_DAV = OUTPUT_PUSHPULL; // Bit runterziehen
    P_SIGNAL_OUT &=~ DAV;


    G_NDAC = INPUT_NO_PULL; // Bit loslassen

    ucHandshakeValue = 0;
    uiErrorCounter = 0;
    ui10msCounter = guiTimer_10ms + 1;
    //Warten bis Daten in Buffer gespeichert NDAC = 0
    while ((ucHandshakeValue == 0) && (uiErrorCounter <= 100))
    {
    //  Wenn NDAC laenger als 1 Sekunde nicht = 0, dann Error
        ucHandshakeValue = ((P_SIGNAL >> 0x03) & 0x01);// NDAC einlesen
        if (guiTimer_10ms  >= ui10msCounter)
        {
            uiErrorCounter ++; // uiErrorCounter alle 10ms hochzählen
            ui10msCounter = guiTimer_10ms + 1;
            if (uiErrorCounter >= 100 )
            {
                return ERROR;   //Nach 1 Sekunde Error zurückgeben
            }
        }

    }
    // Release DAV = 0, Daten sind nun nicht mehr gültig
    G_DAV = INPUT_NO_PULL; // Bit loslassen

    //Warten bis Daten akzeptiert NDAC = 0
    ucHandshakeValue = 1;
    uiErrorCounter = 0;
    ui10msCounter = guiTimer_10ms + 1;
    while ((ucHandshakeValue == 1) && (uiErrorCounter <= 100))
    {
        ucHandshakeValue = ((P_SIGNAL >> 0x03) & 0x01);
        if (guiTimer_10ms  >= ui10msCounter)
        {
            uiErrorCounter ++;
            ui10msCounter = guiTimer_10ms + 1;
            if (uiErrorCounter >= 100 )
            {
                gucError = 1;
                return ERROR;
            }
        }
    }
    Datenrichtung = Datenrichtung &  ~Read_data; // Datenrichtung = Daten lesen
    //PORT3 - Datenleitungen alle Input setzen
    G_DIO1 = INPUT_NO_PULL;
    G_DIO2 = INPUT_NO_PULL;
    G_DIO3 = INPUT_NO_PULL;
    G_DIO4 = INPUT_NO_PULL;
    G_DIO5 = INPUT_NO_PULL;
    G_DIO6 = INPUT_NO_PULL;
    G_DIO7 = INPUT_NO_PULL;
    return 1 ;
}

[Dirk B. (dirkb2)]

WAS für ein Interface hast du denn da?

Wenn du schon das ganze Protokoll per Hand machst, ist (meiner Meinung 
nach) das "GPIB0::1::INSTR" der völlig falsch Werte für die Adresse.

[Rebi (Gast)]

GPIB
Kann sein im Datenblatt habe ich kein Beispiel für die Adresse gefunden.
Ich habe mit einem USB-GPIB Converter über Keysight folgende Befehle 
geschickt:
GPIB0::1::INSTR
OUT 1
VSET 3V
Dies funktioniert, an der Speisung habe ich 3V. Daher dachte ich, ich 
könnte die Befehle übernehmen.

[Ralph B. (rberres)]

Irgendwie kommt mir dieses Programm verdammt aufwendig vor.

Ich schreibe unter HT-Basic exakt zwei Zeilen

10     ASSIGN @Gen TO 717
20     OUTPUT @Gen;"Vset 3V"

Gen ist ein willkürlicher Namen um dem Gerät einen Namen zu geben und 
ihm eine IECbus-Adresse in diesem Fall 17 zuzuweisen.

Man kann das sicher auch in eine Zeile bringen.

Ralph Berres