BusPirate schießt I2C

[Patrik K. (pakr)]

Hi,

ich bin gerade dabei mit dem BusPirat eine I2C anwendung zu entwickeln 
auf dem PIC24F128.

Irgendwie habe ich den verdacht das der BusPirate mir meinen zweiten PIC 
gekillt hat. Wie kann man den PIC davor bewaren. Oder schafft es ein 
Ossi (Oszilloskop, kein neudeutscher ;-)), den PIC zu grillen. betroffen 
ist die I2C2 schnittstelle. die tuts nicht mehr.

gruß


pakr

[Lehrmann M. (ubimbo)]

Das kann ich mir beim besten Willen nicht vorstellen ! Ich sag 
ausgeschlossen.

Es liegt garantiert an der Software bzw. der Beschaltung. Darum das mal 
posten.

[Patrik K. (pakr)]

Lehrmann Michael schrieb:
> Das kann ich mir beim besten Willen nicht vorstellen ! Ich sag
> ausgeschlossen.
>
> Es liegt garantiert an der Software bzw. der Beschaltung. Darum das mal
> posten.

hier auszüge aus dem schaltplan.

[Patrik K. (pakr)]

Lehrmann Michael schrieb:
> Das kann ich mir beim besten Willen nicht vorstellen ! Ich sag
> ausgeschlossen.
>
> Es liegt garantiert an der Software bzw. der Beschaltung. Darum das mal
> posten.

Und hier der Auszug aus dem Code. Die initialisierung der I2C erfolgt 
woanders.

void Server(void)
{
  
  unsigned char   v1,v2,v3,address,adcval;
  unsigned int j;
  
  WORD w, w2;
  BYTE i,AppBuffer[32];
  char    DataBytes[2] ;
    
  BYTE Error_Command[16] =  "Error Command!\r\n";
  BYTE Error_Command2[16] = "Error Mode\r\n"; 
  BYTE Info[15] = "TCP vers 0.1\r\n"; 
  WORD wMaxGet, wMaxPut, wCurrentChunk;
  static TCP_SOCKET  MySocket;
  static enum _TCPServerState
  {
    SM_HOME = 0,
    SM_LISTENING,
  } TCPServerState = SM_HOME;

  switch(TCPServerState)
  {
    case SM_HOME:
      // Allocate a socket for this server to listen and accept connections on
      MySocket = TCPOpen(0, TCP_OPEN_SERVER, SERVER_PORT, TCP_PURPOSE_GENERIC_TCP_SERVER);
      if(MySocket == INVALID_SOCKET)
        return;

      TCPServerState = SM_LISTENING;
      break;

    case SM_LISTENING:
      // See if anyone is connected to us
      if(!TCPIsConnected(MySocket))
        return;


      // Figure out how many bytes have been received and how many we can transmit.
      wMaxGet = TCPIsGetReady(MySocket);  // Get TCP RX FIFO byte count
      wMaxPut = TCPIsPutReady(MySocket);  // Get TCP TX FIFO free space

      // Make sure we don't take more bytes out of the RX FIFO than we can put into the TX FIFO
      if(wMaxPut < wMaxGet)
        wMaxGet = wMaxPut;

      // Process all bytes that we can
      // This is implemented as a loop, processing up to sizeof(AppBuffer) bytes at a time.  
      // This limits memory usage while maximizing performance.  Single byte Gets and Puts are a lot slower than multibyte GetArrays and PutArrays.
      wCurrentChunk = sizeof(AppBuffer);

      
    
      for(w = 0; w < wMaxGet; w += sizeof(AppBuffer))
      {
        // Make sure the last chunk, which will likely be smaller than sizeof(AppBuffer), is treated correctly.
        if(w + sizeof(AppBuffer) > wMaxGet)
          wCurrentChunk = wMaxGet - w;

        // Transfer the data out of the TCP RX FIFO and into our local processing buffer.
        TCPGetArray(MySocket, AppBuffer, wCurrentChunk);
        
        for(w2 = 0; w2 < wCurrentChunk; w2++)
        {
          i = AppBuffer[w2];
          if(i >= 'a' && i <= 'z')
          {
            i -= ('a' - 'A');
            AppBuffer[w2] = i;
          }
        }
        
        if (AppBuffer[0]=='S'){
          //     0    1          2    3 4        5            6            7           8      9
          //    [S] [D]  [A|B|C|D] 0 X  [0..9|A..F] [0..9|A..F] [0..9|A..F][1|2|3|e][P] --> SDA0XFFF1P
          //
          //     0    1          2    3 4        5            6            7           8      9
          //    [S] [E]  [A|B|C|D] 0 X  [0..9|A..F] [0..9|A..F] [0..9|A..F][1|2|3|e][P] --> SDA0XFFF2P
          //  

          switch(AppBuffer[1]) {
            case 'D': 
            switch(AppBuffer[2]){
              case 'A':  address = 0xc0;  break;
              case 'B': address = 0xc2;  break;
              case 'C': address = 0xc4;  break;
              case 'D': address = 0xc6;  break;
            }
            // Convert Value from Ascii to HEX
            v2 =getHex(AppBuffer[6],AppBuffer[7]);
            v1 =getHex('0',AppBuffer[5]);
            
            if(AppBuffer[9]!='P'){
              v1=v1|((AppBuffer[8]-0x30)<<4);
            }
            //Start I2C2
            StartI2C2();
            IdleI2C2();
            
            while(I2C2CONbits.SEN );
                
            MasterWriteI2C2(address);
            IdleI2C2();
            while(I2C2STATbits.ACKSTAT); 
            for(j=0;j<100;j++);  
            IdleI2C2();  
              
            
            MasterWriteI2C2(v1);
            while(I2C2STATbits.ACKSTAT);  
            for(j=0;j<100;j++); 
            IdleI2C2();
                
            MasterWriteI2C2(v2);
            for(j=0;j<100;j++); 
            IdleI2C2();
                
                 
            StopI2C2();
          break;
           
            case 'A': 
                
            //ADC - MODE 
            if (AppBuffer[2]>=0x30 && AppBuffer[2]<=0x37){
              ADC_VAL.sel =  (AppBuffer[2] - 0x30);
            }else{
              break;
            }
            //Full-Scale
            if (AppBuffer[3]=='F'){
              ADC_VAL.rng = 1;
            }else{
              ADC_VAL.rng = 0;
            }
            //Bipolar Unipolar
            if (AppBuffer[3]=='B'||AppBuffer[4]=='B'){
              ADC_VAL.bip =1;
            }else{
              ADC_VAL.bip =0;
            }
            //POWER MODE, Standby, FullDown or Working
            if (AppBuffer[3]=='S'||AppBuffer[4]=='S'||AppBuffer[5]=='S'){
              ADC_VAL.pd1 =0;
              ADC_VAL.pd0 =1;
            }else if(AppBuffer[3]=='D'||AppBuffer[4]=='D'||AppBuffer[5]=='D'){
              ADC_VAL.pd1 =1;
              ADC_VAL.pd0 =1;                
            }else{
              ADC_VAL.pd1 =0;
              ADC_VAL.pd0 =0;                
            }
            ADC_VAL.start=1;
            adcval =ADC_VAL.byte;
            //WRITE 
            StartI2C2();
            IdleI2C2();
            
            while(I2C2CONbits.SEN );
            MasterWriteI2C2(0x50);
            IdleI2C2();
            
            while(I2C2STATbits.ACKSTAT); 
            for(j=0;j<100;j++);  
            IdleI2C2();  
            
            MasterWriteI2C2(adcval);
            while(I2C2STATbits.ACKSTAT);  
            for(j=0;j<100;j++); 
            IdleI2C2();
            StopI2C2();
              
            for(j=0;j<100;j++);
            IdleI2C2();
            StartI2C2();
            
              //READ  
            MasterWriteI2C2(0x51);
            for(j=0;j<100;j++); 
            while(I2C2STATbits.ACKSTAT);
            
            DataBytes[0] = MasterReadI2C2();    // Read first data byte
                
            AckI2C2();
            DataBytes[1] = MasterReadI2C2();    // Read secound data byte

                
            StopI2C2();
          break;
                
            case 'I':  TCPPutArray(MySocket, Info, 15);break;
          default:  TCPPutArray(MySocket, Error_Command2, 11);
          }// END SWITCH CASSE
        
        }else{
          AppBuffer[0]== 0x00;
          TCPPutArray(MySocket, Error_Command, 16);
        }
      }



      break;
  }
}

gruß

pakr

[Peter D. (peda)]

Pa Kr schrieb:
> Oder schafft es ein
> Ossi (Oszilloskop, kein neudeutscher ;-)), den PIC zu grillen.

Durchaus.
Ein Oszi ist in der Regel geerdet.
Wenn dann irgendein Netzteil nicht richtig trennt oder der Schutzleiter 
unterbrochen ist, dann machts kurz mal Britzel, wenn Du das Oszi 
anklemmst.


Peter

[Patrik K. (pakr)]

Peter Dannegger schrieb:
> Pa Kr schrieb:
>> Oder schafft es ein
>> Ossi (Oszilloskop, kein neudeutscher ;-)), den PIC zu grillen.
>
> Durchaus.
> Ein Oszi ist in der Regel geerdet.
> Wenn dann irgendein Netzteil nicht richtig trennt oder der Schutzleiter
> unterbrochen ist, dann machts kurz mal Britzel, wenn Du das Oszi
> anklemmst.
>
>
> Peter

sowas hatte ich schon in verdacht, aber es hängt alles am selben netz. 
ebend habe ich die schutzleiter gegeneinander durchgemessen, 0V. alles 
i.o.

das ist alles wieder seltsam. ich versuche es erstmal mit 10k pullups. 
im forum von microchip gab es ein paar andeutungen das es mit zu kleinen 
probleme geben kann.


paka

[Patrik K. (pakr)]

JAP 10k und es läuft wieder deutlich flüssiger. aber in den 
spezifikationen von microhip ist angegeben 400kHz --> 1kOhm. egal es 
funzt soweit.

ABER der max 127 spielt nicht richtg mit. ansprechen und konfigurieren 
läßt er sich, aber wenn ich in auslesen will hängt er nach dem read.

nach dem ich eine pause zwischen dem write und read eingebaut hatte, 
kommt er zwar durch, also er ließt scheinbar 2 werte aus und ich bekomme 
auch daten. aber die clock leitung bleibt am ende down ?  selbst nach 
einem versuchten stop befehl?

hat da jamand eine ahnung, oder vielleicht erfahrungen mit dem max127?

gruß

paKr