Форум программистов, компьютерный форум, киберфорум
Наши страницы

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
Daemon2017
4 / 4 / 1
Регистрация: 07.01.2013
Сообщений: 101
#1

Прерывание по таймеру - C++

29.07.2016, 00:58. Просмотров 444. Ответов 3
Метки нет (Все метки)

Здравствуйте!

Возможно ли сделать в консольном приложении на Visual Studio так, чтобы во время работы одного из циклов программы, раз в 100 мс его деятельность прерывалась и выполнялась небольшая отдельная функция?
1
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
29.07.2016, 00:58
Здравствуйте! Я подобрал для вас темы с ответами на вопрос Прерывание по таймеру (C++):

Прерывание по таймеру на C++ в консоли - C++
Подскажите пожалуйста,как в консольном приложении можно написать прерывание срабатывающее при истечении какого-то промежутка времени? ...

Прерывание - C++
При вызове прерывание компилятор пишет ошибка доступа. #include <iostream> using namespace std; char a = "hello"; int main() ...

Прерывание цикла! - C++
каким образом можно прервать while путем ввода какого нибудь символа, чтобы не нужно было при каждом проходе тела цикла вводить этот...

Прерывание циклов - C++
Допустим есть цикл в цикле и если во внутреннем цикле выполняется некоторое условие, необходимо прервать оба цикла.Возможно ли это? Заранее...

Прерывание ввода - C++
Я написал программу, которая просит пользователя ввести массив, потом отображает его, и после заново отображает, но только в реверсивном...

Прерывание программы по ESC C++ - C++
доброй ночи Добрался до такой вот темы Пытаюсь реализовать перехват нажатия клавиши ESC и SPACE в консольном режиме Но программа не...

3
Armatus
53 / 53 / 28
Регистрация: 24.03.2016
Сообщений: 377
Завершенные тесты: 4
29.07.2016, 01:20 #2
Функция sleep() приостанавливает выполнение программы на время, задаваемое параметром time. Время задается в секундах.

Пример:
C++
1
sleep(100);
Приостанавливает выполнение программы на 100 мс.
0
hoggy
6764 / 2949 / 507
Регистрация: 15.11.2014
Сообщений: 6,625
Завершенные тесты: 1
29.07.2016, 01:21 #3
Цитата Сообщение от Daemon2017 Посмотреть сообщение
Возможно ли
ага.

http://rextester.com/QXHX23788


C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
// --- timer.h
//#pragma once
 
#include <functional>
#include <stdint.h>
#include <chrono>
 
namespace tools
{
    struct Timer
    {
        //если функция-будильник вернет true, то таймер перезапустится
        typedef ::std::function<bool()> EventWakeUp;
 
        typedef std::chrono::high_resolution_clock Clock;
 
        typedef uint64_t    MicroSeconds;
        typedef double      Seconds;
 
    public:
       ~Timer();
 
        //укажите :
        // --- время, через которое должен сработать будильник,
        // --- функтор, который должен будет запуститься в момент срабатывания будильника,
        // --- числовой идентификатор таймера (если он вам нужен).
        //Имейте ввиду, если функтор будильника вернет true, то будильник снова перезапустится.  
        Timer( const Seconds      delay, const EventWakeUp& wakeup=EventWakeUp(), const int id=0 );
        Timer( const MicroSeconds delay, const EventWakeUp& wakeup=EventWakeUp(), const int id=0 );
        Timer(const int id=0);
 
        //перезапуск будильника, с возможностью указать другой функутор
        void Restart(const Seconds delay,      const EventWakeUp& wakeup=EventWakeUp() );
        void Restart(const MicroSeconds delay, const EventWakeUp& wakeup=EventWakeUp() );
 
        int GetID()const{ return mId;}
    public:
        //вернет промежуток времени с момента последнего запуска этого же метода
        static MicroSeconds QuantMS();
        static Seconds QuantS();
 
        //спать все время в отдельном потоке, а потом пробудиться и вызвать функцию-будильник
        static void BackGround(const Timer::Seconds delay, const Timer::EventWakeUp& wakeup=EventWakeUp());
 
        //усыпить текущий поток, а потом пробудиться и вызвать функцию-будильник
        static void Sleep(const Timer::Seconds delay, const Timer::EventWakeUp& wakeup=EventWakeUp());
    public:
        //засечь время.
        void Mark();
 
        //через какое время сработает будильник
        MicroSeconds RemainingMS()const;
        Seconds RemainingS()const;
 
        //сколько времени уже прошло с момента запуска будильника
        MicroSeconds ElapsedMS()const;
        Seconds ElapsedS()const;
 
        //Приводит механизм будильника в действие
        //вернет true, если будильник ещё не сработал. 
        //В момент срабатывания запустит функцию-будильник
        bool TickTock();
    private:
        int mId; 
        MicroSeconds        mDelay; 
        EventWakeUp         mEvent;
        Clock::time_point   mMark; 
    };
 
}//namespace tools
 
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//#include <tools/timer.h>
#include <thread>
 
namespace tools
{
 
    namespace{
 
        typedef Timer::EventWakeUp  EventWakeUp;
        typedef Timer::MicroSeconds MicroSeconds;
        typedef Timer::Seconds      Seconds;
        typedef Timer::Clock        Clock;
        
        typedef std::chrono::microseconds MSec;
        typedef std::chrono::seconds      Sec;
 
        template<class T> T DeltaTime(Clock::time_point& last)
        {
            const Clock::time_point now = Clock::now();
            const auto result = std::chrono::duration_cast<T>(now - last);
            last = now;
            return result;
        }
 
        Clock::time_point& Quant()
        {
            static Clock::time_point quant;
            return quant;
        }
 
        void Sleeping(const MicroSeconds pause, const EventWakeUp& wakeup)
        {
            do
            {
                std::this_thread::sleep_for(std::chrono::microseconds(pause) );
 
            }while ( wakeup && wakeup() );
        }
 
    }//namespace
 
    MicroSeconds Timer::QuantMS() { return DeltaTime<MSec>(Quant()).count();         }
    Seconds Timer::QuantS()       { return (Seconds)DeltaTime<Sec>(Quant()).count(); }
 
    Timer::Timer(const int id):mId(id){}
 
    Timer::Timer( const Seconds delay, const EventWakeUp& wakeup, const int id):mId(id)
    {
        Restart(delay,wakeup);
    }
 
    Timer::Timer( const MicroSeconds delay, const EventWakeUp& wakeup, const int id):mId(id)
    {
        Restart(delay,wakeup);
    }
    
    
 
    void Timer::Restart(const Seconds delay, const EventWakeUp& wakeup)
    {
        mDelay = static_cast<MicroSeconds>(delay*1000000);
        mEvent = wakeup;
        Mark();
    }
    void Timer::Restart(const MicroSeconds delay,const EventWakeUp& wakeup)
    {
        mDelay = delay;
        mEvent = wakeup;
        Mark();
    }
 
    Timer::~Timer(){}
 
 
    void Timer::Mark() { mMark = Clock::now(); }
 
    MicroSeconds Timer::ElapsedMS()const
    {
        return std::chrono::duration_cast<MSec>(Clock::now() - mMark).count();
    }
    Seconds Timer::ElapsedS()const
    {
        return static_cast<Seconds>( ElapsedMS()/1000000.0 );
    }
 
    MicroSeconds Timer::RemainingMS()const
    {
        if(mMark == Clock::time_point() || mDelay==0) 
            return 0;
        
        const auto elapsed = ElapsedMS(); 
        return (mDelay<=elapsed)? 0: mDelay-elapsed;
    }
    Seconds Timer::RemainingS()const
    {
        if(mMark == Clock::time_point() || mDelay==0) 
            return 0;
 
        const auto elapsed = ElapsedMS(); 
        return (mDelay<=elapsed)? 0.0: (mDelay-elapsed)/1000000.0;
    }
 
    bool Timer::TickTock()
    {
        if(mMark == Clock::time_point())
            return false;
 
        if(RemainingMS()!=0)
            return true;
 
        if(mEvent && mEvent())
            return Mark(), true;
        else
            mMark=Clock::time_point();
        
        return false;
    }
 
 
//-----------------------------------------------------------
    void Timer::BackGround(const Timer::Seconds delay, const Timer::EventWakeUp& wakeup)
    {
        const MicroSeconds pause = static_cast<MicroSeconds>(delay*1000000);
        auto lambda = [pause, wakeup ](){ Sleeping(pause, wakeup); };
        std::thread(lambda).detach();
    }
 
    void Timer::Sleep(const Timer::Seconds delay, const Timer::EventWakeUp& wakeup)
    {
        const auto pause = static_cast<MicroSeconds>(delay*1000000);
        Sleeping(pause, wakeup);
    }
    
}//namespace tools
 
 
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
 
#include <iostream>
 
 
bool userFunction()
{
    static size_t count = 5;
    
    std::cout << "wake up!\n";
    --count;
    return count!=0;
}
 
int main()
{
    std::cout << "Hello, world!\n";
    
    size_t v=0;
    
    
    // создаем будильник, указывая через сколько секунд нужно сработать.
    // и функцию, которую нужно запустить при срабатывании
    // если функция вернет true,
    // то будильник автоматически перезапустится.
    const double seconds = 0.1; 
    tools::Timer timer(seconds, userFunction);
 
    // TickTock возвращает true, если будильник ещё не сработал
    while( timer.TickTock() )
    {
        // здесь может быть любой ваш код
        
        //std::cout<<" Remaining: "<< timer.RemainingS() <<" seconds\n";
        //std::cout<<" Elapsed: "  << timer.ElapsedS()   <<" seconds\n";
    }
    std::cout << "finished" <<std::endl;
    
}
это - лишь пример одной из возможных реализаций.
код нужно дорабатывать для поддержки многопоточности.
1
TheBig
-20 / 0 / 0
Регистрация: 28.07.2016
Сообщений: 41
29.07.2016, 17:31 #4
Цитата Сообщение от hoggy Посмотреть сообщение
код нужно дорабатывать
и сокращать. 250 строк кода это перебор для данной задачи.

Добавлено через 1 час 9 минут

Не по теме:

Кнопка Спасибо сама нажалась

0
29.07.2016, 17:31
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
29.07.2016, 17:31
Привет! Вот еще темы с ответами:

Прерывание цикла по условию - C++
Ребят,помогите пожалуйста,мне нужно,например если сработал первый if, то следующие не срабатывали в цикле,помогите пожалуйста void...

прерывание, вывод числа - C++
Здравствуйте, подскажите пожалуйста как по прерыванию от порта ввода выводить в порт вывода очередное число последовательности 0..255 ?...

Прерывание программы в процессе выполнения - C++
Доброго времени суток! Подскажите, есть ли возможность прерывать программу во время выполнения? Т.е. у меня в программе есть цикл,...

Прерывание в си++, отслеживание нажатых клавиш - C++
Доброго времени суток, пишу программу, которая выполняет ряд различных простых задач друг за другом в бесконечном цикле. Задача следующая,...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
4
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2018, vBulletin Solutions, Inc.