AVR Freaks

Hi,

This is my code.  I think it is correct.  Kinda struggling now.

Thanks,

// File:  spi.c
   
  
#include <avr/io.h>
#include <util/delay.h>
//#include "spi.h"
#include "rs232.h"

typedef unsigned char byte;     

void initialize_spi(void) {
	DDRB |= (1<<2)|(1<<3)|(1<<5);    // CS (PB2), MOSI (PB3) and SCK (PB5) as outputs
	DDRB &= ~(1<<4);                 // MISO (PB4) as input

	SPCR |= (1<<MSTR);               // Set as Master
	SPCR |= (1<<SPR1)|(1<<SPI2X);    // divided clock by 32 (set to 500khz SCK)
	SPCR |= (1<<SPE);                // Enable SPI
	
	/* System FOSC is 16MhZ 
	    16Mhz/32 = 500Mhz  */
	
}

void cs_low(void){
	PORTB &= ~ (1 << PINB2);  // CS Low
	_delay_us(1);
}

void cs_high(void){
	PORTB |= (1 << PINB2);   // CS high
}

void spi_write(byte data){       
	//write_rs232(data);
	//_delay_ms(1000);
	SPDR = data;    		        // send the data
	while((SPSR & (1<<SPIF)) == 0);  	// wait until transmission is complete	
}

byte spi_read(byte data){
	SPDR = data;			       // send the data
	while((SPSR & (1<<SPIF)) == 0);	       // wait until transmission is complete	 
	return SPDR;
}

Ok added the code below, main.c, LTC2983_functions.c, and spi.c.

I have written in the code what happens.  There is one line in main.c "" convert_channel(channel_number);"" that calls this function in LTC2983_functions.c.  This locks main.c up, I cannot send "146" to terminal every 1 second.  This is my way of debugging main in parallel to using the debugger. If I put ""convert_channel(channel_number);"" back in main.c and edit comment out the ""while (conversion_done()==0);"" in ""covert_channels functions"" the program runs again.  I do not know if its the SPI read/ write that is jamming this function up or wrong data types.  Kinda stuck.........

// main.c


#include <avr/io.h>
#include <stdint.h>
#include <stdbool.h>
#include <util/delay.h>
#include "stdio.h"
#include "math.h"

#include "LTC2983_configuration_constants.h"
#include "LTC2983_support_functions.h"
#include "LTC2983_table_coeffs.h"
#include "rs232.h"
#include "spi.h"

typedef unsigned char byte;
typedef int          boolean;


// Function prototypes
void configure_channels();
void configure_global_parameters();


// -------------- Configure the LTC2983 -------------------------------
void setup() {
	IO_configuration();
	initialize_rs232();
	initialize_spi();
	configure_channels();
	configure_global_parameters();
}

void configure_channels() {
		//byte channel_number;
		long channel_assignment_data;

		// ----- Channel 2: Assign Sense Resistor -----
		channel_assignment_data =
		(long) SENSOR_TYPE__SENSE_RESISTOR |
		(long) 0b101101011101101100000000000 << SENSE_RESISTOR_VALUE_LSB;		// sense resistor - value: 93110.
		assign_channel(2, channel_assignment_data);

		// ----- Channel 6: Assign RTD PT-100 -----
		channel_assignment_data =
		(long) SENSOR_TYPE__RTD_PT_100 |
		(long) RTD_RSENSE_CHANNEL__2 |
		(long) RTD_NUM_WIRES__2_WIRE |
		(long) RTD_EXCITATION_MODE__NO_ROTATION_SHARING |
		(long) RTD_EXCITATION_CURRENT__5UA |
		(long) RTD_STANDARD__EUROPEAN;
		assign_channel(6, channel_assignment_data);

}

void configure_global_parameters() {

	// -- Set global parameters
	write_single_byte(0xF0, TEMP_UNIT__C |
	REJECTION__50_60_HZ);
	// -- Set any extra delay between conversions (in this case, 0*100us)
	write_single_byte(0xFF, 0);

}

// -------------- Run the LTC2983 -------------------------------------
int main(void)
 {
	setup();
	byte rs232[] = "146";
	byte channel_number;
	float fdata;
	byte data;

	int channels_to_measure[] = {6};
	int num_measured_channels = sizeof(channels_to_measure)/sizeof(channels_to_measure[0]);


	while(1){
	for (int i = 0; i < num_measured_channels; i++) {
		channel_number = channels_to_measure[i];
//*********************************************************************************************************

		convert_channel(channel_number); // When this line is commented out main loops OK
                                         // This locks up in covert channel function on LTC2983_support_functions.c

//*********************************************************************************************************

		read_voltage_or_resistance_results((channel_number));
		fdata = read_temperature_results((channel_number));
		data = (byte)fdata;

	}
	write_rs232(rs232);
	_delay_ms(1000);
	}

}

// File: LTC2983_support_functions.c:
  

#include <avr/io.h>
#include <stdint.h>
#include <stdbool.h>
#include <util/delay.h>
#include "stdio.h"
#include "math.h"

#include "LTC2983_configuration_constants.h"
#include "LTC2983_table_coeffs.h"
#include "LTC2983_support_functions.h"
#include "spi.h"
#include "rs232.h"

typedef unsigned char byte;      
typedef int         boolean;


// -----------------------------------------------------------------
//                  Memory write functions
// -----------------------------------------------------------------
void assign_channel(int channel_number, long channel_assignment_data) {
	int bytes_per_coeff = 4;
	long start_address = 0x200+4*(channel_number-1);

	initialize_memory_write(start_address);
	write_coefficient(channel_assignment_data, bytes_per_coeff); 
	finish_memory_write();
}

void write_custom_table(struct table_coeffs coefficients[64], long start_address, long table_length) {
	int bytes_per_coeff = 3;
	
	initialize_memory_write(start_address);
	for (int i=0; i< table_length; i++) {
		// write_table multiplies i by 6 and adds 250 to start address
		write_coefficient(coefficients[i].measurement, bytes_per_coeff);
		write_coefficient(coefficients[i].temperature, bytes_per_coeff);
	}
	finish_memory_write();
}

void write_custom_steinhart_hart(long steinhart_hart_coeffs[6], long start_address) {
	int bytes_per_coeff = 4;
	
	initialize_memory_write(start_address);
	for (int i = 0; i < 6; i++) {
		write_coefficient(steinhart_hart_coeffs[i], bytes_per_coeff);
	}
	finish_memory_write();
}

void write_single_byte(long start_address, int single_byte) {
	initialize_memory_write(start_address);
	spi_write(single_byte);
	finish_memory_write();
}

void initialize_memory_write(long start_address) {
	cs_low(); // CS low
	spi_write(0x02); 
	//spi_write(highByte(start_address)); // Address MSB Byte
	spi_write((start_address & 0xFF00) >> 8); // Address MSB Byte
	//spi_write(lowByte(start_address)); // Address LSB Byte
	spi_write(0x00FF & start_address);   // Address LSB Byte	
}

void write_coefficient(long coeff, int bytes_per_coeff) {
	int data_byte;
	for (int i = bytes_per_coeff - 1; i >= 0; i--) {
		data_byte = coeff >> (i*8);
		spi_write(data_byte);
	}
}

void finish_memory_write() {
	cs_high(); // CS high
}

// -----------------------------------------------------------------
//                  Memory read functions
// -----------------------------------------------------------------
void initialize_memory_read(long start_address) {
	cs_low(); // CS low
	spi_write(0x03); // instruction Byte read
	//spi_write(highByte(start_address)); // Address MSB Byte
	spi_write ((start_address & 0xFF00) >> 8); // Address MSB Byte
	//spi_write(lowByte(start_address)); // Address LSB Byte
	spi_write(0x00FF & start_address);   // Address LSB Byte
}

void finish_memory_read() {
	cs_high();
}

// -----------------------------------------------------------------
// 					Channel conversion
// -----------------------------------------------------------------

void convert_channel(byte channel_number) {
	// initiate a new conversion
	initialize_memory_write(0);
	spi_write(0b10000000 | channel_number); // start a conversion
	finish_memory_write();

//******************** LOCKS UP HERE *********************************************************************************
	
	while (conversion_done()==0); // When this line is edited out, main.c loops and sends data to rs232
                                  // I am not sure if SPI Read/ Write is jamming the program up?????
                                  
//*********************************************************************************************************************

}

boolean conversion_done() {	
	initialize_memory_read(0x00); // was 0
	byte data = spi_read(0x00);   
	finish_memory_read();
	return(data & 0b01000000);
}

// -----------------------------------------------------------------
// 					Getting temperature results
// -----------------------------------------------------------------

float read_temperature_results(int channel_number) {
	unsigned char raw_results[4];
	get_raw_results(READ_CH_BASE, channel_number, raw_results);
	float signed_float = convert_to_signed_float(raw_results);
	float temperature_result = get_temperature(signed_float);
	//print_temperature_result(channel_number, temperature_result);
	//print_fault_data(raw_results[3]);
	return (temperature_result);
	return (byte)temperature_result;
}

float read_direct_adc_results(int channel_number) {
	unsigned char raw_results[4];
	get_raw_results(READ_CH_BASE, channel_number, raw_results);
	float signed_float = convert_to_signed_float(raw_results);
	float direct_adc_reading = get_direct_adc_reading(signed_float);
	print_direct_adc_reading(channel_number, direct_adc_reading);
	print_fault_data(raw_results[3]);
	return (direct_adc_reading);
}

void get_raw_results(long base_address, int channel_number, unsigned char results[4]) {
	long address = base_address+4*(channel_number-1);
	initialize_memory_read(address);

	results[3]=spi_read(0x00); // fault data
	results[2]=spi_read(0x00); // MSB result byte
	results[1]=spi_read(0x00); // 2nd result byte
	results[0]=spi_read(0x00); // LSB result byte
	
	finish_memory_read();
}

float convert_to_signed_float(unsigned char results[4]) {
	// Get the last 24 bits of the results (the first 8 bits are status bits)
	long x = 0L;
	x= x | ((unsigned long) results[2]<<16)
	| ((unsigned long) results[1]<<8)
	| ((unsigned long) results[0]);
	
	// Convert a 24-bit two's complement number into a 32-bit two's complement number
	boolean sign;
	if ((results[2]&0b10000000)==128) sign=true; else sign=false;
	if (sign) x=x | 0xFF000000;

	return (float)x;  // changed from float (x);
}

float get_temperature(float x) {
	// The temperature format is (14, 10) so we divide by 2^10
	return x/1024;
}

float get_direct_adc_reading(float x) {
	// The direct ADC format is (3, 21) so we divide by 2^21
	return x/2097152;
}

// -----------------------------------------------------------------
// 		Getting raw results -
//    voltage (for thermocouples), resistance (for RTDs/thermistors)
// -----------------------------------------------------------------

float read_voltage_or_resistance_results(int channel_number) {
	unsigned char raw_results[4];
	get_raw_results(VOUT_CH_BASE, channel_number, raw_results);
	float signed_float = convert_vr_to_signed_float(raw_results);
	float voltage_or_resistance_result = get_voltage_or_resistance(signed_float);
	//print_voltage_or_resistance_result(channel_number, voltage_or_resistance_result);
	return (voltage_or_resistance_result);
}

float convert_vr_to_signed_float(unsigned char results[4]) {
	long x = 0L;
	x= x | ((unsigned long) results[3]<<24)
	| ((unsigned long) results[2]<<16)
	| ((unsigned long) results[1]<<8)
	| ((unsigned long) results[0]);
	return (float)x;
}

float get_voltage_or_resistance(float x) {
	// The format is (14, 10) so we divide by 2^10
	return x/1024;
}

// -----------------------------------------------------------------

// Find out if a number is an element in an array
bool is_number_in_array(int number, int *array, int array_length) {
	int i;
	bool found = false;
	for (i=0; i< array_length; i++) {
		if (number == array[i]) {
			found = true;
		}
	}
	return found;
}

// File:  spi.c
   
  
#include <avr/io.h>
#include <util/delay.h>
//#include "spi.h"
#include "rs232.h"

typedef unsigned char byte;     

void initialize_spi(void) {
	DDRB |= (1<<2)|(1<<3)|(1<<5);    // CS (PB2), MOSI (PB3) and SCK (PB5) as outputs
	DDRB &= ~(1<<4);                 // MISO (PB4) as input

	SPCR |= (1<<MSTR);               // Set as Master
	SPCR |= (1<<SPR1)|(1<<SPI2X);    // divided clock by 32 (set to 500khz SCK)
	SPCR |= (1<<SPE);                // Enable SPI
	
	/* System FOSC is 16MhZ 
	    16Mhz/32 = 500Mhz  */
	
}

void cs_low(void){
	PORTB &= ~ (1 << PINB2);  // CS Low
	_delay_us(1);
}

void cs_high(void){
	PORTB |= (1 << PINB2);   // CS high
}

void spi_write(byte data){       
	//write_rs232(data);
	//_delay_ms(1000);
	SPDR = data;    		        // send the data
	while((SPSR & (1<<SPIF)) == 0);  	// wait until transmission is complete	
}

byte spi_read(byte data){
	SPDR = data;			       // send the data
	while((SPSR & (1<<SPIF)) == 0);	       // wait until transmission is complete	 
	return SPDR;
}

 

OK, can you point me in the direction of a good (cheap) reader in the UK.

Thanks for your help.

Ok, When I add a break-point, then select "start debugging and break", the break point goes nearly invisible and says "The current selected device is unable to hit breakpoints at runtime".  I come out of debugging, and try again and it says the same.

Also the watch on data variable in "spi_write function" when debug is started and yellow cursor is on main, the data variable says 12, in yet the program is only just started.  On start up should this not be zero?

Thanks, 

Yep, ATmega328P xplained development board, using Atmel Studio 6.2, and onboard eDBG debugger.

Hiya,

Yes kartman I have double checked I have all pins connected correctly - thanks.

Included below are my SPI logic analyzer screen shoots.  It looks like the MISO is stuck high, and the clock varies a bit. 

So the CS is working, SCK is working, MOSI is working, but MISO is stuck high.

I thought you want to keep updated, still trying to work out problem.  Cheers.

Hi Kartman,

No, that change never worked.

What karts do you race.  Are you rotax max?

Cheers,

Hi Kartman,

I read datasheets as (CPOL=0, CPHA=0).  Which is the opposite to the good results below ( CPOL=0, CPHA=1 and DORD =1)

Hi Kartman,

I have been studying datasheets hard the last 24 hours.  On the analyzer front I bought the analyzer, learned, then used, so to be honest I thought default mode was OK.  So are my bits correct, but the analyzer is showing in reverse?

Also the msb and lsb were revered because I am trying to replicate the commands below of the LTC2983 data sheet.  The initial analyzer screen shot came out sending 0xE0 not 0x03.  So changing to ( CPOL=0, CPHA=1 and DORD =1) gave me 0x03.  This was my reasoning. 

LTC2983 SENSOR DATASHEET - INSTRUCTION SPI INSTRUCTION BYTE DESCRIPTION - PAGE 14.

Read 0b00000011 See Figure 1
Write 0b00000010 See Figure 2
No Opp 0bXXXXXX0X

(RECEIVER SAMPLES DATA ON RISING EDGE) (TRANSMITTER TRANSITIONS DATA ON FALLING EDGE)

ATmega328P DATASHEET - SPI PAGE 165

SPI Mode Conditions Leading Edge Trailing Edge

0 CPOL=0, CPHA=0 Sample (Rising) Setup (Falling)
1 CPOL=0, CPHA=1 Setup (Rising) Sample (Falling)
2 CPOL=1, CPHA=0 Sample (Falling) Setup (Rising)
3 CPOL=1, CPHA=1 Setup (Falling) Sample (Rising)

So my conclusion is use ( CPOL=0, CPHA=0 and DORD =1) - unless analyzer is showing in reverse.  Also my clock frequency is 500khz and yet the screen shot shows 144khz? Attached is my screen shot not in SPI mode.

Thanks,   My internet is so slow uploading pics!!!!!!!!!!!!!!!!!!

Edit,

Sorry this is the code that calls initialize_merory_read()

void convert_channel(byte channel_number) {
	// initiate a new conversion
	initialize_memory_write(0);
	//_delay_us(1);
	spi_write(0b10000000 | channel_number); // start a conversion
	//_delay_us(1);
	finish_memory_write();
	//_delay_ms(300);
	
	while (conversion_done()==0); // wait for conversion to complete  ///////////////////////// Problem area.
}

boolean conversion_done() {	
	initialize_memory_read(0x00); 
	//_delay_ms(10);
	byte data = spi_read(0x00);   
	finish_memory_read();
	return(data & 0b01000000);
}

Hi Kartman,

Yes you are correct it is a supercharger.  A turbo looks a bit boring, this supercharger looked quite nice all bling and polished.  Most people don't know the difference.

Will will have a serious Rotax Max chat when i get this darn sensor going.  

Also do you double wrap your exhaust, and run your oil have castor/ half synthetic to coke up your cylinder head to reduce head volume to make faster.  Your head volume is only checked at rebuild.  This is a UK go fast trick.  Most people just run 100% shell M.

This project is starting to wind me a little (a lot).

I have been on to manufacturer and they said maybe chip is faulty.

One last thing do you set I/O like this before a project or just setup is in SPI.c.  So I am doing twice for SPI and rs232?  I have tried with the below setup and without with no change :-(

Ok I will 11th time check the hardware connections.

Thanks again.

#include <avr/io.h>

void IO_configuration(void){
	
	// 1 = output, 0 = input
	
	// Initialize
	DDRB =  0b11111111;  // set all port pins as outputs
	DDRD =  0b11111111;  // set all port pins as outputs
	PORTB = 0b00000000;  // set all levels low
	PORTD = 0b00000000;  // set all levels low
	
	// Configure
	DDRB =  0b11101111;  // out, out, SCK, MISO, MOSI, SS, out, out
	DDRD =  0b11111110;  // out, out, out, out, out, out, Tx, Rx
	PORTB = 0b00000101; 
	PORTD = 0b00000000;
}

All wires are checked again.

What you reckon chip is broke?

Cannot think of any other checks now.

Unless its a type change getting mixed up.

After many hours of being in a landing pattern, It now has an output, but an output I cannot read yet as I have to typecast a float to a byte to print with rs232.

The problem was hardware related, the development board had a dry joint on it on one of the SPI pins.

Wow what a hard learning curve. 

So because I want to finish tonight, how would I type cast a Float to a Byte.  I would like to use sprintf(), but we cannot do this in embedded.  What would be the next best solution.

Many thanks for every bodies help along the way.