VPF::Обнаружение фазового сдвига на atmega

supercelt

Дата 23.8.2015, 20:13 (ссылка)

(нет голосов)

Загрузка ...

Опытный

Профиль
Группа: Участник
Сообщений: 658
Регистрация: 25.8.2005

Репутация: нет
Всего: 1

Добрый день!
Народ подскажите пожалуйста как на avr обнаружить изменение фазы?
Хотя бы просто алгоритм, желательно использовав внешнее прерывание по любому изменению фронта.

Картинку прикрепил
Если обнаружился сдвиг, то это ноль. Если сдвига нет, то 1
На вход МК поступает сигнал Modulator Control. Длина одного бита - 16 циклов несущей

Romikgy

Дата 24.8.2015, 12:37 (ссылка)

(нет голосов)

Загрузка ...

Любитель-программер

Профиль
Группа: Участник Клуба
Сообщений: 7326
Регистрация: 11.5.2005
Где: Porto Franco Odes sa

Репутация: 3
Всего: 146

и в чем сложность ? спад сигнала клок берем значение... если идет подряд 2 одинаковых значения ... значит ноль...

--------------------

Владение русской орфографией это как владение кунг-фу — истинные мастера не применяют его без надобности.

supercelt

Дата 24.8.2015, 13:21 (ссылка)

(нет голосов)

Загрузка ...

Опытный

Профиль
Группа: Участник
Сообщений: 658
Регистрация: 25.8.2005

Репутация: нет
Всего: 1

Сложность как раз и состоит в том, что каждый раз при спаде клока брать значение - это загружает камень. К примеру я таким способом принял бит 4 бита данных и следующий 5 бит четности. И проверяю тут же чётность данных (тех 4 бит). Так вот за время проверки чётности прога опять уходит на приём уже следующего бита так и не завершив проверку чётности и всё сбивается

Romikgy

Дата 24.8.2015, 19:38 (ссылка)

(нет голосов)

Загрузка ...

Любитель-программер

Профиль
Группа: Участник Клуба
Сообщений: 7326
Регистрация: 11.5.2005
Где: Porto Franco Odes sa

Репутация: 3
Всего: 146

покажите код как вы принимаете данные...

--------------------

Владение русской орфографией это как владение кунг-фу — истинные мастера не применяют его без надобности.

bass

Дата 25.8.2015, 17:40 (ссылка)

(нет голосов)

Загрузка ...

Опытный

Профиль
Группа: Участник
Сообщений: 315
Регистрация: 5.8.2007

Репутация: нет
Всего: 2

Цитата(supercelt @ 24.8.2015, 13:21)

Скажите хоть какой камень используете.
На какие ноги раскинуты входы???

http://samou4ka.net/page/vneshnie-preryvanija-mk-avr

Вот статья на прерывания меги 8 ой.

У вас в вопросе как то было - обработка прерываний таймера, вам там отвечали что обработку прерывание нужно делать как можно менее загруженной.

Не пойму как конкретно работает протокол, но если нужно выловить Phase change то я бы сделал так.
Завел данные линии CLOC на INT0 , modulation control на INT1.

Код


#include <stdio.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
 
//переменная счетчик
volatile unsigned long int0_cnt = 0;
 
//настройка внешнего прерывния INT0
void int0_init( void )
{
  //настраиваем на срабатывание INT0 по заднему фронту
  MCUCR |= (1<<ISC01)|(0<<ISC00);

 //настраиваем на срабатывание INT1 по переднему фронту
MCUCR |= (1<<ISC10) | (1<<ISC11);//0b00001100
 //разрешаем внешнее прерывание INT0 INT1 
 GICR |= (1<<INT0);
GICR |= (1<<INT1);//0b10000000

}
 
//функция обработчик внешнего прерывания INT0
ISR( INT0_vect )
{
 int0_cnt++;
}
 
ISR( INT1_vect )
{
     if(int0_cnt == 1)
     {
      // не чего не было
      }
     if(int0_cnt == 2)
     {
      // Было событие Phase
      }
int0_cnt = 0;//Сбросим переменную.
}
 

 
int main( )
{

   int0_init();
   int1_init();
 
  sei();
 
  while(1) {

Обрабатывать событие здесь, четность отправка данных.

  }
  return 0;
}

Какой кварц стоит ???
Если стесняетесь выложить код здесь постучитесь в личку помогу.

supercelt

Дата 26.8.2015, 13:17 (ссылка)

(нет голосов)

Загрузка ...

Опытный

Профиль
Группа: Участник
Сообщений: 658
Регистрация: 25.8.2005

Репутация: нет
Всего: 1

Я не стесняюсь. Просто я делал код для кодировки NRZ, а не для PSK. И там я понял что заходить в перывание так часто, даже если там минимум кода - это накладно. Потому что в отладчике увидел, что у меня не весь код выполняется в основном цикле. А то и дело щёлкает по прерываниям. Поэтому и возник вопрос. Ведь с PSK наверное по другому не получится, всё равно надо уходить в прерывание каждый такт клока.

Код


//Formats#####################################################################

//############################################################################
//Includes####################################################################
#define F_CPU 16000000 //Частота камня
#include <avr/io.h>
#include <stdio.h>
#include <stdlib.h>
#include <avr/interrupt.h>
#include <string.h>
#include "n5110.h"
#include <util/delay.h>
//############################################################################

//Variables###################################################################
volatile unsigned char cycle_counter = 32;
unsigned char bit_counter;
unsigned char byte_counter;
unsigned char crc_counter;
unsigned char RFID_buffer[6];
volatile unsigned char RF = 64;
volatile unsigned char flag;
//flag
//0 - разрешение на обработку в основном цикле программы, при счётчике = RF.
//1 - установка этого бита означает что заголовок из 9 единиц принят и далее идут данные.
//2 - установка этого бита означает, что приняты все биты всключая стоповый и далее следует сравнить чётность столбов и принять решение о распозновании метки.
//3 - если бит в 0 значит ещё не был обнаружен сигнал на входе, если 1, то сигнал обнаружен
//4 - бит для проверки чётности CRC. 1 - нечётно, 0 - чётно.
//5 - бит распознования метки. Если 1 - метка распознана. Если 0 - нет. Распознование - сравнение CRC по столбам.
// unsigned char ks = 0; // test
// unsigned char m = 0b01111110;
// unsigned char n = 0b01111111;
// unsigned char l = 0b11111011;
// unsigned char k = 0b11011111;
// char p[1];
//############################################################################

//Macros######################################################################
#define SetBit(reg, bit)        reg |= (1 << bit)
#define ClearBit(reg, bit)        reg &= ~(1 << bit)
#define BitIsSet(reg, bit)        ((reg & (1 << bit)) != 0)
#define BitIsClear(reg, bit)    ((reg & (1 << bit)) == 0)
#define ShiftBitRight(reg)        reg >>= 1
#define CalculateCRC(reg, bit)    reg ^= (1 << bit) 
//############################################################################

//Functions###################################################################
void USART_SendChar(unsigned char sym){
        while(!(UCSRA & (1<<UDRE)));
        UDR = sym;
}

void Another_Format(){
        cycle_counter = 32;
        bit_counter = 0;
        byte_counter = 0;
        crc_counter = 0;
        RFID_buffer[6] = 0;
        RF = 64;
        flag = 0;
//-------------test in proteus-------------
        PORTD ^= (1 << 5);
        TCCR2 &= ~(1 << COM20);
        _delay_ms(1);
        TCCR2 |= (1 << COM20);
//-----------------------------------------        
}
//############################################################################

ISR(TIMER2_COMP_vect){
        if(BitIsSet(PIND, 7)){
                if(BitIsClear(PIND, 6) && (BitIsClear(flag, 3))){ //Обнаружение первой передачи первого бита.
                        cycle_counter++;
                        SetBit(flag, 3);
                }else if(BitIsSet(flag, 3)){ //Последующее обнаружение после первого бита
                        cycle_counter++;
                }
                if(cycle_counter == RF){ //по стандарту 1 бит занимает опред. число периодов частоты. RF - это число периодов. Как только насчитали, то переходим принимать бит в основной цикл программы
                        SetBit(flag, 0);
                        cycle_counter = 0;
                }
        }    
}

int main(void){
    
    DDRD |= (1 << 2);//test
    PORTD &= ~(1 << 2);//test
    
        DDRC = 0xFF;
        PORTC &= ~(1 << 0);
        PORTC &= ~(1 << 1);
        PORTC &= ~(1 << 2);
        PORTC &= ~(1 << 3);
    
        DDRD &= ~(1 << 6);
        DDRD |= (1 << 7) | (1 << 5);
        PORTD |= (1 << 6); //Ставим подтяг. резистор (1 на пин 6) только для симулятора. В железе на пин 6 надо ноль
        PORTD &= ~(1 << 7);
        PORTD &= ~(1 << 5);
        OCR2 = 63; //Задаём частоту счётчика. При предделителе 1/1 и OCR = 31 Частота будет 125 kHz
        TCCR2 |= (0 << WGM20)|(1 << WGM21); //Режим работы таймера-счётчика2 - сброс при совпадении (СТС)
        TCCR2 |= (0 << CS22)|(0 << CS21)|(1 << CS20); //предделитель частоты 1\1
        TCCR2 |= (0 << COM21)|(1 << COM20); //Смена сигнала на PD7 - Toggle
        TIMSK |= (1 << OCIE2); //Разрешаем уходить в прерывание при совпадении TCNT0 и OCR*/

        // USART initialization
        // Communication Parameters: 8 Data, 1 Stop, No Parity
        // USART Receiver: On
        // USART Transmitter: On
        // USART Mode: Asynchronous
        // USART Baud Rate: 38400
        UCSRA=0x00;
        UCSRB=0x18;
        UCSRC=0x86;
        UBRRH=0x00;
        UBRRL=0x8;

        Lcd_init();
        Lcd_clear();
        PORTD |= (1 << 2);
        asm("sei");
        
        while(1){
            
//            if(ks == 0){
//                asm("cli");
//                sprintf(p, "%hhX%hhX%hhX%hhX", k, l, n, m);
//                Lcd_prints ( 0, 0, FONT_1X, (unsigned char*)PSTR("ID:") );
//                Lcd_print ( 3, 0, FONT_1X, (unsigned char*) p );
//                Lcd_update();
//                ks = 1;
//                asm("sei");
//                break;
//            }
            
            
                if(BitIsSet(flag, 0)){
                    //----test in proteus--------------------
                    PORTC |= (1 << 0);
                    asm("nop");
                    PORTC &= ~(1 << 0);
                    //----test in proteus--------------------
                        if(BitIsSet(flag, 1)){ //Приём данных
                                if(BitIsClear(PIND, 6)){ //Если приняли 1 (Когда на порту ноль, значит идёт приём лог 1)
                                        if(byte_counter == 5){ //Если принимаем 5-й байт - это уже не данные, а биты чётности по столбам
                                                if(bit_counter == 4){ //Принимаем последний стоповый бит //4
                                                        Another_Format(); //Стоповый бит не ноль ошибка
                                                }else{
                                                        SetBit(RFID_buffer[byte_counter], 4); //Набиваем регистр битов чётности по столбам
                                                        ShiftBitRight(RFID_buffer[byte_counter]); //Сдвигаем вправо
                                                        bit_counter++;
                                                }
                                        }else{
                                                if(crc_counter == 4){ //Если принимаем бит чётности
                                                        if(BitIsClear(flag, 4)){ //Если бит чётности - 0
                                                                Another_Format(); //Ошибка, бит должен быть 1
                                                        }
                                                        crc_counter = 0;
                                                        ClearBit(flag, 4); //Обнуляем бит чётности в регистре, что бы проверить следующие 4 бита
                                                        if(bit_counter == 8){ //Если приняли 8 бит, значит это 1 байт
                                                                bit_counter = 0;
                                                                byte_counter++; // Увеличиваем счётчик принятых байтов
                                                        }    
                                                }else{
                                                        SetBit(RFID_buffer[byte_counter], 7); //Набиваем регистр
                                                        if(bit_counter < 7){ShiftBitRight(RFID_buffer[byte_counter]);} //Сдвигаем вправо, если бит не последний
                                                        CalculateCRC(flag, 4); //Расчёт чётности. Просто делаем исключающее или 4 бита регистра flag и лог единицы. Получится в цикле если будет 1,3 единицы, бит будет - 1, если 2, 4 - бит будет 0
                                                        bit_counter++;
                                                        crc_counter++;
                                                }
                                        }
                                }else{ //Если приняли 0 (Когда напорту один, значит идёт приём лог. 0)
                                        if(byte_counter == 5){
                                                if(bit_counter == 4){ //Принимаем последний стоповый бит //4
                                                        SetBit(flag, 2); //Так как приняли 0, то это правильный стоп-бит и устанавливаем флаг, что бы разрешить далее проверку чётности столбов
                                                }else{
                                                        ShiftBitRight(RFID_buffer[byte_counter]); // Просто сдвигаем регистр, так как 0 в этом случае запишется автоматически
                                                        bit_counter++;
                                                }
                                        }else{
                                                if(crc_counter == 4){ //Если принимаем бит чётности
                                                        if(BitIsSet(flag, 4)){ //Если бит чётности - 1
                                                                Another_Format(); //Ошибка, бит должен быть 0
                                                        }
                                                        crc_counter = 0;
                                                        ClearBit(flag, 4); //Обнуляем бит чётности в регистре, что бы проверить следующие 4 бита
                                                        if(bit_counter == 8){
                                                                bit_counter = 0;
                                                                byte_counter++;
                                                        }
                                                }else{
                                                        ClearBit(RFID_buffer[byte_counter], 7); //Набиваем ноль, так как при 7 бите сдвигать не будем. А если не сдвинуть, 0 не запишется
                                                        if(bit_counter < 7){ShiftBitRight(RFID_buffer[byte_counter]);}
                                                        bit_counter++;
                                                        crc_counter++;
                                                }
                                        }
                                }
                        }else{ //Приём заголовка
                                if(BitIsClear(PIND, 6)){
                                        bit_counter++;
                                }else{
                                        Another_Format();
                                }
                                if(bit_counter == 9){
                                        SetBit(flag, 1);
                                        bit_counter = 0;
                                }
                        }
                        ClearBit(flag, 0);
                }
                if(BitIsSet(flag, 2)){//вычисление чётности столбов
                        for(bit_counter = 0; bit_counter < 4; bit_counter++){ //Прогон для битов
                                for(byte_counter = 0; byte_counter < 5; byte_counter++){ //Прогон для байтов
                                        if(BitIsSet(RFID_buffer[byte_counter], bit_counter)){
                                                CalculateCRC(flag, 4);
                                        }
                                        if(BitIsSet(RFID_buffer[byte_counter], (bit_counter + 4))){
                                                CalculateCRC(flag, 4);
                                        }
                                }
                                if(BitIsSet(flag, 4)){
                                        if(!(RFID_buffer[5] & (1 << bit_counter))){
                                                Another_Format();
                                                break;
                                        }else{
                                                SetBit(flag, 5);
                                        }
                                }else{
                                        if(RFID_buffer[5] & (1 << bit_counter)){
                                                Another_Format();
                                                break;
                                        }else{
                                                SetBit(flag, 5);
                                        }
                                }
                                ClearBit(flag, 4);
                        }
                        if(BitIsSet(flag, 5)){
                                char id[1];
                                sprintf(id, "%hhX", RFID_buffer[0]);
                                Lcd_prints (0, 0, FONT_1X, (unsigned char*)PSTR("ID:"));
                                Lcd_print (3, 0, FONT_1X, (unsigned char*) id);
                                Lcd_update();
                                id[1] = 0;
                                sprintf(id, "%hhX%hhX%hhX%hhX", RFID_buffer[4], RFID_buffer[3], RFID_buffer[2], RFID_buffer[1]);    
                                Lcd_prints (0, 2, FONT_1X, (unsigned char*)PSTR("Num:"));
                                Lcd_print (4, 2, FONT_1X, (unsigned char*) id);
                                Lcd_update();
                                ClearBit(flag, 2);
                                break;
                        }
                }
        }
}

кварц на 16. Камень - мега 16. В этом коде много проверочного мусора...

Это сообщение отредактировал(а) supercelt - 26.8.2015, 13:24

bass

Дата 26.8.2015, 16:04 (ссылка)

(нет голосов)

Загрузка ...

Опытный

Профиль
Группа: Участник
Сообщений: 315
Регистрация: 5.8.2007

Репутация: нет
Всего: 2

Цитата(supercelt @ 26.8.2015, 13:17)

Код


//Formats#####################################################################

//############################################################################
//Includes####################################################################
#define F_CPU 16000000 //Частота камня
#include <avr/io.h>
#include <stdio.h>
#include <stdlib.h>
#include <avr/interrupt.h>
#include <string.h>
#include "n5110.h"
#include <util/delay.h>
//############################################################################

//Variables###################################################################
volatile unsigned char cycle_counter = 32;
unsigned char bit_counter;
unsigned char byte_counter;
unsigned char crc_counter;
unsigned char RFID_buffer[6];
volatile unsigned char RF = 64;
volatile unsigned char flag;
//flag
//0 - разрешение на обработку в основном цикле программы, при счётчике = RF.
//1 - установка этого бита означает что заголовок из 9 единиц принят и далее идут данные.
//2 - установка этого бита означает, что приняты все биты всключая стоповый и далее следует сравнить чётность столбов и принять решение о распозновании метки.
//3 - если бит в 0 значит ещё не был обнаружен сигнал на входе, если 1, то сигнал обнаружен
//4 - бит для проверки чётности CRC. 1 - нечётно, 0 - чётно.
//5 - бит распознования метки. Если 1 - метка распознана. Если 0 - нет. Распознование - сравнение CRC по столбам.
// unsigned char ks = 0; // test
// unsigned char m = 0b01111110;
// unsigned char n = 0b01111111;
// unsigned char l = 0b11111011;
// unsigned char k = 0b11011111;
// char p[1];
//############################################################################

//Macros######################################################################
#define SetBit(reg, bit)        reg |= (1 << bit)
#define ClearBit(reg, bit)        reg &= ~(1 << bit)
#define BitIsSet(reg, bit)        ((reg & (1 << bit)) != 0)
#define BitIsClear(reg, bit)    ((reg & (1 << bit)) == 0)
#define ShiftBitRight(reg)        reg >>= 1
#define CalculateCRC(reg, bit)    reg ^= (1 << bit) 
//############################################################################

//Functions###################################################################
void USART_SendChar(unsigned char sym){
        while(!(UCSRA & (1<<UDRE)));
        UDR = sym;
}

void Another_Format(){
        cycle_counter = 32;
        bit_counter = 0;
        byte_counter = 0;
        crc_counter = 0;
        RFID_buffer[6] = 0;
        RF = 64;
        flag = 0;
//-------------test in proteus-------------
        PORTD ^= (1 << 5);
        TCCR2 &= ~(1 << COM20);
        _delay_ms(1);
        TCCR2 |= (1 << COM20);
//-----------------------------------------        
}
//############################################################################

ISR(TIMER2_COMP_vect){
        if(BitIsSet(PIND, 7)){
                if(BitIsClear(PIND, 6) && (BitIsClear(flag, 3))){ //Обнаружение первой передачи первого бита.
                        cycle_counter++;
                        SetBit(flag, 3);
                }else if(BitIsSet(flag, 3)){ //Последующее обнаружение после первого бита
                        cycle_counter++;
                }
                if(cycle_counter == RF){ //по стандарту 1 бит занимает опред. число периодов частоты. RF - это число периодов. Как только насчитали, то переходим принимать бит в основной цикл программы
                        SetBit(flag, 0);
                        cycle_counter = 0;
                }
        }    
}

int main(void){
    
    DDRD |= (1 << 2);//test
    PORTD &= ~(1 << 2);//test
    
        DDRC = 0xFF;
        PORTC &= ~(1 << 0);
        PORTC &= ~(1 << 1);
        PORTC &= ~(1 << 2);
        PORTC &= ~(1 << 3);
    
        DDRD &= ~(1 << 6);
        DDRD |= (1 << 7) | (1 << 5);
        PORTD |= (1 << 6); //Ставим подтяг. резистор (1 на пин 6) только для симулятора. В железе на пин 6 надо ноль
        PORTD &= ~(1 << 7);
        PORTD &= ~(1 << 5);
        OCR2 = 63; //Задаём частоту счётчика. При предделителе 1/1 и OCR = 31 Частота будет 125 kHz
        TCCR2 |= (0 << WGM20)|(1 << WGM21); //Режим работы таймера-счётчика2 - сброс при совпадении (СТС)
        TCCR2 |= (0 << CS22)|(0 << CS21)|(1 << CS20); //предделитель частоты 1\1
        TCCR2 |= (0 << COM21)|(1 << COM20); //Смена сигнала на PD7 - Toggle
        TIMSK |= (1 << OCIE2); //Разрешаем уходить в прерывание при совпадении TCNT0 и OCR*/

        // USART initialization
        // Communication Parameters: 8 Data, 1 Stop, No Parity
        // USART Receiver: On
        // USART Transmitter: On
        // USART Mode: Asynchronous
        // USART Baud Rate: 38400
        UCSRA=0x00;
        UCSRB=0x18;
        UCSRC=0x86;
        UBRRH=0x00;
        UBRRL=0x8;

        Lcd_init();
        Lcd_clear();
        PORTD |= (1 << 2);
        asm("sei");
        
        while(1){
            
//            if(ks == 0){
//                asm("cli");
//                sprintf(p, "%hhX%hhX%hhX%hhX", k, l, n, m);
//                Lcd_prints ( 0, 0, FONT_1X, (unsigned char*)PSTR("ID:") );
//                Lcd_print ( 3, 0, FONT_1X, (unsigned char*) p );
//                Lcd_update();
//                ks = 1;
//                asm("sei");
//                break;
//            }
            
            
                if(BitIsSet(flag, 0)){
                    //----test in proteus--------------------
                    PORTC |= (1 << 0);
                    asm("nop");
                    PORTC &= ~(1 << 0);
                    //----test in proteus--------------------
                        if(BitIsSet(flag, 1)){ //Приём данных
                                if(BitIsClear(PIND, 6)){ //Если приняли 1 (Когда на порту ноль, значит идёт приём лог 1)
                                        if(byte_counter == 5){ //Если принимаем 5-й байт - это уже не данные, а биты чётности по столбам
                                                if(bit_counter == 4){ //Принимаем последний стоповый бит //4
                                                        Another_Format(); //Стоповый бит не ноль ошибка
                                                }else{
                                                        SetBit(RFID_buffer[byte_counter], 4); //Набиваем регистр битов чётности по столбам
                                                        ShiftBitRight(RFID_buffer[byte_counter]); //Сдвигаем вправо
                                                        bit_counter++;
                                                }
                                        }else{
                                                if(crc_counter == 4){ //Если принимаем бит чётности
                                                        if(BitIsClear(flag, 4)){ //Если бит чётности - 0
                                                                Another_Format(); //Ошибка, бит должен быть 1
                                                        }
                                                        crc_counter = 0;
                                                        ClearBit(flag, 4); //Обнуляем бит чётности в регистре, что бы проверить следующие 4 бита
                                                        if(bit_counter == 8){ //Если приняли 8 бит, значит это 1 байт
                                                                bit_counter = 0;
                                                                byte_counter++; // Увеличиваем счётчик принятых байтов
                                                        }    
                                                }else{
                                                        SetBit(RFID_buffer[byte_counter], 7); //Набиваем регистр
                                                        if(bit_counter < 7){ShiftBitRight(RFID_buffer[byte_counter]);} //Сдвигаем вправо, если бит не последний
                                                        CalculateCRC(flag, 4); //Расчёт чётности. Просто делаем исключающее или 4 бита регистра flag и лог единицы. Получится в цикле если будет 1,3 единицы, бит будет - 1, если 2, 4 - бит будет 0
                                                        bit_counter++;
                                                        crc_counter++;
                                                }
                                        }
                                }else{ //Если приняли 0 (Когда напорту один, значит идёт приём лог. 0)
                                        if(byte_counter == 5){
                                                if(bit_counter == 4){ //Принимаем последний стоповый бит //4
                                                        SetBit(flag, 2); //Так как приняли 0, то это правильный стоп-бит и устанавливаем флаг, что бы разрешить далее проверку чётности столбов
                                                }else{
                                                        ShiftBitRight(RFID_buffer[byte_counter]); // Просто сдвигаем регистр, так как 0 в этом случае запишется автоматически
                                                        bit_counter++;
                                                }
                                        }else{
                                                if(crc_counter == 4){ //Если принимаем бит чётности
                                                        if(BitIsSet(flag, 4)){ //Если бит чётности - 1
                                                                Another_Format(); //Ошибка, бит должен быть 0
                                                        }
                                                        crc_counter = 0;
                                                        ClearBit(flag, 4); //Обнуляем бит чётности в регистре, что бы проверить следующие 4 бита
                                                        if(bit_counter == 8){
                                                                bit_counter = 0;
                                                                byte_counter++;
                                                        }
                                                }else{
                                                        ClearBit(RFID_buffer[byte_counter], 7); //Набиваем ноль, так как при 7 бите сдвигать не будем. А если не сдвинуть, 0 не запишется
                                                        if(bit_counter < 7){ShiftBitRight(RFID_buffer[byte_counter]);}
                                                        bit_counter++;
                                                        crc_counter++;
                                                }
                                        }
                                }
                        }else{ //Приём заголовка
                                if(BitIsClear(PIND, 6)){
                                        bit_counter++;
                                }else{
                                        Another_Format();
                                }
                                if(bit_counter == 9){
                                        SetBit(flag, 1);
                                        bit_counter = 0;
                                }
                        }
                        ClearBit(flag, 0);
                }
                if(BitIsSet(flag, 2)){//вычисление чётности столбов
                        for(bit_counter = 0; bit_counter < 4; bit_counter++){ //Прогон для битов
                                for(byte_counter = 0; byte_counter < 5; byte_counter++){ //Прогон для байтов
                                        if(BitIsSet(RFID_buffer[byte_counter], bit_counter)){
                                                CalculateCRC(flag, 4);
                                        }
                                        if(BitIsSet(RFID_buffer[byte_counter], (bit_counter + 4))){
                                                CalculateCRC(flag, 4);
                                        }
                                }
                                if(BitIsSet(flag, 4)){
                                        if(!(RFID_buffer[5] & (1 << bit_counter))){
                                                Another_Format();
                                                break;
                                        }else{
                                                SetBit(flag, 5);
                                        }
                                }else{
                                        if(RFID_buffer[5] & (1 << bit_counter)){
                                                Another_Format();
                                                break;
                                        }else{
                                                SetBit(flag, 5);
                                        }
                                }
                                ClearBit(flag, 4);
                        }
                        if(BitIsSet(flag, 5)){
                                char id[1];
                                sprintf(id, "%hhX", RFID_buffer[0]);
                                Lcd_prints (0, 0, FONT_1X, (unsigned char*)PSTR("ID:"));
                                Lcd_print (3, 0, FONT_1X, (unsigned char*) id);
                                Lcd_update();
                                id[1] = 0;
                                sprintf(id, "%hhX%hhX%hhX%hhX", RFID_buffer[4], RFID_buffer[3], RFID_buffer[2], RFID_buffer[1]);    
                                Lcd_prints (0, 2, FONT_1X, (unsigned char*)PSTR("Num:"));
                                Lcd_print (4, 2, FONT_1X, (unsigned char*) id);
                                Lcd_update();
                                ClearBit(flag, 2);
                                break;
                        }
                }
        }
}

кварц на 16. Камень - мега 16. В этом коде много проверочного мусора...

Дайте еще плиз даташитик что подключаете к МК.
Не пойму протокол.

bass

Дата 26.8.2015, 16:56 (ссылка)

(нет голосов)

Загрузка ...

Опытный

Профиль
Группа: Участник
Сообщений: 315
Регистрация: 5.8.2007

Репутация: нет
Всего: 2

http://www.rlocman.ru/shem/schematics.html?di=148455

Вот статья про rfid
с примером исходного кода, правда не заводской считываетль подключаеться.
Переделать код и будет что вам надо.

supercelt

Дата 27.8.2015, 14:28 (ссылка)

(нет голосов)

Загрузка ...

Опытный

Профиль
Группа: Участник
Сообщений: 658
Регистрация: 25.8.2005

Репутация: нет
Всего: 1

bass, Первое что я сделал как раз нашёл эту статью. В ней уже в самой теории обмена информацией есть ошибка. И ошибки с номиналами элементов. А код так вообще непонятно как он работает. В комментах многие жалуются что у них эта схема не работает. Есть много других схем которые я смотрел, но все они под манчестер

bass

Дата 27.8.2015, 16:34 (ссылка)

(нет голосов)

Загрузка ...

Опытный

Профиль
Группа: Участник
Сообщений: 315
Регистрация: 5.8.2007

Репутация: нет
Всего: 2

Какую микросхему или схему тогда используете для приема самого несущего сигнала.

Так понял на входе МК мы имеем сигнал Modulator Control.
И знаем временные метки протокола. (Clock) Данный сигнал мы не можем принимать на ногу микроконтроллера.
В итоге нам нужно получить Binari Data.
Так понимаю.

Код



volatile unsigned long int0_cnt = 0;
volatile unsigned long ferstTik = 0;
//функция обработчик внешнего прерывания INT0 по нарастающему фронту и падающему фронтам
ISR( INT0_vect )
{
останавливаем таймер.
коллибровка таймера
Выставояем время таймера периуда (не частоты)
ferstTik =1;//сообщаем таймеры что у него временной интервал периуда

//сравниваем

if(int0_cnt == 1)
{
//No pshare change
}
if(int0_cnt == 2)
{
//Pshare change
}
 int0_cnt=0;//сбрасываем счетчик
//Возможно сверка пина с падением фронта или возрастания
//Монипуляции с полученным битом (Запись его в буфер) 

Запускаем таймер.
}


ISR(TIMER2_COMP_vect)
{
if(ferstTik ==1)//смотрим какой интервал на данный момент у таймера
{
ferstTik = 0;
//выставляем временной интервал два периуда (частота клок)
}
int0_cnt++;
      if(int0_cnt >2)
      {
       //ошибка продолжительности сигнала

       }
}

С Инициализацей таймеров и прерываний думаю проблем встать не должно.

supercelt

Дата 27.8.2015, 23:41 (ссылка)

(нет голосов)

Загрузка ...

Опытный

Профиль
Группа: Участник
Сообщений: 658
Регистрация: 25.8.2005

Репутация: нет
Всего: 1

bass, да всё верно. Принимаем на ногу modulator control, метки знаем . Спасибо за наводку, буду ковырять

0 Пользователей читают эту тему (0 Гостей и 0 Скрытых Пользователей)
0 Пользователей:
« Предыдущая тема \| Микроконтроллеры (MCU) и микропроцессоры (MPU) \| Следующая тема »