Subversion Repositories Projects

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
1702 - 1
#include "hdrcapture.h"
2
#include "expcomp_macro.h"
3
 
4
/* fixes avr-gcc incompatibility with virtual destructors */
5
void operator delete( void *p ) {}
6
 
7
QState HDRCapture::Initial(HDRCapture *me, QEvent const *e)
8
{
9
    return Q_TRAN(&HDRCapture::Inactive);
10
}
11
 
12
QState HDRCapture::Inactive(HDRCapture *me, QEvent const *e)
13
{
14
    switch(e->sig)
15
    {
16
    case Q_ENTRY_SIG:
17
        PTPTRACE("Inactive\r\n");
18
        return Q_HANDLED();
19
    case SET_FRAMES_SIG:
20
        me->frmCount = (uint16_t)((SetEvt*)e)->value;
21
        return Q_HANDLED();
22
    case SET_SELF_TIMEOUT_SIG:
23
        me->selfTimeout = ((SetEvt*)e)->value;
24
        return Q_HANDLED();
25
    case SET_FRAME_TIMEOUT_SIG:
26
        me->frameTimeout = ((SetEvt*)e)->value;
27
        return Q_HANDLED();
28
    case SET_BRACKETING_SIG:
29
        me->bktStep     = ((SetBktEvt*)e)->step;
30
        me->bktNegative = ((SetBktEvt*)e)->negative;
31
        me->bktPositive = ((SetBktEvt*)e)->positive;
32
        return Q_HANDLED();
33
    case RUN_SIG:
34
        me->frmCntdn = me->frmCount;
35
        me->bktCntdn = (me->bktStep) ? (me->bktPositive - me->bktNegative) / me->bktStep + 1 : 1;
36
        me->bktPos = me->bktNegative;
37
        return Q_TRAN(&HDRCapture::Active);
38
    }
39
    return Q_SUPER(&QHsm::top);
40
}
41
 
42
QState HDRCapture::Active(HDRCapture *me, QEvent const *e)
43
{
44
    switch (e->sig)
45
    {
46
    case Q_ENTRY_SIG:
47
        PTPTRACE("Active\r\n");
48
        return Q_HANDLED();
49
    case Q_EXIT_SIG:
50
        PTPTRACE("::Q_EXIT_SIG\r\n");
51
        return Q_HANDLED();
52
    case Q_INIT_SIG:
53
        PTPTRACE("Q_INIT_SIG\r\n");
54
        return Q_TRAN(&HDRCapture::SaveSettings);
55
    case RUN_SIG:
56
        PTPTRACE("::RUN_SIG\r\n");
57
        return Q_TRAN(&HDRCapture::SaveSettings);
58
    case ABORT_SIG:
59
        PTPTRACE("ABORT_SIG\r\n");
60
        return Q_TRAN(&HDRCapture::RestoreSettings);
61
    case PTP_RC_SIG:
62
        PTPTRACE("::PTP_RC_SIG\r\n");
63
        switch (((PTP_RC_Evt*)e)->rc)
64
        {
65
        case PTP_RC_OK:
66
            me->qpEvt.sig = PTP_RC_OK_SIG;
67
            me->theQueue.Push(&me->qpEvt);
68
            return Q_HANDLED();
69
        case PTP_RC_DeviceBusy:
70
            me->toEvt.timeout = PTP_TIMEOUT;
71
            me->toEvt.attribs = TA_PTP_TIMEOUT;
72
            me->theQueue.Push(&me->toEvt);
73
            return Q_TRAN(&HDRCapture::Timeout);
74
        default:
75
            return Q_TRAN(&HDRCapture::Inactive);
76
        }
77
    case SET_TIMEOUT_SIG:
78
        PTPTRACE("::SET_TIMEOUT_SIG\r\n");
79
        return Q_HANDLED();
80
    case TIMEOUT_SIG:
81
        PTPTRACE("::TIMEOUT_SIG\r\n");
82
        return Q_TRAN(me->activeHistory);
83
    case PTP_RC_OK_SIG:
84
        PTPTRACE("::PTP_RC_OK_SIG\r\n");
85
        return Q_TRAN(me->activeHistory);
86
    case TICK_MILLIS_SIG:
87
        PTPTRACE("::TICK_MILLIS_SIG\r\n");
88
        return Q_HANDLED();
89
    }
90
    return Q_SUPER(&QHsm::top);
91
}
92
 
93
QState HDRCapture::SaveSettings(HDRCapture *me, QEvent const *e)
94
{
95
    static bool bSaved = false;
96
    switch (e->sig)
97
    {
98
    case Q_ENTRY_SIG:
99
        PTPTRACE("SaveSettings\r\n");
100
        me->activeHistory = (QStateHandler)&SaveSettings;
101
//        me->rcEvt.rc = me->Eos.GetProperty(EOS_DPC_ExposureCompensation, me->bktOldVal);
102
        me->rcEvt.rc = PTP_RC_OK;
103
        me->theQueue.Push(&me->rcEvt);
104
        me->bktOldVal = (uint8_t)0;
105
        return Q_HANDLED();
106
    case PTP_RC_OK_SIG:
107
        PTPTRACE("PTP_RC_OK_SIG\r\n");
108
        if (me->selfTimeout)
109
        {
110
            me->theQueue.Push((QEvent*)e);
111
            return Q_TRAN(&HDRCapture::SelfTimer);
112
        }
113
        return Q_TRAN(&HDRCapture::PreCapture);
114
    }  // switch
115
    return Q_SUPER(&HDRCapture::Active);
116
}
117
 
118
QState HDRCapture::SelfTimer(HDRCapture *me, QEvent const *e)
119
{
120
    switch (e->sig)
121
    {
122
    case Q_ENTRY_SIG:
123
        PTPTRACE("SelfTimer\r\n");
124
        me->activeHistory = (QStateHandler)&SelfTimer;
125
        return Q_HANDLED();
126
    case TICK_MILLIS_SIG:
127
        PTPTRACE("TICK_MILLIS_SIG\r\n");
128
        return Q_TRAN(&HDRCapture::PreCapture);
129
    case PTP_RC_OK_SIG:
130
        PTPTRACE("PTP_RC_OK_SIG\r\n");
131
        me->toEvt.timeout = me->selfTimeout;
132
        me->toEvt.attribs = TA_SELF_TIMER;
133
        me->theQueue.Push(&me->toEvt);
134
        return Q_TRAN(&HDRCapture::Timeout);
135
    case TIMEOUT_SIG:
136
        PTPTRACE("TIMEOUT_SIG\r\n");
137
        return Q_TRAN(&HDRCapture::PreCapture);
138
    }  // switch
139
    return Q_SUPER(&HDRCapture::Active);
140
}
141
 
142
QState HDRCapture::RestoreSettings(HDRCapture *me, QEvent const *e)
143
{
144
    switch (e->sig)
145
    {
146
    case Q_ENTRY_SIG:
147
        PTPTRACE("RestoreSettings\r\n");
148
        me->activeHistory = (QStateHandler)&RestoreSettings;
149
        me->rcEvt.rc = me->Eos.SetProperty(EOS_DPC_ExposureCompensation, me->bktOldVal);
150
        me->theQueue.Push(&me->rcEvt);
151
        return Q_HANDLED();
152
    case PTP_RC_OK_SIG:
153
        return Q_TRAN(&HDRCapture::Inactive);
154
    }  // switch
155
    return Q_SUPER(&HDRCapture::Active);
156
}
157
 
158
QState HDRCapture::PreCapture(HDRCapture *me, QEvent const *e)
159
{
160
    switch (e->sig)
161
    {
162
    case Q_ENTRY_SIG:
163
        PTPTRACE("PreCapture\r\n");
164
        me->activeHistory = (QStateHandler)&PreCapture;
165
        return Q_HANDLED();
166
    case TICK_MILLIS_SIG:
167
        PTPTRACE("TICK_MILLIS_SIG\r\n");
168
 
169
        if (!me->bktCntdn)
170
        {
171
            me->bktCntdn = (me->bktStep) ? (me->bktPositive - me->bktNegative) / me->bktStep + 1 : 1;    
172
            me->bktPos = me->bktNegative;
173
        }
174
        if (me->bktStep)
175
            return Q_TRAN(&HDRCapture::ExpCompSet);
176
 
177
        return Q_TRAN(&HDRCapture::Capture);
178
    } // switch
179
    return Q_SUPER(&HDRCapture::Active);
180
}
181
 
182
QState HDRCapture::Capture(HDRCapture *me, QEvent const *e)
183
{
184
    switch (e->sig)
185
    {
186
    case Q_ENTRY_SIG:
187
        PTPTRACE("Capture\r\n");
188
        me->activeHistory = (QStateHandler)&Capture;
189
        me->rcEvt.rc = me->Eos.Capture();
190
//        me->rcEvt.rc = PTP_RC_OK;
191
        me->theQueue.Push(&me->rcEvt);
192
        return Q_HANDLED();
193
    case PTP_RC_OK_SIG:
194
        PTPTRACE("PTP_RC_OK_SIG\r\n");
195
        return Q_TRAN(&HDRCapture::PostCapture);
196
    }  // switch
197
    return Q_SUPER(&HDRCapture::Active);
198
}
199
 
200
QState HDRCapture::PostCapture(HDRCapture *me, QEvent const *e)
201
{
202
    switch (e->sig)
203
    {
204
    case Q_ENTRY_SIG:
205
        PTPTRACE("PostCapture\r\n");
206
        me->activeHistory = (QStateHandler)&PostCapture;
207
        return Q_HANDLED();
208
    case TICK_MILLIS_SIG:
209
        PTPTRACE("TICK_MILLIS_SIG\r\n");
210
 
211
        if (!me->bktCntdn)
212
            return Q_TRAN(&HDRCapture::PreCapture);
213
 
214
        me->bktPos += me->bktStep;                
215
 
216
        if (--me->bktCntdn == 0)
217
        {
218
            --me->frmCntdn;            
219
            me->OnFrameCaptured(me->frmCntdn);
220
        }
221
        me->OnBktFrameCaptured(me->bktCntdn);
222
 
223
        // if it was the last frame in total
224
        if (!me->frmCntdn)
225
        {
226
            me->qpEvt.sig = ABORT_SIG;
227
            me->theQueue.Push(&me->qpEvt);
228
            return Q_HANDLED();
229
        }
230
        if (me->bktCntdn)
231
            return Q_TRAN(&HDRCapture::PreCapture);
232
 
233
        // if it was the last frame in bracketing            
234
        me->toEvt.timeout = me->frameTimeout;
235
        me->toEvt.attribs = TA_INTR_TIMER;
236
        me->theQueue.Push(&me->toEvt);
237
        return Q_TRAN(&HDRCapture::Timeout);
238
    case TIMEOUT_SIG:
239
        PTPTRACE("TIMEOUT_SIG\r\n");
240
        return Q_TRAN(&HDRCapture::PreCapture);
241
    }
242
    return Q_SUPER(&HDRCapture::Active);
243
}
244
 
245
QState HDRCapture::ExpCompSet(HDRCapture *me, QEvent const *e)
246
{
247
    switch (e->sig)
248
    {
249
    case Q_ENTRY_SIG:
250
        PTPTRACE("ExpCompSet\r\n");
251
        me->activeHistory = (QStateHandler)&ExpCompSet;
252
        me->rcEvt.rc = me->Eos.SetProperty(EOS_DPC_ExposureCompensation, EXP_COMP_VALUE(me->bktPos));
253
//        me->rcEvt.rc = PTP_RC_OK;
254
        me->theQueue.Push(&me->rcEvt);
255
        return Q_HANDLED();
256
    case PTP_RC_OK_SIG:
257
        PTPTRACE("PTP_RC_OK_SIG\r\n");
258
        return Q_TRAN(&HDRCapture::Capture);
259
    }  // switch
260
    return Q_SUPER(&HDRCapture::Active);
261
}
262
 
263
QState HDRCapture::Timeout(HDRCapture *me, QEvent const *e)
264
{
265
    static uint32_t timeout = 0;
266
    static uint32_t local_time = 0;
267
    static uint32_t seconds_left = 0;
268
    static uint8_t  attribs = 0;
269
    static uint16_t sec_cntdn = 1000;
270
 
271
    switch (e->sig)
272
    {
273
    case Q_ENTRY_SIG:
274
        PTPTRACE("Timeout\r\n");
275
        return Q_HANDLED();
276
    case SET_TIMEOUT_SIG:
277
        attribs = ((SetTimeoutEvt*)e)->attribs;
278
        timeout = (attribs & 0x01) ? ((SetTimeoutEvt*)e)->timeout * 1000 : ((SetTimeoutEvt*)e)->timeout;
279
 
280
        if (attribs & 0x01)
281
        {
282
            seconds_left = ((SetTimeoutEvt*)e)->timeout;
283
            sec_cntdn = 1000;
284
 
285
            switch (attribs)
286
            {
287
            case TA_SELF_TIMER:
288
                me->OnSelfTimerProgress(seconds_left);
289
                break;
290
            case TA_INTR_TIMER:
291
                me->OnIntrTimerProgress(seconds_left);
292
                break;
293
//                case TA_BULB_TIMER:
294
//                    me->OnBulbTimerProgress(seconds_left);
295
//                    break;
296
            }  // switch
297
        }    
298
        local_time = millis();
299
        return Q_HANDLED();
300
    case TICK_MILLIS_SIG:
301
        uint32_t dt = local_time;
302
        local_time = millis();
303
        dt = local_time - dt;
304
        timeout = (timeout < dt) ? 0 : timeout - dt;
305
 
306
        if (attribs & 1)
307
        {
308
            bool bTick = (sec_cntdn <= dt);
309
            sec_cntdn = (sec_cntdn > dt) ? sec_cntdn - dt : 1000 - dt;
310
 
311
            if (bTick)
312
            {
313
                seconds_left --;
314
 
315
                switch (attribs)
316
                {
317
                case TA_SELF_TIMER:
318
                    me->OnSelfTimerProgress(seconds_left);
319
                    break;
320
                case TA_INTR_TIMER:
321
                    me->OnIntrTimerProgress(seconds_left);
322
                    break;
323
                }  // switch
324
            } // if (--sec_cntdn == 0)
325
        } // if (attribs & 1)
326
 
327
        if (!timeout)
328
        {
329
            me->qpEvt.sig = TIMEOUT_SIG;
330
            me->theQueue.Push(&me->qpEvt);
331
        }
332
        return Q_HANDLED();
333
    } // switch
334
    return Q_SUPER(&HDRCapture::Active);
335
}
336