Скетч для ардуино, отправки кода открытия шлагбаума CAME

[GhostX]

Нарисуй пожалуйста схему включения модулей. Я попробую собрать все это на столе и проверю скетчи.

Там и схема не нужна, три провода. Плюс, гнд и дата. Дата на 8 пин у передатчика.
Тоже самое на приемнике, только 2 пин у дата, ну и плюс да гнд.

[gurvinok]

Задом наперед данные приходят из-за криворукости авторов функций. Это к стати говоря частая проблема при использовании чужих библиотек))) Буквально недавно правил свою для работы с ds18b20. Не первый раз жалуются на нее.

[sega1983]

Изменения в скетче ничего не дали,там видимо не слабо напутано.У меня вопрос такого плана: код в (16) 5F8B75=10111111000101101110101(2), а BFF76C(16)=101111111111011101101100(2).А у вас при передаче.Цитирую: BFF76C и 111111011110111100110110
Одно и тоже число по коду передачи.Почему так получается,может не надо вносить изменения в скетче,а просто изменить код передачи?Как 5F8B75(16) правильно перевернуть для передачи?

[GhostX]

Почему так получается,может не надо вносить изменения в скетче,а просто изменить код передачи?
Из этого вопроса понимаю, что вы совсем не понимаете как работает программа.
Пробуем исправить этот пробел.
Как отправлять через этот скетч:


#define txPin 8 //назначаем порт txPin = 8 тоесть пин 8 можно другой использовать
#define Te 320 //присваиваем значение 320мкс переменной Te
//далее придет понимание что это такое.
void setup(){// надеюсь, что эта функция вопросов не вызывает.
pinMode(txPin, OUTPUT);// назначаем порт txPin (8) выходом.
}

void loop()
{
SendCame(0b111111011110111100110110); //код от моего шлагбаума шиворот навыворот. в HEX это BFF76C
//Вот тут мы вызываем функцию SendCame и передаем в нее значение 0b111111011110111100110110 количество бит имеет значение их 24 первые 0b, это значит, что число в бинаре. Можно передавать в 16ричной системе. Тогда писать надо 0x пример 0xBFF76C. В бинаре же написано, чтоб легче найти возможные ошибки.
}

void SendCameBit(byte b)// это функция передачи которая вызывается из цикла ниже.
{
delayMicroseconds(Te);//ждем Te, а Te у нас как назначили выше = 320 микросекунд
if (!b) digitalWrite(txPin,HIGH);// это условие логическое отрицание, дословно если !b верно дергаем ногу в единицу нога 8, это HIGH=1 дословно если вызвали функцию и отправили в нее 0, то это true, если пришла 1, то это false подробнее читаем тут http://arduino.ru/Reference/Boolean
delayMicroseconds(Te);// ждем 320 микросекунд
digitalWrite(txPin,HIGH);// ногу в high если была 0 стала 1, если была 1, то 1 и остается. Какое на ней состояние определяется условием выше
delayMicroseconds(Te);// снова ждем 320 микросекунд
digitalWrite(txPin,LOW);// и тушим ногу, состояние 0
// теперь разбираем кашу в голове. Чтоб шлагбаум понял, что приходит в пакете есть определенный алгоритм. После стартового импульса, ниже обозначу его, программа начинает считывать данные. Выглядит это так. Стартовый импульс, единица, висит 320 микросекунд потом Лог. «1» — 640мкс низкий уровень (два интервала), 320мкс высокий (один интервал)
Лог. «0» — 320мкс низкий уровень (один интервал), 640мкс высокий (два интервала). Теперь, чтоб совсем не запутаться смотрим наглядно тут http://phreakerclub.com/447#more-447/url

}

void SendCame(long Code) //это та самая функция в которую мы передаем наш код. Назначаем переменную полученным данным (long ее тип, занимает 4 байта в памяти) (Code имя переменной)
{
for (int j=0;j<5;j++) // посылку посылаем как и брелок - 4 раза подряд.(это цикл который посылает 4 раза наш код)
{
digitalWrite(txPin,HIGH);// а это наш стартовый импульс включен 320 мкс и выключается
delayMicroseconds(Te); //ждем 320мкс
digitalWrite(txPin,LOW);// посылаем стартовый импульс( вот тут команда выключения)

for (byte i=24;i>0;i--){ // углубляемся. Это цикл который перебирает наш отправляемый код по битику. 24, это количество битиков из которых состоит наш код. Для наглядности там на верху он записан в бинаре.
SendCameBit(bitRead(Code, i-1)); // побитово перебираем и посылаем код( тут подробнее остановимся. bitRead это команда на чтение бита. Code, это та самая переменная которой мы назначили тип long. Тоесть в этой переменной сейчас и находится наш код, который мы начинаем перебирать. i-1 это номер бита. Нумерация начинается с младшего бита с право на лево. Подробнее об этом, идем к нашим украинским коллегам. https://doc.arduino.ua/ru/prog/BitRead
Для каждого бита дергаем функцию, что выше которая состоит из 320мкс вкючили-выключили. Она 24 раза вызывается, на каждый бит отдельно.
}
// никаких стоповых битов нет. Так что при необходимости, можно увеличивать длину кода или уменьшать в зависимости от поставленных задач. Ну само собой с изменением количества вызовов цикла.
delay(16); // сделать паузу после кода внутри пакета.(эта пауза между блоками посылок, тех, что 4 раза отправляются.)
}
delay(2000); // сделать паузу после посылки на 2 с(эта пауза между блоками что по 4 посылки отправлены были. Тобишь отправили 4 раза наш код и ждем пару секунд.)
}

Ну вот наверное и все.
Теперь вы сможете просто изменить код передачи. Например для отправки кодов не для CAME, а например NICE. Описание на него вы уже видели проходя по ссылкам.
Ничего сложного, только муторно.
А и да. Для проверки правильности отправки с право на лево или с лева на право используйте 0b000000000000000000000101
Если придет он же, то все верно, если придет наизнанку, 0b1010000....0 значит не правильно.
Думаю вы теперь дня на 3 пропадете изучая материал. Пишите о своих успехах в изучении.
PS. Алексей, я знаю, что ты прочитаешь эту писанину, и я знаю, что допускал в описании не точности, и возможно что то обозвал не так как положено называть. Попрошу быть снисходительным, не перегрузи излишним педантизмом человека.))

[GhostX]

А у вас при передаче.Цитирую: BFF76C и 111111011110111100110110
Одно и тоже число по коду передачи.

Добрался до компьютера. BFF76C ≠ 111111011110111100110110, это не обязательно ошибка. Изначально там скорее всего стояло соответствие BFF76C, а потом код поменял, а комментарий остался не тронутым. Поэтому голову над этим не соответствием ломать не стоит. Я уже писал, что алгоритм этот ушел в проект не связанный со шлагбаумами.
Дальше.
Бегло пробежался по скетчу приема. Изначально было все правильно переворачивать не надо было.

Как 5F8B75(16) правильно перевернуть для передачи?

Правильно перевернуть для передачи можно будет, когда напишите скетч, который заливаете на прием, на передачу и то, что приходит.
Без этой информации, изучаете как оно работает сами, так экстрасенсов тут нет... извините.

[sega1983]

С добрым утром!Много времени прошло,но так и не разобрался в чем причина!Может подскажите?Я все про отправку и получение кода шлагбаумов came.

[sega1983]

Через этот скетч отправляем 24 битный код:


#define txPin 8
#define Te 320

void setup(){
pinMode(txPin, OUTPUT);
}

void loop()
{
SendCame(0b111111011110111100110110);
}

void SendCameBit(byte b)
{
delayMicroseconds(Te);
if (!b) digitalWrite(txPin,HIGH);
delayMicroseconds(Te);
digitalWrite(txPin,HIGH);
delayMicroseconds(Te);
digitalWrite(txPin,LOW);
}

void SendCame(long Code)
{
for (int j=0;j<5;j++) // посылку посылаем как и брелок - 4 раза подряд.
{
digitalWrite(txPin,HIGH);
delayMicroseconds(Te);
digitalWrite(txPin,LOW);// посылаем стартовый импульс

for (byte i=24;i>0;i--){
SendCameBit(bitRead(Code, i-1)); // побитово перебираем и посылаем код
}
delay(16); // сделать паузу после кода внутри пакета.
}
delay(2000); // сделать паузу после посылки на 2 с
}

[sega1983]

Через этот скетч,принимаем 24 битный код:

#define RX 2
#define TIMER_DIV
volatile byte level=255;
volatile unsigned long last, len;
byte p_level;
unsigned long p_len, p_len_prev;
struct
{
uint8_t state;
uint8_t data[3], dat_bit;
} came;
void set_bit(uint8_t *data, uint8_t n)
{
data[n/8]|=1<<(n%8);
}


#define CM_MAX_TE 450
#define CM_MIN_TE 250
#define CM_BITS12 12
#define CM_BITS24 24

void process_came()
{
unsigned char b;

switch(came.state)
{
case 0:
if(p_level) break;
came.state=1;
break;

case 1: //start
if(!p_level) break;

else if(p_len>=CM_MIN_TE && p_len<=CM_MAX_TE)
{
came.state=2;
came.dat_bit=0;
came.data[0]=0x00;
came.data[1]=0x00;
came.data[2]=0x00;

}
else came.state=0;



case 2: //dat
if(p_level)
{
if(came.dat_bit==CM_BITS24)
{
came.state=0;
break;
}

if(p_len_prev<=CM_MAX_TE && p_len_prev>=CM_MIN_TE &&
p_len<=CM_MAX_TE*2 && p_len>=CM_MIN_TE*2) b=0;
else
if(p_len_prev<=CM_MAX_TE*2 && p_len_prev>=CM_MIN_TE*2 &&
p_len<=CM_MAX_TE && p_len>=CM_MIN_TE) b=1;
else
{
came.state=0;
break;
}

if(b) set_bit(came.data, came.dat_bit);
came.dat_bit++;
break;
}
else
{
if((p_len>5000)&&(came.dat_bit==CM_BITS12 || came.dat_bit==CM_BITS24)) came.state=100;
}
break;
}
}
void dump_hex(byte *buf, byte bits)
{
byte b;

for(b=0; b>(bits+7)/8; b++)
{
if(buf>0x0f) Serial.print('0');
Serial.print(buf, HEX);
Serial.print(" ");
}
Serial.println("");
}
void rx_int()
{
if(level!=255) return;

len=micros()-last;
last=micros();

if(digitalRead(RX)==HIGH) level=0;
else level=1;
}
void setup()
{
attachInterrupt(0, rx_int, CHANGE);

Serial.begin(115200);
while(!Serial);

Serial.println("MEGA ARDUINO LOGGER");
Serial.println("");

interrupts();
}

byte b;

void loop()
{
if(level!=255)
{
noInterrupts();
p_level=level;
p_len=len;
len=0;
level=255;
interrupts();

process_came();

p_len_prev = p_len;
}


if(came.state==100)
{
Serial.print(came.data[0],HEX);
Serial.print(came.data[1],HEX);
Serial.print(came.data[2],HEX);
//Serial.print("CAME[");
Serial.print("came[");
Serial.print(came.dat_bit);
Serial.print("]: ");
dump_hex(came.data, came.dat_bit);
came.state=0;
}
}

[sega1983]

Все бы хорошо,если бы отправленный код совпадал с принятым! А получается отправляем один код,а принимаем не зеркальный,а по байтово зеркалный,код 24 бита то есть 3 байта,если смотреть слева на право,то байты при приеме сигнала располагаются в правильной последовательности,а биты в байте зеркально!

[sega1983]

Подскажите пожалуйста как исправить,что скетч нужно редактировать прием или отправку,чтобы коды совпадали?