DAC (TLV5616) gibt nichts aus

[HerrPitillo (Gast)]

Hallo,
ich habe hier einen TLV5616 (ein Digital -> Analog Wandler), ich habe 
jedoch das Problem das er sich nicht ansteuern lässt. Um ihn zu testen 
hab ich ein Testprogramm für einen AVR geschrieben jedoch funktioniert 
es nicht. Am Ausgang des DAC´s ist bisher bis auf mein Multimeter nichts 
angeschlossen. Die Restliche verkabelung ist so ausgebaut:
MOSI ---- DIN
SCLK ---- SCLK
GND ----- CS
GND ----- GND
REFIN --- Spannungsteiler -> 2,6V
OUT ----- Multimeter
VDD ----- 5,2V

Das Datenblatt findet ihr hier:
http://www.ti.com/lit/ds/slas152d/slas152d.pdf

Und mein Code sieht wie folgt aus:

#define F_CPU 4000000UL


#include "spi.h"
#include <avr/io.h>
#include <util/delay.h>

int main(void)
{
  DDRB |= (1<<PB2) | (1<<PB3) | (1<<PB5);//ausgänge für SPI setzen
  setup_spi(SPI_MODE_2,SPI_MSB,SPI_NO_INTERRUPT,SPI_MSTR_CLK16);
  send_spi(0b01001111);// 4bit daten + control bits
  _delay_us(100);
  send_spi(0b11111111);// restlichen daten
  while(1)
    {
    }
}

Die SPI Lib sieht wie folgt aus (sie ist nicht von mir) :
SPI.h

/* 
 * Copyright (c) 2009 Andrew Smallbone <[e-mail]>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#ifndef _spi_h__
#define _spi_h__

#include <avr/io.h>

#ifdef __cplusplus
extern "C"{
#endif

// create alias for the different SPI chip pins - code assumes all on port B
#if (defined(__AVR_AT90USB82__) || defined(__AVR_AT90USB162__))
 #define SPI_SS_PIN PORTB0
 #define SPI_SCK_PIN PORTB1
 #define SPI_MOSI_PIN PORTB2
 #define SPI_MISO_PIN PORTB3
#elif (defined(__AVR_ATmega48__) || defined(__AVR_ATmega88__) || defined(__AVR_ATmega168__) || defined(__AVR_ATmega328__) || defined(__AVR_ATmega328P__) || defined(__AVR_ATmega8__))
 #define SPI_SS_PIN PORTB2
 #define SPI_SCK_PIN PORTB5
 #define SPI_MOSI_PIN PORTB3
 #define SPI_MISO_PIN PORTB4
#else
 #error unknown processor - add to spi.h
#endif

// SPI clock modes
#define SPI_MODE_0 0x00 /* Sample (Rising) Setup (Falling) CPOL=0, CPHA=0 */
#define SPI_MODE_1 0x01 /* Setup (Rising) Sample (Falling) CPOL=0, CPHA=1 */
#define SPI_MODE_2 0x02 /* Sample (Falling) Setup (Rising) CPOL=1, CPHA=0 */
#define SPI_MODE_3 0x03 /* Setup (Falling) Sample (Rising) CPOL=1, CPHA=1 */

// data direction
#define SPI_LSB 1 /* send least significant bit (bit 0) first */
#define SPI_MSB 0 /* send most significant bit (bit 7) first */

// whether to raise interrupt when data received (SPIF bit received)
#define SPI_NO_INTERRUPT 0
#define SPI_INTERRUPT 1

// slave or master with clock diviser
#define SPI_SLAVE 0xF0
#define SPI_MSTR_CLK4 0x00 /* chip clock/4 */
#define SPI_MSTR_CLK16 0x01 /* chip clock/16 */
#define SPI_MSTR_CLK64 0x02 /* chip clock/64 */
#define SPI_MSTR_CLK128 0x03 /* chip clock/128 */
#define SPI_MSTR_CLK2 0x04 /* chip clock/2 */
#define SPI_MSTR_CLK8 0x05 /* chip clock/8 */
#define SPI_MSTR_CLK32 0x06 /* chip clock/32 */



// setup spi
void setup_spi(uint8_t mode,   // timing mode SPI_MODE[0-4]
         int dord,             // data direction SPI_LSB|SPI_MSB
         int interrupt,        // whether to raise interrupt on recieve
         uint8_t clock); // clock diviser

// disable spi
void disable_spi(void);

// send and receive a byte of data (master mode)
uint8_t send_spi(uint8_t out);

// receive the byte of data waiting on the SPI buffer and
// set the next byte to transfer - for use in slave mode
// when interrupts are enabled.
uint8_t received_from_spi(uint8_t out);

#ifdef __cplusplus
} // extern "C"
#endif

#endif

SPI.c

/* 
 * Copyright (c) 2009 Andrew Smallbone <[e-mail]>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "spi.h"

#ifdef __cplusplus
extern "C"{
#endif

#ifdef __ARDUINO__
#include <wiring.h>
#endif

void setup_spi(uint8_t mode, int dord, int interrupt, uint8_t clock)
{
  // specify pin directions for SPI pins on port B
  if (clock == SPI_SLAVE) { // if slave SS and SCK is input
    DDRB &= ~(1<<SPI_MOSI_PIN); // input
    DDRB |= (1<<SPI_MISO_PIN); // output
    DDRB &= ~(1<<SPI_SS_PIN); // input
    DDRB &= ~(1<<SPI_SCK_PIN);// input
  } else {
    DDRB |= (1<<SPI_MOSI_PIN); // output
    DDRB &= ~(1<<SPI_MISO_PIN); // input
    DDRB |= (1<<SPI_SCK_PIN);// output
    DDRB |= (1<<SPI_SS_PIN);// output
  }
  SPCR = ((interrupt ? 1 : 0)<<SPIE) // interrupt enabled
    | (1<<SPE) // enable SPI
    | (dord<<DORD) // LSB or MSB
    | (((clock != SPI_SLAVE) ? 1 : 0) <<MSTR) // Slave or Master
    | (((mode & 0x02) == 2) << CPOL) // clock timing mode CPOL
    | (((mode & 0x01)) << CPHA) // clock timing mode CPHA
    | (((clock & 0x02) == 2) << SPR1) // cpu clock divisor SPR1
    | ((clock & 0x01) << SPR0); // cpu clock divisor SPR0
  SPSR = (((clock & 0x04) == 4) << SPI2X); // clock divisor SPI2X
}

void disable_spi()
{
  SPCR = 0;
}

uint8_t send_spi(uint8_t out)
{
  SPDR = out;
  while (!(SPSR & (1<<SPIF)));
  return SPDR;
}

uint8_t received_from_spi(uint8_t data)
{
  SPDR = data;
  return SPDR;
}

Ich hoffe ma ich hab alles erwähnt was wichtig ist und ihr könnt mir 
weiterhelfen :)

DANKE:)

[Dieter Werner (Gast)]

CS fest an GND ist keine gute Idee. Viele SPI Bausteine benötigen die CS 
Flanke von aktiv (meistens low) zu inaktiv für die interne 
Datenübernahme.

[Ich (Gast)]

Notes on SPI and Microwire: Before the controller starts the data 
transfer, the software has to generate a falling edge on the I/O pin 
connected to FS.


FS erwähnst Du zwar nicht direkt im Text, da Du aber drei Pins als 
Ausgang setzt, wird einer davon wohl mit FS verbunden sein.

Nur das Datenrichtungsregister zu setzen ist mindestens schlechter Stil.
Die Pins sollten von Hochohmig auf Null gehen weil für die AVRs die 
meisten Register beim Reset ja mit Null beschrieben werden.

Aber selbst wenn das wie gedacht funktioniert, erzeugt das eben keine 
Flanke.


Um was messen zu können würde ich den Rest dann eher so schreiben:

  while(1)
    {
     send_spi(0b01001111);// 4bit daten + control bits
     send_spi(0b11111111);// restlichen daten
     _delay_us(10);
    }

[Ich (Gast)]

Ach ja, mit weiterem Umschalten von FS in der Schleife natürlich. :-)

[HerrPitillo (Gast)]

Hallo,
also soll ich jetzt FS einmal am anfang toggeln und einmal am ende 
richtig?
zudem soll ich jetzt pulldown widerstände hinzu fügen oder wie ist das 
gemeint?

Danke schon ma bis hier hin;)
echt ein super Forum hier:)

[Ich (Gast)]

Nein, FS wird nicht am Anfang getoggelt und dann noch mal.

FS wird auf High gesetz.
Direkt vor dem Transfer wird FS auf Low gesetzt.
Nach dem Transfer wird FS auf High gesetzt.

 ...
 PORTB |= (1<< xx); // FS auf High setzen
  _delay_us(10);
 ...

  while(1)
    {
     PORTB &= ~(1<< xx); // FS auf Low setzen
     send_spi(0b01001111);// 4bit daten + control bits
     send_spi(0b11111111);// restlichen daten
     PORTB |= (1<< xx); // FS auf High setzen
     _delay_us(10);
    }

Folge dem Datenblatt. :-)

[HerrPitillo (Gast)]

Danke:)
es funktioniert endlich:D
bei dem IC kriegt man nicht bei 0xFFF dem höchst möglichen wert sondern 
bei 0x00.


echt nen riesengroßes Danke:)
kann mir vllt noch jemand helfen eine Funktion zu schreiben der ich 
nurnoch den Wert den ich ahben will übergeben muss und der dann das an 
den Dac sendet?

DANKE c:

[HerrPitillo (Gast)]

Sorry ich hab eben vergessen meine überlegung des Codes anzuhängen:D

int DAC_write(uint16_t Value, uint8_t SS_PIN)
{
  Value = Value * -1;
  
  uint8_t MSB = 0;
  uint8_t LSB = 0;
  uint8_t CTRL = 0b01000000;
  
  MSB = CTRL;
  MSB = Value << 4;
  LSB = Value << 8;
  PORTB &= ~(1<< SS_PIN); // FS auf Low setzen
  send_spi(MSB);// 4bit daten + control bits
  send_spi(LSB);// restlichen daten
  PORTB |= (1<< SS_PIN); // FS auf High setzen
  _delay_us(10);
  
  return 0;
}

[HerrPitillo (Gast)]

Ich muss jetzt hier zum dritten mal hintereinander schreiben
Aber bei mir aht das phänomen wer misst misst mist zugeschlagen und ich 
hab ausversehen den ausgang gegen VCC anstatt gegen GND gemessen 
:facepalm:

Sorry:/