.swp

# Generic AVR Makefile

# Brian Mayton <bmayton@media.mit.edu>

#

# This is a basic Makefile for building programs for the AVR.  I usually start

# with this for any new project; it's pretty versatile.

#

# 'make' builds the .hex file.

# 'make install' uses the programmer to load it onto the target chip.

# 'make fuses' programs the fuse bits on the target chip.

# 'make clean' removes all autogenerated files.

# OBJECTS should list all of the object files for the program (e.g. for each

# .c file, list a corresponding .o file here.)  APPLICATION just specifies the

# name of the hex/elf files, and can be whatever you want. 

OBJECTS = \

	analog_exp.o \

	uart.o \

	debug.o \

	onewire.o \

	onewire_hal_bitbang.o \

	excitation.o \

APPLICATION = analog_exp

# Set up which MCU you're using, and what programmer, and the clock speed

# here.

MCU = atmega168p

PROGRAMMER = jtag2isp

F_CPU = 8000000UL

# Make sure you check these fuse settings before actually using them, using

# fuse settings for the wrong clock setup or chip can make it hard to

# reprogram.  http://www.engbedded.com/fusecalc/ is very useful!

EFUSE=0x01

HFUSE=0xD7

LFUSE=0xE2

# Edit these if you want to use different compilers

CC = avr-gcc

OBJCOPY = avr-objcopy

SIZE = avr-size

AVRDUDE = avrdude

# Compiler and linker flags

CFLAGS=-mmcu=$(MCU) -Wall -DF_CPU=$(F_CPU) -I. -funsigned-char \

	-funsigned-bitfields -fpack-struct -fshort-enums -Os -DDEBUG --std=gnu99

LDFLAGS=-mmcu=$(MCU)

all: $(APPLICATION).hex

clean:

	rm -f *.hex *.elf *.o 

%.hex: %.elf

	$(OBJCOPY) -j .text -j .data -O ihex $< $@

$(APPLICATION).elf: $(OBJECTS)

	$(CC) $(LDFLAGS) -o $@ $^

	$(SIZE) -C --mcu=$(MCU) $@

%.o: %.c

	$(CC) $(CFLAGS) -c $< -o $@

install: all

	$(AVRDUDE) -p $(MCU) -c $(PROGRAMMER) -P usb -e \

		-U flash:w:$(APPLICATION).hex

fuses:

	$(AVRDUDE) -p $(MCU) -c $(PROGRAMMER) -P usb -e \

		-U lfuse:w:$(LFUSE):m -U hfuse:w:$(HFUSE):m \

		-U efuse:w:$(EFUSE):m

.PHONY: all clean install fuses

#include <util/delay.h>

#include "debug.h"

#include "onewire.h"

#include "excitation.h"

onewire_id onewire_devices[4];

    debug_setup();

    exc_setup();

    exc_enable(0, 0xFF);

    ds18b20_scratchpad_t scratchpad;

    _delay_ms(1000);

    uint8_t n_devices = 4;

    onewire_searchrom(onewire_devices, &n_devices);

    onewire_skiprom();

    onewire_convert_t();

    _delay_ms(750);

    debugf("%d devices\n", n_devices);

    for(uint8_t i=0; i<n_devices; i++) {

        debugf("  0x");

        for(uint8_t j=0; j<sizeof(onewire_id); j++) {

            debugf("%02X", onewire_devices[i][j]);

        }

        uint8_t crc = onewire_crc_rom(onewire_devices[i]);

        debugf(" crc: %d\n", crc);

        onewire_matchrom(onewire_devices[i]);

        crc = onewire_read_scratchpad(&scratchpad);

        debugf("    scratchpad crc: %d\n", crc);

        debugf("    temperature: %d.%04d\n", scratchpad.temperature >> 4, 

            (scratchpad.temperature & 0xF) * 625 );

    }

#define ONEWIRE_PORT         PORTB

#define ONEWIRE_PIN          PINB

#define ONEWIRE_DDR          DDRB

#define ONEWIRE              PB1

#include <stdio.h>

#include "uart.h"

#include "debug.h"

#ifdef DEBUG

static FILE uart_stream = FDEV_SETUP_STREAM(

    uart_putchar_f,

    uart_getchar_f,

    _FDEV_SETUP_RW

);

#endif

void debug_setup(void) {

#ifdef DEBUG

    stdout = &uart_stream;

    stderr = &uart_stream;

    uart_setup();

#endif

}

#ifdef DEBUG

void debug_printf(const char *fmt, ...) {

    va_list args;

    va_start(args, fmt);

    vfprintf_P(&uart_stream, fmt, args);

    va_end(args);

}

#endif

#ifndef __debug_h_

#define __debug_h_

#include <avr/pgmspace.h>

void debug_setup(void);

#ifdef DEBUG

    void debug_printf(const char *fmt, ...);

#   define debugf(format, ...) { \

        debug_printf(PSTR(format), ## __VA_ARGS__); \

    }

#else

#   define debugf(format, ...)

#endif

#endif // __debug_h_

#include <avr/io.h>

#include "board.h"

#include "excitation.h"

#define SPI_CS_HIGH() EXC_SPI_PORT |=  (1<<EXC_SPI_SS)

#define SPI_CS_LOW()  EXC_SPI_PORT &= ~(1<<EXC_SPI_SS)

void exc_setup(void) {

    SPI_CS_HIGH();

    EXC_SPI_DDR |= (1<<EXC_SPI_MOSI) | (1<<EXC_SPI_SCK) | (1<<EXC_SPI_SS);

    SPCR = (1<<SPE) | (1<<MSTR);

    EXC_EN_DDR |= (1<<EXC_VEN0) | (1<<EXC_VEN1);

}

static uint8_t spi_transfer(uint8_t data) {

    SPDR = data;

    while(! (SPSR & (1<<SPIF)));

    return SPDR;

}

void exc_power_on(bool on) {

    SPI_CS_LOW();

    spi_transfer(EXC_CMD_ACR_WRITE);

    spi_transfer(on? EXC_SHDN_bm : 0);

    SPI_CS_HIGH();

}

void exc_enable(uint8_t ch, uint8_t value) {

    exc_power_on(true);

    SPI_CS_LOW();

    spi_transfer(EXC_CMD_WRITE | ch);

    spi_transfer(value);

    SPI_CS_HIGH();

    EXC_EN_PORT |= (ch? (1<<EXC_VEN1) : (1<<EXC_VEN0));

}

void exc_disable(uint8_t ch) {

    EXC_EN_PORT &= ~(ch? (1<<EXC_VEN1) : (1<<EXC_VEN0));

    if((EXC_EN_PORT & ((1<<EXC_VEN1) | (1<<EXC_VEN0))) == 0) {

        exc_power_on(false);

    }

}

#ifndef __excitation_h_

#define __excitation_h_

#include <stdint.h>

#include <stdbool.h>

void exc_setup(void);

void exc_power_on(bool on);

void exc_enable(uint8_t ch, uint8_t value);

void exc_disable(uint8_t ch);

#define EXC_CMD_ACR_READ 0x20

#define EXC_CMD_ACR_WRITE 0x60

#define EXC_CMD_READ 0x80

#define EXC_CMD_WRITE 0xC0

#define EXC_REG_ACR 0x10

#define EXC_REG_WR1 0x1

#define EXC_REG_WR0 0x0

#define EXC_SHDN_bm (1<<6)

#define EXC_SDO_bm = (1<<1)

#endif // __excitation_h_

#include <string.h>

#include "debug.h"

uint8_t onewire_rx_byte(void) {

    onewire_reset();

    onewire_reset();

void onewire_skiprom(void) {

    onewire_reset();

    onewire_tx_byte(ONEWIRE_CMD_SKIPROM);

}

                deviation = bit_index;

            } else if((state->bit_pattern[bit_index / 8] & (1<<(bit_index % 8))) == 0) {

        if(state->bit_pattern[bit_index / 8] & (1<<(bit_index % 8))) {

    if(deviation == -1) state->done = true;

    state.prev_deviation = -1;

    memset(state.bit_pattern, 0, sizeof(onewire_id));

        *n = *n - 1;

static uint8_t onewire_crc8_byte(uint8_t seed, uint8_t data) {

    const uint8_t poly = 0x18;

    for(uint8_t i=0; i<8; i++) {

        if((data ^ seed) & 1) {

            seed = ((seed ^ poly) >> 1) | 0x80;

        } else {

            seed >>= 1;

        }

        data >>= 1;

    }

    return seed;

}

uint8_t onewire_crc8(uint8_t *data, uint8_t length) {

    uint8_t crc = 0;

    for(; length > 0; length--) {

        crc = onewire_crc8_byte(crc, *data++);

    }

    return crc;

}

bool onewire_crc_rom(onewire_id id) {

    return onewire_crc8(id, 8) == 0;

}

void onewire_convert_t(void) {

    onewire_tx_byte(ONEWIRE_CMD_CONVERT_T);

}

void onewire_write_scratchpad(uint8_t th, uint8_t tl, uint8_t config) {

    onewire_tx_byte(ONEWIRE_CMD_WRITE_SCRATCHPAD);

    onewire_tx_byte(th);

    onewire_tx_byte(tl);

    onewire_tx_byte(config);

}

bool onewire_read_scratchpad(ds18b20_scratchpad_t *scratchpad) {

    onewire_tx_byte(ONEWIRE_CMD_READ_SCRATCHPAD);

    uint8_t *buf = (uint8_t*)scratchpad;

    for(uint8_t i=0; i<sizeof(ds18b20_scratchpad_t); i++) {

        *buf++ = onewire_rx_byte();

    }

    return onewire_crc8((uint8_t*)scratchpad, sizeof(ds18b20_scratchpad_t)) == 0;

}

#include <stdbool.h>

typedef uint8_t onewire_id[8];

typedef struct {

    int16_t temperature;

    uint8_t threshold_h;

    uint8_t threshold_l;

    uint8_t config;

    uint8_t resv0;

    uint8_t resv1;

    uint8_t resv2;

    uint8_t crc;

} ds18b20_scratchpad_t;

void onewire_skiprom(void);

uint8_t onewire_crc8(uint8_t *data, uint8_t length);

bool onewire_crc_rom(onewire_id id);

void onewire_convert_t(void);

void onewire_write_scratchpad(uint8_t th, uint8_t tl, uint8_t config);

bool onewire_read_scratchpad(ds18b20_scratchpad_t *scratchpad);

#define ONEWIRE_CMD_CONVERT_T 0x44

#define ONEWIRE_CMD_WRITE_SCRATCHPAD 0x4E

#define ONEWIRE_CMD_READ_SCRATCHPAD 0xBE

#define ONEWIRE_CMD_COPY_SCRATCHPAD 0x48

#define ONEWIRE_CMD_RECALL_EE 0xB8

#define ONEWIRE_CMD_READ_POWER 0xB4

#define ONEWIRE_LOW()  ONEWIRE_DDR |=  (1<<ONEWIRE)

#define ONEWIRE_HIGH() ONEWIRE_DDR &= ~(1<<ONEWIRE)

#define ONEWIRE_IN     ((ONEWIRE_PIN & (1<<ONEWIRE)) >> ONEWIRE)

        ONEWIRE_PORT &= ~(1<<ONEWIRE);

        ONEWIRE_LOW();

        ONEWIRE_HIGH();

        presence = (ONEWIRE_IN == 0);

        _delay_us(410);

        ONEWIRE_LOW();

        ONEWIRE_HIGH();

        ONEWIRE_LOW();

        ONEWIRE_HIGH();

        ONEWIRE_LOW();

        ONEWIRE_HIGH();

        bit = ONEWIRE_IN;

#include <avr/io.h>

#include <avr/interrupt.h>

#include "uart.h"

// UART buffers

volatile char rxbuf[64];

volatile uint8_t rdptr = 0;

volatile uint8_t wrptr = 0;

/**

 * Set up the UART

 */

void uart_setup(void) {

    DDRD |= (1<<TXD_PIN);

	UBRR0H = 0;

	UBRR0L = 25;

	UCSR0A |= (0<<U2X0);

	UCSR0B |= (1<<RXEN0) | (1<<TXEN0) | (1<<RXCIE0);

}

void uart_putchar(uint8_t c) {

	while( ! (UCSR0A & (1<<UDRE0)) );

	UDR0 = c;

}

int uart_putchar_f(char c, FILE *stream) {

    if(c == '\n') uart_putchar_f('\r', stream);

	while( ! (UCSR0A & (1<<UDRE0)) );

	UDR0 = c;

    return 0;

}

void uart_putdata(uint8_t *data, uint8_t count) {

	int i;

	for(i=0; i<count; i++) uart_putchar(data[i]);

}

uint8_t uart_data_available() {

    return !(rdptr == wrptr);

}

int16_t uart_getchar(uint8_t blocking) {

	char c;

    if(blocking)

        while(rdptr == wrptr);

    else

        if(rdptr == wrptr) return -1;

	c = rxbuf[rdptr];

	rdptr = (rdptr + 1) & 63;

	return c;

}

int uart_getchar_f(FILE *stream) {

    char c;

    while(rdptr == wrptr);

    c = rxbuf[rdptr];

    rdptr = (rdptr + 1) & 63;

    return c;

}

/**

 * UART Receive ISR

 */

ISR(USART_RX_vect) {

	rxbuf[wrptr] = UDR0;

    //uart_putchar(rxbuf[wrptr]);

	wrptr = (wrptr + 1) & 63;

	if(wrptr == rdptr) rdptr = (rdptr + 1) & 63;

}

#ifndef __uart_h_

#define __uart_h_

#include <stdio.h>

#define RXD_PIN 0

#define TXD_PIN 1

void uart_setup(void);

int16_t uart_getchar(uint8_t blocking);

void uart_putchar(uint8_t c);

void uart_putdata(uint8_t *data, uint8_t count);

uint8_t uart_data_available();

int uart_getchar_f(FILE *stream);

int uart_putchar_f(char c, FILE *stream);

#endif // __uart_h_