dan/AVR_Learning
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Started following some tutorial on att85 usi. Downloaded example code from make avr book.

Browse Source
This commit is contained in:
Dan
2022-09-20 01:08:01 -04:00
parent d0cbc0000e
commit 361a828c46
295 changed files with 68746 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

105
Make AVR Examples/Chapter17_I2C/loggingThermometer/25LC256.c Normal file
View File

@@ -0,0 +1,105 @@
#include "25LC256.h"
void initSPI(void) {
SPI_SS_DDR |= (1 << SPI_SS); /* set SS output */
SPI_SS_PORT |= (1 << SPI_SS); /* start off not selected (high) */
SPI_MOSI_DDR |= (1 << SPI_MOSI); /* output on MOSI */
SPI_MISO_PORT |= (1 << SPI_MISO); /* pullup on MISO */
SPI_SCK_DDR |= (1 << SPI_SCK); /* output on SCK */
/* Don't have to set phase, polarity b/c
default works with 25LCxxx chips */
SPCR |= (1 << SPR1); /* div 16, safer for breadboards */
SPCR |= (1 << MSTR); /* clockmaster */
SPCR |= (1 << SPE); /* enable */
}
void SPI_tradeByte(uint8_t byte) {
SPDR = byte; /* SPI starts sending immediately */
loop_until_bit_is_set(SPSR, SPIF); /* wait until done */
/* SPDR now contains the received byte */
}
void EEPROM_send16BitAddress(uint16_t address) {
SPI_tradeByte((uint8_t) (address >> 8)); /* most significant byte */
SPI_tradeByte((uint8_t) address); /* least significant byte */
}
uint8_t EEPROM_readStatus(void) {
SLAVE_SELECT;
SPI_tradeByte(EEPROM_RDSR);
SPI_tradeByte(0); /* clock out eight bits */
SLAVE_DESELECT;
return (SPDR); /* return the result */
}
void EEPROM_writeEnable(void) {
SLAVE_SELECT;
SPI_tradeByte(EEPROM_WREN);
SLAVE_DESELECT;
}
uint8_t EEPROM_readByte(uint16_t address) {
SLAVE_SELECT;
SPI_tradeByte(EEPROM_READ);
EEPROM_send16BitAddress(address);
SPI_tradeByte(0);
SLAVE_DESELECT;
return (SPDR);
}
uint16_t EEPROM_readWord(uint16_t address) {
uint16_t eepromWord;
SLAVE_SELECT;
SPI_tradeByte(EEPROM_READ);
EEPROM_send16BitAddress(address);
SPI_tradeByte(0);
eepromWord = SPDR;
eepromWord = (eepromWord << 8); /* most-sig bit */
SPI_tradeByte(0);
eepromWord += SPDR; /* least-sig bit */
SLAVE_DESELECT;
return (eepromWord);
}
void EEPROM_writeByte(uint16_t address, uint8_t byte) {
EEPROM_writeEnable();
SLAVE_SELECT;
SPI_tradeByte(EEPROM_WRITE);
EEPROM_send16BitAddress(address);
SPI_tradeByte(byte);
SLAVE_DESELECT;
while (EEPROM_readStatus() & _BV(EEPROM_WRITE_IN_PROGRESS)) {;
}
}
void EEPROM_writeWord(uint16_t address, uint16_t word) {
EEPROM_writeEnable();
SLAVE_SELECT;
SPI_tradeByte(EEPROM_WRITE);
EEPROM_send16BitAddress(address);
SPI_tradeByte((uint8_t) (word >> 8));
SPI_tradeByte((uint8_t) word);
SLAVE_DESELECT;
while (EEPROM_readStatus() & _BV(EEPROM_WRITE_IN_PROGRESS)) {;
}
}
void EEPROM_clearAll(void) {
uint8_t i;
uint16_t pageAddress = 0;
while (pageAddress < EEPROM_BYTES_MAX) {
EEPROM_writeEnable();
SLAVE_SELECT;
SPI_tradeByte(EEPROM_WRITE);
EEPROM_send16BitAddress(pageAddress);
for (i = 0; i < EEPROM_BYTES_PER_PAGE; i++) {
SPI_tradeByte(0);
}
SLAVE_DESELECT;
pageAddress += EEPROM_BYTES_PER_PAGE;
while (EEPROM_readStatus() & _BV(EEPROM_WRITE_IN_PROGRESS)) {;
}
}
}

60
Make AVR Examples/Chapter17_I2C/loggingThermometer/25LC256.h Normal file
View File

@@ -0,0 +1,60 @@
/* SPI EEPROM 25LC256 Library */
#include <avr/io.h>
#include "pinDefines.h"
/* Which pin selects EEPROM as slave? */
#define SLAVE_SELECT SPI_SS_PORT &= ~(1 << SPI_SS)
#define SLAVE_DESELECT SPI_SS_PORT |= (1 << SPI_SS)
// Instruction Set -- from data sheet
#define EEPROM_READ 0b00000011 /* read memory */
#define EEPROM_WRITE 0b00000010 /* write to memory */
#define EEPROM_WRDI 0b00000100 /* write disable */
#define EEPROM_WREN 0b00000110 /* write enable */
#define EEPROM_RDSR 0b00000101 /* read status register */
#define EEPROM_WRSR 0b00000001 /* write status register */
// EEPROM Status Register Bits -- from data sheet
// Use these to parse status register
#define EEPROM_WRITE_IN_PROGRESS 0
#define EEPROM_WRITE_ENABLE_LATCH 1
#define EEPROM_BLOCK_PROTECT_0 2
#define EEPROM_BLOCK_PROTECT_1 3
#define EEPROM_BYTES_PER_PAGE 64
#define EEPROM_BYTES_MAX 0x7FFF
// Functions
void initSPI(void);
/* Init SPI to run EEPROM with phase, polarity = 0,0 */
void SPI_tradeByte(uint8_t byte);
/* Generic. Just loads up HW SPI register and waits */
void EEPROM_send16BitAddress(uint16_t address);
/* splits 16-bit address into 2 bytes, sends both */
uint8_t EEPROM_readStatus(void);
/* reads the EEPROM status register */
void EEPROM_writeEnable(void);
/* helper: sets EEPROM write enable */
uint8_t EEPROM_readByte(uint16_t address);
/* gets a byte from a given memory location */
uint16_t EEPROM_readWord(uint16_t address);
/* gets two bytes from a given memory location */
void EEPROM_writeByte(uint16_t address, uint8_t byte);
/* writes a byte to a given memory location */
void EEPROM_writeWord(uint16_t address, uint16_t word);
/* gets two bytes to a given memory location */
void EEPROM_clearAll(void);
/* sets every byte in memory to zero */

196
Make AVR Examples/Chapter17_I2C/loggingThermometer/Makefile Normal file
View File

@@ -0,0 +1,196 @@
##########------------------------------------------------------##########
########## Project-specific Details ##########
########## Check these every time you start a new project ##########
##########------------------------------------------------------##########
MCU = atmega168p
F_CPU = 8000000UL
BAUD = 9600UL
## Also try BAUD = 19200 or 38400 if you're feeling lucky.
## A directory for common include files and the simple USART library.
## If you move either the current folder or the Library folder, you'll
## need to change this path to match.
LIBDIR = ../../AVR-Programming-Library
##########------------------------------------------------------##########
########## Programmer Defaults ##########
########## Set up once, then forget about it ##########
########## (Can override. See bottom of file.) ##########
##########------------------------------------------------------##########
PROGRAMMER_TYPE = usbtiny
# extra arguments to avrdude: baud rate, chip type, -F flag, etc.
PROGRAMMER_ARGS =
##########------------------------------------------------------##########
########## Program Locations ##########
########## Won't need to change if they're in your PATH ##########
##########------------------------------------------------------##########
CC = avr-gcc
OBJCOPY = avr-objcopy
OBJDUMP = avr-objdump
AVRSIZE = avr-size
AVRDUDE = avrdude
##########------------------------------------------------------##########
########## Makefile Magic! ##########
########## Summary: ##########
########## We want a .hex file ##########
########## Compile source files into .elf ##########
########## Convert .elf file into .hex ##########
########## You shouldn't need to edit below. ##########
##########------------------------------------------------------##########
## The name of your project (without the .c)
# TARGET = blinkLED
## Or name it automatically after the enclosing directory
TARGET = $(lastword $(subst /, ,$(CURDIR)))
# Object files: will find all .c/.h files in current directory
# and in LIBDIR. If you have any other (sub-)directories with code,
# you can add them in to SOURCES below in the wildcard statement.
SOURCES=$(wildcard *.c $(LIBDIR)/*.c)
OBJECTS=$(SOURCES:.c=.o)
HEADERS=$(SOURCES:.c=.h)
## Compilation options, type man avr-gcc if you're curious.
CPPFLAGS = -DF_CPU=$(F_CPU) -DBAUD=$(BAUD) -I. -I$(LIBDIR)
CFLAGS = -Os -g -std=gnu99 -Wall
## Use short (8-bit) data types
CFLAGS += -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums
## Splits up object files per function
CFLAGS += -ffunction-sections -fdata-sections
LDFLAGS = -Wl,-Map,$(TARGET).map
## Optional, but often ends up with smaller code
LDFLAGS += -Wl,--gc-sections
## Relax shrinks code even more, but makes disassembly messy
## LDFLAGS += -Wl,--relax
## LDFLAGS += -Wl,-u,vfprintf -lprintf_flt -lm ## for floating-point printf
## LDFLAGS += -Wl,-u,vfprintf -lprintf_min ## for smaller printf
TARGET_ARCH = -mmcu=$(MCU)
## Explicit pattern rules:
## To make .o files from .c files
%.o: %.c $(HEADERS) Makefile
$(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c -o $@ $<;
$(TARGET).elf: $(OBJECTS)
$(CC) $(LDFLAGS) $(TARGET_ARCH) $^ $(LDLIBS) -o $@
%.hex: %.elf
$(OBJCOPY) -j .text -j .data -O ihex $< $@
%.eeprom: %.elf
$(OBJCOPY) -j .eeprom --change-section-lma .eeprom=0 -O ihex $< $@
%.lst: %.elf
$(OBJDUMP) -S $< > $@
## These targets don't have files named after them
.PHONY: all disassemble disasm eeprom size clean squeaky_clean flash fuses
all: $(TARGET).hex
debug:
@echo
@echo "Source files:" $(SOURCES)
@echo "MCU, F_CPU, BAUD:" $(MCU), $(F_CPU), $(BAUD)
@echo
# Optionally create listing file from .elf
# This creates approximate assembly-language equivalent of your code.
# Useful for debugging time-sensitive bits,
# or making sure the compiler does what you want.
disassemble: $(TARGET).lst
disasm: disassemble
# Optionally show how big the resulting program is
size: $(TARGET).elf
$(AVRSIZE) -C --mcu=$(MCU) $(TARGET).elf
clean:
rm -f $(TARGET).elf $(TARGET).hex $(TARGET).obj \
$(TARGET).o $(TARGET).d $(TARGET).eep $(TARGET).lst \
$(TARGET).lss $(TARGET).sym $(TARGET).map $(TARGET)~ \
$(TARGET).eeprom
squeaky_clean:
rm -f *.elf *.hex *.obj *.o *.d *.eep *.lst *.lss *.sym *.map *~ *.eeprom
##########------------------------------------------------------##########
########## Programmer-specific details ##########
########## Flashing code to AVR using avrdude ##########
##########------------------------------------------------------##########
flash: $(TARGET).hex
$(AVRDUDE) -c $(PROGRAMMER_TYPE) -p $(MCU) $(PROGRAMMER_ARGS) -U flash:w:$<
## An alias
program: flash
flash_eeprom: $(TARGET).eeprom
$(AVRDUDE) -c $(PROGRAMMER_TYPE) -p $(MCU) $(PROGRAMMER_ARGS) -U eeprom:w:$<
avrdude_terminal:
$(AVRDUDE) -c $(PROGRAMMER_TYPE) -p $(MCU) $(PROGRAMMER_ARGS) -nt
## If you've got multiple programmers that you use,
## you can define them here so that it's easy to switch.
## To invoke, use something like `make flash_arduinoISP`
flash_usbtiny: PROGRAMMER_TYPE = usbtiny
flash_usbtiny: PROGRAMMER_ARGS = # USBTiny works with no further arguments
flash_usbtiny: flash
flash_usbasp: PROGRAMMER_TYPE = usbasp
flash_usbasp: PROGRAMMER_ARGS = # USBasp works with no further arguments
flash_usbasp: flash
flash_arduinoISP: PROGRAMMER_TYPE = avrisp
flash_arduinoISP: PROGRAMMER_ARGS = -b 19200 -P /dev/ttyACM0
## (for windows) flash_arduinoISP: PROGRAMMER_ARGS = -b 19200 -P com5
flash_arduinoISP: flash
flash_109: PROGRAMMER_TYPE = avr109
flash_109: PROGRAMMER_ARGS = -b 9600 -P /dev/ttyUSB0
flash_109: flash
##########------------------------------------------------------##########
########## Fuse settings and suitable defaults ##########
##########------------------------------------------------------##########
## Mega 48, 88, 168, 328 default values
LFUSE = 0x62
HFUSE = 0xdf
EFUSE = 0x00
## Generic
FUSE_STRING = -U lfuse:w:$(LFUSE):m -U hfuse:w:$(HFUSE):m -U efuse:w:$(EFUSE):m
fuses:
$(AVRDUDE) -c $(PROGRAMMER_TYPE) -p $(MCU) \
$(PROGRAMMER_ARGS) $(FUSE_STRING)
show_fuses:
$(AVRDUDE) -c $(PROGRAMMER_TYPE) -p $(MCU) $(PROGRAMMER_ARGS) -nv
## Called with no extra definitions, sets to defaults
set_default_fuses: FUSE_STRING = -U lfuse:w:$(LFUSE):m -U hfuse:w:$(HFUSE):m -U efuse:w:$(EFUSE):m
set_default_fuses: fuses
## Set the fuse byte for full-speed mode
## Note: can also be set in firmware for modern chips
set_fast_fuse: LFUSE = 0xE2
set_fast_fuse: FUSE_STRING = -U lfuse:w:$(LFUSE):m
set_fast_fuse: fuses
## Set the EESAVE fuse byte to preserve EEPROM across flashes
set_eeprom_save_fuse: HFUSE = 0xD7
set_eeprom_save_fuse: FUSE_STRING = -U hfuse:w:$(HFUSE):m
set_eeprom_save_fuse: fuses
## Clear the EESAVE fuse byte
clear_eeprom_save_fuse: FUSE_STRING = -U hfuse:w:$(HFUSE):m
clear_eeprom_save_fuse: fuses

39
Make AVR Examples/Chapter17_I2C/loggingThermometer/i2c.c Normal file
View File

@@ -0,0 +1,39 @@
#include "i2c.h"
void initI2C(void) {
/* set pullups for SDA, SCL lines */
I2C_SDA_PORT |= ((1 << I2C_SDA) | (1 << I2C_SCL));
TWBR = 32; /* set bit rate (p.242): 8MHz / (16+2*TWBR*1) ~= 100kHz */
TWCR |= (1 << TWEN); /* enable */
}
void i2cWaitForComplete(void) {
loop_until_bit_is_set(TWCR, TWINT);
}
void i2cStart(void) {
TWCR = (_BV(TWINT) | _BV(TWEN) | _BV(TWSTA));
i2cWaitForComplete();
}
void i2cStop(void) {
TWCR = (_BV(TWINT) | _BV(TWEN) | _BV(TWSTO));
}
uint8_t i2cReadAck(void) {
TWCR = (_BV(TWINT) | _BV(TWEN) | _BV(TWEA));
i2cWaitForComplete();
return (TWDR);
}
uint8_t i2cReadNoAck(void) {
TWCR = (_BV(TWINT) | _BV(TWEN));
i2cWaitForComplete();
return (TWDR);
}
void i2cSend(uint8_t data) {
TWDR = data;
TWCR = (_BV(TWINT) | _BV(TWEN)); /* init and enable */
i2cWaitForComplete();
}

22
Make AVR Examples/Chapter17_I2C/loggingThermometer/i2c.h Normal file
View File

@@ -0,0 +1,22 @@
// Functions for i2c communication
#include <avr/io.h>
#include "pinDefines.h"
void initI2C(void);
/* Sets pullups and initializes bus speed to 100kHz (at FCPU=8MHz) */
void i2cWaitForComplete(void);
/* Waits until the hardware sets the TWINT flag */
void i2cStart(void);
/* Sends a start condition (sets TWSTA) */
void i2cStop(void);
/* Sends a stop condition (sets TWSTO) */
void i2cSend(uint8_t data);
/* Loads data, sends it out, waiting for completion */
uint8_t i2cReadAck(void);
/* Read in from slave, sending ACK when done (sets TWEA) */
uint8_t i2cReadNoAck(void);
/* Read in from slave, sending NOACK when done (no TWEA) */

172
Make AVR Examples/Chapter17_I2C/loggingThermometer/loggingThermometer.c Normal file
View File

@@ -0,0 +1,172 @@
// ------- Preamble -------- //
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/power.h>
#include "pinDefines.h"
#include "USART.h"
#include "i2c.h" /* for i2c functions */
#include "25LC256.h" /* for EEPROM specific */
// -------- Defines --------- //
#define LM75_ADDRESS_W 0b10010000
#define LM75_ADDRESS_R 0b10010001
#define LM75_TEMP_REGISTER 0b00000000
#define LM75_CONFIG_REGISTER 0b00000001
#define LM75_THYST_REGISTER 0b00000010
#define LM75_TOS_REGISTER 0b00000011
#define CURRENT_LOCATION_POINTER 0
/* where to store a pointer to the current reading in EEPROM */
#define SECONDS_POINTER 2
/* store seconds-delay value here */
#define MEMORY_START 4
/* where to start logging temperature values */
#define MENU_DELAY 5
/* seconds to wait before bypassing main menu */
// -------- Functions --------- //
static inline void printTemperature(uint8_t tempReading) {
/* temperature stored as 2x Celcius */
printByte((tempReading >> 1));
if (tempReading & 1) {
printString(".5\r\n");
}
else {
printString(".0\r\n");
}
}
int main(void) {
uint16_t secondsDelay; /* how long to wait between readings */
uint16_t currentMemoryLocation; /* where are we in EEPROM? */
uint16_t i; /* used to count memory locations */
uint8_t tempHighByte, tempLowByte, temperatureByte; /* from LM75 */
uint8_t enterMenu; /* logical flag */
// -------- Inits --------- //
clock_prescale_set(clock_div_1); /* 8 MHz */
initSPI();
initI2C();
initUSART();
LED_DDR |= (1 << LED0);
/* Load up last values from EEPROM */
secondsDelay = EEPROM_readWord(SECONDS_POINTER);
/* Delay to allow input to enter main menu */
printString("*** Press [m] within ");
printByte(MENU_DELAY);
printString(" seconds to enter menu. ***\r\n ");
for (i = 0; i < MENU_DELAY; i++) {
_delay_ms(1000);
}
if (bit_is_set(UCSR0A, RXC0) && (UDR0 == 'm')) {
enterMenu = 1;
}
else {
enterMenu = 0;
}
while (enterMenu) {
printString("\r\n====[ Logging Thermometer ]====\r\n ");
currentMemoryLocation = EEPROM_readWord(CURRENT_LOCATION_POINTER);
printWord(currentMemoryLocation - MEMORY_START);
printString(" readings in log.\r\n ");
printWord(secondsDelay);
printString(" seconds between readings.\r\n");
printString(" [<] to shorten sample delay time\r\n");
printString(" [>] to increase sample delay time\r\n");
printString(" [?] to reset delay time to 60 sec\r\n");
printString(" [d] to print out log over serial\r\n");
printString(" [e] to erase memory\r\n");
printString(" [s] to start logging\r\n\r\n");
switch (receiveByte()) {
case 'd':
SLAVE_SELECT;
SPI_tradeByte(EEPROM_READ);
EEPROM_send16BitAddress(MEMORY_START);
for (i = MEMORY_START; i < currentMemoryLocation; i++) {
SPI_tradeByte(0);
printTemperature(SPDR);
}
SLAVE_DESELECT;
break;
case '<':
if (secondsDelay >= 10) {
secondsDelay -= 5;
EEPROM_writeWord(SECONDS_POINTER, secondsDelay);
}
break;
case '>':
if (secondsDelay < 65000) {
secondsDelay += 5;
EEPROM_writeWord(SECONDS_POINTER, secondsDelay);
}
break;
case '?':
secondsDelay = 60;
EEPROM_writeWord(SECONDS_POINTER, secondsDelay);
break;
case 'e':
printString("Clearing EEPROM, this could take a few seconds.\r\n");
EEPROM_clearAll();
EEPROM_writeWord(CURRENT_LOCATION_POINTER, MEMORY_START);
EEPROM_writeWord(SECONDS_POINTER, secondsDelay);
break;
case 's':
printString("OK, logging...\r\n");
enterMenu = 0;
break;
default:
printString("Sorry, didn't understand that.\r\n");
}
}
// ------ Event loop ------ //
while (1) {
currentMemoryLocation = EEPROM_readWord(CURRENT_LOCATION_POINTER);
/* Make sure in temperature mode */
i2cStart();
i2cSend(LM75_ADDRESS_W);
i2cSend(LM75_TEMP_REGISTER);
/* Get Temp from thermometer */
i2cStart(); /* Setup and send address, with read bit */
i2cSend(LM75_ADDRESS_R);
tempHighByte = i2cReadAck(); /* two bytes of temperature */
tempLowByte = i2cReadNoAck();
i2cStop();
temperatureByte = (tempHighByte << 1) | (tempLowByte >> 7);
/* temperatureByte now contains 2x the temperature in Celcius */
printTemperature(temperatureByte); /* serial output */
/* Save the new temperature value */
EEPROM_writeByte(currentMemoryLocation, temperatureByte);
/* move on to next location and record new position
if not already at the end of memory */
if (currentMemoryLocation < EEPROM_BYTES_MAX) {
currentMemoryLocation++;
EEPROM_writeWord(CURRENT_LOCATION_POINTER, currentMemoryLocation);
}
/* delay */
for (i = 0; i < secondsDelay; i++) {
_delay_ms(1000);
LED_PORT ^= (1 << LED0); /* blink to show working */
}
} /* End event loop */
return 0; /* This line is never reached */
}