No changes between revisions
/Designs/Measuring_instruments/Fluxgate_magnetometer/SW/firmware/Makefile
0,0 → 1,35
PRG = fluxgate
OBJ = main.o ./libs/usart.o ./libs/spi.o ./libs/mcp4922.o
MCU_TARGET = atmega8
AVRDUDE_PART = m8
 
# OPTIMIZE = -O1
OPTIMIZE = -Os
 
CC = avr-gcc
override CFLAGS = -g -Wall $(OPTIMIZE) -mmcu=$(MCU_TARGET) $(DEFS)
OBJCOPY = avr-objcopy
OBJDUMP = avr-objdump
 
all: hex
 
#./libs/adc.o: ./libs/adc.h
./libs/spi.o: ./libs/spi.h
./libs/usart.o: ./libs/usart.h
./libs/mcp4922.o: ./libs/mcp4922.h
#./libs/timer.o: ./libs/timer.h
 
hex: $(PRG).hex
 
%.hex: %.elf
$(OBJCOPY) -j .text -j .data -O ihex $< $@
 
$(PRG).elf: $(OBJ)
$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^ $(LIBS)
 
load: $(PRG).hex
avrdude -p $(AVRDUDE_PART) -c stk500v2 -P /dev/ttyUSB1 -B 1 -U flash:w:$<
 
clean:
rm -rf *.o $(PRG).elf $(PRG).hex ./libs/*.o
 
Property changes:
Added: svn:executable
/Designs/Measuring_instruments/Fluxgate_magnetometer/SW/firmware/libs/adc.c
0,0 → 1,32
#include "adc.h"
 
#include <avr/io.h>
 
void AD_Init_Interrupt() {
ADMUX = 0b01000000; // PORTC_0,Vref=V_ACC,capacitor on AVREF
 
ADCSRA = (0b00000011); // 8 Prescaling
ADCSRA |= (1 << ADFR); // Set ADC to Free-Running Mode
ADCSRA |= (1 << ADIE); // enable interrupt
// sei();
ADCSRA |= (1 << ADEN); // Enable ADC
ADCSRA |= (1 << ADSC); // Start A2D Conversions
}
 
 
void AD_Init() {
ADMUX = 0b01000000; // PORTC_0,Vref=Vacc with cap. on ref.
 
ADCSRA |= (0b00000101); // 32 Prescaling
ADCSRA |= (1 << ADFR); // Set ADC to Free-Running Mode
ADCSRA |= (1 << ADEN); // Enable ADC
ADCSRA |= (1 << ADSC); // Start A2D Conversions
}
 
 
unsigned char AD_Read() {
char val;
val=(ADCL>>2); // low must be read first!! see datasheet...
val|=(ADCH<<6);
return val;
}
/Designs/Measuring_instruments/Fluxgate_magnetometer/SW/firmware/libs/adc.h
0,0 → 1,8
#ifndef ADC_H
#define ADC_H
 
void AD_Init_Interrupt();
void AD_Init();
unsigned char AD_Read();
 
#endif
/Designs/Measuring_instruments/Fluxgate_magnetometer/SW/firmware/libs/mcp4922.c
0,0 → 1,15
#include <avr/io.h>
#include "mcp4922.h"
#include "spi.h"
 
 
void DAC_write(unsigned char data) {
unsigned char first, second;
first=(0b10110000 | data>>4); // DACB, unbuffered, 1x, ON, 12 data bites
second=(data<<4);
DAC_CS_PORT &= ~(1 << DAC_CS_PIN);
SPI_MasterTransmit(first);
SPI_MasterTransmit(second);
DAC_CS_PORT |= 1 << DAC_CS_PIN;
}
/Designs/Measuring_instruments/Fluxgate_magnetometer/SW/firmware/libs/mcp4922.h
0,0 → 1,9
#ifndef MCP4922_H
#define MCP4922_H
 
#define DAC_CS_PORT PORTB
#define DAC_CS_PIN 1
 
void DAC_write(unsigned char data);
 
#endif
/Designs/Measuring_instruments/Fluxgate_magnetometer/SW/firmware/libs/spi.c
0,0 → 1,20
#include "spi.h"
 
#include <avr/io.h>
 
void SPI_MasterInit(void)
{
/* Enable SPI, Master, set clock rate fck/16, SCK high when idle, sample on rising */
// SPSR|= 0b00000001;
SPCR = 0b01011101;
}
 
unsigned char SPI_MasterTransmit(unsigned char cData) {
/* Start transmission */
SPDR = cData;
 
/* Wait for transmission complete */
while(!(SPSR & (1<<SPIF)))
;
return SPDR;
}
/Designs/Measuring_instruments/Fluxgate_magnetometer/SW/firmware/libs/spi.h
0,0 → 1,7
#ifndef SPI_H
#define SPI_H
 
void SPI_MasterInit(void);
unsigned char SPI_MasterTransmit(unsigned char cData);
 
#endif
/Designs/Measuring_instruments/Fluxgate_magnetometer/SW/firmware/libs/timer.c
0,0 → 1,14
#include "timer.h"
 
#include <avr/io.h>
 
void Timer0_Init_Interrupt() {
TIMSK |= 0b0000001; // Enable overflow interrupt tim0
TCCR0=0b00000010; //8 prescale,start timer
}
 
void Timer1_Init_Interrupt() {
TIMSK |= 0b00000100; // Enable overflow interrupt tim1
TCCR1B=0b00000010; //8 prescale,start timer
}
 
/Designs/Measuring_instruments/Fluxgate_magnetometer/SW/firmware/libs/timer.h
0,0 → 1,7
#ifndef TIMER_H
#define TIMER_H
 
void Timer0_Init_Interrupt();
void Timer1_Init_Interrupt();
 
#endif
/Designs/Measuring_instruments/Fluxgate_magnetometer/SW/firmware/libs/usart.c
0,0 → 1,104
#include "usart.h"
 
#include <avr/io.h>
 
 
void USART_Init( unsigned int ubrr)
{
/* Set baud rate */
UBRRH = (unsigned char)(ubrr>>8);
UBRRL = (unsigned char)ubrr;
 
/* flush transmitt register Double speed */
UCSRA = (1<<UDRE)|(1 << U2X);
 
/* enable receiver interrupt and transmitter, pins forced */
UCSRB = (1<<RXCIE)|(1<<RXEN)|(1<<TXEN);
 
/* Asynchronous, no parity, Set frame format: 8data, 1stop bit */
UCSRC = (1<<URSEL)|(1<<UCSZ0)|(1<<UCSZ1);
}
 
 
void USART_Transmit( unsigned char data )
{
while ( !( UCSRA & (1<<UDRE)) ); /* Wait for empty transmit buffer */
 
UDR = data; /* Put data into buffer, sends the data */
}
 
 
void USART_Transmit_string( char *data )
{
while ( *data != 0 ) {
USART_Transmit(*data);
data++;
}
}
 
 
void USART_Transmit_longnum(signed long data ) {
unsigned char digits[10],i;
 
if (data==0)
USART_Transmit('0');
else { // PROZKOUMAT!
 
if (data<0) {
USART_Transmit('-');
data*=-1;
}
 
for (i=0;i<10;i++) {
digits[i]=data%10;
data=data/10;
}
 
i=9;
while (digits[i]==0) i--;
while (i>0) {
USART_Transmit(digits[i]+48);
i--;
}
USART_Transmit(digits[0]+48);
 
}
}
 
 
void USART_Transmit_num(unsigned char data ) {
unsigned char a,b,c;
 
c=data%10;
data=data/10;
b=data%10;
data=data/10;
a=data%10;
 
USART_Transmit(a+48);
USART_Transmit(b+48);
USART_Transmit(c+48);
}
 
 
/*void USART_Transmit_float( float data ) {
int a,b,c;
 
c=((int)data)%10;
b=((int)(data/10))%10;
a=((int)(data/100))%10;
 
USART_Transmit(a+48);
USART_Transmit(b+48);
USART_Transmit(c+48);
}*/
 
 
void USART_Transmit_byte( char data ) {
unsigned char i;
i=0b10000000;
while (i) {
USART_Transmit( ( (i&data)&&1 ) + 48 );
i>>=1;
}
}
/Designs/Measuring_instruments/Fluxgate_magnetometer/SW/firmware/libs/usart.h
0,0 → 1,16
#ifndef USART_H
#define USART_H
 
//Inits:
void USART_Init( unsigned int ubrr); // 8b, no parity, 1 stop
// asynchronous, RX interrupt
 
// Busy loop send:
void USART_Transmit( unsigned char data ); // send char (1B)
void USART_Transmit_string( char *data ); // send string
void USART_Transmit_num( unsigned char data ); // send ascii
void USART_Transmit_longnum( signed long data ); // send ascii
//void USART_Transmit_float( float data );
void USART_Transmit_byte( char data ); //send in ascii hex reprezentation
 
#endif
/Designs/Measuring_instruments/Fluxgate_magnetometer/SW/firmware/main.c
0,0 → 1,145
// Template - Roman Pavelka, 2011
// written for atmega8
 
#define F_CPU 16000000
#define BAUD 1000000
//#define MYUBRR F_CPU/8/BAUD-1
#define MYUBRR 1
 
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
 
#include "./libs/usart.h"
#include "./libs/spi.h"
//#include "./libs/mcp4922.h"
//#include "./libs/adc.h"
//#include "./libs/timer.h"
 
 
#define LEN 128
 
void act(void);
void drive(unsigned char t);
 
int main (void) {
USART_Init(MYUBRR);
PORTC = 0b00000000; // drive port
DDRC = 0b00000011; // drive port out
 
DDRB = 0b00101110; //MOSI out CONV out, DAC CS out
PORTB = 0b00101010; // SCK, MOSI, CONV, DAC high
SPI_MasterInit();
 
sei();
 
while (1) ;
return 0;
}
 
 
void act(void) {
 
unsigned char data[2*LEN];
unsigned char i,j;
 
for(j=0;j<40;j++) {
for(i=0;i<LEN;i++) {
drive(i);
_delay_us(5);
}
}
 
for(i=0;i<LEN;i++) {
drive(i);
 
PORTB |= 0b00000100;
_delay_us(4); // converting
PORTB &= 0b11111011;
 
data[2*i]=SPI_MasterTransmit(0x0);
data[2*i+1]=SPI_MasterTransmit(0x0);
}
 
PORTC=0;
 
for(i=0;i<LEN;i++) {
USART_Transmit(data[2*i]);
// USART_Transmit(data[2*i+1]);
}
 
}
 
 
void value(void) {
 
unsigned char i,j;
long resultH,resultL;
 
resultH=0;
resultL=0;
 
for(j=0;j<32;j++) {
for(i=0;i<LEN;i++) {
drive(i);
_delay_us(5);
}
}
 
for(j=0;j<4;j++) {
for(i=0;i<LEN/2;i++) {
drive(i);
 
PORTB |= 0b00000100;
_delay_us(4); // converting
PORTB &= 0b11111011;
 
resultH+=(unsigned char)SPI_MasterTransmit(0x0);
resultL+=(unsigned char)SPI_MasterTransmit(0x0);
}
for(i=LEN/2;i<(LEN/4)*3;i++) { //dela podivnou kvantitatizaci vysledku
drive(i);
 
PORTB |= 0b00000100;
_delay_us(4); // converting
PORTB &= 0b11111011;
 
resultH-=(unsigned char)SPI_MasterTransmit(0x0);
resultL-=(unsigned char)SPI_MasterTransmit(0x0);
}
}
 
PORTC=0; // drive off
 
// resultH *= 256;
// USART_Transmit_longnum(resultH+resultL);
 
USART_Transmit_longnum(resultH);
 
USART_Transmit('\n');
}
 
 
ISR(USART_RXC_vect) {
cli();
char c;
 
c=UDR; //must be read to untrigger interupt
 
if (c=='a')
act();
else if (c=='v')
value();
 
sei();
}
 
 
void drive(unsigned char t) {
if (t<LEN/2)
PORTC = 0b00000001;
else
PORTC = 0b00000010;
}