maix-embedded/day06
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

ex01

Browse source
This commit is contained in:
Maix0 2026-04-21 16:44:13 +02:00
parent f021ef0fa6
commit 4f2b659b93
19 changed files with 1290 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

61
ex01/Makefile Normal file
View file

@ -0,0 +1,61 @@
# Makefile
MCU=atmega328p
F_CPU=16000000
CC=avr-gcc
OBJCOPY=avr-objcopy
WFLAGS=-Wall -Wextra
CFLAGS=--std=c99 -g -Os -mmcu=$(MCU) -ffunction-sections -fdata-sections
CPPFLAGS=-DF_CPU=$(F_CPU) -MMD -Iinclude
IFLAGS=
LDFLAGS=-Wl,--gc-sections
TARGET=main
SERIAL=-P /dev/ttyUSB0 -b 115200
SRC_DIR=src
OBJ_DIR=build
SRC_FILES=main.c utils.c uart.c rgb.c i2c.c aht20.c
OBJ_FILES=$(patsubst %.c,%.o,$(SRC_FILES))
DEP_FILES=$(patsubst %.c,%.d,$(SRC_FILES))
SRC=$(addprefix $(SRC_DIR)/,$(SRC_FILES))
OBJ=$(addprefix $(OBJ_DIR)/,$(OBJ_FILES))
DEP=$(addprefix $(OBJ_DIR)/,$(DEP_FILES))
ELF_FILE=$(OBJ_DIR)/$(TARGET).elf
HEX_FILE=$(OBJ_DIR)/$(TARGET).hex
all: flash
re: fclean all
fclean: clean
rm -f $(HEX_FILE)
rm -f $(ELF_FILE)
clean:
rm -rf $(OBJ_DIR)
hex: $(HEX_FILE)
flash: hex
avrdude -p $(MCU) -c arduino -U flash:w:$(HEX_FILE):i $(SERIAL)
$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c
@mkdir -p $(shell dirname $@)
$(CC) $(CPPFLAGS) $(WFLAGS) $(CFLAGS) $(IFLAGS) -c $< -o $@
$(ELF_FILE): $(OBJ)
$(CC) $(CFLAGS) $(LDFLAGS) $(OBJ) -o $@
$(HEX_FILE): $(ELF_FILE)
$(OBJCOPY) -j .text -j .data -O ihex $< $@
print:
@echo $(SRC)
@echo $(OBJ)
@echo $(ELF_FILE)
@echo $(HEX_FILE)
-include $(DEP);

74
ex01/include/adc.h Normal file
View file

@ -0,0 +1,74 @@
#ifndef ADC_H
#define ADC_H
#include <avr/io.h>
#include "mystd.h"
typedef enum e_adc_ref {
ADC_AREF = 0,
ADC_AVCC = BV(REFS0),
ADC_INT = BV(REFS0) | BV(REFS1),
_ADC_REF_MASK = BV(REFS0) | BV(REFS1),
} e_adc_ref;
typedef enum e_adc_size {
ADC_10BIT = 0,
ADC_8BIT = BV(ADLAR),
_ADC_SIZE_MASK = BV(ADLAR),
} e_adc_size;
typedef enum e_adc_prescaler {
ADC_PRESCALER_2 = BV(ADPS0),
ADC_PRESCALER_4 = BV(ADPS1),
ADC_PRESCALER_8 = BV(ADPS1) | BV(ADPS0),
ADC_PRESCALER_16 = BV(ADPS2),
ADC_PRESCALER_32 = BV(ADPS2) | BV(ADPS0),
ADC_PRESCALER_64 = BV(ADPS2) | BV(ADPS1),
ADC_PRESCALER_128 = BV(ADPS2) | BV(ADPS1) | BV(ADPS0),
_ADC_PRESCALER_MASK = BV(ADPS2) | BV(ADPS1) | BV(ADPS0),
} e_adc_prescaler;
typedef enum e_adc_input {
ADC_ADC0 = 0,
ADC_ADC1 = BV(MUX0),
ADC_ADC2 = BV(MUX1),
ADC_ADC3 = BV(MUX0) | BV(MUX1),
ADC_ADC4 = BV(MUX2),
ADC_ADC5 = BV(MUX2) | BV(MUX0),
ADC_ADC6 = BV(MUX2) | BV(MUX1),
ADC_ADC7 = BV(MUX2) | BV(MUX1) | BV(MUX0),
ADC_TEMP = BV(MUX3),
ADC_11V = BV(MUX3) | BV(MUX2) | BV(MUX1),
ADC_0V = BV(MUX3) | BV(MUX2) | BV(MUX1) | BV(MUX0),
_ADC_INPUT_MASK = BV(MUX0) | BV(MUX1) | BV(MUX2) | BV(MUX3),
} e_adc_input;
static inline uint8_t adc_read_pin(e_adc_input input) {
ADMUX = (ADMUX & ~(_ADC_INPUT_MASK | _ADC_SIZE_MASK)) | input | BV(ADLAR);
ADCSRA |= BV(ADSC);
while (ADCSRA & BV(ADSC))
;
return ADCH;
}
static inline uint16_t adc_read_pin_10bit(e_adc_input input) {
ADMUX = (ADMUX & ~(_ADC_SIZE_MASK | _ADC_INPUT_MASK)) | (input & _ADC_INPUT_MASK);
ADCSRA |= BV(ADSC);
while (ADCSRA & BV(ADSC))
;
return ADC;
}
static inline void adc_init(e_adc_ref v_ref, e_adc_prescaler prescaler) {
ADMUX = (ADMUX & ~(_ADC_REF_MASK)) | v_ref;
ADCSRA = BV(ADEN) | (prescaler & _ADC_PRESCALER_MASK);
(void)adc_read_pin(0);
}
#endif /* ADC_H */

18
ex01/include/aht20.h Normal file
View file

@ -0,0 +1,18 @@
#ifndef AHT20_H
#define AHT20_H
#include <avr/io.h>
typedef struct aht20_reading {
float temperature;
float humidity;
} aht20_reading;
aht20_reading aht20_read_measure(void);
uint8_t aht20_status(void);
void aht20_init(void);
void aht20_print_status(uint8_t status);
void aht20_trigger(void);
#define AHT20 (0x38)
#endif /* AHT20_H */

57
ex01/include/i2c.h Normal file
View file

@ -0,0 +1,57 @@
#ifndef I2C_H
#define I2C_H
#include <avr/io.h>
#include <util/twi.h>
#define PCA9555_ADDR_OTHER 0b0100111
#define PCA9555_ADDR_SELF 0b0100000
#define REG_INPUT_PORT0 0x00
#define REG_INPUT_PORT1 0x01
#define REG_OUTPUT_PORT0 0x02
#define REG_OUTPUT_PORT1 0x03
#define REG_CONFIG_PORT0 0x06
#define REG_CONFIG_PORT1 0x07
#define I2C_CLOCK 100000UL
#define I2C_ADDR(ADDR, RW) ((ADDR) << 1 | (RW & 1))
void i2c_init(void);
void i2c_start(void);
void i2c_stop(void);
void i2c_write(uint8_t);
uint8_t i2c_read_nack(void);
uint8_t i2c_read_ack(void);
uint8_t pca9555_read(uint8_t addr, uint8_t reg);
void pca9555_write(uint8_t addr, uint8_t reg, uint8_t value);
static inline void pca9555_set_output(uint8_t addr, uint8_t port, uint8_t mask) {
uint8_t cfg = pca9555_read(addr, port);
cfg &= ~mask;
pca9555_write(addr, port, cfg);
}
static inline void pca9555_set_low(uint8_t addr, uint8_t port, uint8_t mask) {
uint8_t out = pca9555_read(addr, port);
out &= ~mask; // clear bit
pca9555_write(addr, port, out);
}
static inline void pca9555_set_high(uint8_t addr, uint8_t port, uint8_t mask) {
uint8_t out = pca9555_read(addr, port);
out |= mask; // set bit;
pca9555_write(addr, port, out);
}
static inline void pca9555_toggle(uint8_t addr, uint8_t port, uint8_t mask) {
uint8_t out = pca9555_read(addr, port);
out ^= mask;
pca9555_write(addr, port, out);
}
#endif /* I2C_H */

15
ex01/include/interupt.h Normal file
View file

@ -0,0 +1,15 @@
#ifndef INTERUPT_H
#define INTERUPT_H
#include <avr/io.h>
#include "mystd.h"
static inline void my_sei(void) {
SREG |= BV(SREG_I);
}
static inline void my_cli(void) {
SREG &= ~BV(SREG_I);
}
#endif /* INTERUPT_H */

18
ex01/include/mystd.h Normal file
View file

@ -0,0 +1,18 @@
#ifndef MYSTDINT_H
#define MYSTDINT_H
#include <avr/io.h>
typedef unsigned char uint8_t;
typedef signed char int8_t;
typedef uint8_t bool;
#define true (1)
#define false (0)
#define BV(bit) (1 << bit)
#define NULL ((void*)0)
#endif /* MYSTDINT_H */

9
ex01/include/rgb.h Normal file
View file

@ -0,0 +1,9 @@
#ifndef RGB_H
#define RGB_H
#include "mystd.h"
void init_rgb(void);
void set_rgb(uint8_t r, uint8_t g, uint8_t b);
#endif /* RGB_H */

168
ex01/include/timer0.h Normal file
View file

@ -0,0 +1,168 @@
#ifndef TIMER0_H
# define TIMER0_H
# include <avr/io.h>
# include "mystd.h"
# include "timer_global.h"
static inline void t0_init_ctc_2(e_timer_prescaler prescaler) {
// Fast PWM (8-bit): WGM22:0 = 0b011
TCCR0A = BV(WGM01);
// reset to zero -> timer off
TCCR0B &= ~(BV(CS02) | BV(CS01) | BV(CS00));
// set the correct prescaler
switch (prescaler) {
case (PRESCALER_1): {
TCCR0B |= (BV(CS00));
break;
}
case (PRESCALER_8): {
TCCR0B |= (BV(CS01));
break;
}
case (PRESCALER_64): {
TCCR0B |= (BV(CS01) | BV(CS00));
break;
}
case (PRESCALER_256): {
TCCR0B |= (BV(CS02));
break;
}
case (PRESCALER_1024): {
TCCR0B |= (BV(CS02) | BV(CS00));
break;
}
case (PRESCALER_OFF): {
break;
}
}
}
static inline void t0_init_fpwm_3(e_timer_prescaler prescaler) {
// Fast PWM (8-bit): WGM22:0 = 0b011
TCCR0A = BV(WGM00) | BV(WGM01);
// reset to zero -> timer off
TCCR0B &= ~(BV(CS02) | BV(CS01) | BV(CS00));
// set the correct prescaler
switch (prescaler) {
case (PRESCALER_1): {
TCCR0B |= (BV(CS00));
break;
}
case (PRESCALER_8): {
TCCR0B |= (BV(CS01));
break;
}
case (PRESCALER_64): {
TCCR0B |= (BV(CS01) | BV(CS00));
break;
}
case (PRESCALER_256): {
TCCR0B |= (BV(CS02));
break;
}
case (PRESCALER_1024): {
TCCR0B |= (BV(CS02) | BV(CS00));
break;
}
case (PRESCALER_OFF): {
break;
}
}
}
static inline void t0_overflow_interrupt(bool enable) {
if (enable)
TIMSK0 |= BV(TOIE0);
else
TIMSK0 &= ~BV(TOIE0);
}
static inline void t0_interrupt(enum e_timer_output output, bool enable) {
if (output & TO_A) {
if (enable)
TIMSK0 |= BV(OCIE0A);
else
TIMSK0 &= ~BV(OCIE0A);
}
if (output & TO_B) {
if (enable)
TIMSK0 |= BV(OCIE0B);
else
TIMSK0 &= ~BV(OCIE0B);
}
}
static inline void t0_set_ocr(enum e_timer_output output, uint8_t value) {
if (output & TO_A)
OCR0A = value;
if (output & TO_B)
OCR0B = value;
}
static inline void t0_set_out_mode(enum e_timer_output output, enum e_timer_output_mode mode) {
if (output & TO_A) {
TCCR0A &= ~(BV(COM0A1) | BV(COM0A0));
switch (mode) {
case (TOM_00): {
break;
}
case (TOM_10): {
TCCR0A |= (BV(COM0A1));
break;
}
case (TOM_01): {
TCCR0A |= (BV(COM0A0));
break;
}
case (TOM_11): {
TCCR0A |= (BV(COM0A1) | BV(COM0A0));
break;
}
}
}
if (output & TO_B) {
TCCR0A &= ~(BV(COM0B1) | BV(COM0B0));
switch (mode) {
case (TOM_00): {
break;
}
case (TOM_10): {
TCCR0A |= (BV(COM0B1));
break;
}
case (TOM_01): {
TCCR0A |= (BV(COM0B0));
break;
}
case (TOM_11): {
TCCR0A |= (BV(COM0B1) | BV(COM0B0));
break;
}
}
}
}
// OC2B => RED => PD3
// OC0B => GREEN => PD5
// OC0A => BLUE => PD6
#endif /* TIMER0_H */
/*
// OC2B = PD3 → output
DDRD |= BV(DDD3) | BV(DDD5) | BV(DDD6);
// Fast PWM (8-bit): WGM22:0 = 0b011
TCCR0A = BV(WGM00) | BV(WGM01);
TCCR0A |= BV(COM0B1);
// 50% duty cycle
OCR0B = 128;
// Start timer, prescaler = 64
TCCR0B = BV(CS02);
*/

159
ex01/include/timer1.h Normal file
View file

@ -0,0 +1,159 @@
#ifndef TIMER1_H
#define TIMER1_H
#include <avr/io.h>
#include "mystd.h"
#include "timer_global.h"
static inline void t1_init_fpwm_14(e_timer_prescaler prescaler) {
// Fast PWM (8-bit): WGM22:0 = 0b011
TCCR1A = BV(WGM11);
TCCR1B = BV(WGM12) | BV(WGM13);
// set the correct prescaler
switch (prescaler) {
case (PRESCALER_1): {
TCCR1B |= (BV(CS10));
break;
}
case (PRESCALER_8): {
TCCR1B |= (BV(CS11));
break;
}
case (PRESCALER_64): {
TCCR1B |= (BV(CS11) | BV(CS10));
break;
}
case (PRESCALER_256): {
TCCR1B |= (BV(CS12));
break;
}
case (PRESCALER_1024): {
TCCR1B |= (BV(CS12) | BV(CS10));
break;
}
case (PRESCALER_OFF): {
break;
}
}
}
static inline void t1_init_ctc_4(e_timer_prescaler prescaler) {
// CTC mode 4
TCCR1A = 0;
TCCR1B = BV(WGM12);
// set the correct prescaler
switch (prescaler) {
case (PRESCALER_1): {
TCCR1B |= (BV(CS10));
break;
}
case (PRESCALER_8): {
TCCR1B |= (BV(CS11));
break;
}
case (PRESCALER_64): {
TCCR1B |= (BV(CS11) | BV(CS10));
break;
}
case (PRESCALER_256): {
TCCR1B |= (BV(CS12));
break;
}
case (PRESCALER_1024): {
TCCR1B |= (BV(CS12) | BV(CS10));
break;
}
case (PRESCALER_OFF): {
break;
}
}
}
static inline void t1_set_counter(uint16_t val) {
TCNT1 = val;
}
static inline void t1_set_icr1(uint16_t value) {
ICR1 = value;
}
static inline void t1_overflow_interrupt(bool enable) {
if (enable)
TIMSK1 |= BV(TOIE1);
else
TIMSK1 &= ~BV(TOIE1);
}
static inline void t1_interrupt(enum e_timer_output output, bool enable) {
if (output & TO_A) {
if (enable)
TIMSK1 |= BV(OCIE1A);
else
TIMSK1 &= ~BV(OCIE1A);
}
if (output & TO_B) {
if (enable)
TIMSK1 |= BV(OCIE1B);
else
TIMSK1 &= ~BV(OCIE1B);
}
}
static inline void t1_set_ocr(enum e_timer_output output, uint16_t value) {
if (output & TO_A)
OCR1A = value;
if (output & TO_B)
OCR1B = value;
}
static inline void t1_set_out_mode(enum e_timer_output output, enum e_timer_output_mode mode) {
if (output & TO_A) {
TCCR1A &= ~(BV(COM1A1) | BV(COM1A0));
switch (mode) {
case (TOM_00): {
break;
}
case (TOM_10): {
TCCR1A |= (BV(COM1A1));
break;
}
case (TOM_01): {
TCCR1A |= (BV(COM1A0));
break;
}
case (TOM_11): {
TCCR1A |= (BV(COM1A1) | BV(COM1A0));
break;
}
}
}
if (output & TO_B) {
TCCR1A &= ~(BV(COM1B1) | BV(COM1B0));
switch (mode) {
case (TOM_00): {
break;
}
case (TOM_10): {
TCCR1A |= (BV(COM1B1));
break;
}
case (TOM_01): {
TCCR1A |= (BV(COM1B0));
break;
}
case (TOM_11): {
TCCR1A |= (BV(COM1B1) | BV(COM1B0));
break;
}
}
}
}
// OC2B => RED => PD3
// OC0B => GREEN => PD5
// OC0A => BLUE => PD6
#endif /* TIMER1_H */

134
ex01/include/timer2.h Normal file
View file

@ -0,0 +1,134 @@
#ifndef TIMER2_H
# define TIMER2_H
# include <avr/io.h>
# include "mystd.h"
# include "timer_global.h"
static inline void t2_init_fpwm_3(e_timer_prescaler prescaler) {
// Fast PWM (8-bit): WGM22:0 = 0b011
TCCR2A = BV(WGM20) | BV(WGM21);
// reset to zero -> timer off
TCCR2B &= ~(BV(CS22) | BV(CS21) | BV(CS20));
// set the correct prescaler
switch (prescaler) {
case (PRESCALER_1): {
TCCR2B |= (BV(CS20));
break;
}
case (PRESCALER_8): {
TCCR2B |= (BV(CS21));
break;
}
case (PRESCALER_64): {
TCCR2B |= (BV(CS21) | BV(CS20));
break;
}
case (PRESCALER_256): {
TCCR2B |= (BV(CS22));
break;
}
case (PRESCALER_1024): {
TCCR2B |= (BV(CS22) | BV(CS20));
break;
}
case (PRESCALER_OFF): {
break;
}
}
}
static inline void t2_overflow_interrupt(bool enable) {
if (enable)
TIMSK2 |= BV(TOIE2);
else
TIMSK2 &= ~BV(TOIE2);
}
static inline void t2_interrupt(enum e_timer_output output, bool enable) {
if (output & TO_A) {
if (enable)
TIMSK2 |= BV(OCIE2A);
else
TIMSK2 &= ~BV(OCIE2A);
}
if (output & TO_B) {
if (enable)
TIMSK2 |= BV(OCIE2B);
else
TIMSK2 &= ~BV(OCIE2B);
}
}
static inline void t2_set_ocr(enum e_timer_output output, uint8_t value) {
if (output & TO_A)
OCR2A = value;
if (output & TO_B)
OCR2B = value;
}
static inline void t2_set_out_mode(enum e_timer_output output, enum e_timer_output_mode mode) {
if (output & TO_A) {
TCCR2A &= ~(BV(COM2A1) | BV(COM2A0));
switch (mode) {
case (TOM_00): {
break;
}
case (TOM_10): {
TCCR2A |= (BV(COM2A1));
break;
}
case (TOM_01): {
TCCR2A |= (BV(COM2A0));
break;
}
case (TOM_11): {
TCCR2A |= (BV(COM2A1) | BV(COM2A0));
break;
}
}
}
if (output & TO_B) {
TCCR2A &= ~(BV(COM2B1) | BV(COM2B0));
switch (mode) {
case (TOM_00): {
break;
}
case (TOM_10): {
TCCR2A |= (BV(COM2B1));
break;
}
case (TOM_01): {
TCCR2A |= (BV(COM2B0));
break;
}
case (TOM_11): {
TCCR2A |= (BV(COM2B1) | BV(COM2B0));
break;
}
}
}
}
// OC2B => RED => PD3
// OC0B => GREEN => PD5
// OC0A => BLUE => PD6
#endif /* TIMER0_H */
/*
// OC2B = PD3 → output
DDRD |= BV(DDD3) | BV(DDD5) | BV(DDD6);
// Fast PWM (8-bit): WGM22:0 = 0b011
TCCR2A = BV(GM20) | BV(GM21);
TCCR2A |= BV(COM2B1);
// 50% duty cycle
OCR0B = 128;
// Start timer, prescaler = 64
TCCR2B = BV(CS22);
*/

25
ex01/include/timer_global.h Normal file
View file

@ -0,0 +1,25 @@
#ifndef TIMER_GLOBAL_H
#define TIMER_GLOBAL_H
typedef enum e_timer_prescaler {
PRESCALER_OFF = 0,
PRESCALER_1 = 1,
PRESCALER_8 = 8,
PRESCALER_64 = 64,
PRESCALER_256 = 256,
PRESCALER_1024 = 1024,
} e_timer_prescaler;
typedef enum e_timer_output {
TO_A = (1 << 0),
TO_B = (1 << 1),
} e_timer_output;
typedef enum e_timer_output_mode {
TOM_00,
TOM_01,
TOM_10,
TOM_11,
} e_timer_output_mode;
#endif /* TIMER_GLOBAL_H */

26
ex01/include/uart.h Normal file
View file

@ -0,0 +1,26 @@
#ifndef UART_H
#define UART_H
#include "mystd.h"
void uart_init(void);
void uart_tx(char data);
void uart_sendstring(const char* str);
void uart_send_u8(uint8_t val);
void uart_send_u16(uint16_t val);
void uart_send_u32(uint32_t val);
void uart_send_u8_hex(uint8_t val);
void uart_send_u16_hex(uint16_t val);
static inline void print_hex_value(char c)
{
uart_send_u8_hex(c);
}
char uart_rx(void);
#endif /* UART_H */

13
ex01/include/utils.h Normal file
View file

@ -0,0 +1,13 @@
#ifndef UTILS_H
#define UTILS_H
#include "mystd.h"
void delay_ms(uint16_t count);
void ft_bzero(void* data, uint16_t size);
uint8_t ft_stridx(const char* str, char chr);
uint8_t ft_ftoa(float val, char* out, uint16_t precision);
#endif /* UTILS_H */

85
ex01/src/aht20.c Normal file
View file

@ -0,0 +1,85 @@
#include <avr/io.h>
#include <util/delay.h>
#include "aht20.h"
#include "i2c.h"
#include "uart.h"
void aht20_print_status(uint8_t status) {
uart_sendstring("AHT20: ");
uart_sendstring((status & BV(3)) ? "Calibrated" : "Not Calibrated");
uart_sendstring(";");
uart_sendstring((status & BV(7)) ? "Busy" : "Not Busy");
uart_sendstring(";\r\n");
}
// https://datasheet4u.com/pdf/1551700/AHT20.pdf
void aht20_init(void) {
// we need to wait a bit after the poweron of the AHT20 device
_delay_ms(40);
i2c_start();
i2c_write(I2C_ADDR(AHT20, TW_WRITE));
i2c_write(0xBE);
i2c_stop();
//_delay_ms(10);
}
void aht20_trigger(void) {
i2c_start();
i2c_write(I2C_ADDR(AHT20, TW_WRITE));
// trigger measurement command (7.4)
i2c_write(0xAC);
i2c_write(0x33);
i2c_write(0x00);
i2c_stop();
}
aht20_reading aht20_read_measure(void) {
uint8_t data[6];
i2c_start();
i2c_write(I2C_ADDR(AHT20, TW_READ));
for (uint8_t i = 0; i < 5; i++)
data[i] = i2c_read_ack();
data[5] = i2c_read_nack();
// we dont read the checksum
i2c_stop();
uint32_t raw_humi = 0;
uint32_t raw_temp = 0;
struct aht20_reading out;
raw_humi = data[1];
raw_humi <<= 8;
raw_humi += data[2];
raw_humi <<= 4;
raw_humi += data[3] >> 4;
out.humidity = (float)raw_humi / 1048576.0;
raw_temp = data[3] & 0x0f;
raw_temp <<= 8;
raw_temp += data[4];
raw_temp <<= 8;
raw_temp += data[5];
out.temperature = (float)raw_temp / 1048576.0 * 200.0 - 50.0;
return out;
}
uint8_t aht20_status(void) {
i2c_start();
i2c_write(I2C_ADDR(AHT20, TW_READ));
uint8_t status = i2c_read_nack();
i2c_stop();
return status & (BV(7) | BV(3));
}

87
ex01/src/i2c.c Normal file
View file

@ -0,0 +1,87 @@
#include "mystd.h"
#include "uart.h"
#include <avr/io.h>
#include <util/twi.h>
#include "i2c.h"
void i2c_init(void) {
// clear the status registers
TWSR = 0x00;
// set the i2c clock speed
TWBR = ((F_CPU / I2C_CLOCK) - 16) / 2;
}
void i2c_start(void) {
// CLR INT | SET MASTER | ENABLE ;
TWCR = BV(TWINT) | BV(TWSTA) | BV(TWEN);
// wait until done
while (!(TWCR & BV(TWINT)))
;
}
void i2c_stop(void) {
// CLR INT | ENABLE | STOP ;
TWCR = BV(TWINT) | BV(TWEN) | BV(TWSTO);
uart_sendstring("\r\n");
}
void i2c_write(uint8_t data) {
// set data to write
TWDR = data;
uart_tx('>');
uart_send_u8_hex(data);
uart_tx(' ');
// CLR INT | ENABLE ;
TWCR = BV(TWINT) | BV(TWEN);
// wait until done
while (!(TWCR & BV(TWINT)))
;
}
uint8_t i2c_read_ack(void) {
TWCR = BV(TWINT) | BV(TWEN) | BV(TWEA);
while (!(TWCR & BV(TWINT)))
;
uint8_t data = TWDR;
uart_tx('<');
uart_send_u8_hex(data);
uart_tx(' ');
return data;
}
uint8_t i2c_read_nack(void) {
TWCR = BV(TWINT) | BV(TWEN);
while (!(TWCR & (1 << TWINT)))
;
uint8_t data = TWDR;
uart_tx('<');
uart_send_u8_hex(data);
uart_tx(' ');
return data;
}
void pca9555_write(uint8_t addr, uint8_t reg, uint8_t value) {
i2c_start();
i2c_write((addr << 1) | TW_WRITE); // write mode
i2c_write(reg);
i2c_write(value);
i2c_stop();
}
uint8_t pca9555_read(uint8_t addr, uint8_t reg) {
uint8_t val;
i2c_start();
i2c_write((addr << 1) | TW_WRITE);
i2c_write(reg);
i2c_start(); // repeated start
i2c_write((addr << 1) | TW_READ);
val = i2c_read_nack();
i2c_stop();
return val;
}

69
ex01/src/main.c Normal file
View file

@ -0,0 +1,69 @@
#include <avr/io.h>
#include <util/delay.h>
#include <util/twi.h>
#include "aht20.h"
#include "i2c.h"
#include "mystd.h"
#include "uart.h"
#include "utils.h"
void display_result(aht20_reading data) {
char str[128];
uart_sendstring("Temperature: ");
ft_bzero(str, sizeof(str));
ft_ftoa(data.temperature, str, 2);
uart_sendstring(str);
uart_sendstring("C, Humidity: ");
ft_bzero(str, sizeof(str));
ft_ftoa(data.humidity * 100, str, 0);
uart_sendstring(str);
uart_sendstring("%\r\n");
}
aht20_reading avg_reading(aht20_reading* data) {
return (aht20_reading){
.temperature = (data[0].temperature + data[1].temperature + data[2].temperature) / 3.f,
.humidity = (data[0].humidity + data[1].humidity + data[2].humidity) / 3.f,
};
}
int main(void) {
uart_init();
i2c_init();
aht20_init();
while (!(aht20_status() & BV(3)))
_delay_ms(10);
aht20_reading data[3] = {};
_delay_ms(100);
aht20_trigger();
data[0] = aht20_read_measure();
display_result(data[0]);
_delay_ms(100);
aht20_trigger();
data[1] = aht20_read_measure();
display_result((aht20_reading){.temperature = (data[0].temperature + data[1].temperature) / 2.f,
.humidity = (data[0].humidity + data[1].humidity) / 2.f});
_delay_ms(100);
aht20_trigger();
data[2] = aht20_read_measure();
display_result(avg_reading(data));
while (true) {
data[0] = data[1];
data[1] = data[2];
aht20_trigger();
_delay_ms(100);
data[2] = aht20_read_measure();
display_result(avg_reading(data));
}
}

45
ex01/src/rgb.c Normal file
View file

@ -0,0 +1,45 @@
#include <avr/io.h>
#include "mystd.h"
#include "timer0.h"
#include "timer2.h"
#define D5_R PD5
#define D5_G PD6
#define D5_B PD3
#define RGB_MASK (_BV(D5_R) | _BV(D5_G) | _BV(D5_B))
void init_rgb(void) {
t0_init_fpwm_3(PRESCALER_64);
t2_init_fpwm_3(PRESCALER_64);
t0_set_out_mode(TO_A | TO_B, TOM_00);
t2_set_out_mode(TO_B, TOM_00);
DDRD |= RGB_MASK;
}
void set_rgb(uint8_t r, uint8_t g, uint8_t b) {
if (r == 0x00) {
t0_set_out_mode(TO_B, TOM_00);
PORTD = (PORTD & ~_BV(D5_R));
} else {
t0_set_out_mode(TO_B, TOM_10);
t0_set_ocr(TO_B, r);
}
if (g == 0x00) {
t0_set_out_mode(TO_A, TOM_00);
PORTD = (PORTD & ~_BV(D5_G));
} else {
t0_set_out_mode(TO_A, TOM_10);
t0_set_ocr(TO_A, g);
}
if (b == 0x00) {
t2_set_out_mode(TO_B, TOM_00);
PORTD = (PORTD & ~_BV(D5_B));
} else {
t2_set_out_mode(TO_B, TOM_10);
t2_set_ocr(TO_B, b);
}
}

127
ex01/src/uart.c Normal file
View file

@ -0,0 +1,127 @@
#include "uart.h"
#include <avr/io.h>
#include "mystd.h"
#include "utils.h"
#define BAUD_RATE 115200
#define UBRR_VALUE ((F_CPU / (8UL * BAUD_RATE)) - 1)
// uart is 115200 baud rate, 8 bits per word, no parrity and 1 stop bit
// 115200 8N1
void uart_init(void) {
// Set baud rate
UBRR0H = (uint8_t)(UBRR_VALUE >> 8);
UBRR0L = (uint8_t)(UBRR_VALUE);
UCSR0A |= BV(U2X0);
// Enable transmitter
UCSR0B = BV(TXEN0) | BV(RXEN0);
// Set frame format: 8 data bits, no parity, 1 stop bit
UCSR0C = BV(UCSZ01) | BV(UCSZ00);
// Set TX (PD1) as output
DDRD |= BV(PD1);
}
void uart_tx(char data) {
// wait for transmit buffer to be empty
while (!(UCSR0A & BV(UDRE0)))
;
// load data into transmit register
UDR0 = data;
}
char uart_rx(void) {
while (!(UCSR0A & BV(RXC0)))
;
return UDR0;
}
void uart_sendstring(const char* str) {
if (!str)
return;
while (*str) {
uart_tx(*str);
str++;
}
}
void uart_send_u8(uint8_t val) {
if (val == 0)
return uart_tx('0');
char buf[4] = {0, 0, 0, 0};
uint8_t idx = 0;
bool print = false;
uint8_t modulus = 100;
while (modulus) {
uint8_t digit = val / modulus;
if (print || digit != 0) {
print = true;
buf[idx++] = '0' + digit;
}
val %= modulus;
modulus /= 10;
}
uart_sendstring(buf);
}
void uart_send_u16(uint16_t val) {
if (val == 0)
return uart_tx('0');
char buf[6] = {0, 0, 0, 0, 0, 0};
uint8_t idx = 0;
bool print = false;
uint16_t modulus = 10000;
while (modulus) {
uint8_t digit = val / modulus;
if (print || digit != 0) {
print = true;
buf[idx++] = '0' + digit;
}
val %= modulus;
modulus /= 10;
}
uart_sendstring(buf);
}
void uart_send_u32(uint32_t val) {
if (val == 0)
return uart_tx('0');
char buf[6] = {0, 0, 0, 0, 0, 0};
uint8_t idx = 0;
bool print = false;
uint32_t modulus = 1000000000;
while (modulus) {
uint8_t digit = val / modulus;
if (print || digit != 0) {
print = true;
buf[idx++] = '0' + digit;
}
val %= modulus;
modulus /= 10;
}
uart_sendstring(buf);
}
void uart_send_u8_hex(uint8_t val) {
char buf[3] = {0, 0, 0};
buf[0] = "0123456789abcdef"[(val >> 4) & 0x0F];
buf[1] = "0123456789abcdef"[(val >> 0) & 0x0F];
uart_sendstring(buf);
}
void uart_send_u16_hex(uint16_t val) {
char buf[5] = {0, 0, 0, 0, 0};
buf[0] = "0123456789abcdef"[(val >> 12) & 0x0F];
buf[1] = "0123456789abcdef"[(val >> 8) & 0x0F];
buf[2] = "0123456789abcdef"[(val >> 4) & 0x0F];
buf[3] = "0123456789abcdef"[(val >> 0) & 0x0F];
uart_sendstring(buf);
}

100
ex01/src/utils.c Normal file
View file

@ -0,0 +1,100 @@
#include "utils.h"
#include "mystd.h"
#include "uart.h"
// this just burns cycles.
// the volatile is important, it means that the cpu can't optimize any
// read/writes for the value
static inline void spin_loop(volatile uint16_t counts) {
while (counts)
counts--;
}
void delay_ms(uint16_t ms) {
while (ms) {
// this value was taken using a delay of 500ms, and just recording the led
// blinking. it seems to be high enough such that each loop of delay_loop
// takes 1ms :D
spin_loop((F_CPU) / 5000);
ms--;
}
}
void ft_bzero(void* data, uint16_t size) {
char* d = data;
while (size) {
*d = 0;
d++;
size--;
}
}
uint8_t ft_stridx(const char* str, char chr) {
if (!str)
return -1;
for (uint8_t i = 0; str[i]; i++) {
if (str[i] == chr)
return i;
}
return -1;
}
static float ft_pow(float base, float count) {
float out = 1;
while (count--)
out *= base;
return out;
}
// Reverses a string 'str' of length 'len'
static void reverse(char* str, uint16_t len) {
uint16_t i = 0, j = len - 1, temp;
while (i < j) {
temp = str[i];
str[i] = str[j];
str[j] = temp;
i++;
j--;
}
}
static uint16_t ft_itoa(uint32_t value, char* out, uint16_t width) {
uint16_t i = 0;
if (value == 0) {
while (i < width)
out[i++] = '0';
return i;
}
while (value) {
out[i++] = (value % 10) + '0';
value = value / 10;
}
// If number of digits required is more, then
// add 0s at the beginning
while (i < width)
out[i++] = '0';
// we need to reverse the data
reverse(out, i);
out[i] = 0;
return i;
}
// 0.3250351
// Converts a floating-point/double number to a string.
uint8_t ft_ftoa(float val, char* out, uint16_t precision) {
uint32_t ipart = (uint32_t)val;
float fpart = val - (float)ipart;
// convert integer part to string
uint8_t i = ft_itoa(ipart, out, 1);
if (precision != 0) {
out[i] = '.';
fpart = fpart * ft_pow(10.f, precision);
i += ft_itoa((uint32_t)fpart, &out[i + 1], precision);
}
return i;
}