Похоже при редактировании что-то покоцалось

VIC, помница в период моей практики муханики отключали УТС на время окна, затем включали, проверки делали на память размыкали контрольные контакты и смотрели потерю контроля, также некое подобие щупа было подкладывали под УТС и смотрели даст контроль или нет, также проверки были с кнопками от колонки которая стояла около УТС.

ардуино-творчество вживую
https://yadi.sk/i/tru_8tLQmKiiJ
как и в прошлый раз какчество лучче будет если видюшку качнуть а не смотреть прямо с яндекс диска

Очень даже интересно!
Недавно тоже такую штучку приобрёл, в свободное время играюсь с ней. Как я понял, Вы делаете дешифратор или просто измеряете временные последовательности? Очень интересная задумка.
Я, чтобы не делать дополнительных устройств подключенных к Ардуино, делаю обмен по СОМ порту в программку на компе (в программе сделать кнопки, вывод чего-либо нет проблем), а там это обрабатываю, такой подход значительно облегчает и ускоряет отладку ПО Ардуино. Более того, в ПО на компе использую те же самые классы и функции, которые применяю в ПО Ардуино, таким образом отладку этих классов произвожу на компе с приемлемым отладчиком (кое где приходится использовать условную компиляцию).
То, чем Вы занимаетесь мне интересно, может быть чем-то смогу быть Вам полезен. Удачи Вам!

Ваяю презенташку по расчету ординат если не сложно проверьте, может косяков кучу найдете, пока не встречал литературы в которой расчет ординат был бы по человечески описан
http://scbist.com/scb/uploaded/33_1453190478.zip
ссылка скорее всего заработает не сразу ...

яндекс диск ссылка https://yadi.sk/d/mR2JiD3VnLDDG

"следующей идеей собираюсь попробовать ДК для учебного полигона".
Мы в своё время делали ДК, но снимали прямо с лампочек пульт-табло. Очень простой монтаж, выполняется просто и быстро. Для этого сделали свой модуль съёма (48 дискретных сигнала) - простой как палка, регистры ввода, Альтера и элементы гальванической инверсной токовой петли, модули подключались как лампочки гирлянды (все в параллель), до 10 модулей на один СОМ порт. В пульт-табло модули крепились на колодке с размерами ПП20.
http://morepic.ru/images3/asdsn1_9943_5762.jpg

Видно было давно, что наука в этом вопросе занималась мультиками...

Этот девайс был разработан где-то 1997 г. От начала разработки до опытного образца 2 недели и это была не какая-то сложная разработка, а хорошее инженерное решение. Потому, что удалось избавится от кучи оптронов гальванической развязки дискретных сигналов. Естественно электроника шагнула далеко вперед. Обмен велся на скорости 19200 или 9600 бит/с. Этой скорости вполне хватало для съема дискретных сигналов, кроме того съём был с лампочек пульт-табло, которые питаются переменкой, поэтому быстрее, чем 1/50 снимать не возможно. Дребезг подавлялся программно, так же определялся режим мигания.
Очень простой и дешевый способ съёма, не требующий сложного монтажа, как, например, для ПИК-120.
Для сигнальных установок ДК делают как я знаю "ЮгПромАвтоматизация", "КИТ" и ёще некоторые разработчики. Дальше всех по объёму передаваемой информации с СУ продвинулась ЮгПромАвтоматизация.
Для ДК СУ две принципиальные задачи:
- как снять,
- и более сложная задача как передать на станцию.
Для передачи на станцию могут быть варианты:
- многоточка,
- передача с последовательными переприёмами на каждой СУ.

Структурная схема
http://morepic.ru/images3/1cr_3811_1794.png
Принципиальная схема
http://morepic.ru/images3/11cr_2529_8334.png
http://morepic.ru/images3/12cr_5474_1767.png
Последовательный интерфейс
http://morepic.ru/images3/1cr_453_130.png
Вот что удалось найти в архиве.

Просто инженер АиТ добавил 21.01.2016 в 10:23
Ещё была сделана одна разработка адаптера съёма дискретных сигналов. Несколько неудобно обрабатывать дискретные сигналы в компьютере, поэтому предварительную обработку отдали модулям съема, таким образом снятые сигналы можно было отдавать сразу в устройства связи (модем), не устанавливая компьютера на линейной станции.
http://morepic.ru/images3/img0126m_9929_47.jpg
АСДК получалась слишком простой, быстро монтируемой и главное экономичной (стоимость АСДК одной станции не превышала $1000) и это была наша большая и самая главная ошибка! Никому не нужны дешевые системы.

В своё время разрабатывали мы Комплекс Горочный Микропроцессорный на базе элементов КТС-ЛИУС-2. В его состав входили различные модули:
- модуль процессора (на базе процессора КР580ВМ80),
- модуль ввода,
- модуль вывода и т.д.
В КГМ необходимо было вводить достаточно много дискретных сигналов, один модуль ввода мог ввести 32 дискретных сигнала, кол-во модулей устанавливаемых в блок было, вроде 21, т.е. нужное кол-во модулей не помещалось. Вот тогда В.В. Кольцов (сейчас гл. инженер ЮгПромАвтоматизации) предложил сделать матричный ввод (1988 г. в матрице были сухие контакты реле), т.е. поставить один элемент ввода и один элемент вывода, что позволило вводить 1024 сигнала (32*32). Кроме того сразу же сделать диагностику элементов ввода-вывода, искусственно по главным диагоналям вводить по одной 1, по другой 0.
Тоже самое можно сделать на базе Arduino. Рекомендую писать на "С" (или на С++)(изучение "С" займет не много времени), это гораздо проще и быстрее, чем на ассемблере.
Всем всего доброго!

Просто инженер АиТ добавил 25.01.2016 в 09:10
А еще. На адаптере ввода производится ввод дискретного сигнала, питаемый переменным током. Т.е. опрос в какой-то любой момент времени не подходит, поэтому на один из входов подаётся напряжение питание, которое генерирует что-то типа прерывания, в момент, когда на этом входе 1. По прерыванию начинается опрос всех дискретных сигналов (пока на входе прерывания 1) по принципу интегрирования состояния, если после интеграции получаем 1, то в регистр записывается 1.

В 1993 г. на Вологодском отделении внедряли ДЦМ-Дон (элементная база КТС-ЛИУС2). Вот там впервые был сделан съём с лампочек пульт-табло матричным способом. Повозиться вместе с разработчиками пришлось не мало.
Чтобы сделать матричный ввод планировалось в релейной поставить от 1 до 3 дополнительных стативов с распаянными диодами, естественно в релейных эти стативы ставить было некуда.
Тогда мы с М.Б. Зингером предложили сделать конструктив с диодными платами (на что оформили рацуху (где-то валяется)(результат рацухи огромная экономия, а могли бы на деньги от рацухи купить по 3 Жигуля)), надобность в доп. стативах пропала.
Дальше переменка, пришлось сделать формирование прерывания на элементах ввода, откорректировать ПО ЛПУ.
И ёще ДЦМ-Дон имел горячее резервирование УВК на ЛПУ, т.е. ввод должен идти на два комплекта УВК ЛПУ. И тут начались мощные обвязки входов на элементах ввода. Элементы ввода стандартные, особо что-то не добавишь, но "пытливый детский ум" нашёл выход. Перед оптронами на входе эл-та ввода стояло несколько элементов (резисторы), так вот просто выпаяли последовательные резисторы и заменили их на диоды.
В итоге ввод всё же получился.

И мне пришлось с таким поработать (возможно это был просто КТС-ЛИУС без двойки). Мы даже разработали на него свой МОНИТОР, который позволял не только пересылать по СОМ-порту программу с персоналки Нейрон (советский аналог IBM PC XT), но и производить с персоналки полноценную отладку (старт/стоп, просмотр регистров/памяти и т.п.)

У нас модули ввода были на 16 входов (если не путаю, вывода тоже, скорее всего, на 16).


Не совсем понятно что имеется ввиду под "интеграцией". Если многократный опрос каждого входа с последующим подсчетом 1 и 0 то не совсем понятно для чего это нужно при наличие прерывания "приход положительной полуволны". Или интеграция за несколько периодов или за период >1 сек для определения что лампа горит, но мигает?

Можно вводить сигналы переменного тока и без дополнительного входа, обеспечивающего прерывание. Но тогда цикл опроса должен быть 1-2 мс чтобы за один период гарантированно поймать несколько 1 (остальные будут 0). Вот тут интеграция и пригодится чтобы не реагировать на одиночные 1 (считать их помехами). Заодно идет диагностика входа. Если на входе постоянно 1, то это признак пробоя полупроводниковых элементов.

Дрожание контактов реле.
#define MaxLevel = 10 // Необходимый уровень интеграции, чтобы сигнал был в 1.

unsigned short MState[число дискретных сигналов/sizeof(unsigned short)]; // Бинарный массив дискретных сигналов.
int LevelState[число дискретных сигналов]; // Интеграторы.

// Функция определения состояния дискретного сигнала.
int Integ ( int State, // Состояние сигнала.
int Num ) // Его номер.
{
// Интегрирование.
if ( State != 0 ) LevelState[Num]++;
else LevelState[Num]--;
// Определение состояния сигнала и запись в бинарный массив.
if ( LevelState[Num] > MaxLevel )
{
MState[Num/sizeof(unsigned short)] |= 1<<(Num%sizeof(unsigned short));
return 1;
}
else
{
MState[Num/sizeof(unsigned short)] &= ~(1<<(Num%sizeof(unsigned short)));
}
return 0;
}
Ну как-то так.

Просто инженер АиТ добавил 25.01.2016 в 16:58
Несколько слабая диагностика. Например, есть стрелки, которые очень редко переводятся!

Просто инженер АиТ добавил 25.01.2016 в 17:06
Для КТС-ЛИУС2 у нас был очень мощный кроссовый отладчик собственной разработки. Сначала он был реализован на Искре-226 (могу ошибаться). Затем появился Robotron-1715 переделали под него. Ну, а последняя версия была реализована под IBM.
Почему я говорю мощный отладчик. У этого отладчика, например, можно было установить Break по условию записи/чтению определенного байта из любой области памяти или порта. Очень мощная система окон с установкой уровня косвенности (до 9 уровня). И так далее.

не врубился очень быстро уже на "матрице".

свою прожку писал естественно на СИ... но матерился после бейсика очень часто... да что там "часто" ... "без остановки" матерился.

сегодня наконец-то подключили к РШ на измерительной панели к переменке, заработало , но не сразу (кондер подбирали для сглаживания пульсации) на мосте.

Мы тоже делали контроллер для аналогово съёма напряжения на том же процессоре, что стоит в Arduino. Но мы не сглаживали, а сразу оцифровали, считали средне квадратичное и делали быстрое преобразование Фурье для спектрального анализа. Считывание с АЦП по прерываниям от таймера, остальная обработка на фоне.
Я, когда (году 1987, книг тогда не было и я учился по чужим исходникам) изучал 'С' после ассемблера и Бейсика, тоже не мог привыкнуть! :)

Просто инженер АиТ добавил 26.01.2016 в 16:49
Чтобы не скучно было.
/*------------------------------------------------------------------------------
Класс Фурье преобразования
05.03.2015 13:35
------------------------------------------------------------------------------*/
class TFure
{
private:
// Параметры для Спектрального Анализа
public:
TFure ( ) : FureA ( NULL ), FureB ( NULL ), FureC ( NULL ),
Buff ( NULL )
{ }

~TFure ( )
{
if ( FureA != NULL )
{ delete ( FureA ); FureA = NULL; }
if ( FureB != NULL )
{ delete ( FureB ); FureB = NULL; }
if ( FureC != NULL )
{ delete ( FureC ); FureC = NULL; }
if ( Buff != NULL )
{ delete ( Buff ); Buff = NULL; }
}
//-----------------------------------------
// Исходные данные Спектрального Анализа.
int Count; // Общее кол-во Отсчётов в Выборке.
// Всегда должно быть Count >= FrequencyDiscr.
int FrequencyDiscr; // Частота Дискретизации, на каком
// кол-во отсчётов следует определять
// Спектральный анализ.
int StepFrequency; // Шаг Частоты определени
// Спектрального Анализа.
//------------------------------------------------------------
int CountPoints; // Необходимое кол-во Отсчётов дл
// требуемого Шага Частоты.
// Вычисление CountPoints = FrequencyDiscr/StepFrequency;
//------------------------------------------------------------
int CountHarmonicFrequency; // Кол-во Гармоник
//------------------------------------------------------------
int FrViewBeg; // Частота начала Сп. Анализа.
int FrViewEnd; // Частота конца Сп. Анализа.

int IndViewBeg; // Индекс начала Сп. Анализа.
int IndViewEnd; // Индекс конца Сп. Анализа.
//------------------------------------------------------------
Word* Buff; // Указатель на Буфер.
//--------------------------------------
// Преобразование Фурье.
double* FureA; // Коэффициенты А.
double* FureB; // Коэффициенты В.
double* FureC; // Коэффициенты С.
double FureCMax; // Максимум.
double IndCMax; // Индекс Максимума.
//-----------------------------------------
// Преобразование Фурье 27.02.2014 16:42
void MakeFure ( int _StepFrequency );

};
/*------------------------------------------------------------------------------
Преобразование Фурье
27.02.2014 16:42
------------------------------------------------------------------------------*/
void TFure::MakeFure ( int _StepFrequency ) // Шаг Частоты Дискретизации.
{
if ( _StepFrequency == 0 )
return;

StepFrequency = _StepFrequency;
// Определим сколько точек надо Анализировать?
/*
Так как полное количество точек определяетс количеством точек на 1 секунду
при частоте дискретизации для файла Wav равное FrequencyDiscr, тогда
T = 1 / FrequencyDiscr;
Дл исследуемой частоты, гармоники, которой будем вычислять период будет
равен t = 1 / StepFrequency.
А количество точек определится из отношени t/T. После некоторых
преобразований получаем CountPoints = FrequencyDiscr/StepFrequency;
*/
CountPoints = FrequencyDiscr/StepFrequency;
double K = 2.0/CountPoints;
double DeltaT = K * M_PI;
//-------------------------------------------------------------------
// Создадим буфера для Коэффициентов по кол-во Гармоник.

// Количество Гармоник.
CountHarmonicFrequency = (FrViewEnd - StepFrequency)/StepFrequency + 1;
IndViewBeg = FrViewBeg/StepFrequency;
IndViewEnd = FrViewEnd/StepFrequency + 1;
//-------------------------------------------------------------------
if ( FureA != NULL )
{ delete ( FureA ); FureA = NULL; }
if ( FureB != NULL )
{ delete ( FureB ); FureB = NULL; }
if ( FureC != NULL )
{ delete ( FureC ); FureC = NULL; }
FureA = new double[CountHarmonicFrequency];
FureB = new double[CountHarmonicFrequency];
FureC = new double[CountHarmonicFrequency];
//----------------------------------------
if ( FureA == NULL
|| FureB == NULL
|| FureC == NULL )
return;
//----------------------------------------
int SizeFure = CountHarmonicFrequency*sizeof(double);
memset ( FureA, 0, SizeFure );
memset ( FureB, 0, SizeFure );
memset ( FureC, 0, SizeFure );
//-------------------------------------------------------------------
// Бежим по Отсчётам.
for ( int j=0; j < CountPoints; j++ )
{
//------------------------------------------------
// Получить значение Отсчёта.
double CurAmp = Buff[j];
//------------------------------------------------
// Бежим по гармоникам.
for ( int i=1; i <= CountHarmonicFrequency; i++ )
{
FureA[i-1] += CurAmp * cos( (j*i*DeltaT));
FureB[i-1] += CurAmp * sin( (j*i*DeltaT));
}
}
//-------------------------------------------------------------------
// Получить Модуль Вектора.
FureCMax = 0;
IndCMax = 0;
for ( int i=0; i < CountHarmonicFrequency; i++ )
{
FureC[i] = sqrt( K * ((FureA[i]*FureA[i])
+ (FureB[i]*FureB[i])) );
if ( FureCMax < FureC[i] )
{
FureCMax = FureC[i];
IndCMax = i;
}
}
}