GPIB Speisung

Rebi Gast #4133495
Lesenswert?
• ▲
▼ 
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Rebi Gast #4149402
Lesenswert?
• ▲
▼ 
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
}


  





  

    Antwort Zitieren Bearbeiten Löschen Beitrag melden
  








      

      





      

      



  

    

      Rebi

    

      Gast


    

    
    #4149593
  




  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
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.

  





  

    Antwort Zitieren Bearbeiten Löschen Beitrag melden
  








      

      



  

    

      Ralph B.
      

    



    

    
    #4149727
  




  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
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 Zitieren Bearbeiten Löschen Beitrag melden
  









    

    

    

       Thread beobachten


    

    
        


Antwort schreiben











  


    
    
      

    
    
    

      

        Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt. Bitte hier nur auf die
        ursprüngliche Frage antworten, für neue Fragen einen
        neuen Beitrag erstellen.
      


    



    

    

      
      
      
      

  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.
      


      
    
        
      


      

      

    


      

        

          
Dein Name und deine E-Mail-Adresse

          
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.