Астрономическое время работы

Сколько минут академический час?

Для всех видов аудиторных занятий в средних учебных заведениях (колледжах, техникумах, лицеях, ПТУ и т.

п.) академический час устанавливается продолжительностью 45 минут, а объём занятий — не более 36 академических часов в неделю.

Чему равен один академический час?

В учреждениях начального и среднего профессионального образования академический час устанавливается в 45 минут Согласно СанПиН 2.4.2.2821-10 урок в школе не может быть больше 45 минут, в коррекционной — не больше 40 минут. Также используется понятие «учебная пара» («пара») — 2 академических часа.

Чему равен 1 астрономический час?

Термин «астрономический час» (60 минут, или просто час) используют, чтобы отличить от «академического часа», который равен 45 минутам. Астрономический час — обычный час, в отличие от, например, академического.

Сколько минут в одном астрономическом часе?

Астрономический час = 60 минут, то, что мы привыкли называть обычным «часом». Различают также «академический час» — традиционное название учебного часа в вузах, он не равен астрономическому и устанавливается нормативными документами. Длительность академического часа может быть в пределах от 45 до 50 минут.

Сколько по времени длится пара в институте?

Сколько идет пара

Каждый вуз вправе самостоятельно устанавливать временные рамки академического часа в пределах 45-50 минут и определять, сколько будет длиться пара. В среднем пара в университете или институте идет порядка ста минут, включая пятиминутный перерыв между полупарами, если он не предусмотрен, то – 90 минут.

Что значит один астрономический час?

Астрономический час, это расстояние, на которое проходит солнечный свет за один час в вакууме. 60 минут 1 минута это 60 секунд секунду все зают 😉

Сколько академических часов в паре?

У нас, например, пары урезаны — от двух академ. часов отсекается десять минут (итого — 40 + 40 = 80 минут). Но обычно это 90 минут. пара — это 2 академических часа 45 мин+45мин=90 мин (1,5 часа) . Между часами в паре перерыв, в разных вузах разный попродолжительности (5-10 мин) .18 сент. 2010 г.

Что такое пара в университете?

Потому что университетская пара это не один час занятий, а два, путаница появляется из-за того, что академический час продолжается не 60, а 45 минут, поэтому два академических часа составляют 90 минут. Два такие часа и называют парой.

Что такое астрономическое время работы?

астрономическое время — истинное солнечное время Время, определяемое по изменению часового угла Солнца. Часовой угол измеряется по экватору Земли, от 0 до 360о. Здесь 150 составляет один час. Таким образом истинное солнечное время определяется движением Солнца вокруг… …

Сколько разрешено пар в день?

— Продолжительность аудиторных занятий для студентов не должна превышать 8 часов в день; количество пар в день: максимальное количество пар – четыре, минимальное количество пар – две, пять пар допускается в том случае, если одна из дисциплин физическая культура.

Сколько длится один курс в институте?

Так как продолжительность учебного года составляет всего 10 месяцев, не считая летних каникул, то один семестр длится 4-5 месяцев. Общепринятая дата начала первого осеннего семестра – 1 сентября, завершается он в декабре, после чего следует зачетная неделя и сессия, затем наступают каникулы.

Сколько длится лекция в университете?

обычно лекция (или как их называют пара) длится 1 час 25 мин. По нормативам лекций не может быть меньше двух и более четырех в день. Во многих по разному. У меня пара состоит с 2 полупар по 45 минут.

астрономическое время работы

Опрос показаний часов процессорного времени

Базовым средством для работы с часами процессорного времени является функция clock() (см. листинг 12.15). Она возвращает в качестве результата процессорное время, затраченное процессом с некоего момента, зависящего от реализации и связанного только с его (процесса) запуском. В случае ошибки результат равен ( clock_t ) (-1).

#include <time.h>
clock_t clock (void);

Чтобы перевести время, возвращаемое функцией clock(), в секунды, его следует поделить на константу CLOCKS_PER_SEC, которая определена в заголовочном файле <time.h> равной одному миллиону, хотя разрешающая способность часов процессорного времени в конкретной реализации может и отличаться от микросекунды.

Отметим, что если значения типа clock_t представлены как 32-разрядные целые со знаком, то менее чем через 36 минут ( процессорного времени ) наступит переполнение.

В листинге 12.16 показан пример использования функции clock(). Поскольку начало отсчета для часов процессорного времени не специфицировано, их показания опрашиваются в начале и конце измеряемого промежутка, а результатом измерения затраченного процессорного времени служит разность этих показаний.

#include <stdio.h>
#include <time.h>

int main (void) {
time_t st;
clock_t ct;
double s = 0;
double d = 1;
int i;

fprintf (stderr, "Начало выполнения циклаn");
(void) time (&st);
ct = clock;
for (i = 1; i <= 100000000; i++) {
    s += d / i;
    d = -d;
}
fprintf (stderr, "Процессорное время выполнения цикла: %g сек.n",
            (double) (clock - ct) / CLOCKS_PER_SEC);
fprintf (stderr, "Астрономическое время выполнения цикла: %g сек.n",
            difftime (time (NULL), st));

return (0);
}

Возможные результаты работы этой программы показаны в листинге 12.17. Процессорное время получилось больше астрономического из-за ошибок округления.

Начало выполнения цикла
Процессорное время выполнения цикла: 15.19 сек.
Астрономическое время выполнения цикла: 15 сек.

Для измерения времени выполнения простой команды можно воспользоваться служебной программой time (не входящей, правда, в обязательную часть стандарта POSIX-2001 ):

time [-p] команда [аргумент ...]

Она выдает в стандартный протокол астрономическое и процессорное время, прошедшее от запуска до завершения команды с указанными аргументами. Если задана опция -p, время выдается в секундах в виде вещественных чисел. Процессорное время подразделяется на пользовательское (затраченное самой командой) и системное (ушедшее на оказание системных услуг команде). Если предположить, что выполнимый файл приведенной выше программы называется my_tcex, то командная строка

выдаст в стандартный протокол примерно следующее (см. листинг 12.18):

Начало выполнения цикла
Процессорное время выполнения цикла: 15.2 сек.
Астрономическое время выполнения цикла: 15 сек.
real 15.20
user 15.20
sys 0.00

Если нужно измерить время выполнения конвейера или списка команд, их можно поместить в файл, превратив тем самым в простую команду, или воспользоваться конструкцией вида

time sh -c 'составная команда'

Оружием более крупного калибра является специальная встроенная в shell команда

Она выдает на стандартный вывод процессорное время, затраченное командным интерпретатором и порожденными им процессами. Например, после выполнения команд

my_tcex & my_tcex
times
на стандартный вывод может быть выдано:
0m0.010s 0m0.000s
0m30.410s 0m0.000s

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

Реализация описанных выше утилит time и times опирается на функцию times() (см. листинг 12.19). Она опрашивает данные о времени выполнения вызывающего процесса и порожденных процессов, завершение которых ожидалось с помощью функций wait() или waitpid(). В отличие от clock(), функция times() измеряет время в тактах часов, и переполнение 32-разрядного представления значений типа clock_t происходит не через полчаса, а примерно в течение года (если секунда делится на 60 — 100 тактов). Соответственно, для перевода результатов работы times() в секунды их нужно делить на sysconf ( _SC_CLK_TCK ), а не на CLOCKS_PER_SEC.

#include <sys/times.h>
clock_t times (struct tms *buffer);

В качестве результата функция times() возвращает астрономическое время, прошедшее от некоторого момента в прошлом (например, от загрузки системы), но основные, содержательные данные, относящиеся к вызывающему процессу и его потомкам, помещаются в структуру типа tms, которая описана в заголовочном файле <sys/times.h> и, согласно стандарту POSIX-2001, должна содержать по крайней мере следующие поля:

clock_t tms_utime;  
/* Процессорное время, затраченное */
/* вызывающим процессом            */

clock_t tms_stime;  
/* Процессорное время, затраченное системой */
/* на обслуживание вызывающего процесса     */

clock_t tms_cutime; 
/* Процессорное время, затраченное 
/*завершившимися порожденными процессами    */

clock_t tms_cstime; 
/* Процессорное время, затраченное системой */
/* на обслуживание завершившихся            */
/* порожденных процессов                    */

Значения времени завершившихся порожденных процессов ( tms_utime и tms_cutime, а также tms_stime и tms_cstime ) добавляются, соответственно, к элементам tms_cutime и tms_cstime структуры родительского процесса при возврате из функций wait() или waitpid(). Это происходит рекурсивно: если порожденный процесс ожидал завершения своих потомков, то в упомянутых элементах структуры накопятся данные о времени выполнения поддерева процессов.

В качестве примера использования функции times() измерим время работы рассматривавшейся ранее программы, копирующей строки со стандартного ввода на стандартный вывод через сокеты адресного семейства AF_UNIX с помощью порожденного процесса (см. листинг 12.20).

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* Программа копирует строки со стандартного ввода на стандартный вывод, */
/* "прокачивая" их через пару сокетов.                                   */
/* Используются функции ввода/вывода нижнего уровня.                     */
/* Измеряется астрономическое и процессорное время                       */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <sys/times.h>

#define MY_PROMPT       "Вводите строкиn"
#define MY_MSG          "Вы ввели: "

int main (void) {
 int sds [2];
 char buf [1];
 int new_line = 1;     /* Признак того, что надо выдать сообщение MY_MSG   */
                              /* перед отображением очередной строки              */
 clock_t st_ct;        /* Данные об астрономическом и процессорном времени */
 struct tms st_cpt;    /* в начале работы программы                        */
 clock_t en_ct;        /* Данные об астрономическом и процессорном времени */
 struct tms en_cpt;    /* в конце работы программы                         */
 long tck_p_sec;       /* Количество тактов часов в секунде                */

 /* Опросим данные о времени начала выполнения */
 if ((st_ct = times (&st_cpt)) == (clock_t) (-1)) {
    perror ("TIMES-1");
    return (1);
 }

 /* Создадим пару соединенных безымянных сокетов */
 if (socketpair (AF_UNIX, SOCK_STREAM, 0, sds) < 0) {
    perror ("SOCKETPAIR");
    return (2);
 }

 switch (fork ()) {
    case -1:
      perror ("FORK");
      return (3);
    case 0:
      /* Чтение из сокета sds [0] и выдачу на стандартный вывод */
      /* реализуем в порожденном процессе                       */
      while (read (sds [0], buf, 1) == 1) {
    if (write (STDOUT_FILENO, buf, 1) != 1) {
            perror ("WRITE TO STDOUT");
      break;
    }
      }
      exit (0);
 }

 /* Чтение со стандартного ввода и запись в сокет sds [1] */
 /* возложим на родительский процесс                      */
 if (write (sds [1], MY_PROMPT, sizeof (MY_PROMPT) - 1) !=
                                          sizeof (MY_PROMPT) - 1) {
    perror ("WRITE TO SOCKET-1");
 }

 while (read (STDIN_FILENO, buf, 1) == 1) {
    /* Перед отображением очередной строки */
    /* нужно выдать сообщение MY_MSG       */
    if (new_line) {
      if (write (sds [1], MY_MSG, sizeof (MY_MSG) - 1) != sizeof (MY_MSG) - 1) {
         perror ("WRITE TO SOCKET-2");
         break;
      }
    }
    if (write (sds [1], buf, 1) != 1) {
      perror ("WRITE TO SOCKET-3");
      break;
    }
    new_line = (buf [0] == 'n');
 }
 shutdown (sds [1], SHUT_WR);

 (void) wait (NULL);

 /* Опросим данные о времени конца выполнения, */
 /* вычислим и выдадим результаты измерений    */
 if ((en_ct = times (&en_cpt)) == (clock_t) (-1)) {
    perror ("TIMES-2");
    return (4);
 }

 tck_p_sec = sysconf (_SC_CLK_TCK);
 fprintf (stderr, "Тактов в секунде: %ldn", tck_p_sec);
 fprintf (stderr, "Астрономическое время работы программы: %g сек.n",
             (double) (en_ct - st_ct) / tck_p_sec);
 fprintf (stderr, "Процессорное время, затраченное процессом: %g сек.n",
             (double) (en_cpt.tms_utime - st_cpt.tms_utime) / tck_p_sec);
 fprintf (stderr, "Процессорное время, затраченное системой: %g сек.n",
             (double) (en_cpt.tms_stime - st_cpt.tms_stime) / tck_p_sec);
 fprintf (stderr, "Аналогичные данные для порожденных процессов:n");
 fprintf (stderr, "%g сек.n%g сек.n",
             (double) (en_cpt.tms_cutime - st_cpt.tms_cutime) / tck_p_sec,
             (double) (en_cpt.tms_cstime - st_cpt.tms_cstime) / tck_p_sec);

 return (0);
}

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

Тактов в секунде: 100
Астрономическое время работы программы: 1.19 сек.
Процессорное время, затраченное процессом: 0.02 сек.
Процессорное время, затраченное системой: 0.08 сек. 
Аналогичные данные для порожденных процессов:
0.09 сек.
1 сек.

Прямое манипулирование часами процессорного времени возможно после обращения к функции clock_getcpuclockid() (см. листинг 12.22), позволяющей выяснить их идентификатор. Оговоримся, однако, что эта функция не входит в обязательную часть стандарта POSIX-2001 (она относится к продвинутым средствам реального времени).

#include <time.h>
int clock_getcpuclockid 
      (pid_t pid, clockid_t *clock_id);

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

В листинге 12.23 показан пример употребления функции clock_getcpuclockid() и манипулирования часами процессорного времени. Возможные результаты выполнения этой программы — в листинге 12.24.

#include <stdio.h>
#include <time.h>
#include <sys/types.h>
#include <errno.h>

int main (void) {
 clockid_t clk_id;     /* Идентификатор часов процессорного времени */
 struct timespec tmsp;
 double s = 0;
 double d = 1;
 int i;

 if ((errno = clock_getcpuclockid ((pid_t) 0, &clk_id)) != 0) {
    perror ("CLOCK_GETCPUCLOCKID");
    return (1);
 }

 if (clock_getres (clk_id, &tmsp) == -1) {
    perror ("CLOCK_GETRES");
    return (2);
 }
 printf ("Разрешающая способность часов процессорного времени: %ld нсек.n",
      tmsp.tv_nsec);

 /* Измерим процессорное время выполнения цикла. */
 fprintf (stderr, "Начало выполнения циклаn");
 tmsp.tv_sec = tmsp.tv_nsec = 0;
 if (clock_settime (clk_id, &tmsp) == -1) {
    perror ("CLOCK_SETTIME");
    return (3);
 }
 for (i = 1; i <= 100000000; i++) {
    s += d / i;
    d = -d;
 }
 if (clock_gettime (clk_id, &tmsp) == -1) {
    perror ("CLOCK_GETTIME");
    return (4);
 }
 fprintf (stderr, "Процессорное время выполнения цикла: %ld сек. %ld нсек.n",
      tmsp.tv_sec, tmsp.tv_nsec);

 return (0);
}

Разрешающая способность часов процессорного времени: 2 нсек.
Начало выполнения цикла
Процессорное время выполнения цикла: 15 сек. 350313054 нсек.

Обратим внимание на два момента. Перед началом измеряемого участка программы на часах процессорного времени были установлены нулевые показания, что, разумеется, не влияет на приоритет процесса и его планирование. Конечно, можно было обойтись без переустановки, запомнив показания часов в начале и конце измеряемого промежутка и произведя затем их вычитание, но технически это чуть сложнее; кроме того, нам хотелось применить функцию clock_settime(). Второй заслуживающий отдельного упоминания момент состоит в отсутствии необходимости выяснять идентификатор часов процессорного времени вызывающего процесса с помощью функции clock_getcpuclockid(): можно воспользоваться именованной константой CLOCK_PROCESS_CPUTIME_ID.

Электронные ключи Guardant Time/ Net Time / Code Time оснащены часами реального времени и позволяют ограничивать астрономическое время работы защищенного приложения.

Смысл технологии ограничения времени заключается в том, что работоспособность алгоритма зависит от таймера (RTC), встроенного в ключ.

С помощью ключей с часами реального времени можно реализовывать различные лицензионные политики, влияющие на время работы защищенного приложения:

• Приложение сможет работать только после активации алгоритма, которая произойдет по наступлению указанной даты
• Приложение перестанет работать после деактивации алгоритма, которая произойдет по наступлению указанной даты
• Срок работы приложения ограничен заданным периодом работоспособности, т. н. «временем жизни», алгоритма. Алгоритм активируется при первом запуске приложения и деактивируется по истечению «времени жизни»

Установка временной зависимости алгоритма

FlipTime. Изменение ответов алгоритма через указанный период времени

В ключах с RTC реализована технология FlipTime, позволяющая автоматически изменять значения, возвращаемые алгоритмом ключа по наступлению заданного временного значения.

Технология FlipTime неприменима к ячейкам типа «Загружаемый код» в ключах Guardant Code Time!

FlipTime – это механизм, модифицирующий часть определителя алгоритма по достижению указанной при программировании ключа даты. Причем это изменение не однократное, определитель будет продолжать изменяться через заданный промежуток времени (в днях). Соответственно, всякий раз после изменения определителя, алгоритм будет возвращать другие значения в ответ на запросы.

Чтобы использовать механизм FlipTime, разработчик должен знать, какие ответы вернет алгоритм в каждом случае. Для решения этой задачи в комплект разработчика включена консольная утилита FlipTime.exe, генерирующая массивы вопросов-ответов алгоритму для каждого факта изменения определителя.

Чтобы активировать механизм FlipTime:

1. Выделите в маске ключа c RTC нужный алгоритм, выполните команду меню Образ ключа | (Поле) Свойства поля и перейдите на вкладку Временные зависимости.
2. Установите флаг Алгоритм изменяется каждые… и в появившемся поле задайте период (в днях) изменения алгоритма.
3. С помощью комбинированного поля/календаря определите дату, по достижении которой механизм FlipTime будет задействован.
4. Сохраните маску и запишите ее в ключ (команда меню Ключ | (Операции с ключом) Записать образ в ключ).
5. Запустите утилиту FlipTime.exe и, следуя ее указаниям, получите массивы вопросов-ответов алгоритма после каждого факта изменения определителя.
6. Используйте полученные массивы в приложении согласно заданным временным зависимостям.

1. Технология FlipTime предназначена для использования только при защите с помощью Guardant API. Недопустимо ее использование при автозащите!
2. Пользоваться FlipTime следует с известной осмотрительностью, т. к. если в расчетах при проектировании защиты, программировании ключа или защите приложения будет допущена ошибка, то ее достаточно сложно будет диагностировать и исправлять в «боевых» условиях, когда ключ находится у конечного пользователя.

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

Установка запрета на изменение времени

В ключах Guardant Time/ Time Net/ Code Time можно задавать новое значение для встроенного таймера при помощи специальной функции Guardant API (см. описание GrdSetTime).

Однако если такая необходимость и возникает, то, как правило, на этапе программирования ключа (например, при реализации утилиты прошивки ключа, альтернативной GrdUtil.exe).

И, наоборот, для защиты приложения это несет угрозу, потому что при некоторых обстоятельствах (к примеру, компрометации кодов доступа), станет возможным перепрограммирование таймера ключа и незаконное продление лицензии.

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

Важно!
В RTC-ключах, поступающих с производства компании «Актив», а также в образах, создаваемых для RTC-моделей, блокировка времени уже выставлена по умолчанию (см. состояние флага Запретить изменение времени в ключе в Панели инструментов/ленточном интерфейсе GrdUtil.exe).

Категорически не рекомендуется менять умолчательное значение без особой необходимости.

Чтобы проверить, блокирована ли возможность изменения времени в ключе, выполните его диагностику (см. предыдущий пункт или описание утилиты диагностики). Глобальный флаг ProtectTime должен быть установлен:

 
В случае отсутствия блокировки изменения времени в ключе загрузите в Редактор нужный образ RTC-ключа, проверьте состояние флага Запретить изменение времени, и если он не установлен, выполните команду меню Ключ | (Режимы) Запретить изменение времени в ключе. После этого запишите образ в ключ.

В результате в ключе будет выставлен глобальный флаг GrdGF_Pro-tectTime (см. описание GrdProtect), и изменение состояния таймера станет невозможным без инициализации памяти ключа.

Астрономическое время

Cтраница 1

Астрономическое время t выступает как дополнительная фазовая координата. Важная особенность оптимизации — использование динамики оптимизируемой системы.
 [1]

Часы астрономического времени осуществляют непрерывное измерение прошедшего времени и используются для индикации календарной даты и времени суток. Полный цикл часов составляет приблизительно 143 года.
 [2]

Часы астрономического времени представляют собой двоичный счетчик, в котором используется формат, показанный ниже. Позиции битов в этих часах нумеруются с 0 по 63 и соответствуют битам числа с фиксированной запятой и двойной точности, в котором не используется знак. Время измеряется посредством добавления приращений к показанию часов в соответствии с правилами действий над числами без знака с фиксированной запятой.
 [3]

Часы астрономического времени переходят в нерабочее состояние.
 [4]

Часы астрономического времени переходят в состояние ошибки.
 [5]

Часы астрономического времени представляют собой внутренний двоичный счетчик двойной длины, позволяющий измерять прошедшее время с высокой точностью независимо от режима работы системы. Разрешающая способность таких часов составляет 1 икс, что достигается введением в его 51 — й бит единицы каждую микросекунду. Полное время заполнения часов составляет около 142 лет. Установка содержимого часов астрономического времени осуществляется привилегированной командой установка часов, однако эта команда выполняется только при условии, что ключ защиты таймера на пульте оператора находится в соответствующем положении. Непривилегированная команда запомнить содержимое часов позволяет занести в основную память текущее значение времени по показаниям таймера. В памяти показания часов запоминаются в поле длиной 8 байтов; в биты 52 — 63, которым соответствуют неиспользуемые разряды счетчика, заносятся нули.
 [6]

Для часов астрономического времени различаются следующие состояния: установленное, неустановленное, стоп, неисправное и нерабочее. В зависимости от состояния часов уста яавливается признак результата при выполнении команды запись в память показания часов. Часы считаются работающими, если они находятся в состоянии установленное или неустановленное.
 [7]

Разрешающая способность часов астрономического времени такова, что скорость изменения их показания сравнима со скоростью выполнения команд в данной модели.
 [8]

Обращение к часам астрономического времени с помощью команды запись в память показания часов во время выполнения сброса не изменяет содержимого часов.
 [9]

Средства синхронизации часов астрономического времени функционируют так, что позволяют с помощью единой не зависящей от модели супервизорной программы синхронизации часов обслуживать системы и с одними часами астрономического времени, и с несколькими такими часами. Кроме того, эти средства совместно с супервизорной программой синхронизации часов по существу обеспечивают для мультипроцессорной системы такое положение, что она как бы пользуется одними часами. Во всех программах, записывающих показания часов, эти показания воспринимаются так, как если бы все CPU считывали их с одних и тех же часов.
 [10]

Текущее показание часов астрономического времени замещается содержимым двойного слова, заданного адресом второго операнда, а часы устанавливаются в состояние стоп.
 [11]

Задача ЧАСЫ осуществляет подсчет астрономического времени, имеется также возможность установить время дня в часах / минутах / секундах.
 [13]

В современных ЭВМ часы астрономического времени и компаратор составляют основу так называемого интервального таймера, предназначенного для отсчета времени. Интервальный таймер вместе с соответствующей программой обеспечивает получение отметок истинного времени и измерение относительно небольших временных интервалов с формированием сигналов прерываний по истечении заданного промежутка времени.
 [14]

ЦВУ должно обеспечивать выработку астрономического времени и календаря, учет рабочих и нерабочих дней, зимнего и летнего времени, а также позволять производить ручную и автоматическую ( по радиосигналам точного времени) коррекцию системного времени как в самом ЦВУ, так и в периферийных УСПД по каналам телекоммуникации. Ручная коррекция времени должна быть программно защищена от несанкционированного доступа.
 [15]

Страницы:  

   1

   2

   3

   4