Модуль time – таймеры времени


Оглавление (нажмите, чтобы открыть):

Модульные таймеры времени

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

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

Рассмотрим для примера трёхцепное модульное реле времени РВ3-22.

Оно может коммутировать три независимые цепи с предварительно установленными выдержками в каждой из цепей. Данное реле применяется в качестве комплектующего в различных схемах автоматики.

Конструкция реле — унифицированный пластмассовый корпус, шириной 22 мм, модульного исполнения для монтажа на DIN-рейку, с передним присоединением проводов питания и коммутируемых электрических цепей. Реле может быть установлено и на ровную поверхность, для этого достаточно раздвинуть замки. Провода надежно зажимаются в клеммы, провод может иметь сечение до 2,5мм2.

На лицевой панели располагаются: три переключателя установки выдержки времени просто поворотом стрелок «время t1», «время t2», «время t3», индикатор зеленого цвета свидетельствует о наличии напряжения питания «U», три индикатора желтого цвета — показывают срабатывание встроенных реле «К1», «К2», «К3». Сбоку на корпусе расположены DIP-переключатели для выбора нужной диаграммы работы и требуемых временных диапазонов.

Реле имеет 8 поддиапазонов временной выдержки для каждой из цепей. Диаграмма работы и временной диапазон выбирается с помощью указанных DIP-переключателей, расположенных сбоку. Временные выдержки t1, t2, и t3 выставляются поворотом переключателей с учетом диапазона.

При выключенных встроенных реле замкнуты контакты (15-16 для К1), (25-26 для К2) и (35-36 для К3). При включённых встроенных реле замкнуты контакты (15-18 для К1), (25-28 для К2) и (35-38 для К3) при этом светятся соответствующие индикаторы. Цепь К3 можно перевести в режим мгновенного контакта. Реле РВ3-22 имеет диапазон выдержек времени от 1 секунды до 30 часов.

Наиболее продвинутые модульные таймеры программируются, и могут работать по недельному или суточному графику, управлять включением и выключением освещения и других нагрузок на предприятиях, в быту, на производстве и т. д. Есть немало торговых центров, работающих с 8 до 22, где с помощью таймеров осуществляется включение освещения на период с 7-50 до 22-10.

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

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

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

Использование python timeit

Функция timeit обычно нужна для отладки скриптов, в том числе тогда когда используются обрабатывающиеся медленно регулярные выражения.

Рассмотрим более простой пример.

Здесь функция hello с одник передаваемым ей аргументом — это тестируемый код.

В функции main определяется, что hello требуется выполнять передавая значение аргумента 10. Выполнение требуется 14 раз.

20
20
20
20
20
20
20
20
20
20
20
20
20
20
0.0001920969998536748

Поскольку код максимально упрощен какого-либо разброса не получилось, однако есть финальный результат — усредненное время выполнение.

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

Принцип для реальных скриптов остается тем же, меняется в общем случае только сама функция, которая требуется проверять.

Можно выполнять скрипты и через Linux утилиту time:

Можно вызывать не однократное исполнение, запуск в цикле for.

Для той же цели подойдет и модуль subprocess. Он позволяет получать информацию в более удобной для дальнейшей обработки форме.

блог JOHN_16

Здесь я планирую размещать небольшие статьи на интересующие меня темы.

четверг, 2 февраля 2012 г.

Python: модуль timeit — измерение времени выполнения маленьких фрагментов кода. Примеры использования.

Этот модуль предоставляет простой способ замерить быстродействие некоторого фрагмента Python кода. Он имеет как интерфейс командной строки, так и интерфейс вызовов. Это позволяет избежать ряда общих ловушек для измерения времени выполнения.

Модуль определяет следующий класс:

Класс для измерения скорости выполнения маленьких фрагментов кода.

Конструктор принимает аргумент stmt содержащий выражение которое будет замерено, дополнительный аргумент setup представляющий собой выражение, выполняемое перед основным выражением. Функция таймера timer является платформозависимой (см. модуль doc string). Выражения могут содержать символы новой строки, если они не содержат многострочных строковых литералов.

Для измерения времени выполнения первого выражения необходимо использовать метод timeit() . Метод repeat() удобен для многократного вызова timeit() , возвращает список с результатами.

Новое в версии 2.6
Параметры stmt и setup могут принимать объекты которые вызываются без аргументов.Это позволит встраивать вызовы в функцию таймер, который будет выполнен по timeit() . Обратите внимание, в этом случае будут произведены дополнительные затраты, из-за вызывов дополнительных функций.

Выводит информацию о полученном исключении из выполняемого кода. Приемущество данного метода перед стандартным выводом исключения состоит в том, что будут отображены исходные строки из компилированного шаблона. Дополнительный аргумент file указывает куда направить вывод об исключении, по-умолчанию это стандартный поток ошибок sys.stderr .

Например так выглядит обычное сообщение об ошибке:

А так будет выглядеть сообщение об ошибке, используя метод класса:

Начиная с версии 2.6 были добавлены 2 удобные функции.

timeit.timeit(stmt[, setup[, timer[, number=1000000]]]])

Многострочное выражение может быть заданно с помощью символов переноса строки и отступных пробелов, например:

Если -n не задан, то соответствующее количество циклов рассчитывается путем последовательного перебора степеней 10, пока общее время составит не менее 0,2 секунды.

Таймер по-умолчанию платформозависим. На платформе MS Windows time.clock() имеет точность микросекунд, но точность time.time() составляет 1/60 секунды. На платформе Unix time.clock() имеет точность 1/100 секунды и time.time() является более точным. На других платформах функция стандартного таймера измеряет wall clock time, а не время CPU. Это означает что другие процессы, запущенные на том же компьютере, могут быть не синхронизированы. Лучший способ что бы достичь точного времени является повторение измерений несколько раз и выбрать лучшее время. Для этого подходит опция -r, повторение по-умолчанию происходит 3 раза, этого в большинстве случаев может быть достаточно. На платформе Unix вы можете использовать time.clock() что бы замерить время CPU.

import time, timeit

class Test_class(object):
def some_slow_method(self, loop_count):
for i in xrange(loop_count):
time.sleep(1)

def some_quick_method(self, loop_count):
for i in xrange(loop_count):
time.sleep(0.1)

if __name__== ‘__main__’ :
# Для того что бы воспользоваться классом необходимого модуля, его необходимо импортировать в инициализирующем выражении setup
setup= «»»
from __main__ import Test_class
test=Test_class()
«»»
statements=[ ‘test.some_slow_method(5)’ ,
‘test.some_slow_method(3)’ ,
‘test.some_quick_method(5)’ ,
‘test.some_quick_method(3)’ ]
for item in statements:
print ‘%s execute in %s seconds’ %(item, min(timeit.repeat(item, setup, timeit.default_timer, 3, 1)))

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

Часы реального времени на RTC модулях Ардуино DS1302, DS1307, DS3231

Во многих проектах Ардуино требуется отслеживать и фиксировать время наступления тех или иных событий. Модуль часов реального времени, оснащенный дополнительной батарей, позволяет хранить текущую дату, не завися от наличия питания на самом устройстве. В этой статье мы поговорим о наиболее часто встречающихся модулях RTC DS1307, DS1302, DS3231, которые можно использовать с платой Arduino.


Модули часов реального времени в проектах Arduino

Модуль часов представляет собой небольшую плату, содержащей, как правило, одну из микросхем DS1307, DS1302, DS3231.Кроме этого, на плате практически можно найти механизм установки батарейки питания. Такие платы часто применяется для учета времени, даты, дня недели и других хронометрических параметров. Модули работают от автономного питания – батареек, аккумуляторов, и продолжают проводить отсчет, даже если на Ардуино отключилось питание. Наиболее распространенными моделями часов являются DS1302, DS1307, DS3231. Они основаны на подключаемом к Arduino модуле RTC (часы реального времени).

Часы ведут отсчет в единицах, которые удобны обычному человеку – минуты, часы, дни недели и другие, в отличие от обычных счетчиков и тактовых генераторов, которые считывают «тики». В Ардуино имеется специальная функция millis(), которая также может считывать различные временные интервалы. Но основным недостатком этой функции является сбрасывание в ноль при включении таймера. С ее помощью можно считать только время, установить дату или день недели невозможно. Для решения этой проблемы и используются модули часов реального времени.

Электронная схема включает в себя микросхему, источник питания, кварцевый резонатор и резисторы. Кварцевый резонатор работает на частоте 32768 Гц, которая является удобной для обычного двоичного счетчика. В схеме DS3231 имеется встроенный кварц и термостабилизация, которые позволяют получить значения высокой точности.

Сравнение популярных модулей RTC DS1302, DS1307, DS3231

В этой таблице мы привели список наиболее популярных модулей и их основные характеристики.

Название Частота Точность Поддерживаемые протоколы
DS1307 1 Гц, 4.096 кГц, 8.192 кГц, 32.768 кГц Зависит от кварца – обычно значение достигает 2,5 секунды в сутки, добиться точности выше 1 секунды в сутки невозможно. Также точность зависит от температуры. I2C
DS1302 32.768 кГц 5 секунд в сутки I2C, SPI
DS3231 Два выхода – первый на 32.768 кГц, второй – программируемый от 1 Гц до 8.192 кГц ±2 ppm при температурах от 0С до 40С.

±3,5 ppm при температурах от -40С до 85С.

Точность измерения температуры – ±3С

I2C

Модуль DS1307

DS1307 – это модуль, который используется для отсчета времени. Он собран на основе микросхемы DS1307ZN, питание поступает от литиевой батарейки для реализации автономной работы в течение длительного промежутка времени. Батарея на плате крепится на обратной стороне. На модуле имеется микросхема AT24C32 – это энергонезависимая память EEPROM на 32 Кбайт. Обе микросхемы связаны между собой шиной I2C. DS1307 обладает низким энергопотреблением и содержит часы и календарь по 2100 год.

Модуль обладает следующими параметрами:

  • Питание – 5В;
  • Диапазон рабочих температур от -40С до 85С;
  • 56 байт памяти;
  • Литиевая батарейка LIR2032;
  • Реализует 12-ти и 24-х часовые режимы;
  • Поддержка интерфейса I2C.

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

Взаимодействие с другими устройствами и обмен с ними информацией производится с помощью интерфейса I2C с контактов SCL и SDA. В схеме установлены резисторы, которые позволяют обеспечивать необходимый уровень сигнала. Также на плате имеется специальное место для крепления датчика температуры DS18B20.Контакты распределены в 2 группы, шаг 2,54 мм. В первой группе контактов находятся следующие выводы:

  • DS – вывод для датчика DS18B20;
  • SCL – линия тактирования;
  • SDA – линия данных;
  • VCC – 5В;
  • GND.

Во второй группе контактов находятся:

Для подключения к плате Ардуино нужны сама плата (в данном случае рассматривается Arduino Uno), модуль часов реального времени RTC DS1307, провода и USB кабель.

Чтобы подключить контроллер к Ардуино, используются 4 пина – VCC, земля, SCL, SDA.. VCC с часов подключается к 5В на Ардуино, земля с часов – к земле с Ардуино, SDA – А4, SCL – А5.

Для начала работы с модулем часов нужно установить библиотеки DS1307RTC, TimeLib и Wire. Можно использовать для работы и RTCLib.

Проверка RTC модуля

При запуске первого кода программа будет считывать данные с модуля раз в секунду. Сначала можно посмотреть, как поведет себя программа, если достать из модуля батарейку и заменить на другую, пока плата Ардуино не присоединена к компьютеру. Нужно подождать несколько секунд и вытащить батарею, в итоге часы перезагрузятся. Затем нужно выбрать пример в меню Examples→RTClib→ds1307. Важно правильно поставить скорость передачи на 57600 bps.

При открытии окна серийного монитора должны появиться следующие строки:

Будет показывать время 0:0:0. Это связано с тем, что в часах пропадает питание, и отсчет времени прекратится. По этой причине нельзя вытаскивать батарею во время работы модуля.

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

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

Настройка произведена корректно и дополнительно перенастраивать часы реального времени не придется.

Считывание времени. Как только модуль настроен, можно отправлять запросы на получение времени. Для этого используется функция now(), возвращающая объект DateTime, который содержит информацию о времени и дате. Существует ряд библиотек, которые используются для считывания времени. Например, RTC.year() и RTC.hour() – они отдельно получают информацию о годе и часе. При работе с ними может возникнуть проблема: например, запрос на вывод времени будет сделан в 1:19:59. Прежде чем показать время 1:20:00, часы выведут время 1:19:00, то есть, по сути, будет потеряна одна минута. Поэтому эти библиотеки целесообразно использовать в случаях, когда считывание происходит нечасто – раз в несколько дней. Существуют и другие функции для вызова времени, но если нужно уменьшить или избежать погрешностей, лучше использовать now() и из нее уже вытаскивать необходимые показания.

Пример проекта с i2C модулем часов и дисплеем

Проект представляет собой обычные часы, на индикатор будет выведено точное время, а двоеточие между цифрами будет мигать с интервалом раз в одну секунду. Для реализации проекта потребуются плата Arduino Uno, цифровой индикатор, часы реального времени (в данном случае вышеописанный модуль ds1307), шилд для подключения (в данном случае используется Troyka Shield), батарейка для часов и провода.

В проекте используется простой четырехразрядный индикатор на микросхеме TM1637. Устройство обладает двухпроводным интерфейсом и обеспечивает 8 уровней яркости монитора. Используется только для показа времени в формате часы:минуты. Индикатор прост в использовании и легко подключается. Его выгодно применять для проектов, когда не требуется поминутная или почасовая проверка данных. Для получения более полной информации о времени и дате используются жидкокристаллические мониторы.

Модуль часов подключается к контактам SCL/SDA, которые относятся к шине I2C. Также нужно подключить землю и питание. К Ардуино подключается так же, как описан выше: SDA – A4, SCL – A5, земля с модуля к земле с Ардуино, VCC -5V.

Индикатор подключается просто – выводы с него CLK и DIO подключаются к любым цифровым пинам на плате.

Скетч. Для написания кода используется функция setup, которая позволяет инициализировать часы и индикатор, записать время компиляции. Вывод времени на экран будет выполнен с помощью loop.

После этого скетч нужно загрузить и на мониторе будет показано время.

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

Для записи и чтения времени в энергонезависимую память или из нее нужно добавить функции EEPROMWriteInt и EEPROMReadInt. Они нужны для проверки совпадения/несовпадения хэша с хэшем, записанным в EEPROM.

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

В результате в коде нужно будет указать новую библиотеку (для жидкокристаллических экранов это LiquidCrystal), и добавить в функцию loop() строки для получения даты.

Алгоритм работы следующий:

  • Подключение всех компонентов;
  • Загрузка скетча;
  • Проверка – на экране монитора должны меняться ежесекундно время и дата. Если на экране указано неправильное время, нужно добавить в скетч функцию RTC.write (tmElements_t tm). Проблемы с неправильно указанным временем связаны с тем, что модуль часов сбрасывает дату и время на 00:00:00 01/01/2000 при выключении.
  • Функция write позволяет получить дату и время с компьютера, после чего на экране будут указаны верные параметры.

Заключение

Модули часов используются во многих проектах. Они нужны для систем регистрации данных, при создании таймеров и управляющих устройств, которые работают по заданному расписанию, в бытовых приборах. С помощью широко распространенных и дешевых модулей вы можете создать такие проекты как будильник или регистратор данных с сенсоров, записывая информацию на SD-карту или показывая время на экране дисплея. В этой статье мы рассмотрели типичные сценарии использования и варианты подключения наиболее популярных видов модулей.

time — Time access and conversions¶

Although this module is always available, not all functions are available on all platforms. Most of the functions defined in this module call platform C library functions with the same name. It may sometimes be helpful to consult the platform documentation, because the semantics of these functions varies among platforms.

An explanation of some terminology and conventions is in order.


The epoch is the point where the time starts, and is platform dependent. For Unix, the epoch is January 1, 1970, 00:00:00 (UTC). To find out what the epoch is on a given platform, look at time.gmtime(0) .

The term seconds since the epoch refers to the total number of elapsed seconds since the epoch, typically excluding leap seconds. Leap seconds are excluded from this total on all POSIX-compliant platforms.

The functions in this module may not handle dates and times before the epoch or far in the future. The cut-off point in the future is determined by the C library; for 32-bit systems, it is typically in 2038.

Year 2000 (Y2K) issues: Python depends on the platform’s C library, which generally doesn’t have year 2000 issues, since all dates and times are represented internally as seconds since the epoch. Function strptime() can parse 2-digit years when given %y format code. When 2-digit years are parsed, they are converted according to the POSIX and ISO C standards: values 69–99 are mapped to 1969–1999, and values 0–68 are mapped to 2000–2068.

UTC is Coordinated Universal Time (formerly known as Greenwich Mean Time, or GMT). The acronym UTC is not a mistake but a compromise between English and French.

DST is Daylight Saving Time, an adjustment of the timezone by (usually) one hour during part of the year. DST rules are magic (determined by local law) and can change from year to year. The C library has a table containing the local rules (often it is read from a system file for flexibility) and is the only source of True Wisdom in this respect.

The precision of the various real-time functions may be less than suggested by the units in which their value or argument is expressed. E.g. on most Unix systems, the clock “ticks” only 50 or 100 times a second.

On the other hand, the precision of time() and sleep() is better than their Unix equivalents: times are expressed as floating point numbers, time() returns the most accurate time available (using Unix gettimeofday() where available), and sleep() will accept a time with a nonzero fraction (Unix select() is used to implement this, where available).

The time value as returned by gmtime() , localtime() , and strptime() , and accepted by asctime() , mktime() and strftime() , is a sequence of 9 integers. The return values of gmtime() , localtime() , and strptime() also offer attribute names for individual fields.

See struct_time for a description of these objects.

Changed in version 3.3: The struct_time type was extended to prov > tm_gmtoff and tm_zone attributes when platform supports corresponding struct tm members.

Changed in version 3.6: The struct_time attributes tm_gmtoff and tm_zone are now available on all platforms.

Use the following functions to convert between time representations:

seconds since the epoch

seconds since the epoch

seconds since the epoch

seconds since the epoch

Functions¶

Convert a tuple or struct_time representing a time as returned by gmtime() or localtime() to a string of the following form: ‘Sun Jun 20 23:21:05 1993’ . The day field is two characters long and is space padded if the day is a single digit, e.g.: ‘Wed Jun 9 04:26:40 1993’ .

Unlike the C function of the same name, asctime() does not add a trailing newline.

Return the clk_id of the thread-specific CPU-time clock for the specified thread_id.

Use threading.get_ident() or the ident attribute of threading.Thread objects to get a suitable value for thread_id.

Passing an invalid or expired thread_id may result in undefined behavior, such as segmentation fault.

Availability : Unix (see the man page for pthread_getcpuclockid(3) for further information).

New in version 3.7.

New in version 3.3.

New in version 3.3.

Similar to clock_gettime() but return time as nanoseconds.

New in version 3.7.

New in version 3.3.

Similar to clock_settime() but set time with nanoseconds.

New in version 3.7.

Convert a time expressed in seconds since the epoch to a string of a form: ‘Sun Jun 20 23:21:05 1993’ representing local time. The day field is two characters long and is space padded if the day is a single digit, e.g.: ‘Wed Jun 9 04:26:40 1993’ .

If secs is not prov > None , the current time as returned by time() is used. ctime(secs) is equivalent to asctime(localtime(secs)) . Locale information is not used by ctime() .

time. get_clock_info ( name ) В¶

Get information on the specified clock as a namespace object. Supported clock names and the corresponding functions to read their value are:

The result has the following attributes:

adjustable: True if the clock can be changed automatically (e.g. by a NTP daemon) or manually by the system administrator, False otherwise

implementation: The name of the underlying C function used to get the clock value. Refer to Clock ID Constants for possible values.

monotonic: True if the clock cannot go backward, False otherwise

resolution: The resolution of the clock in seconds ( float )

New in version 3.3.

Convert a time expressed in seconds since the epoch to a struct_time in UTC in which the dst flag is always zero. If secs is not prov > None , the current time as returned by time() is used. Fractions of a second are ignored. See above for a description of the struct_time object. See calendar.timegm() for the inverse of this function.

time. localtime ( [ secs ] ) В¶

Like gmtime() but converts to local time. If secs is not prov > None , the current time as returned by time() is used. The dst flag is set to 1 when DST applies to the given time.

time. monotonic ( ) → floatВ¶

Return the value (in fractional seconds) of a monotonic clock, i.e. a clock that cannot go backwards. The clock is not affected by system clock updates. The reference point of the returned value is undefined, so that only the difference between the results of consecutive calls is valid.

New in version 3.3.

Changed in version 3.5: The function is now always available and always system-wide.

Similar to monotonic() , but return time as nanoseconds.


New in version 3.7.

Return the value (in fractional seconds) of a performance counter, i.e. a clock with the highest available resolution to measure a short duration. It does include time elapsed during sleep and is system-wide. The reference point of the returned value is undefined, so that only the difference between the results of consecutive calls is valid.

New in version 3.3.

Similar to perf_counter() , but return time as nanoseconds.

New in version 3.7.

Return the value (in fractional seconds) of the sum of the system and user CPU time of the current process. It does not include time elapsed during sleep. It is process-wide by definition. The reference point of the returned value is undefined, so that only the difference between the results of consecutive calls is valid.

New in version 3.3.

Similar to process_time() but return time as nanoseconds.

New in version 3.7.

Suspend execution of the calling thread for the given number of seconds. The argument may be a floating point number to indicate a more precise sleep time. The actual suspension time may be less than that requested because any caught signal will terminate the sleep() following execution of that signal’s catching routine. Also, the suspension time may be longer than requested by an arbitrary amount because of the scheduling of other activity in the system.

Changed in version 3.5: The function now sleeps at least secs even if the sleep is interrupted by a signal, except if the signal handler raises an exception (see PEP 475 for the rationale).

0 is a legal argument for any position in the time tuple; if it is normally illegal the value is forced to a correct one.

Locale’s abbreviated weekday name.

Locale’s full weekday name.

Locale’s abbreviated month name.

Locale’s full month name.

Locale’s appropriate date and time representation.

Day of the month as a decimal number [01,31].

Hour (24-hour clock) as a decimal number [00,23].

Hour (12-hour clock) as a decimal number [01,12].

Day of the year as a decimal number [001,366].

Month as a decimal number [01,12].

Minute as a decimal number [00,59].

Locale’s equivalent of either AM or PM.

Second as a decimal number [00,61].

Week number of the year (Sunday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Sunday are considered to be in week 0.

Weekday as a decimal number [0(Sunday),6].

Week number of the year (Monday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Monday are considered to be in week 0.

Locale’s appropriate date representation.

Locale’s appropriate time representation.

Year without century as a decimal number [00,99].

Year with century as a decimal number.

Time zone offset indicating a positive or negative time difference from UTC/GMT of the form +HHMM or -HHMM, where H represents decimal hour digits and M represents decimal minute digits [-23:59, +23:59].

Time zone name (no characters if no time zone exists).

A literal ‘%’ character.

When used with the strptime() function, the %p directive only affects the output hour field if the %I directive is used to parse the hour.

The range really is 0 to 61 ; value 60 is val > 61 is supported for historical reasons.

When used with the strptime() function, %U and %W are only used in calculations when the day of the week and the year are specified.

Here is an example, a format for dates compatible with that specified in the RFC 2822 Internet email standard. 1

Additional directives may be supported on certain platforms, but only the ones listed here have a meaning standardized by ANSI C. To see the full set of format codes supported on your platform, consult the strftime(3) documentation.

On some platforms, an optional field w > ‘%’ of a directive in the following order; this is also not portable. The field w > %j where it is 3.

time. strptime ( string [ , format ] ) В¶

Parse a string representing a time according to a format. The return value is a struct_time as returned by gmtime() or localtime() .

The format parameter uses the same directives as those used by strftime() ; it defaults to «%a %b %d %H:%M:%S %Y» which matches the formatting returned by ctime() . If string cannot be parsed according to format, or if it has excess data after parsing, ValueError is raised. The default values used to fill in any missing data when more accurate values cannot be inferred are (1900, 1, 1, 0, 0, 0, 0, 1, -1) . Both string and format must be strings.

Support for the %Z directive is based on the values contained in tzname and whether daylight is true. Because of this, it is platform-specific except for recognizing UTC and GMT which are always known (and are considered to be non-daylight savings timezones).

Only the directives specified in the documentation are supported. Because strftime() is implemented per platform it can sometimes offer more directives than those listed. But strptime() is independent of any platform and thus does not necessarily support all directives available that are not documented as supported.

The type of the time value sequence returned by gmtime() , localtime() , and strptime() . It is an object with a named tuple interface: values can be accessed by index and by attribute name. The following values are present:

(for example, 1993)

range [0, 61]; see (2) in strftime() description


range [0, 6], Monday is 0

0, 1 or -1; see below

abbreviation of timezone name

offset east of UTC in seconds

Note that unlike the C structure, the month value is a range of [1, 12], not [0, 11].

In calls to mktime() , tm_isdst may be set to 1 when daylight savings time is in effect, and 0 when it is not. A value of -1 indicates that this is not known, and will usually result in the correct state being filled in.

When a tuple with an incorrect length is passed to a function expecting a struct_time , or having elements of the wrong type, a TypeError is raised.

time. time ( ) → floatВ¶

Return the time in seconds since the epoch as a floating point number. The specific date of the epoch and the handling of leap seconds is platform dependent. On Windows and most Unix systems, the epoch is January 1, 1970, 00:00:00 (UTC) and leap seconds are not counted towards the time in seconds since the epoch. This is commonly referred to as Unix time. To find out what the epoch is on a given platform, look at gmtime(0) .

Note that even though the time is always returned as a floating point number, not all systems provide time with a better precision than 1 second. While this function normally returns non-decreasing values, it can return a lower value than a previous call if the system clock has been set back between the two calls.

The number returned by time() may be converted into a more common time format (i.e. year, month, day, hour, etc…) in UTC by passing it to gmtime() function or in local time by passing it to the localtime() function. In both cases a struct_time object is returned, from which the components of the calendar date may be accessed as attributes.

time. thread_time ( ) → floatВ¶

Return the value (in fractional seconds) of the sum of the system and user CPU time of the current thread. It does not include time elapsed during sleep. It is thread-specific by definition. The reference point of the returned value is undefined, so that only the difference between the results of consecutive calls in the same thread is valid.

Availability : Windows, Linux, Unix systems supporting CLOCK_THREAD_CPUTIME_ID .

New in version 3.7.

Similar to thread_time() but return time as nanoseconds.

New in version 3.7.

Similar to time() but returns time as an integer number of nanoseconds since the epoch.

New in version 3.7.

Reset the time conversion rules used by the library routines. The environment variable TZ specifies how this is done. It will also set the variables tzname (from the TZ environment variable), timezone (non-DST seconds West of UTC), altzone (DST seconds west of UTC) and daylight (to 0 if this timezone does not have any daylight saving time rules, or to nonzero if there is a time, past, present or future when daylight saving time applies).

Although in many cases, changing the TZ environment variable may affect the output of functions like localtime() without calling tzset() , this behavior should not be relied on.

The TZ environment variable should contain no whitespace.

The standard format of the TZ environment variable is (whitespace added for clarity):

Where the components are:

Three or more alphanumerics giving the timezone abbreviations. These will be propagated into time.tzname

The offset has the form: ± hh[:mm[:ss]] . This indicates the value added the local time to arrive at UTC. If preceded by a ‘-‘, the timezone is east of the Prime Meridian; otherwise, it is west. If no offset follows dst, summer time is assumed to be one hour ahead of standard time.

Indicates when to change to and back from DST. The format of the start and end dates are one of the following:

The zero-based Julian day (0 M m . n . d

The d’th day (0

time has the same format as offset except that no leading sign (‘-‘ or ‘+’) is allowed. The default, if time is not given, is 02:00:00.

On many Unix systems (including *BSD, Linux, Solaris, and Darwin), it is more convenient to use the system’s zoneinfo ( tzfile(5)) database to specify the timezone rules. To do this, set the TZ environment variable to the path of the required timezone datafile, relative to the root of the systems ‘zoneinfo’ timezone database, usually located at /usr/share/zoneinfo . For example, ‘US/Eastern’ , ‘Australia/Melbourne’ , ‘Egypt’ or ‘Europe/Amsterdam’ .

Clock ID Constants¶

These constants are used as parameters for clock_getres() and clock_gettime() .

> CLOCK_MONOTONIC , except it also includes any time that the system is suspended.

This allows applications to get a suspend-aware monotonic clock without having to deal with the complications of CLOCK_REALTIME , which may have discontinuities if the time is changed using settimeofday() or similar.

New in version 3.7.

The Solaris OS has a CLOCK_HIGHRES timer that attempts to use an optimal hardware source, and may give close to nanosecond resolution. CLOCK_HIGHRES is the nonadjustable, high-resolution clock.

New in version 3.3.

Clock that cannot be set and represents monotonic time since some unspecified starting point.

New in version 3.3.

Similar to CLOCK_MONOTONIC , but provides access to a raw hardware-based time that is not subject to NTP adjustments.

Availability : Linux 2.6.28 and newer, macOS 10.12 and newer.

New in version 3.3.

High-resolution per-process timer from the CPU.

New in version 3.3.

High-resolution per-process timer from the CPU.

Availability : FreeBSD, NetBSD 7 or later, OpenBSD.

New in version 3.7.

Thread-specific CPU-time clock.

New in version 3.3.


Time whose absolute value is the time the system has been running and not suspended, providing accurate uptime measurement, both absolute and interval.

Availability : FreeBSD, OpenBSD 5.5 or later.

New in version 3.7.

Clock that increments monotonically, tracking the time since an arbitrary point, unaffected by frequency or time adjustments and not incremented while the system is asleep.

Availability : macOS 10.12 and newer.

New in version 3.8.

The following constant is the only parameter that can be sent to clock_settime() .

System-wide real-time clock. Setting this clock requires appropriate privileges.

New in version 3.3.

Timezone Constants¶

The offset of the local DST timezone, in seconds west of UTC, if one is defined. This is negative if the local DST timezone is east of UTC (as in Western Europe, including the UK). Only use this if daylight is nonzero. See note below.

Nonzero if a DST timezone is defined. See note below.

The offset of the local (non-DST) timezone, in seconds west of UTC (negative in most of Western Europe, positive in the US, zero in the UK). See note below.

A tuple of two strings: the first is the name of the local non-DST timezone, the second is the name of the local DST timezone. If no DST timezone is defined, the second string should not be used. See note below.

For the above Timezone constants ( altzone , daylight , timezone , and tzname ), the value is determined by the timezone rules in effect at module load time or the last time tzset() is called and may be incorrect for times in the past. It is recommended to use the tm_gmtoff and tm_zone results from localtime() to obtain timezone information.

More object-oriented interface to dates and times.

Internationalization services. The locale setting affects the interpretation of many format specifiers in strftime() and strptime() .

General calendar-related functions. timegm() is the inverse of gmtime() from this module.

The use of %Z is now deprecated, but the %z escape that expands to the preferred hour/minute offset is not supported by all ANSI C libraries. Also, a strict reading of the original 1982 RFC 822 standard calls for a two-digit year (%y rather than %Y), but practice moved to 4-digit years long before the year 2000. After that, RFC 822 became obsolete and the 4-digit year has been first recommended by RFC 1123 and then mandated by RFC 2822.

Модуль time – таймеры времени

Начнём с того, откуда вообще микроконтроллер знает, сколько проходит времени. Ведь у него нет часов! Для работы микроконтроллера жизненно важен так называемый тактовый генератор, или кварцевый генератор, или он же кварц. Он же oscillator, он же clock. Clock по-английски это часы. Да, но не всё так просто =) Кварц расположен рядом с МК на плате (также во многих МК есть встроенный тактовый генератор), на Ардуинах обычно стоит кварц на 16 МГц, также встречаются модели на 8 МГц. Кварц выполняет очень простую вещь: он пинает микроконтроллер со своей тактовой частотой, то есть 16 МГц кварц пинает МК 16 миллионов раз в секунду. Микроконтроллер, в свою очередь зная частоту кварца, может прикинуть время между пинками (16 МГц = 0.0625 микросекунды), и таким образом ориентироваться во времени. Но на деле не всё так просто, потому что принимают пинки таймера так называемые таймеры-счётчики (Timer-counter). Это физически расположенные внутри МК устройства, которые занимаются подсчётом пинков тактового генератора. И вот микроконтроллер уже может обратиться к счётчику и спросить, а сколько там натикало? И счётчик ему расскажет. И вот этим мы уже можем пользоваться, для этого у Ардуино есть готовые функции времени. В Ардуино на МК 328 имеются три счётчика, и подсчётом времени занимается таймер под номером 0. Этим может заниматься любой другой счётчик, но работая в Arduino IDE вы сразу получаете такую настройку, т.к. создавая скетч в Arduino IDE вы автоматически работаете с библиотекой Arduino.h, где и реализованы все удобные функции.

Задержки

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

    delay(time) – “Приостанавливает” выполнение кода на time миллисекунд. Дальше функции delay выполнение кода не идёт, за исключением прерываний. Использовать рекомендуется только в самых крайних или тех случаях, когда delay не влияет на скорость работы устройства. time принимает тип данных unsigned long и может приостановить выполнение на срок от 1 мс до

50 суток (4 294 967 295 миллисекунд) с разрешением в 1 миллисекунду. Работает на системном таймере Timer 0
delayMicroseconds(time) – Аналог delay(), приостанавливает выполнение кода на time микросекунд. time принимает тип данных unsigned long и может приостановить выполнение на срок от 4 мкс до

70 минут (4 294 967 295 микросекунд) с разрешением 4 микросекунды. Работает на системном таймере Timer 0

Задержки использовать очень просто:

И вот мы можем делать какое-то действие два раза в секунду. А что делать, если нам нужно выполнять одно действие два раза в секунду, а другое – три? А третье – 10 раз в секунду например. Сразу привыкаем к той мысли, что задержки лучше вообще не использовать в реальном коде. Разве что delayMicroseconds, он бывает нужен для генерации каких-то протоколов связи. Нормальным инструментом для тайм-менеджмента своего кода являются функции, которые считают время со старта МК.

Функции счёта времени

Данные функции возвращают время, прошедшее с момента запуска микроконтроллера. Таких функций у нас две:

    millis() – Возвращает количество миллисекунд, прошедших с запуска. Возвращает unsigned int, от 1 до 4 294 967 295 миллисекунд (

50 суток), имеет разрешение 1 миллисекунда, после переполнения сбрасывается в 0. Работает на системном таймере Timer 0
micros() – Возвращает количество микросекунд, прошедших с запуска. Возвращает unsigned int, от 4 до 4 294 967 295 микросекунд (

70 минут), имеет разрешение в 4 микросекунды, после переполнения сбрасывается в 0. Работает на системном таймере Timer 0

Вы спросите, а как время со старта МК поможет нам организовать действия по времени? Очень просто, схема вот такая:

  • Выполнили действие
  • Запомнили текущее время со старта МК (в отдельную переменную)
  • Ищем разницу между текущим временем и запомненным
  • Как только разница больше нужного нам времени “Таймера” – выполняем действие и так по кругу

Реализация такого “таймера на millis()” выглядит вот так:

Напомню, что uint32_t это второе название типа данных unsigned long, просто оно короче в записи. Почему переменная должна быть именно такого типа? Потому что функция millis() возвращает именно этот тип данных, т.е. если мы сделаем нашу переменную например типа int, то она переполнится через 32.7 секунды. Но миллис тоже ограничен числом 4 294 967 295, и при переполнении тоже сбросится в 0. Сделает он это через 4 294 967 295 / 1000 / 60 / 60 / 24 = 49.7 суток. Значит ли это, что наш таймер “сломается” через 50 суток? Нет, данная конструкция спокойно переживает переход через 0 и работает дальше, не верьте диванным экспертам, проверьте =)

Вернёмся к вопросу многозадачности: хотим выполнять одно действие два раза в секунду, второе – три, и третье – 10. Нам понадобится 3 переменные таймера и 3 конструкции с условием:

И вот так мы можем например 10 раз в секунду опросить датчик, фильтровать значения, и два раза в секунду выводить показания на дисплей. И три раза в секунду мигать лампочкой. Почему нет?

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

Библиотека GyverTimer

Скачать библиотеку можно с GitHub, листайте вниз, там будет прямая ссылка на загрузку актуальной версии. Смотрим простой пример – сравнение с предыдущим кодом.


Помимо метода isReady(), который сигнализирует о срабатывании таймера, в библиотеке есть куча других:

Пользуйтесь на здоровье! Несколько примеров также есть в папке examples в библиотеке.

Виртуальное время. Часть 1: источники времени в компьютере

Человек, имеющий одни часы, твердо знает, который час. Человек, имеющий несколько часов, ни в чём не уверен.
Закон Сегала

Зачем нужно знать время внутри программы? На самом деле, довольно большое число алгоритмов, используемых на практике, вообще никак не зависят от того, который сейчас час. И это хорошо: история знает много случаев, когда программы, работавшие на старой аппаратуре, «ломаются» при выполнении на новой, более быстрой, как раз из-за завязанности на характерные временные длительности процессов.
Я смог придумать три вида задач, которые требуют чтения текущего времени в повседневной жизни.

  1. Определять относительный порядок событий. Для этого используются часы, измеряющие время от «начала времён», «эпохи» или какого-то иного фиксированного события в прошлом.
  2. Измерять длительность процессов. Для этого используются секундомеры, таймеры.
  3. Не пропустить важное событие в будущем. Для этого нужны будильники.

Внутри компьютеров ситуация аналогичная: временны́е устройства работают как один из трёх приборов, а иногда и как все три сразу.
В этой части статьи я сделаю краткий обзор общих свойств устройств-измерителей времени, присутствующих в современных системах, опишу их особенности и проблемы. Во второй части статьи я расскажу об особенностях моделирования таймеров при создании симуляторов и мониторов виртуальных машин.

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

Требования на устройства времени многочисленны и разнообразны.

  • Известное и высокое разрешение. Определяется частотой осциллятора, используемого в составе устройства. Чем она выше, тем короче минимально измеримый интервал времени.
  • Низкая задержка при чтении. Обращение к устройству-источнику времени само по себе не мгновенно, и к тому моменту, когда ответ от него доберётся до процессора, значение уже устареет. Кроме того, величина данной задержки может быть непостоянной, что будет вносить дополнительную неопределённость в считываемые значения. Порядок величины задержки определяется положением устройства-источника времени по отношению к читающему ядру: время, полученное с сетевого сервера синхронизации, запоздает гораздо больше, чем измерение, взятое со счётчика, расположенного в самом ядре.
  • Наибольшая длительность интервала времени, который может быть измерен. Так как для представления показаний времени используются числа фиксированной ширины, существует возможность переполнения счётчика между двумя измерениями. Чем выше разрешение таймера, т.е. его частота, тем быстрее может переполниться регистр, хранящий время.
  • Независимость от внешнего питания. Что произойдёт с содержимым регистров типичного устройства, если выключить питание системы? Чаще всего они потеряют свои значения и заполнятся «мусором», в лучшем случае — нулями. И всё же иногда хочется, чтобы течение времени отслеживалось и при выключенном компьютере. Для этого устройство времени может быть сделано энергонезависимым, т.е. попросту иметь собственную батарейку, ресурса которой хватает, чтобы переждать характерный период нахождения системы в выключенном состоянии.
  • Монотонность изменения значений. Каждое следующее значение, полученное от таймера, должно быть строго больше всех предыдущих, за исключением случаев, когда происходит переполнение; однако этот случай может быть сигнализирован аппаратурой и обработан программно специальным способом. Отсутствие гарантий монотонности вынуждает пользователей таймера учитывать возможность возвращения отрицательных или нулевых длительностей для интервалов (например, нельзя без проверки делить на длину интервала времени — она может оказаться нулевой).
  • Равномерность изменения значений. Если частота колебаний таймера изменяется в процессе, или он приостанавливает свою работу, например, при переходе в режим энергосбережения, то события, запланированные в предположении о его монотонности, могут случиться позже, чем ожидалось. Другая, присущая всем причина для неравномерности — чисто физическая нестабильность источника колебаний, связанная с температурными колебаниями, процессами деградации материала и тому подобными странными вещами.
  • Согласованность с другими таймерами в системе. Если в компьютере имеется несколько устройств-источников времени, очень возможна ситуация, что их показания не будут соответствовать друг другу. И, даже будучи сверенными друг с другом в начале, они могут разойтись в процессе работы по многочисленным причинам, в том числе описанным выше.

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

Обзор таймеров в архитектуре PC

Источников времени в системе может быть несколько. Прикладные программы редко обращаются к каким-либо из них напрямую. Вместо этого используются всевозможные API, предлагаемые использованным языком программирования (например, C++11 &lt chrono &gt), средой исполнения (например, gettimeofday из POSIX или QueryPerformanceCounter на MS Windows), или даже системными вызовами используемой операционной системы.

Самой ОС также необходимо знать время и уметь отмерять его отрезки для планирования работы пользовательских потоков, учёта потреблённых ими ресурсов, профилировки производительности, управления энергопотреблением и т.п. При этом сама ОС работает напрямую с интерфейсами, предоставляемыми аппаратурой. Так как таймеров присутствует много, современные ОС умеют выбирать один «центрально» используемый в начале загрузки, исходя из своих представлений о «качестве» обнаруженных устройств (например, на некоторых системах часть таймеров может быть занесена в «чёрный список» из-за известных проблем в работе) или же настроек пользователя (параметр clocksource у ядра Linux и опции useplatformclock, tscsyncpolicy, disabledynamictick у BCDEDIT в Windows).
Опишу наиболее часто встречаемые устройства, являющиеся часами и таймерами в PC.

Общераспространённые

Часы реального времени (Real Time Clock, RTC) — источник текущей даты и времени для нужд ОС. Типичное разрешение этого таймера — одна секунда. Все системы, удовлетворяющие стандарту ACPI, имеют чип RTC, совместимый с Motorola MC146818, присутствовавшем в оригинальном IBM PC/AT с 1984 года. В современных системах RTC обычно интегрирован в набор системной логики южного моста на материнской плате (что означает довольно большую задержку при чтении). Энергонезависимость этого таймера обеспечивается специальной батарейкой. Принципы программирования RTC вызывают ностальгию по BCD-числам и проблеме Y2K.

Programmable Interval Timer (PIT) 8253 или 8254 от Intel — стандартный счётчик и таймер, имеющийся в PC с самого начала существования этой платформы (1981 год). Как и RTC, изначально был отдельной микросхемой, а ныне является частью системной логики. Довольно интересное устройство, содержащее три таймера (хотя последние два всегда были зарезервированы под задачи обновления ОЗУ и работу PC-спикера соответственно) и позволяющее запрограммировать их в различные режимы: периодические прерывания, однократное (one-shot) прерывание по таймауту, меандр и т.д.

Первый канал PIT до сих пор может использоваться ОС как источник прерываний для работы вытесняющего планировщика задач. Однако по современным меркам он не очень удобен в работе: низкая частота осциллятора 1193181,8 Гц (странное значение — это историческое наследие от частоты развёртки NTSC), ширина счётчика всего 16 бит (частое переполнение) при ширине регистров статуса и команд всего в восемь бит (т.е. приходится передавать или читать значение по частям), да и доступ к регистрам через медленный и негибкий механизм PIO (команды IN/OUT процессора).

Local APIC (advanced programmable interrupt controller), встроенный во все современные процессоры Intel (начиная с архитектуры P54C) и который в своём составе имеет ещё и таймер. Более того, каждый логический процессор имеет свой собственный LAPIC, что может быть удобно для выполнения работы, локальной для текущего ядра, без необходимости управления ресурсами. Однако, данное устройство не имеет фиксированной известной частоты; последняя скорее привязана к частоте ядра. Поэтому перед использованием программе необходимо её вычислить (калибровать), а для этого нужно дополнительное референсное устройство. Режимы, поддерживаемые LAPIC: однократное прерывание, периодические прерывание, и период, определяемый TSC.

Таймер в составе ACPI, почему-то называемый Performance Monitoring Timer (PMTIMER) — ещё одно устройство, которое поддерживается всеми системами, реализующими стандарт ACPI, с 1996 года. Данный таймер имеет частоту 3.579545 МГц, ширина регистра-счётчика может быть 24 или 32 бита. Сам таймер всегда активен при включенном питании системы и не зависит от режима работы центрального процессора.

High Precision Event Timer (HPET) — устройство, созданное как замена устаревшему PIT. Согласно стандарту, HPET должен содержать осциллятор, работающий с фиксированной частотой по крайней мере в 10 МГц, величину которой можно программно прочитать из его статусного регистра, и монотонно увеличивающий значение счётчик шириной в 64 бита. Также он должен содержать минимум три компаратора шириной в 32 или 64 бита, которые и используются для генерации прерываний по истечении запрограммированных периодов времени. Как и PIT, он способен работать в периодическом режиме или в режиме однократного прерывания. При этом метод его программирования (MMIO вместо PIO) удобнее и быстрее, чем у PIT, что вместе с повышенным разрешением, позволяет задавать интервалы более точно и с меньшей задержкой. Требуемая стабильность генератора равна 0,05% для интервалов длиннее 1 мс и 0,2% для промежутков короче 100 мкс; много это или мало — зависит от приложений.

Несмотря на то, что HPET уже давно присутствует в PC (с 2005 года), операционные системы не торопятся начать его использовать. Частично это вызвано не самым удобным способом задания интервалов с помощью возрастающего счётчика вместо убывающего — из-за немгновенности операций существует риск «не успеть» и задать событие в прошлом. Зачастую ОС используют таймер из APIC или PMTIMER, или же функциональность TSC, использующую такты процессора в качестве источника времени.

Трудная судьба инструкции RDTSC

История TSC достаточно интересна и поучительна, чтобы остановиться на ней подольше.
Сама идея очень прозрачная — использовать в качестве источника времени сам процессор, а точнее его тактовый генератор. Текущий номер такта сохраняется в регистре TSC (timestamp counter).
С помощью TSC можно как узнавать время от начала работы, так и замерять интервалы времени с помощью двух чтений. TSC также работает как будильник в связке с APIC в режиме TSC deadline.

  • RDTSC (Read TimeStamp Counter — прочесть метку времени) появилась в Intel® Pentium™. Она записывает в пару регистров EDX:EAX 64-битное число тактов, прошедших с момента последнего включения питания/перезагрузки текущего ядра процессора. В отличие от всех ранее описанных устройств, которые доступны только привилегированному коду, RDTSC по умолчанию может исполняться на любом уровне привилегий (хотя ОС может динамически отключить поддержку RDTSC в пользовательском режиме, и тогда она будет вызывать исключение).
  • RDMSR [0x10] — чтение модель-специфичного регистра (MSR) IA32_TIMESTAMP_COUNTER также возвращает текущее TSC. Данная инструкция допускается только в привилегированном режиме, и некоторые ОС активно используют именно её для чтения TSC (хотя лично мне непонятно, почему). Полезное свойство состоит в том, что через MSR значение TSC можно не только читать, но и изменять, используя инструкцию WRMSR.
  • RDTSCP — Наличие её можно установить, проверив соответствующий лист CPUID. О двух её отличиях от RDTSC будет сказано чуть ниже.

Что ж, TSC — вполне естественная штука с простой логикой и простым сценарием использования, которая должна обладать многими полезными свойствами: высокое разрешение (один такт ЦПУ), низкая задержка при чтении (десятки тактов), редкие переполнения (64-битного счётчика должно хватать минимум на 10 лет), монотонность чтений (ведь счётчик всегда увеличивает своё значение), равномерность (процессор всегда работает), согласованность с другими таймерами (при старте системы можно выставить нужное значение записью в MSR).
Разве что-то могло пойти не так? На пути к успешному использованию TSC в качестве основного средства измерения времени в PC встала последующая эволюция процессоров. Новые возможности, появившиеся в процессорах после Pentium, «испортили» RDTSC и много лет мешали использовать её как основной таймер в популярных ОС. Так, в 2006 году один из Linux-разработчиков Ingo Molnar писал:

Мы наблюдали, что в течение 10 лет ни одной реализации gettimeofday, основанной на TSC и работающей в общем случае, не было написано (а я написал первую версию для Pentium, так что и я в этом повинен), и что лучше мы обойдёмся без неё.

We just observed that in the past 10 years no generally working TSC-based gettimeofday was written (and i wrote the first version of it for the Pentium, so the blame is on me too), and that we might be better off without it.

Отмечу, что со временем в архитектуру IA-32 вносились коррективы, устранявшие проявившиеся недостатки, и в настоящий момент TSC может (пока опять не сломали) быть использован в том качестве, в котором он задумывался.

  • Внеочередное исполнение (Out of Order Execution, OoO). Начиная с Intel® Pentium™ Pro (1995 г.), процессор может исполнять машинные инструкции в порядке, отличном от использованного в программе, или даже параллельно (если они не зависят друг от друга). Это означает, что исполнение RDTSC может быть задержано или, наоборот, выполнено раньше, чем того требует последовательный программный порядок. Из-за этого, например, невозможно понять, сколько каких инструкций исполнилось между двумя вызовами RDTSC — нельзя надёжно измерить длительность участка кода. В результате не гарантируется монотонность показаний.
    RDTSC не является инструкцией, сериализующей поток исполнения. Поэтому обычно используется «забор» из сериализующих команд вокруг неё, например, CPUID. Это, конечно, не выглядит очень изящно. В последующих обновлениях архитектуры появилась RDTSCP — инструкция, частично сериализующая поток исполнения, поэтому она не нуждается в дополнительных барьерах. У неё есть ещё одно хорошее свойство, но о нём чуть позже.
  • Управление энергопотреблением. Значение TSC увеличиваетсся каждый такт процессора. Всегда ли такт имеет один и тот же период, и всегда ли следующий такт следует сразу за предыдущим? Для Intel® Pentium™ это выполнялось. Для современных процессоров ответы на оба вопроса отрицательные. Процессор довольно значительную долю времени может быть приостановлен для экономии энергии (C-состояния). Исполняя инструкции, он может использовать динамическое изменение частоты для экономии энергии (P-состояния) или наоборот, для максимизации производительности (Turbo-состояния). Из этого следует, что просто счётчик тактов не будет обладать ни равномерностью, ни согласованностью.
    И для этой проблемы было представлено (начиная с Nehalem) решение в виде т.н. invariant TSC, темп изменения которого не зависит от C- и P-состояний отдельных ядер.
  • Многопроцессорность и многоядерность. В системе с несколькими потоками, ядрами или процессорами у каждого из логических процессоров будет свой TSC. Это создаёт не одну, а целых две сложности.
    Во-первых, значения, возвращаемые RDTSC на различных логических процессорах, могут оказаться сдвинутыми из-за неодновременности моментов инициализации ядер. Более того, из-за неустранимого дрейфа частот отдельных таймеров эта разница могла непредсказуемым образом флуктуировать в процессе работы.
    Во-вторых, перестаёт работать возможность надёжно измерять время в пользовательских приложениях. Без дополнительных ухищрений вроде прописывания affinity в любой момент программа может быть вытеснена с одного процессора и затем продолжена на другом. Если процесс, желающий измерить длительность между двумя событиями, в процессе работы был перемещён ОС с одного ядра на другое, два чтения RDTSC, выполненные им, не будут связаны.
    Для компенсации первой проблемы в последних поколениях процессоров для TSC заводится единый источник сигнала. Показания TSC со всех ядер при этом должны быть одинаковыми.
    Для устранения второго недостатка RDTSCP обладает ещё одним свойством, позволяющим пользовательскому приложению детектировать миграцию в процессе измерения интервала времени. Кроме значения TSC в EDX:EAX она возвращает значение отдельного модель-специфичного регистра IA32_TSC_AUX в ECX. Обе записи происходят атомарно, т.е. TSC и TSC_AUX всегда берутся с одного логического процессора. В начале работы ОС должна выставить уникальные значения TSC_AUX на всех процессорах системы. Совпадение считанных ECX для двух вызовов RDTSCP гарантирует, что они были выполнены на одном процессоре; в противном случае на разницу двух TSC полагаться нельзя, и измерение следует повторить. Вообще этот механизм может иметь и другие применения; например, с помощью него можно оповещать приложение не только о факте миграции, но и просто о вытеснении, также способном исказить результаты измерений времени. Вместо прикладных программ могут выступать и «привилегированные»: гипервизор Xen использует данный механизм для нотификации DomU систем о миграции между машинами.

В качестве ещё одной «недоделки» в первых реализациях TSC выступал тот факт, что не на всех процессорах была возможность записи во все 64 бита TSC — в регистр попадали лишь младшие 32, а старшие обнулялись. Это проблема тоже была впоследствии устранена.

Прочие устройства

Выше я описал наиболее часто распространённые и используемые устройства по определению времени. Конечно же, конкретные системы могут иметь дополнительные устройства, уникальные для процессора, интегрированной логики или даже в форме специализированных периферийных устройств (например, сверхточные атомные часы). Степень их доступности из программ зависит от того, существует ли драйвер для конкретного устройства в выбранной ОС. Так, пробежавшись по исходникам Linux, я нашёл как минимум ещё два поддерживаемых источника времени для сборок x86: устройство NatSemi SCx200 в системах AMD Geode, и Cyclone для систем IBM x440. К сожалению, в Интернете не очень много документации по ним.

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

  • PowerPC. Спецификации для 32- и 64-битных систем постулируют наличие регистра TB (time base) шириной в 64 бита, доступного на чтение пользовательским приложениям и на чтение/запись из супервизора. Изменения TB должны монотонно не убывать и не обязаны быть равномерными, а их частота зависит от реализации. Также из режима супервизора доступен 32-битный регистр DEC (decrementer), позволяющий программировать прерывание через промежуток времени. Его значение убывает до нуля с той же самой частотой, с которой возрастает TB.
  • ARM. В целом наличие средств измерения времени сильно зависит от выбранного семейства. На архитектуре ARM11 регистр CCNT может быть использован для чтения текущего номера такта; однако ширина его всего 32 бита, что означает переполнение примерно каждые 10 секунд на системе с частотой в 400 МГц. На системах Cortex M3 присутствует устройство Systick шириной 24 бита, а скорость его изменения специфицируется значением из регистра TENMS.
  • Intel ® IA-64 (Itanium). На данных системах в качестве счётчика тактов используется 64-битный регистр ar.itc (interval time counter). Для программирования периодов времени может использоваться набор регистров cr.itm (interval timer match), cr.itv (interval timer vector). Первый задаёт значение ITC, при котором сгенерируется прерывание, а второй определяет его номер.
  • SPARC v9. Архитектура подразумевает наличие 63-битного регистра TICK. Последний 64-й бит этого регистра контролирует, разрешено ли непривилегированному приложению читать время.

Заключение

Я надеюсь, что из этой заметки стало понятно, что работа со временем внутри компьютера на системном уровне на самом деле далека от тривиальной. Требования к устройствам, поставляющим время, зависят от решаемой задачи, и не всегда легко найти полностью подходящий вариант. При этом сами устройства зачастую содержат «архитектурные особенности», способные сломать голову несчастному программисту.
Однако это всё архитектурная присказка к симуляционной сказке. На самом деле мне хотелось рассказать о том, как можно моделировать весь этот зоопарк устройств. В следующей статье я опишу, как проявляется капризная природа времени при создании виртуальных окружений — симуляторов и мониторов виртуальных машин. Спасибо за внимание!

Таймеры и реле времени

Все товары Выбрать магазин

Принцип работы: электронный

Max подключаемая мощность: 3500 Вт

Принцип работы: механический

Max подключаемая мощность: 3500 Вт

Принцип работы: электронный

Max подключаемая мощность: 3500 Вт

Max число включений: 8

Принцип работы: механический

Max подключаемая мощность: 3500 Вт


Max число включений: 48

Принцип работы: электронный

Max подключаемая мощность: 3500 Вт

Max число включений: 10

Принцип работы: электронный

Max подключаемая мощность: 3500 Вт

Max число включений: 10

Принцип работы: электронный

Max число включений: 99

Принцип работы: электронный

Max подключаемая мощность: 3500 Вт

Max число включений: 20

Принцип работы: электронный

Принцип работы: электронный

Max число включений: 99

Принцип работы: механический

Max подключаемая мощность: 3500 Вт

Max число включений: 48

Принцип работы: механический

Max подключаемая мощность: 3500 Вт

Max число включений: до 48 в сутки

Принцип работы: механический

Max подключаемая мощность: 3500 Вт

  • Прост и надежен в работе

Принцип работы: механический

Max подключаемая мощность: 3500 Вт

Max число включений: 48 в сутки

Принцип работы: электронный

Max подключаемая мощность: 3520 Вт

Принцип работы: электронный

Max подключаемая мощность: 3500 Вт

Max число включений: 56 в неделю

Принцип работы: механический

Принцип работы: электронный

Max подключаемая мощность: 2200 Вт

Max число включений: 16 в сутки

Принцип работы: электронный

Max подключаемая мощность: 1800 Вт

Max число включений: до 140 в неделю

Принцип работы: электронный

Max подключаемая мощность: 5280 Вт

Max число включений: 16 в сутки

Принцип работы: электронный

Max подключаемая мощность: 3600 Вт

Max число включений: 10 в сутки/70 в неделю

Принцип работы: электронный

Max подключаемая мощность: 5280 Вт

Max число включений: 99 в сутки


Принцип работы: электронный

Max подключаемая мощность: 1800 Вт

Max число включений: 140 в неделю

Принцип работы: механический

Max подключаемая мощность: 2200 Вт

Принцип работы: механический

Max подключаемая мощность: 3680 Вт

Принцип работы: электронный

Max подключаемая мощность: 3600 Вт

Принцип работы: механический

Max подключаемая мощность: 3500 Вт

Принцип работы: механический

Max подключаемая мощность: 3500 Вт

Принцип работы: электронный

Max подключаемая мощность: 1 Вт

Принцип работы: электронный

Max подключаемая мощность: 3000 Вт

Принцип работы: электронный

Max подключаемая мощность: 3600 Вт

Max число включений: 56 в неделю

Принцип работы: электро-механический

Max подключаемая мощность: 3500 Вт

Принцип работы: электронный

Max подключаемая мощность: 1 Вт

Принцип работы: электронный

Max подключаемая мощность: 1 Вт

Принцип работы: механический

Max подключаемая мощность: 3680 Вт

Max число включений: 12 в сутки, 84 в неделю

Принцип работы: электронный

Max подключаемая мощность: 3600 Вт

Принцип работы: электронный

Max подключаемая мощность: 150 Вт

Max число включений: 8

Принцип работы: механический

Max подключаемая мощность: 3000 Вт

Принцип работы: электронный

Max подключаемая мощность: 3500 Вт

Max число включений: 10

Принцип работы: механический

Max подключаемая мощность: 3500 Вт

Max число включений: 24 в сутки

Сортировать по: Отображать по: товаров

© 2006 — 2020. ВсеИнструменты.ру

Email: info@vseinstrumenti.ru
Тел.: +7 (495) 730-35-00 ( с 07:00 до 22:00 )
8 800 550-37-70 ( с 07:00 до 22:00 )
Звонок бесплатный

Вся информация на сайте – собственность интернет-магазина Vseinstrumenti.ru.
Публикация информации с сайта vseinstrumenti.ru без разрешения запрещена. Все права защищены.

Информация на сайте www.vseinstrumenti.ru не является публичной офертой. Указанные цены действуют только при оформлении заказа через интернет-магазин www.vseinstrumenti.ru.

Цены в пунктах выдачи заказов и розничных магазинах компании ВсеИнструменты.ру могут отличаться от указанных на сайте.

Вы принимаете условия политики конфиденциальности и пользовательского соглашения каждый раз, когда оставляете свои данные в любой форме обратной связи на сайте ВсеИнструменты.ру.


Модуль time – таймеры времени

Модуль для работы со временем. Время начинается с 00:00:00 1970 года.

accept2dyear¶

в третьем питоне нету

Год, вида 2012 или 12

altzone¶

Хранит в секундах значение времени часового пояса с учетом перехода на летнее время. Если часовой пояс находится восточнее Гринвича, то значение имеет знак минус (отрицательное значение)

daylight¶

Если не равен 0, если DST часовой пояс определен.

timezone¶

Хранит в секундах значение времени часового пояса (сдвиг часового пояса) без учета перехода на летнее время. Значение также принимает отрицательное значение, если часовой пояс находится восточнее Гринвича.

tzname¶

Кортеж из двух строк: имя локального часового пояса, имя местного часового пояса.

time. asctime ( [ time_tuple ] ) ¶

Возвращает строкове представление переданной либо текущей даты.

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

Возвращает строковое представление текущего местного времени.

Возвращает объект struct_time , текущего или переданного времени.

Возвращает объект struct_time , текущего или переданного времени. Представляющий местное время с начала Эпохи.

Преобразует кортеж или объект struct_time во время в секундах.

Останавливает выполнение программы на sec секунд.

Преобразует кортеж или объект struct_time в соответствии с форматом в строку. Если кортеж не указан преобразует текущее время. Формат представляет из себя строку, содержащую управляющие символы

Разбирает строку string в соответствии с форматом format и возвращает struct_time .

Возвращает текущее время в секундах по Гринвичу, прошедшее с начала Эпохи.

Gifts for All-Abilities.

The entire family of products at Time Timer is designed to create less stress in the lives of differently-abled people of all ages and abilities, whether at home, school or work.

As Seen In

See the iconic red disk and know it’s a Time Timer.

For Special Needs

There’s a world of difference between looking at a clock and being able to say that it’s 3 o’clock and understanding “how long” 5 minutes is. For those who learn differently, this type of abstract thinking is even more difficult and often creates a high level of anxiety.

In Education

Teachers around the world have discovered the power of the award-winning Time Timer to transform stressful transition periods, reduce resistance to routines and increase their ability to manage their classrooms.

At Home

You know what a difference the Time Timer makes in the classroom, but what about at home? Discover the power of the award-winning Time Timer to transform never-ending meals, stressful transition periods and resistance to routines.

At Work

At your desk, in the boardroom or on the wall of the conference hall, the Time Timer increases productivity by creating a sense of urgency and keeping everyone on track.

Featured Products

Unlike traditional timers that fail to make the abstract concept of time concrete, the award-winning Time Timer’s visual depiction of “time remaining” provides stress-free time management at work, school and home to make every moment count.

Time Timer PLUS® 120 Minute Make Time Edition
Time Timer® MAX
Time Timer PLUS® 5 Minute
Time Timer® 8” MAGNET
Time Timer® iPhone App

How much longer?

For anyone who wants to measure and manage time more effectively, Time Timer® is an innovative visual timer designed to “show” the passage of time through the use of a patented red disk that disappears as time elapses. Unlike traditional timers that fail to make the abstract concept of time concrete, the award-winning Time Timer’s visual depiction of “time remaining” provides stress-free time management at work, school and home to make every moment count.

What people are saying

“Since using the Time Timer, my meetings have never been more efficient or effective. People actually want to attend because I don’t waste their time.”

Corporate Department Head

«I just wanted to thank you for your terrific product. Your timer has greatly aided my husband and I in getting our two-year old daughter in to bed and nap time and at bed time!»

Parent & Psychologist

Stay In The Know

Subscribe and get exclusive access to promotions, insights and resources.

Мастер Йода рекомендует:  Напишите функцию, меняющую местами значения переменных, не используя временные переменные
Добавить комментарий
Найдено товаров: 123