ADS1255: SPI connection to ADS1255

Here is the code.


#define BAUD 115200UL
#define UBRR0_Value (F_CPU/(16*BAUD)-1)

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

// Send char via UART
//__________________________________________________________
static void uart_transmit_char (unsigned char ch)
{
	while (!(UCSR0A & (1<<UDRE0)))
	{
		;
	}

	UDR0 = ch;
}

// Send string via UART
//__________________________________________________________
static void uart_transmit_string (char * s)
{
	while (*s)
	{
		uart_putc (*s);
		s++;
	}
}

// Receive Byte via UART
// _________________________________________________________
char UART_receive(void){
	while(!(UCSR0A & (1<<RXC0)));
	return UDR0;
}

// Configure UART
//__________________________________________________________
void UARTinit(){
	UBRR0H = (unsigned char) (UBRR0_Value >> 8);
	UBRR0L = (unsigned char) UBRR0_Value;
	UCSR0B = (1<<TXEN0) | (1<<RXEN0);
	UCSR0C = (1<<UCSZ00) | (1<<UCSZ01);
	
}

// Configure SPI
// ________________________________________________________
void spi_init()
{
	DDRB = (1<<5)|(1<<3)|(1<<2);			 // MOSI, !CS , SCK as Output
	SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);     // SPI Enable, SPI = Master, Prescaler = 16
}  


// Send SPI Data and return the return byte
//________________________________________________________
unsigned char ADS1255_transceive (unsigned char data)
{
	SPDR = data;           
	while(!(SPSR & (1<<SPIF) ));    // Wait until transmission complete
	_delay_us(20);					// wait for 20µ until DOUT (t6)
	return(SPDR);                      
}

// Read Status-Register of ADS1255
// _______________________________________________________
char ADS1255_Read_Status(){
	
	char ans;						// return value
	 
	PORTB &= ~(1 << PORTB2);		// !CS = LOW  
	_delay_us(20);
    ADS1255_transceive(0b10|0x00);   // Send RREG command (Status)
	//_delay_us(10);
	ADS1255_transceive(0);           // read one register
	//_delay_us(10);
	ans = ADS1255_transceive(0);     // send Dummy-Byte and save return value
//	_delay_us(10);
	PORTB |= (1 << PORTB2);			// !CS = HIGH
    _delay_us(20);
	
	return ans;
}

int main(void)
{
	
	 char test;
	 
	
	 // External Interrupt for !DRDY
	 //_______________________________________________-
	 DDRD &= ~(1 << 2);    
	 PORTD |= (1 << 2);     
	 EICRA |= (1 << ISC00) |(1 << ISC01);  
	 EIMSK |= (1<<INT0);				   
		
	 
	// Start UART and SPI
	//_______________________________________________
	UARTinit();							   
	spi_init();
	
	
	_delay_ms(500);   // wait for 0.5 sec
	
	// Send SDATAC Command
	//____________________________________________
	PORTB |= (1 << PORTB2);	
	_delay_us(20);
	PORTB &= ~(1 << PORTB2);		// !CS = LOW	
	_delay_us(20);
	ADS1255_transceive(0xF);        // SDATAC	
	PORTB |= (1 << PORTB2);			// !CS = HIGH
	_delay_us(20);						   
	
	//___________________________________________
	
	//sei();
	
    while(1)
	
    {     
		// senbd WAKEUP command
		//__________________________________________________
		PORTB &= ~(1 << PORTB2);		// !CS = LOW
		_delay_us(20);
		ADS1255_transceive(0);          // Send WAKUP
		PORTB |= (1 << PORTB2);			// !CS = HIGH
		_delay_us(20);
		
		// read status register every second
		//_____________________________________________
		
		test = ADS1255_Read_Status();    // Send RREG command (Status)
		uart_transmit_char(test);		 // Send register value via UART
		_delay_ms(1000);				 // wait 1 sec
    }
}

ISR(INT0_vect){
	
 // !DOUT-Interrupt
}

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#define BAUD 115200UL
#define UBRR0_Value (F_CPU/(16*BAUD)-1)
#define CS_LOW PORTB &= ~(1 << PORTB2);
#define CS_HIGH PORTB |= (1 << PORTB2);

#define REG_Status 0x00
#define REG_DRATE 0x03
	
volatile int Drdy_flag = 1;

//UART functions_________________________________________________________________

//________ Configure UART _______
void UART_init(){
	UBRR0H = (unsigned char) (UBRR0_Value >> 8);
	UBRR0L = (unsigned char) UBRR0_Value;
	UCSR0B = (1<<TXEN0) | (1<<RXEN0);
	UCSR0C = (1<<UCSZ00) | (1<<UCSZ01);
	
}
// _____ Send char via UART ______
static void UART_transmit_char (unsigned char ch)
{
	while (!(UCSR0A & (1<<UDRE0)))
	{
		;
	}

	UDR0 = ch;
}

// ______ Send string via UART _____
static void UART_transmit_string (char * s)
{
	while (*s)
	{
		UART_transmit_char (*s);
		s++;
	}
}

// _____ Receive Byte via UART ____
char UART_receive(void){
	while(!(UCSR0A & (1<<RXC0)));
	return UDR0;
}
//end UART functions______________________________________________________________

// SPI functions__________________________________________________________________

// _____ Configure SPI ______
void SPI_Init()
{
	DDRB |= (1<<5)|(1<<3)|(1<<2);			 // MOSI, !CS , SCK as Output
	SPCR |= (1<<SPE)|(1<<MSTR)|(1<<SPR0)|(1<<CPHA);     // SPI Enable, SPI = Master, Prescaler = 16
}

// ____ Send SPI Data and return the received byte _____
unsigned char ADS1255_transceive (unsigned char data)
{
	SPDR = data;
	while(!(SPSR & (1<<SPIF) ));    // Wait until transmission complete
	_delay_us(20);					// wait for 10µ until DOUT (t6)
	return(SPDR);
}

// Analog-digital converter (ADS1255) functions_________________________________________

// _____ Read register of ADS1255 and return register value _____
void ADS1255_Init(){
	
	CS_LOW;
	
	ADS1255_transceive(0xFE);
	UART_transmit_string("ADS1255 RESET");
	UART_transmit_char('\r');
	_delay_us(5);
	
	ADS1255_transceive(0xF);
	UART_transmit_string("ADS1255 SDATAC");
	UART_transmit_char('\r');
	_delay_us(10);
	
	ADS1255_transceive(0xF0);
	_delay_ms(1000);
	UART_transmit_string("ADS1255 Offset and Gain Self-Calibration");
	UART_transmit_char('\r');
	_delay_us(10);
	
	
	
	CS_HIGH;
	
}

char ADS1255_Read_Register(char reg, char num){
	char ans;
	
	CS_LOW;		 // !CS = LOW
	
	ADS1255_transceive(0x10|reg);   // Send RREG command (Status)	
	ADS1255_transceive(num);           // read one register	
	ans = ADS1255_transceive(0);	 // send dummy byte and save received value

	CS_HIGH;	 // !CS = HIG
	_delay_us(10);
	
	return ans;
}

void ADS1255_Write_Register(char reg, char num, char data){
	
	CS_LOW;		 // !CS = LOW
	ADS1255_transceive(0x50|reg);   // Send RREG command (Status)
	ADS1255_transceive(num);           // read one register
	ADS1255_transceive(data);	 // send dummy byte and save received value
	CS_HIGH;	 // !CS = HIG
	_delay_us(10);
}

int32_t ADS1255_Read_Data(){
	
	int32_t result = 0;
	uint8_t ADC_bytes[3];
	
	CS_LOW;
	_delay_us(5);
	ADS1255_transceive(0x01);
	
	ADC_bytes[0] = ADS1255_transceive(0);   //
	ADC_bytes[1] = ADS1255_transceive(0);
	ADC_bytes[2] = ADS1255_transceive(0);
	_delay_us(10);
	
	CS_HIGH;
	_delay_us(5);
	
	if (ADC_bytes[0] & 0x80)     //  negativ 
	{
		result = (int32_t) (((0xFF)<<24)|((ADC_bytes[0]&0xFF)<<16)|
										 ((ADC_bytes[1]&0xFF)<<8)|
										 ((ADC_bytes[2]&0xFF)<<0));
	}
	else						 // positiv
	{
		result = (int32_t) (((0x00)<<24)|((ADC_bytes[0] & 0xFF)<<16)|
										 ((ADC_bytes[1] & 0xFF)<<8)|
										 ((ADC_bytes[2] & 0xFF)<<0));
	}
	
	Drdy_flag = 1;    // DRDY_flag back to 1 --> all values read
	return result;
}

// Gerneral functions _____________________________________________________________

// ____ configure external interrupt for !DRDY _____
void External_Intterrupt_Init(){
	DDRD &= ~(1 << 2);
	PORTD |= (1 << 2);
	EICRA |= (1 << ISC00) |(1 << ISC01);
	EIMSK |= (1<<INT0);
}
// ____ INT0 external interrupt service routine _____
ISR(INT0_vect){
	
Drdy_flag = 0;	

}


// Main funcion _____________________________________________________________________
int main(void)
{
	int32_t result = 0;
	double voltage = 0;
	char buf[32];
	
	_delay_ms(3000);   // startup delay
	
	UART_init();
	SPI_Init();
	ADS1255_Init();
	External_Intterrupt_Init();
	
	sei();
	
	
    while(1)
    {
	  if (Drdy_flag == 0)    // data available? 
	  {
		  result = ADS1255_Read_Data();				// read ADC data
		  voltage = (double)result*0.0005960;       // convert to voltage [V]
		 
		  _delay_ms(100);
		  
		  UART_transmit_string("ADC Value:  ");	  
		  UART_transmit_string(itoa(voltage,buf,10));   // convert voltage to string ..no floating point yet
		  UART_transmit_char('\r');
	  }
	  
    }
}