Ardutester - Arduino Component Tester (INCOMPLETO)

Le resistenze di Paolo le ho viste. Erano fusi neri con il valore scritto sopra in numeri, se non ricordo male. Il tester però confermava il valore nominale.

Ciao Michele, non ho visto la domanda. :sweat_smile: Comunque le mie resistenze polacche sono tutte nere con la scritta sopra: 680R e 470K. Me le hanno date per resistenze con precisione allo 0.1%.

PaoloP: Ciao Michele, non ho visto la domanda. :sweat_smile: Comunque le mie resistenze polacche sono tutte nere con la scritta sopra: 680R e 470K. Me le hanno date per resistenze con precisione allo 0.1%.

una foto?

Al momento non mi è possibile. Domattina. ;)

PaoloP: Comunque le mie resistenze polacche sono tutte nere con la scritta sopra: 680R e 470K. Me le hanno date per resistenze con precisione allo 0.1%.

Ho acquistato anche io resistenze con precisione allo 0,1% qui da un distributore Svizzero (https://www.distrelec.ch/home) ... alcune sono normali altre, come quelle che descrivi tu, pur essendo da 0,5w sono dei bei barilotti neri con su scritto il valore ;)

Guglielmo

@Leo :

Sia che cerchi di modificare il post per allegare la foto, sia che cerchi di crearne uno nuovo con solo la foto, stà li un bel po' e poi .....

           `:;;;,`                      .:;;:.           
        .;;;;;;;;;;;`                :;;;;;;;;;;:     TM 
      `;;;;;;;;;;;;;;;`            :;;;;;;;;;;;;;;;      
     :;;;;;;;;;;;;;;;;;;         `;;;;;;;;;;;;;;;;;;     
    ;;;;;;;;;;;;;;;;;;;;;       .;;;;;;;;;;;;;;;;;;;;    
   ;;;;;;;;:`   `;;;;;;;;;     ,;;;;;;;;.`   .;;;;;;;;   
  .;;;;;;,         :;;;;;;;   .;;;;;;;          ;;;;;;;  
  ;;;;;;             ;;;;;;;  ;;;;;;,            ;;;;;;. 
 ,;;;;;               ;;;;;;.;;;;;;`              ;;;;;; 
 ;;;;;.                ;;;;;;;;;;;`      ```       ;;;;;`
 ;;;;;                  ;;;;;;;;;,       ;;;       .;;;;;
`;;;;:                  `;;;;;;;;        ;;;        ;;;;;
,;;;;`    `,,,,,,,,      ;;;;;;;      .,,;;;,,,     ;;;;;
:;;;;`    .;;;;;;;;       ;;;;;,      :;;;;;;;;     ;;;;;
:;;;;`    .;;;;;;;;      `;;;;;;      :;;;;;;;;     ;;;;;
.;;;;.                   ;;;;;;;.        ;;;        ;;;;;
 ;;;;;                  ;;;;;;;;;        ;;;        ;;;;;
 ;;;;;                 .;;;;;;;;;;       ;;;       ;;;;;,
 ;;;;;;               `;;;;;;;;;;;;                ;;;;; 
 `;;;;;,             .;;;;;; ;;;;;;;              ;;;;;; 
  ;;;;;;:           :;;;;;;.  ;;;;;;;            ;;;;;;  
   ;;;;;;;`       .;;;;;;;,    ;;;;;;;;        ;;;;;;;:  
    ;;;;;;;;;:,:;;;;;;;;;:      ;;;;;;;;;;:,;;;;;;;;;;   
    `;;;;;;;;;;;;;;;;;;;.        ;;;;;;;;;;;;;;;;;;;;    
      ;;;;;;;;;;;;;;;;;           :;;;;;;;;;;;;;;;;:     
       ,;;;;;;;;;;;;;,              ;;;;;;;;;;;;;;       
         .;;;;;;;;;`                  ,;;;;;;;;:         
                                                         
                                                         
                                                         
                                                         
    ;;;   ;;;;;`  ;;;;:  .;;  ;; ,;;;;;, ;;. `;,  ;;;;   
    ;;;   ;;:;;;  ;;;;;; .;;  ;; ,;;;;;: ;;; `;, ;;;:;;  
   ,;:;   ;;  ;;  ;;  ;; .;;  ;;   ,;,   ;;;,`;, ;;  ;;  
   ;; ;:  ;;  ;;  ;;  ;; .;;  ;;   ,;,   ;;;;`;, ;;  ;;. 
   ;: ;;  ;;;;;:  ;;  ;; .;;  ;;   ,;,   ;;`;;;, ;;  ;;` 
  ,;;;;;  ;;`;;   ;;  ;; .;;  ;;   ,;,   ;; ;;;, ;;  ;;  
  ;;  ,;, ;; .;;  ;;;;;:  ;;;;;: ,;;;;;: ;;  ;;, ;;;;;;  
  ;;   ;; ;;  ;;` ;;;;.   `;;;:  ,;;;;;, ;;  ;;,  ;;;;   
We expect to be back online soon, however in the meantime you may try to find help and informations here:

Arduino Main Website
Arduino Playground
Arduino Store
We regret any inconvenience.

... soliti casini con gli attach ??? In questo caso si tratta di un .jpg di meno di 200 KB :(

Guglielmo

No, a me allega i file correttamente… vedi sotto

arduino_due_in_hand.jpg

… ci riprovo …
… ecco la resistenza allo 0,1% :

@Leo : … come vedi … è casuale … :frowning: :frowning: :frowning:

Guglielmo

Guglielmo, le hai usate da qualche parte, tutto ok? A me ricorda roba di trent'anni fa, non è che semplicemente sono straossidati i pin e non fanno contatto sulla bread?

[quote author=Michele Menniti link=topic=163227.msg1306507#msg1306507 date=1373184426] Guglielmo, le hai usate da qualche parte, tutto ok? A me ricorda roba di trent'anni fa, non è che semplicemente sono straossidati i pin e non fanno contatto sulla bread? [/quote]

No, no, Michele, sono recentissime, le ultime me le hanno consegnate non più di una settimana fa ... e a me non danno problemi.

Però, ripeto, le mie sono comprate da un distributore qui e non in Polonia ... quindi ... non so quelle di Paolo ... :roll_eyes:

Guglielmo

Le mie le ho prese meno di 20 gg fa. Sembrano nuove e non ossidate: sono identiche a quelle di Guglielmo.

Allora succede qualcosa quando sono attraversate da correnti, potrebbero essere impedenze?

How to work!

Nel setup l’Ardutester setta la Seriale e inizializza LCd, poi passa a inizializzare l’ADC e carica i valori di default della configurazione

  ADCSRA = (1 << ADEN) | ADC_CLOCK_DIV;          //Enable ADC and set clock divider
  MCUSR &= ~(1 << WDRF);                         //Reset watchdog flag
  wdt_disable();                                 //Disable watchdog
  
//Cycling
  RunsMissed = 0;
  RunsPassed = 0;
 
 //Default offsets and values
  Config.Samples = ADC_SAMPLES;                  //Number of ADC samples
  Config.AutoScale = 1;                          //Enable ADC auto scaling
  Config.RefFlag = 1;                            //No ADC reference set yet
  analogReference(EXTERNAL);                     //Set Analog Reference to External
  pinMode(pushButton, INPUT_PULLUP);             //Set pin to input and turn on pullup resistors

imposta il riferimento esterno (si userà poi il riferimento interno a 1.1V) e il pulsante.

Nell loop, viene abilitato il watchdog a 2 secondi, resettate le variabili di riconoscimento di componenti e impostati tutti gli ingressi dell’ADc ad alta impedenza

  ADC_DDR &= ~(1<<TP1);                                                           
  ADC_DDR &= ~(1<<TP2);
  ADC_DDR &= ~(1<<TP3);

Viene letta poi la tensione di riferimento.

Config.U_Bandgap = ReadU(0x0e);                //Get voltage of bandgap reference

dove la funzione ReadU è:

//Read ADC and return voltage in mV (GOTO Free - Thanks to PaoloP)
unsigned int ReadU(byte Probe)
{
  unsigned int      U;                            //Return value (mV)
  byte              Counter;                      //Loop counter
  unsigned long     Value;                        //ADC value
  Probe |= (1 << REFS0);                          //Use internal reference anyway
  boolean cycle;
  do {
    cycle = false;                                // One Time cycle
    ADMUX = Probe;                                //Set input channel and U reference
    //If voltage reference has changed run a dummy conversion
    Counter = Probe & (1 << REFS1);               //Get REFS1 bit flag
    if (Counter != Config.RefFlag)
    {
      waitus(100);                                //Time for voltage stabilization
      ADCSRA |= (1 << ADSC);                      //Start conversion
      while (ADCSRA & (1 << ADSC));               //Wait until conversion is done
      Config.RefFlag = Counter;                   //Update flag
    }
    //Sample ADC readings
    Value = 0UL;                                  //Reset sampling variable
    Counter = 0;                                  //Reset counter
    while (Counter < Config.Samples)              //Take samples
    {
      ADCSRA |= (1 << ADSC);                      //Start conversion
      while (ADCSRA & (1 << ADSC));               //Wait until conversion is done
      Value += ADCW;                              //Add ADC reading
      //Auto-switch voltage reference for low readings
      if ((Counter == 4) && ((unsigned int)Value < 1024) && !(Probe & (1 << REFS1)) && (Config.AutoScale == 1))
      {
        Probe |= (1 << REFS1);                    //Select internal bandgap reference
        cycle = true;
        break;                                    //Re-run sampling 
      }
      Counter++;                                  //One less to do
    }
  } 
  while (cycle);
  //Convert ADC reading to voltage
  if (Probe & (1 << REFS1)) U = Config.U_Bandgap; //Bandgap reference
  else U = UREF_VCC;                              //Vcc reference   
  //Convert to voltage
  Value *= U;                                     //ADC readings U_ref 
  //Value += 511 * Config.Samples;                //Automagic rounding
  Value /= 1024;                                  // / 1024 for 10bit ADC
  //De-sample to get average voltage
  Value /= Config.Samples;
  U = (unsigned int)Value;
  return U; 
}

Analizziamo bene la ReadU…

La funzione inizializza per primo il valore U che sarà poi quello restituito.
Viene impostato il riferimento interno dell’ADC

 Probe |= (1 << REFS0);                          //Use internal reference anyway

Inizia il ciclo e viene scelto il canale dell’mux

ADMUX = Probe;                                //Set input channel and U reference

canale 14 ovvero la tensione interna a 1.1V (nuovo datasheet pag 255 → http://www.atmel.com/Images/Atmel-8271-8-bit-AVR-Microcontroller-ATmega48A-48PA-88A-88PA-168A-168PA-328-328P_datasheet.pdf)
Siamo ancora nella fase di inizializzazione dei valori e non nella lettura delle sonde esterne.

il ciclo completo è

  boolean cycle;
  do {
    cycle = false;                                // One Time cycle
    ADMUX = Probe;                                //Set input channel and U reference
    //If voltage reference has changed run a dummy conversion
    Counter = Probe & (1 << REFS1);               //Get REFS1 bit flag
    if (Counter != Config.RefFlag)
    {
      waitus(100);                                //Time for voltage stabilization
      ADCSRA |= (1 << ADSC);                      //Start conversion
      while (ADCSRA & (1 << ADSC));               //Wait until conversion is done
      Config.RefFlag = Counter;                   //Update flag
    }
    //Sample ADC readings
    Value = 0UL;                                  //Reset sampling variable
    Counter = 0;                                  //Reset counter
    while (Counter < Config.Samples)              //Take samples
    {
      ADCSRA |= (1 << ADSC);                      //Start conversion
      while (ADCSRA & (1 << ADSC));               //Wait until conversion is done
      Value += ADCW;                              //Add ADC reading
      //Auto-switch voltage reference for low readings
      if ((Counter == 4) && ((unsigned int)Value < 1024) && !(Probe & (1 << REFS1)) && (Config.AutoScale == 1))
      {
        Probe |= (1 << REFS1);                    //Select internal bandgap reference
        cycle = true;
        break;                                    //Re-run sampling 
      }
      Counter++;                                  //One less to do
    }
  } 
  while (cycle);

Si controlla che il riferimento non sia cambiato e nel caso si effettua una lettura a vuoto

  //If voltage reference has changed run a dummy conversion
    Counter = Probe & (1 << REFS1);               //Get REFS1 bit flag
    if (Counter != Config.RefFlag)

se invece il riferimento non e stato modifica si esegue la lettura reale con un numero di lettura pari a Config.Samples (in questo caso 200).
Config.RefFlag è posto a 1 nel setup.

Nel ciclo while interno

while (Counter < Config.Samples)              //Take samples
    {
      ADCSRA |= (1 << ADSC);                      //Start conversion
      while (ADCSRA & (1 << ADSC));               //Wait until conversion is done
      Value += ADCW;                              //Add ADC reading
      //Auto-switch voltage reference for low readings
      if ((Counter == 4) && ((unsigned int)Value < 1024) && !(Probe & (1 << REFS1)) && (Config.AutoScale == 1))
      {
        Probe |= (1 << REFS1);                    //Select internal bandgap reference
        cycle = true;
        break;                                    //Re-run sampling 
      }
      Counter++;                                  //One less to do
    }

è letto il valore dell’ADC a 16 bit, a differenze dell’analogread che legge 2 byte e poi li unisce

	// start the conversion
	sbi(ADCSRA, ADSC);

	// ADSC is cleared when the conversion finishes
	while (bit_is_set(ADCSRA, ADSC));

	// we have to read ADCL first; doing so locks both ADCL
	// and ADCH until ADCH is read.  reading ADCL second would
	// cause the results of each conversion to be discarded,
	// as ADCL and ADCH would be locked when it completed.
	low  = ADCL;
	high = ADCH;
#else
	// we dont have an ADC, return 0
	low  = 0;
	high = 0;
#endif
	// combine the two bytes
	return (high << 8) | low;

ADC è definito nelle lib AVR come

#define ADCW    _SFR_MEM16(0x78)

Alla 4° lettura, se il valore è inferiore a 1024, quindi meno di 256 a lettura e se è stato settato l’autoscale con riferimento normale (5V)

 if ((Counter == 4) && ((unsigned int)Value < 1024) && !(Probe & (1 << REFS1)) && (Config.AutoScale == 1))
      {
        Probe |= (1 << REFS1);                    //Select internal bandgap reference
        cycle = true;
        break;                                    //Re-run sampling 
      }

viene impostato il rifermento a 1.1V, la variabile cycle è vera e il ciclo ricomincia. (prima qui c’era un orribile goto. :grin:
Così migliora la risoluzione in lettura.
Terminato il campionamento, le solite operazioni.

if (Probe & (1 << REFS1)) U = Config.U_Bandgap; //Bandgap reference
  else U = UREF_VCC;                              //Vcc reference   
  //Convert to voltage
  Value *= U;                                     //ADC readings U_ref 
  //Value += 511 * Config.Samples;                //Automagic rounding
  Value /= 1024;                                  // / 1024 for 10bit ADC
  //De-sample to get average voltage
  Value /= Config.Samples;
  U = (unsigned int)Value;
  return U;

Il valore viene moltiplicato per il valore di riferimento, 1.1V o 5V, diviso per 1024 (dovrebbe essere 1023??), e diviso per il numero di campioni.

Tutto questo, la prima volta, dovrebbe restituire 1100 mV.

Nel loop(), una volta stabilita la tensione di riferimento interna con la migliore accuratezza possibile si passa alla scarica di eventuali componenti collegati (come i condensatori), poi al controllo dei cortocircuiti tra le sonde e se tutto va bene si passa all'analisi dei componenti collegati alle sonde, vero cuore dell'ArduTester.

//Try to discharge any connected component
  DischargeProbes();
  if (CompFound == COMP_ERROR)                   //Discharge failed
  {
    ErrFnd=4;                                    //Skip all other checks
  }
  //Short-circuit
  if (AllProbesShorted() == 3)
  {
    ErrFnd=3;                                    //New cycle after job is is done
  }
  else
  {
    //Check all 6 combinations of the 3 probes
    CheckProbes(TP1, TP2, TP3);
    CheckProbes(TP2, TP1, TP3);
    CheckProbes(TP1, TP3, TP2);
    CheckProbes(TP3, TP1, TP2);
    CheckProbes(TP2, TP3, TP1);
    CheckProbes(TP3, TP2, TP1);

La scarica dei componenti è semplice, vengono portati a massa tutte le resistenze (pull-down) effettuando dei cicli di lettura della tensione e controllando fino a un valore inferiore ad una soglia preimpostata. Dopo la scarica, viene effettuato il test per verificare il corto delle sonde e in caso positivo si passa al sefttest interno, altrimenti si procede con la funzione CheckProbes. (che vedremo dopo mangiato) :grin:

Viste cosi a occhio, quelle sembrano le resistenze che produceva la Welwyn per i tester analogici ... credo che esista ancora ...

Di migliori credo ci siano solo quelle a strato metallico della Vishay da 0,01%, laser trimmed ... ma l'ultima volta che ho visto uno dei loro listini, costavano come se fossero state fatte d'oro massiccio :P :fearful:

E usarle SMD ? ... ci sono anche le 1206 allo 0,1% ...

Le mie sono della Welwyn.

Ho acquistato da Digikey queste:

A103210CT-ND A103233CT-ND

Alla modica cifra di 124€ per reel (1.000 pezzi)