Управление RGB светодиодом по CAN шине на микроконтроллере ATtiny13

[code lang=»C»]
/*
* Created: 05.06.2016 13:59:35
* Author: instalator
*/
#define F_CPU 9600000
#include <avr/eeprom.h>
#include <avr/wdt.h>
#include <avr/io.h>
#include <avr/interrupt.h>
/////////////////////////////////////////////////////////////////////////////
#define TXPORT PORTB // Имя порта для передачи
#define RXPORT PINB // Имя порта на прием
#define TXDDR DDRB // Регистр направления порта на передачу
#define RXDDR DDRB // Регистр направления порта на прием
#define TXD PINB0 // Номер бита порта для использования на передачу
#define RXD PINB1 // Номер бита порта для использования на прием
/*
* Ниже задаются константы, определяющие скорость передачи данных (бодрейт)
* расчет BAUD_DIV осуществляется следующим образом:
* BAUD_DIV = (CPU_CLOCK / DIV) / BAUD_RATE
* где CPU_CLOCK — тактовая частота контроллера, BAUD_RATE — желаемая скорость UART,
* а DIV — значение делителя частоты таймера, задающееся в регистре TCCR0B.
* Например, делитель на 8, скорость порта 9600 бод:
* BAUD_DIV = (9 600 000 / 8) / 9600 = 125 (0x7D).
*/
//#define T_DIV 0x01 // DIV = 1
#define T_DIV 0x02 // DIV = 8
//#define T_DIV 0x03 // DIV = 64
#define BAUD_DIV 0x3E // Скорость = 9600 бод. 7D / 19200 3E

volatile uint16_t txbyte;
volatile uint8_t rxbyte;
volatile uint8_t txbitcount;
volatile uint8_t rxbitcount;
/////////////////////////////////////////////////////////////////////////////
#define R_ADRR 1 //Ячейка EEPROM для хранения красного канала
#define G_ADRR 2 //Ячейка EEPROM для хранения зеленого канала
#define B_ADRR 3 //Ячейка EEPROM для хранения синего канала
#define SAVE 88 //Команда для сохранения значений в EEPROM
#define ADDRESS 1 // Адрес устройства, от 1 до 99 (99 команда на все устройства)
#define SIZE_RECEIVE_BUF 14 //Размер буфера передаваемой строки
#define AMOUNT_PAR 4 //Количество параметров в команде, для парсинга
#define TRUE 1
#define FALSE 0
char buf[SIZE_RECEIVE_BUF];
char *argv[AMOUNT_PAR];
uint8_t argc;
uint8_t i = 0;
uint8_t flag = 0;
uint8_t cnt = 0;
uint8_t R, G, B, buf_R, buf_G, buf_B;

void EEPROM_write(unsigned char addr, unsigned char data){ //Функция записи в EEPROM
cli(); // Отключаем все прерывания
while(EECR & (1<<EEWE));
EECR = (0<<EEPM1)|(0>>EEPM0);
EEARL = addr;
EEDR = data;
EECR |= (1<<EEMWE);
EECR |= (1<<EEWE);
sei(); // Включаем прерывания
}
uint8_t EEPROM_read(unsigned char addr){ //Функция чтения из EEPROM
while(EECR & (1<<EEWE));
EEARL = addr;
EECR |= (1<<EERE);
return EEDR;
}

ISR(TIM0_COMPA_vect){
TXPORT = (TXPORT & ~(1 << TXD)) | ((txbyte & 0x01) << TXD); // Выставляем в бит TXD младший бит txbyte
txbyte = (txbyte >> 0x01) + 0x8000; // Двигаем txbyte вправо на 1 и пишем 1 в старший разряд (0x8000)
if(txbitcount > 0){ // Если идет передача (счетик бит больше нуля),
txbitcount—; // то уменьшаем его на единицу.
}
if (++cnt == 0){ //счетчик перехода таймера через ноль
buf_R = R; //значения длительности ШИМ
buf_G = G;
buf_B = B;
if (buf_R > 0){PORTB |= (1<<PINB2);}
if (buf_G > 0){PORTB |= (1<<PINB4);}
if (buf_B > 0){PORTB |= (1<<PINB3);}
}
if (cnt == buf_R) PORTB &=~(1<<PINB2); //подаем 0 на канал
if (cnt == buf_G) PORTB &=~(1<<PINB4); //по достижении
if (cnt == buf_B) PORTB &=~(1<<PINB3); //заданной длительности.
}

ISR(TIM0_COMPB_vect){
if(RXPORT & (1 << RXD)) // Проверяем в каком состоянии вход RXD
rxbyte |= 0x80; // Если в 1, то пишем 1 в старший разряд rxbyte
if(—rxbitcount == 0){ // Уменьшаем на 1 счетчик бит и проверяем не стал ли он нулем
TIMSK0 &= ~(1 << OCIE0B); // Если да, запрещаем прерывание по сравнению OCR0B
TIFR0 |= (1 << OCF0B); // Очищаем флаг прерывания (важно!)
GIFR |= (1 << INTF0); // Очищаем флаг прерывания по INT0
GIMSK |= (1 << INT0); // Разрешаем прерывание INT0
} else {
rxbyte >>= 0x01; // Иначе сдвигаем вправо на 1 rxbyte
}
}

ISR(INT0_vect){
rxbitcount = 0x09; // 8 бит данных и 1 стартовый бит
rxbyte = 0x00; // Обнуляем содержимое rxbyte
if(TCNT0 < (BAUD_DIV / 2)){ // Если таймер не досчитал до середины текущего периода
OCR0B = TCNT0 + (BAUD_DIV / 10); // То прерывание произойдет в текущем периоде спустя пол периода
// } else {
// OCR0B = TCNT0 — (BAUD_DIV / 2); // Иначе прерывание произойдет в уже следующем периоде таймера
}
GIMSK &= ~(1 << INT0); // Запрещаем прерывание по INT0
TIFR0 |= (1 << OCF0A) | (1 << OCF0B); // Очищаем флаг прерывания INT0
TIMSK0 |= (1 << OCIE0B); // Разрешаем прерывание по OCR0B
}

void uart_send(uint8_t tb) {
while(txbitcount); // Ждем пока закончится передача предыдущего байта
txbyte = (tb + 0xFF00) << 0x01; // Пишем в младшие разряды txbyte данные для передачи и сдвигаем влево на 1
txbitcount = 0x0A; // Задаем счетчик байт равным 10
}

int16_t uart_recieve(uint8_t* rb){
if(rxbitcount < 0x09){ // Если счетчик бит на прием меньше 9
while(rxbitcount); // Ждем пока завершится текущий прием
*rb = rxbyte; // Пишем по адресу указателя принятый байт
rxbitcount = 0x09; // Восстанавливаем значение счетчика бит
return (*rb); // Возвращаемся
} else {
return (-1); // Иначе возвращаем -1 (принимать нечего)
}
}

void uart_init(){
txbyte = 0xFFFF; // Значение буфера на передачу — все единицы
rxbyte = 0x00; // Значение буфера на прием — все нули
txbitcount = 0x00; // Значение счетчика преедаваемых бит — ноль (ничего пока не передаем)
rxbitcount = 0x09; // Значение счетчика бит на прием — 9 (ожидаем возможного приема)

TXDDR |= (1 << TXD); // Задаем направление порта на передачу как выход
RXDDR &= ~(1 << RXD); // Задаем направление порта на прием как вход
TXPORT |= (1 << TXD); // Пишем единицу в выход TXD
RXPORT |= (1 << RXD); // Подтягиваем к единице вход RXD
OCR0A = BAUD_DIV; // Задаем значение регистра OCR0A в соответствии с бодрейтом
TIMSK0 |= (1 << OCIE0A); // Разрешаем прерывание TIM0_COMPA
TCCR0A |= (1 << WGM01); // Режим таймера CTC (очистка TCNT0 по достижению OCR0A)
TCCR0B |= T_DIV; // Задаем скорость счета таймера в соответствии с делителем
MCUCR |= (1 << ISC01); // Задаем прерывание INT0 по заднему фронту импульса
GIMSK |= (1 << INT0); // Разрешаем прерывание INT0
sei(); // Разрешаем прерывания глобально
}
uint8_t PARS_StrToUchar(char *s){
uint8_t value = 0;
/*while(*s == ‘0’){
s++;
}*/
while(*s){
value += (*s — 0x30);
s++;
if (*s){
value *= 10;
}
};
return value;
}
int main(void) {
wdt_enable(WDTO_1S); //Включаем Watchdog, 1 секунда
DDRB = (1<<PINB2) | (1<<PINB3) | (1<<PINB4); //Порты 2, 3 и 4 на выход
uint8_t b = 0;
char sym;
R = EEPROM_read(R_ADRR); //начальные значения
G = EEPROM_read(G_ADRR); //длительности ШИМ
B = EEPROM_read(B_ADRR); //трёх каналов
argc = 0;
argv[0] = buf;
flag = FALSE;
i = 0;
uart_init(); //Инициализация UART

while (1) {
wdt_reset(); //Сброс таймера Watchdog
if (uart_recieve(&b) >= 0){
//uart_send(b);
sym = b;
if (sym != ‘\r’){
if (i < SIZE_RECEIVE_BUF — 1){
if (sym != ‘R’ && sym != ‘G’ && sym != ‘B’){
if (!argc){
argv[0] = buf;
argc++;
}
if (flag){
if (argc < AMOUNT_PAR){
argv[argc] = &buf[i];
argc++;
}
flag = FALSE;
}
buf[i] = sym;
i++;
} else {
if (!flag){
buf[i] = 0;
i++;
flag = TRUE;
}
}
}
buf[i] = 0;
} else {
buf[i] = 0;
if (argc){
uint8_t cmd = PARS_StrToUchar(argv[0]);
uint8_t pR = PARS_StrToUchar(argv[1]);
uint8_t pG = PARS_StrToUchar(argv[2]);
uint8_t pB = PARS_StrToUchar(argv[3]);
if (cmd == ADDRESS || cmd == 99){
R = pR;
G = pG;
B = pB;
} else if (cmd == SAVE){
EEPROM_write(R_ADRR, pR);
EEPROM_write(G_ADRR, pG);
EEPROM_write(B_ADRR, pB);
R = pR;
G = pG;
B = pB;
}
}
argc = 0;
flag = FALSE;
i = 0;
}
}
}
}
[/code]