potenziometro digitale interface SPI come si colle

Ciao a tutti .
Volevo sapere se il potenziometro http://it.rs-online.com/web/search/searchBrowseAction.html?method=getProduct&R=0403676 va bene per essere interfacciato ad arduino ?
Leggevo sul forum di questa libreria creata da Federico http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1266875130/4.

E' possibile e lo puoi controllare con questa libreria: Arduino Playground - Spi

Sai dove posso trovare qualche esempio su come si collega ad arduino e qualche esempio di codice.
A me servirebbe cambiare la resistenza alla pressione di un tasto.
grazie /me

Ora gli do una bella lettura su questo protocollo, anche se un bel esempio rende sempre più l'idea.

Di quale esempio hai bisogno?
Dal momento in cui hai una libreria a disposizione, la devi solo utilizzare nel tuo codice...
Se guardi nella pagina della libreria, la prima cosa che ti viene indicata è proprio come deve essere collegata fisicamente.
Poi non devi far altro che scrivere il codice per dare i comandi e/o ricevere i dati al dispositivo che avrai collegato. :wink:
Cosa non ti è chiaro?

P.S: non ti aspetterai che qualcuno scriva il codice per il tuo progetto?? Allora non sarebbe più il "tuo" progetto... :stuck_out_tongue:

Perdonami è da poco che uso Arduino e i microcontrollori in generale.
Chiedevo degli esempi per capire non per copiare!
Io il mio primo programmino l'ho scritto proprio dagli esempi sul sito arduino.cc e da li si cerca di migliorare e fare cose piu "belle".

ciaoo ragazzi scusatemi avevate ragione con un po di pazienza e tanto mal di testa sono riuscito a comnicare con un potenziometro digitale , precisamente con questo http://ww1.microchip.com/downloads/en/DeviceDoc/11195c.pdf
ho realizzato un piccolo programma che da seriale fa cambiare l aresistenza da 0 a 100% e lo voglio condividere!! :wink: :wink: :wink:
ringrazio tutti in particolare kokiua,brainbooster

  #define DATAOUT 11//MOSI
  #define DATAIN 12//MISO - not used, but part of builtin SPI
  #define SPICLOCK  13//sck
  #define SLAVESELECT 10//ss
  
  const int dim =2 ;
  
  char valore[dim]; //array che memorizza i dati da tastiera 
  char* p;  //puntatore
  char inByte;  // singolo dato immesso 
  int LED = 1;
  int duty=0; // duty da tastiera
  int dutyprovvisorio=0; // variabile che mi sono creato per verificare se quello che digito è un dato possibile
  
  int i; //indice dell'array
  
  byte address = B00010001;
  byte pot=0;
  byte resistance=0;
  int serIn1;
  
  char spi_transfer(char data)
{
  SPDR = data;                    // Start the transmission
  while (!(SPSR & (1<<SPIF)))     // Wait the end of the transmission
  {
  };
  return SPDR;                    // return the received byte
}
  
void setup() {
  TCCR0B = TCCR0B & 0b11111000 | 0x03;
   Serial.begin(9600); 
   pinMode(LED, OUTPUT);
   analogWrite(LED,0 );  //faccio in modo che il mio led sia inizialmente spento
    
   
   
    byte clr;
  pinMode(DATAOUT, OUTPUT);
  pinMode(DATAIN, INPUT);
  pinMode(SPICLOCK,OUTPUT);
  pinMode(SLAVESELECT,OUTPUT);
  digitalWrite(SLAVESELECT,HIGH); //disable device
  // SPCR = 01010000
  //interrupt disabled,spi enabled,msb 1st,master,clk low when idle,
  //sample on leading edge of clk,system clock/4 (fastest)
  
/*
SPCR bits:
7: SPIEE - enables SPI interrupt when high
6: SPE - enable SPI bus when high
5: DORD - LSB first when high, MSB first when low
4: MSTR - arduino is in master mode when high, slave when low
3: CPOL - data clock idle when high if 1, idle when low if 0
2: CPHA - data on falling edge of clock when high, rising edge when low
1: SPR1 - set speed of SPI bus
0: SPR0 - set speed of SPI bus (00 is fastest @ 4MHz, 11 is slowest @ 250KHz)
*/


  SPCR = (1<<SPE)|(1<<MSTR);
  clr=SPSR;
  clr=SPDR;
 
  delay(10);
    write_pot(0);
}

void write_pot(byte value)
{
  digitalWrite(SLAVESELECT,LOW);  //2 byte opcode
  spi_transfer(address);
  spi_transfer(value);
  digitalWrite(SLAVESELECT,HIGH); //release chip, signal end transfer
}



void loop() {
          if( Serial.available() > 0){
             inByte = Serial.read();
           if (inByte!='*'){
              dutyf();
           }
            
          else{
             Serial.print("Arresto");
             analogWrite(LED, 0);}
             
             
          } 

}

void dutyf(){
//            if (Serial.available() > 0) { 
//                        
//                       inByte =  Serial.read();
                       if (inByte != '#') {
                                            valore[i] = inByte;
                                            int dutyprovvisorio = atof(valore); // dutyprovvisorio mi dice dopo che l'ho impostato da tastiera se è un valore possibile
                           
                                            if(dutyprovvisorio <=100  & i<= 2  & dutyprovvisorio >= 0) { 
                                                  
                                          
                                                                Serial.print("dutyprovvisorio = ");
                                                                Serial.println(dutyprovvisorio);
                                                                Serial.print("Valore digitato=");
                                                                Serial.println(valore[i]);
                                                                Serial.print("indice=");
                                                                Serial.println(i);
                                                                }
                                                               else{
                                                      
                                                               Serial.println("Error");
                                                               Serial.println("Ridigita duty 2");
                                                               for (p=valore, i=0; i<dim; i++,  p++){  //inializzza il mio array 
                                                               *p = 0;}
                                                                i= 0-1 ;
              
                                                }
                                            
                                  
                                              i= i+1;
                                             } 
                                              else{
                                                   int duty = atof(valore);
                                                   int dutyled=map(duty, 0, 100, 0, 255);  //analogWrite acceta valori da 0 a 255 quindi gli traslo vedi arduino-->reference
                                                   analogWrite(LED, dutyled);
                                                   Serial.print("duty= "); //valore che digito sulla tastiera
                                                   Serial.println(duty);
                                                    write_pot(dutyled);
                                                   
                                                   
                                                   Serial.print("dutyled= ");
                                                   Serial.println(dutyled);
                                                   
                                                   Serial.print("invio= ");  //mi dice ho premuto ul tasto # 
                                                   Serial.println(inByte);
                                                   
                                                   
                                                   for (p=valore, i=0; i<dim; i++,  p++){
                                                   *p = 0;}
                                                   
                                                   
                                                   
                                                   i= 0;
                                                   }
                      //  }
       delay(10);



}