Контроллер антенного переключателя на 8 антенн

/*****************************************************
Project : Antenna Switch
Version : 1.2
Date    : 23.03.2021
Author  : R4ADX
Company : Unlis
Comments: 

Chip type           : ATtiny2313
Clock frequency     : 11,059200 MHz
Memory model        : Tiny
External SRAM size  : 0
Data Stack size     : 32
*****************************************************/


#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

#define SH PD4 								// Тактовый выход 74HC595
#define DS PD3 								// Выход данных 74HC595
#define ST PD2 								// Синхронизация
#define F_CPU 11059200							// Тактовая частота MCU
#define baudrate 9600L							// Скорость передачи USART
#define baud (F_CPU/(16*baudrate)-1)					// 

unsigned char tab[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; // Коды антенных портов
unsigned char count;							// Счетчик для клавиатуры
unsigned char temp;
volatile unsigned char antenna;						// Активный антенный порт
unsigned char buf[2];							// Буфер приема UART
unsigned char addr = 0;
volatile unsigned char enabled;						// Разрешенные антенные порты

/* Функция передачи байта по UART */
void USART_Transmit(unsigned char data) {
	while (!(UCSRA & (1<<UDRE)));
	UDR = data;
}

/* Функция записи в EEPROM */
void EEPROM_write(unsigned int uiAddress, unsigned char ucData) {
	while(EECR & (1<<EEPE)) {}; 					// Ожидание окончания предыдущей записи
	EEAR = uiAddress;						// Установка регистра адреса
	EEDR = ucData;							// Установка регистра данных
	EECR |= (1<<EEMPE);						// Подготовка к записи
	EECR |= (1<<EEPE);						// Начало записи в EEPROM
}

/* Функция чтения из EEPROM */
unsigned char EEPROM_read(unsigned int uiAddress) {
	while(EECR & (1<<EEPE)) {}; 					// Ожидание окончания предыдущей записи
	EEAR = uiAddress; 						// Установка регистра адреса
	EECR |= (1<<EERE); 						// Начало чтения из EEPROM
	return EEDR;							// Возврат регистра данных
}

/* Функция вывода данных в сдвиговый регистр 74HC595 */
void shift_595(antenna) {
	for (count = 0; count < 8; count++) {
		PORTD =(antenna & 0x80) ? PORTD | (1<<DS) : PORTD & ~(1<<DS);
		PORTD |= (1<<SH);
		_delay_us(2);
		PORTD &= ~(1<<SH);
		antenna = antenna <<1;
		}
	PORTD |= (1<<ST);
	_delay_us(2);
	PORTD &= ~(1<<ST);
}

/* Отправка переключенной антенны в UART */
void S_to_PC() {
	USART_Transmit('S');						// Шлем в порт S
	USART_Transmit(antenna);					// Шлем в порт адрес антенны
}

/* Обработчик приемного буфера */
void from_PC(unsigned char *data) {
	switch (data[0]) {
		case 0x49:	USART_Transmit('I');			// I - Инициализация коммутатора программой с ПК. Шлем в порт I 
				USART_Transmit(enabled);		// Шлем в порт байт разрешенных антенн
				S_to_PC();				// Вызываем функцию для отсылки адреса антенны
				break;
		case 0x53:	antenna = data[1];			// S - Переключение антенн с ПК
				shift_595(antenna);			// 	...переключили
				EEPROM_write(0x01, antenna);		// 	...запомнили
				break;
		case 0x57:	enabled = data[1];			// W - Запись разрешенных антенн
				EEPROM_write(0, enabled);
				break;
	}
}

int main(void) {

/* Настройка портов */
	DDRB = 0x00; 							// PortB на вход
	PORTB = 0xFF; 							// Подтяжка
	DDRD |= (1<<SH) | (1<<DS) | (1<<ST); 				// PortD HC595 на выход
  
/* Настройка UART */
	UBRRH = (unsigned char)(baud>>8); 				// Скорость порта
	UBRRL = (unsigned char)baud;					//
	UCSRB = (1<<RXEN) | (1<<TXEN) | (1<<RXCIE); 			// Разрешение прием и передачу через USART. Разрешение прерывания по приему
	UCSRC = (0<<USBS) | (1<<UCSZ0) | (1<<UCSZ1); 			// Режим UART: 8n1 
	enabled = EEPROM_read(0x00);					// Читаем разрешенные антенные порты
	antenna = EEPROM_read(0x01); 					// Последняя включенная антенна
	shift_595(antenna);						// Включаем антенну
	sei();

while(1)
	{
m1:		temp = PINB;  
		for (count = 0; count < 8; count++) {			// Цикл сканирования клавиатуры
			if ((temp&1) == 0) { 				// Проверка младшего бита
			_delay_ms(10); 					// Антидребезг
			while ( PINB != 0xFF ) {};	 		// Ждем отпускания кнопок
			goto m2;
			}
			temp >>= 1; 					// Сдвигаем для проверки следующий бит
		}
		goto m1;						// Идем в начало сканирования клавиатуры
m2:		if ((enabled & (1<<count)) != 0 ) {			// Проверка разрешено ли включать антенный порт
			antenna = tab[count]; 				// Запись значения антенны
			shift_595(antenna);				// Переключаем антенные реле
			S_to_PC();					// Отправляем в UART
			EEPROM_write(0x01, antenna); 			// Запоминаем что включили
		}
	}
}

/* Обработчик вектора прерывания по приему UART */
ISR(USART_RX_vect) {
	buf[addr] = UDR;						// Читаем UART в буфер
	addr++;								// Увеличиваем адрес буфера
	if (addr == 2) {
		from_PC(buf);						// Если заполнился -  вызываем обработчик приемного буфера
		addr = 0;  						// Сбрасываем адрес буфера.
	}
}

/*****************************************************
Project : Antenna Switch
Version : 1.3
Date    : 12.04.2021
Author  : R4ADX
Company : Unlis
Comments: 

Chip type           : ATtiny2313
Clock frequency     : 11,059200 MHz
Memory model        : Tiny
External SRAM size  : 0
Data Stack size     : 32
*****************************************************/

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

#define SH PD5 									// Тактовый выход 74HC595
#define DS PD4 									// Выход данных 74HC595
#define ST PD3 									// Синхронизация
#define SPW PD2									// Вход супервизора
#define F_CPU 11059200								// Тактовая частота MCU
#define baudrate 9600L								// Скорость передачи USART
#define baud (F_CPU/(16*baudrate)-1)						// 

unsigned char tab[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; 	// Коды антенных портов
unsigned char count;								// Счетчик для клавиатуры
unsigned char i;
unsigned char temp;
unsigned char antenna;								// Активный антенный порт
unsigned char buf[3];								// Буфер приема UART
unsigned char addr = 0;
unsigned char crc_byte;								// Байт для побитного вычисления CRC
volatile unsigned char enabled;							// Разрешенные антенные порты

/* Функция записи в EEPROM */
void EEPROM_write(unsigned int uiAddress, unsigned char ucData) {
	while(EECR & (1<<EEPE)) {}; 						// Ожидание окончания предыдущей записи
	EEAR = uiAddress;							// Установка регистра адреса
	EEDR = ucData;								// Установка регистра данных
	EECR |= (1<<EEMPE);							// Подготовка к записи
	EECR |= (1<<EEPE);							// Начало записи в EEPROM
}

/* Функция чтения из EEPROM */
unsigned char EEPROM_read(unsigned int uiAddress) {
	while(EECR & (1<<EEPE)) {}; 						// Ожидание окончания предыдущей записи
	EEAR = uiAddress; 							// Установка регистра адреса
	EECR |= (1<<EERE); 							// Начало чтения из EEPROM
	return EEDR;								// Возврат регистра данных
}

/* Функция вывода данных в сдвиговый регистр 74HC595 */
void shift_595(antenna) {
	for (count = 0; count < 8; count++) {
		PORTD =(antenna & 0x80) ? PORTD | (1<<DS) : PORTD & ~(1<<DS);
		PORTD |= (1<<SH);
		_delay_us(2);
		PORTD &= ~(1<<SH);
		antenna = antenna <<1;
		}
	PORTD |= (1<<ST);
	_delay_us(2);
	PORTD &= ~(1<<ST);
}
/* Расчет CRC-8 по алгоритму MAXIM (Dallas) */
unsigned char crc8(unsigned char *buff, unsigned char bsize) {
	unsigned char crc = 0;
	for (count = 0; count < bsize; count++) {
		crc_byte = buff[count];
		for (i = 0; i < 8; i++) { crc = ((crc ^ crc_byte) & 0x01) ? (crc >> 1) ^ 0x8C : (crc >> 1);
		crc_byte >>= 1;
		}
	}
	return crc;
}

/* Функция обработки и отправки данных в USART */
void to_PC(unsigned char head, unsigned char body) {
	unsigned char buffer[3];						// Создадим буфер по образу и подобию нашему
	buffer[0] = head;							// Заголовок пакета
	buffer[1] = body;							// Данные пакета
	buffer[2] = crc8(buffer, sizeof(buffer) - 1);				// Вычислаем CRC буфера, кроме последней ячейки
	for (count = 0; count < sizeof(buffer); count++) {			// Скармливаем буфер в USART
		while(!(UCSRA&(1<<UDRE))){}; 					// Ждем готовность порта 
		UDR = buffer[count];						// Отправляем очередной байт
	}
}

/* Обработчик приемного буфера */
void from_PC(unsigned char *data) {
    unsigned char crc = crc8(buf, sizeof(buf));					// считаем CRC буфера полностью
    if (crc == 0) {								// Если сошлось - 
		switch (data[0]) {						// смотрим что в заголовке
			case 0x49:	to_PC('I', enabled);			// I - Инициализация коммутатора. Посылка разрешенных антенн
						_delay_ms(10);			//
						to_PC('S', antenna);		// Посылка включенной антенны
						break;
			case 0x53:	antenna = data[1];			// S - Переключение антенн с ПК
						shift_595(antenna);		// ...переключили
//						EEPROM_write(0x01, antenna);	// ...запомнили
						to_PC('S', antenna);		// ...отсылаем обратно для контроля
						break;
			case 0x57:	enabled = data[1];			// W - Запись разрешенных антенн
						EEPROM_write(0, enabled);	// в EEPROM
						to_PC('W', enabled);		// Отсылаем обратно для контроля
						break;
		}
    } else {									// Для отладки...
    PORTD |= (1<<PD6);								// При ошибке в CRC	
	_delay_ms(500);								// 
	PORTD &= ~(1<<PD6);							// мигаем светодиодом
    }
}

int main(void) {

/* Настройка портов */
	DDRB = 0x00; 								// PortB на вход
	PORTB = 0xFF; 								// Подтяжка
	DDRD |= (1<<SH) | (1<<DS) | (1<<ST); 					// PortD HC595 на выход
	DDRD &= ~(1<<SPW);							// Вход от супервизора
	DDRD |= (1<<PD6);							// Светодиод для отладки

/* Настройка прерывания INT0 */
	GIMSK |= (1<<INT0);							// Разрешаем внешнее прерывание от INT0
	MCUCR |= (0<<ISC00) | (0<<ISC01); 					// Прерывание по низкому уровню на входе INT0 

/* Настройка UART */ 
	UBRRH = (unsigned char)(baud>>8); 					// Скорость порта
	UBRRL = (unsigned char)baud;						//
	UCSRB = (1<<RXEN) | (1<<TXEN) | (1<<RXCIE); 				// Разрешение прием и передачу через USART. Разрешение прерывания по приему
	UCSRC = (0<<USBS) | (1<<UCSZ0) | (1<<UCSZ1); 				// Режим UART: 8n1 
	enabled = EEPROM_read(0x00);						// Читаем разрешенные антенные порты
	antenna = EEPROM_read(0x01); 						// Последняя включенная антенна
	shift_595(antenna);							// Включаем антенну
	sei();

while(1) {
m1:		temp = PINB;  
		for (count = 0; count < 8; count++) { 				// Цикл сканирования клавиатуры 
			if ((temp&1) == 0) { 					// Проверка младшего бита 
			_delay_ms(10); 						// Антидребезг 
			while ( PINB != 0xFF ) {}; 				// Ждем отпускания кнопок 
			goto m2; 
			} 
			temp >>= 1; 						// Сдвигаем для проверки следующий бит
		}
		goto m1;							// Идем в начало сканирования клавиатуры
m2:		if ((enabled & (1<<count)) != 0 ) { 				// Проверка разрешено ли включать антенный порт 
			antenna = tab[count]; 					// Запись значения антенны 
			shift_595(antenna); 					// Переключаем антенные реле 
			to_PC('S', antenna); 					// Отправляем в UART 
// 			EEPROM_write(0x01, antenna); 				// Запоминаем что включили 
		} 
	} 
}

/* Обработчик вектора прерывания по приему UART */ 
ISR(USART_RX_vect) { 
	buf[addr] = UDR; // Читаем UART в буфер 
	addr++; 								// Увеличиваем адрес буфера 
	if (addr > 2) {
		from_PC(buf);							// Если заполнился -  вызываем обработчик приемного буфера
		addr = 0;  							// Сбрасываем адрес буфера.
	}
}

/* Обработчик вектора прерывания по срабатыванию супервизора */
ISR(INT0_vect) {
	EEPROM_write(0x01, antenna);						// Сохраняемся при пропадании питания
}

/*****************************************************
Project : Antenna Switch
Version : 1.4
Date    : 27.04.2021
Author  : R4ADX
Company : Unlis
Comments: 

Chip type           : ATtiny2313
Clock frequency     : 11,059200 MHz
Memory model        : Tiny
External SRAM size  : 0
Data Stack size     : 32
*****************************************************/

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

#define SH PD5 																// Тактовый выход 74HC595
#define DS PD4 																// Выход данных 74HC595
#define ST PD3 																// Синхронизация
#define SPW PD2																// Вход супервизора
#define F_CPU 11059200														// Тактовая частота MCU
#define baudrate 9600L														// Скорость передачи USART
#define baud (F_CPU/(16*baudrate)-1)										// 

unsigned char tab[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; 	// Коды антенных портов
unsigned char count;														// Счетчик для клавиатуры
unsigned char i;
unsigned char temp;
unsigned char antenna;														// Активный антенный порт
unsigned char buf[3];														// Буфер приема UART
unsigned char buf_addr = 0x00;												// Адрес буфера приема
unsigned char ee_addr = 0x01;												// Адрес ячейки EEPROM для сохранения включенной антенны
unsigned char crc_byte;														// Байт для побитного вычисления CRC
volatile unsigned char enabled;												// Разрешенные антенные порты

/* Функция записи в EEPROM */
void EEPROM_write(unsigned int uiAddress, unsigned char ucData) {
	while(EECR & (1<<EEPE)) {}; 											// Ожидание окончания предыдущей записи
	EEAR = uiAddress;														// Установка регистра адреса
	EEDR = ucData;															// Установка регистра данных
	EECR |= (1<<EEMPE);														// Подготовка к записи
	EECR |= (1<<EEPE);														// Начало записи в EEPROM
}

/* Функция чтения из EEPROM */
unsigned char EEPROM_read(unsigned int uiAddress) {
	while(EECR & (1<<EEPE)) {}; 											// Ожидание окончания предыдущей записи
	EEAR = uiAddress; 														// Установка регистра адреса
	EECR |= (1<<EERE); 														// Начало чтения из EEPROM
	return EEDR;															// Возврат регистра данных
}

/* Функция кольцевой записи в EEPROM */
void store(void) {
	unsigned char old_addr;													
	if (ee_addr == 0x01) {													// Если адрес будущей записи пепешел с конца на начало буфера -
		old_addr = 0x7F;													// адрес для затирания старой записи ставим на конец буфера
	} else {																// Если это не переход с конца на начало буфера -
		old_addr = ee_addr - 1;												// просто отнимем единицу
	}
	EEPROM_write(old_addr, 0xFF);											// Затираем ячейку с предыдущей записью
	EEPROM_write(ee_addr, antenna);		 									// Запоминаем что включили
	ee_addr++;																// Адрес для последующей записи
	if (ee_addr == 0x80) ee_addr = 0x01;									// Если дошли до конца - устанавливаем адрес на начало
}

/* Функция вывода данных в сдвиговый регистр 74HC595 */
void shift_595(antenna) {
	for (count = 0; count < 8; count++) {
		PORTD =(antenna & 0x80) ? PORTD | (1<<DS) : PORTD & ~(1<<DS);
		PORTD |= (1<<SH);
		_delay_us(2);
		PORTD &= ~(1<<SH);
		antenna = antenna <<1;
		}
	PORTD |= (1<<ST);
	_delay_us(2);
	PORTD &= ~(1<<ST);
}
/* Расчет CRC-8 по алгоритму MAXIM (Dallas) */
unsigned char crc8(unsigned char *buff, unsigned char bsize) {
	unsigned char crc = 0;
	for (count = 0; count < bsize; count++) {
		crc_byte = buff[count];
		for (i = 0; i < 8; i++) { crc = ((crc ^ crc_byte) & 0x01) ? (crc >> 1) ^ 0x8C : (crc >> 1);
		crc_byte >>= 1;
		}
	}
	return crc;
}

/* Функция обработки и отправки данных в USART */
void to_PC(unsigned char head, unsigned char body) {
	unsigned char buffer[3];												// Создадим буфер по образу и подобию нашему
	buffer[0] = head;														// Заголовок пакета
	buffer[1] = body;														// Данные пакета
	buffer[2] = crc8(buffer, sizeof(buffer) - 1);							// Вычислаем CRC буфера, кроме последней ячейки
	for (count = 0; count < sizeof(buffer); count++) {						// Скармливаем буфер в USART
		while(!(UCSRA&(1<<UDRE))){}; 										// Ждем готовность порта 
		UDR = buffer[count];												// Отправляем очередной байт
	}
}

/* Обработчик приемного буфера */
void from_PC(unsigned char *data) {
    unsigned char crc = crc8(buf, sizeof(buf));								// считаем CRC буфера полностью
    if (crc == 0) {															// Если сошлось - 
		switch (data[0]) {													// смотрим что в заголовке
			case 0x49:	to_PC('I', enabled);								// I - Инициализация коммутатора. Посылка разрешенных антенн
					_delay_ms(10);										//
					to_PC('S', antenna);								// Посылка включенной антенны
					break;
			case 0x53:	antenna = data[1];									// S - Переключение антенн с ПК
					shift_595(antenna);									// 		...переключили
					store();											// 		...запомнили
					to_PC('S', antenna);								// 		...отсылаем обратно для контроля
					break;
			case 0x57:	enabled = data[1];									// W - Запись разрешенных антенн
					EEPROM_write(0x00, enabled);						// в EEPROM
					to_PC('W', enabled);								// Отсылаем обратно для контроля
					break;
		}
    } else {																// Для отладки...
    PORTD |= (1<<PD6);														// При ошибке в CRC	
	_delay_ms(500);															// 
	PORTD &= ~(1<<PD6);														// мигаем светодиодом
    }
}

int main(void) {

/* Настройка портов */
	DDRB = 0x00; 															// PortB на вход
	PORTB = 0xFF; 															// Подтяжка
	DDRD |= (1<<SH) | (1<<DS) | (1<<ST); 									// PortD HC595 на выход
	DDRD |= (1<<PD6); // Светодиод для отладки /* Настройка UART */ UBRRH = (unsigned char)(baud>>8); 										// Скорость порта
	UBRRL = (unsigned char)baud;											//
	UCSRB = (1<<RXEN) | (1<<TXEN) | (1<<RXCIE); 							// Разрешение прием и передачу через USART. Разрешение прерывания по приему
	UCSRC = (0<<USBS) | (1<<UCSZ0) | (1<<UCSZ1); 							// Режим UART: 8n1 
	enabled = EEPROM_read(0x00);											// Читаем разрешенные антенные порты
	do  {																	// Ищем адрес ячейки 
		antenna = EEPROM_read(ee_addr); 									// Читаем значение из EEPROM
		ee_addr++;															// Увеличиваем адрес
		if (ee_addr == 0x80) ee_addr = 0x01;								// Если дошли до конца - устанавливаем адрес на начало
		}																	// !!! Указатель адреса останется на ячейке для СЛЕДУЮЩЕЙ записи !!!
	while (antenna == 0xFF);												// Перебираем ячейки до тех пор, пока будет не FF
	shift_595(antenna);														// Включаем антенну
	sei();

while(1)
	{
m1:		temp = PINB;  
		for (count = 0; count < 8; count++) { 						// Цикл сканирования клавиатуры 
		if ((temp&1) == 0) { 								// Проверка младшего бита 
		_delay_ms(10); 										// Антидребезг
		 while ( PINB != 0xFF ) {}; 								// Ждем отпускания кнопок
		 goto m2; 
		}
 		temp >>= 1; 													// Сдвигаем для проверки следующий бит
		}
		goto m1;															// Идем в начало сканирования клавиатуры
m2:		if ((enabled & (1<<count)) != 0 ) { 				// Проверка разрешено ли включать антенный порт 
		antenna = tab[count];						 // Запись значения антенны 
		shift_595(antenna); 						// Переключаем антенные реле 
		to_PC('S', antenna);						 // Отправляем в UART
		 store(); 								// Записываем в EEPROM 
		} 
		} 
} 
/* Обработчик вектора прерывания по приему UART */ 
ISR(USART_RX_vect) { 
	buf[buf_addr] = UDR; // Читаем UART в буфер
	buf_addr++; // Увеличиваем адрес буфера 
	if (buf_addr > 2) {
		from_PC(buf);														// Если заполнился -  вызываем обработчик приемного буфера
		buf_addr = 0;  														// Сбрасываем адрес буфера.
	}
}