GPIB Speisung

#4133481
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 ?
Gast #4133495
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.
Gast #4149402
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.
1
uchar GPIB_Command[40]= ("OUT 1\n");
2
uchar GPIB_gucDevice_Address[40] = ("GPIB0::1::INSTR\n");
3
uchar GPIB_VSET[40] = ("VSET 3V\n");
1
G_ATN = OUTPUT_PUSHPULL; // Bit runterziehen
2
        P_SIGNAL_OUT &=~ ATN;
3
        G_EOI = INPUT_NO_PULL; // Bit loslassen
4
        
5
          uebergeben = 1;
6
        for(int x = 0; uebergeben!= 0; x++)
7
        {
8
           uebergeben = GPIB_gucDevice_Address[x];
9
           test = gpib_write_data(uebergeben);
10
           if(test == ERROR)
11
           {
12
             Write_String(0,1,(uchar*)"Fehler");
13
             break;
14
           }
15
           else
16
           {
17
             Write_String(0,1,(uchar*)"Okey");
18
           }
19
        }
20

21
        G_ATN = OUTPUT_PUSHPULL; // Bit runterziehen
22
        P_SIGNAL_OUT |= ATN;
23

24
        uebergeben = 1;
25

26
         for(int x = 0; uebergeben!= 0; x++)
27
         {
28
           uebergeben = GPIB_Command[x];
29
           if (uebergeben != 0)
30
           {
31
           test = gpib_write_data(uebergeben);
32
           if(test == ERROR)
33
           {
34
             Write_String(0,2,(uchar*)"Fehler");
35
             break;
36
           }
37
           else
38
           {
39
             Write_String(0,2,(uchar*)"Okey");
40
           }
41
           }
42
         }
43

44

45
        uchar ucLength = 0;
46
        uchar i = 0;
47
            ucLength = 0xFF;
48
            for (i = 0; ucLength == 0xFF; i ++)
49
            {
50
              uebergeben = GPIB_VSET[i];
51
                if (uebergeben == 0)
52
                {
53
                    ucLength = i;
54
                }
55
            }
56

57
            for (i = 0; ucLength != 0; ucLength -- )
58
            {
59

60
              uebergeben = GPIB_VSET[i] ;
61
                test = gpib_write_data(uebergeben);
62
                if(test == ERROR)
63
                {
64
                    Write_String(0,3,(uchar*)"Fehler");
65
                    break;
66
                }
67
                i ++;
68
            }
69
            //Bei letztem Byte EOI = 0
70
            G_EOI = OUTPUT_PUSHPULL; // Bit runterziehen
71
            P_SIGNAL_OUT &=~EOI;
72

73
            //letztes Bit schreiben
74
            i ++;
75
            uebergeben = GPIB_VSET[i] ;
76
            test = gpib_write_data(uebergeben);
77
            if(test == ERROR)
78
            {
79
              Write_String(0,3,(uchar*)"Fehler");
80
            }
81
            else
82
            {
83
                Write_String(0,3,(uchar*)"Okey");
84
            }
85
}

1
uchar gpib_write_data(uchar c)
2
{
3
    uchar ucHandshakeValue;
4

5
    Variabel = c;
6
    //PORT3 - Datenleitungen - Alle INPUT
7
    G_DIO1 = INPUT_NO_PULL;
8
    G_DIO2 = INPUT_NO_PULL;
9
    G_DIO3 = INPUT_NO_PULL;
10
    G_DIO4 = INPUT_NO_PULL;
11
    G_DIO5 = INPUT_NO_PULL;
12
    G_DIO6 = INPUT_NO_PULL;
13
    G_DIO7 = INPUT_NO_PULL;
14
    G_DIO8 = INPUT_NO_PULL;
15

16
    if ((c&0x01))
17
    {
18
        G_DIO1 = OUTPUT_PUSHPULL; // Bit runterziehen
19
        P_DATA_OUT &=~ DIO1;
20
    } else
21
    {
22
        G_DIO1 = INPUT_NO_PULL; // Bit loslassen
23
    }
24

25
    if ((c&0x02))
26
    {
27
        G_DIO2 = OUTPUT_PUSHPULL;// Bit runterziehen
28
        P_DATA_OUT &=~ DIO2;
29
    }
30
    else
31
    {
32
        G_DIO2 = INPUT_NO_PULL; // Bit loslassen
33
    }
34

35
    if ((c&0x04))
36
    {
37
        G_DIO3 = OUTPUT_PUSHPULL; // Bit runterziehen
38
        P_DATA_OUT &=~ DIO3;
39
    } else
40
    {
41
        G_DIO3 = INPUT_NO_PULL; // Bit loslassen
42
    }
43

44
    if ((c&0x08))
45
    {
46
        G_DIO4 = OUTPUT_PUSHPULL; // Bit runterziehen
47
        P_DATA_OUT &=~ DIO4;
48
    } else
49
    {
50
        G_DIO4 = INPUT_NO_PULL; // Bit loslassen
51
    }
52

53
    if ((c&0x10))
54
    {
55
        G_DIO5 = OUTPUT_PUSHPULL; // Bit runterziehen
56
        P_DATA_OUT &=~ DIO5;
57
    } else
58
    {
59
        G_DIO5 = INPUT_NO_PULL; // Bit loslassen
60
    }
61

62
    if ((c&0x20))
63
    {
64
        G_DIO6 = OUTPUT_PUSHPULL; // Bit runterziehen
65
        P_DATA_OUT &=~ DIO6;
66
    } else
67
    {
68
        G_DIO6 = INPUT_NO_PULL; // Bit loslassen
69
    }
70

71
    if ((c&0x40))
72
    {
73
        G_DIO7 = OUTPUT_PUSHPULL; // Bit runterziehen
74
        P_DATA_OUT &=~ DIO7;
75
    }
76
    else
77
    {
78
        G_DIO7 = INPUT_NO_PULL; // Bit loslassen
79
    }
80

81
    if ((c&0x80))
82
    {
83
        G_DIO8 = OUTPUT_PUSHPULL; // Bit runterziehen
84
        P_DATA_OUT &=~ DIO8;
85
    }
86
    else
87
    {
88
        G_DIO8 = INPUT_NO_PULL; // Bit loslassen
89
    }
90

91
    G_NRFD = INPUT_NO_PULL; // Bit loslassen
92

93
    G_NDAC = INPUT_NO_PULL; // Bit loslassen
94

95
    //Datenauf Buschreiben
96
    Datenrichtung |= Write_data; // Datenrichtung = Daten schreiben
97

98
    ucHandshakeValue = 0;
99
    uiErrorCounter = 0;
100
    ui10msCounter = guiTimer_10ms + 1;
101
    // Warten bis Gerät bereit ist für neue Daten - NRFD = 1
102
    while ((ucHandshakeValue == 0) && (uiErrorCounter <= 100))
103
    {
104
    //  Wenn NRFD laenger als 1 Sekunde nicht = 0, dann Error
105
        ucHandshakeValue = ((P_SIGNAL >> 0x02) & 0x01);
106
        if (guiTimer_10ms  >= ui10msCounter)
107
        {
108
      uiErrorCounter ++;
109
      ui10msCounter = guiTimer_10ms + 1;
110
      if (uiErrorCounter >= 100 )
111
      {
112
        return ERROR;
113
      }
114
        }
115
    }
116
    //DAV = 1
117
    G_DAV = OUTPUT_PUSHPULL; // Bit runterziehen
118
    P_SIGNAL_OUT &=~ DAV;
119

120

121
    G_NDAC = INPUT_NO_PULL; // Bit loslassen
122

123
    ucHandshakeValue = 0;
124
    uiErrorCounter = 0;
125
    ui10msCounter = guiTimer_10ms + 1;
126
    //Warten bis Daten in Buffer gespeichert NDAC = 0
127
    while ((ucHandshakeValue == 0) && (uiErrorCounter <= 100))
128
    {
129
    //  Wenn NDAC laenger als 1 Sekunde nicht = 0, dann Error
130
        ucHandshakeValue = ((P_SIGNAL >> 0x03) & 0x01);// NDAC einlesen
131
        if (guiTimer_10ms  >= ui10msCounter)
132
        {
133
            uiErrorCounter ++; // uiErrorCounter alle 10ms hochzählen
134
            ui10msCounter = guiTimer_10ms + 1;
135
            if (uiErrorCounter >= 100 )
136
            {
137
                return ERROR;   //Nach 1 Sekunde Error zurückgeben
138
            }
139
        }
140

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

145
    //Warten bis Daten akzeptiert NDAC = 0
146
    ucHandshakeValue = 1;
147
    uiErrorCounter = 0;
148
    ui10msCounter = guiTimer_10ms + 1;
149
    while ((ucHandshakeValue == 1) && (uiErrorCounter <= 100))
150
    {
151
        ucHandshakeValue = ((P_SIGNAL >> 0x03) & 0x01);
152
        if (guiTimer_10ms  >= ui10msCounter)
153
        {
154
            uiErrorCounter ++;
155
            ui10msCounter = guiTimer_10ms + 1;
156
            if (uiErrorCounter >= 100 )
157
            {
158
                gucError = 1;
159
                return ERROR;
160
            }
161
        }
162
    }
163
    Datenrichtung = Datenrichtung &  ~Read_data; // Datenrichtung = Daten lesen
164
    //PORT3 - Datenleitungen alle Input setzen
165
    G_DIO1 = INPUT_NO_PULL;
166
    G_DIO2 = INPUT_NO_PULL;
167
    G_DIO3 = INPUT_NO_PULL;
168
    G_DIO4 = INPUT_NO_PULL;
169
    G_DIO5 = INPUT_NO_PULL;
170
    G_DIO6 = INPUT_NO_PULL;
171
    G_DIO7 = INPUT_NO_PULL;
172
    return 1 ;
173
}
Gast #4149593
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.
#4149727
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

Antwort schreiben

Eine eigene Frage? Dieser Thread ist über 11 Jahre alt. Stell sie in einem eigenen Thread – dort lesen mehr Leute mit, und sie wird öfter und schneller beantwortet.

Neuen Thread starten

Eine Lösung, Ergänzung oder Rückmeldung zu diesem Thread? Dann antworte hier.

Formatierung
  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] – Link zu einem Artikel
  • Verweis auf einen anderen Beitrag: Rechtsklick auf dessen Beitrags-ID (#8078628), „Adresse kopieren“, in den Text einfügen

Mehr zur Formatierung

Längeren Sourcecode als Anhang, nicht in den Text. JPG nur für Fotos und Scans; Zeichnungen und Screenshots als PNG oder GIF. Siehe Bildformate.

Schon registriert? Anmelden

Wird nicht angezeigt. Wir schicken dir einen Link; sobald du damit bestätigst, erscheint dein Beitrag.

Mit dem Abschicken legst du einen kostenlosen Account an und erkennst die Nutzungsbedingungen und die Datenschutzerklärung an.