update()

void erisAudioAnalyzeScope::update ( void  )

virtual

Implements AudioStream.

Definition at line 52 of file eris_analyze_scope.cpp.

{
    audio_block_t *block;
    audio_block_t *blockb; //2nd channel (optional)
    bool isDualChannel;
 
    uint32_t offset;
    uint32_t remain;
 
    //capture only if channel 0 is connected
    block = receiveReadOnly(0);
    if (!block){
        blockb = receiveReadOnly(1); 
        if (blockb) release(blockb);
        return;
    }
    
    blockb = receiveReadOnly(1);
    if (!blockb) {
        isDualChannel = false;
    } else isDualChannel = true;
 
    offset = 0;
    while (offset < AUDIO_BLOCK_SAMPLES) {
        remain = AUDIO_BLOCK_SAMPLES - offset;
        switch (state) {
          case STATE_WAIT_TRIGGER:
            // TODO: implement this....
            offset = AUDIO_BLOCK_SAMPLES;
            break;
 
          case STATE_DELAY:
            //Serial.printf("STATE_DELAY, count = %u\n", count);
            if (remain < count) {
                count -= remain;
                offset = AUDIO_BLOCK_SAMPLES;
            } else {
                offset += count;
                count = mem_length;
                state = STATE_PRINTING;
            }
            break;
 
          case STATE_PRINTING:
            //wait for the zero crossing on ch1 
            if (count == mem_length){ 
                dot = 0;
                dotAvg = 0;
                dotAvgSlow = 0;
                dotDelta = 0;
                dotDeltaMACD = 0;
                dotAccel = 0;
                dotMACD = 0;
                edgeCount = 0;
                edgeCount_ch2 = 0;
                peakValue = 0;
                edgeTimer=0;
                edgeDelay=0;
                edgeTimer2=0;
                edgeDelay2=0;               
 
                bool found = false;
                for(int16_t i=1;i < AUDIO_BLOCK_SAMPLES-h_div;i++){
                    if(trigger_wait_count > SCOPE_MAX_TRIGGER_WAIT){
                        //force the trigger
                        found=true;
                        edgeTimer=0;
                        edgeTimer2=0;
                        break;
                    }
                    if (block->data[i] > 0 && block->data[i-1] < 0){
                        offset = i;
                        if(isDualChannel){
                            if (blockb->data[i] > 0  || 1){
                                found = true;
                            }
                        }else found = true;
                        if (found){
                            edgeTimer=0;
                            edgeTimer2=0;
                            break;
                        }
                    }
                }
                //skip to the next block
                if(!found) {offset = AUDIO_BLOCK_SAMPLES;};
 
            }
            
            while ((offset < AUDIO_BLOCK_SAMPLES) && (count > 0)){
                edgeTimer++;
                edgeTimer2++;
                //for every sample
                if ((offset >= h_div) && block->data[offset] <= 0 && block->data[offset-h_div] >0){
                    if((edgeCount > 0) && (edgeTimer > 20)){
                        if (edgeDelay==0){edgeDelay = edgeTimer;
                        } else {
                            edgeDelay = (edgeDelay+edgeTimer)/2;
                        }
                    }
                    edgeTimer=0;
                } 
                if (isDualChannel && (offset >= h_div) && blockb->data[offset] <= 0 && blockb->data[offset-h_div] >0){
                    if((edgeCount_ch2 > 0) && (edgeTimer2 > 20)){
                        if (edgeDelay2==0){edgeDelay2 = edgeTimer2;
                        } else {
                            edgeDelay2 = (edgeDelay2 + edgeTimer2)/2;
                        }
                    }
                    edgeTimer2=0;
                } 
 
                h_div_count++;
                //for the captured samples
                if(h_div_count==h_div){
                    h_div_count=0;
                    count--;
                    _memory[0][mem_length - count - 1 ] = block->data[offset];
                    peakValue = max(peakValue,abs(block->data[offset]));
                    if (isDualChannel){ 
                        _memory[1][mem_length - count - 1 ] = blockb->data[offset];
                        //peakValue = max(peakValue,abs(blockb->data[offset]));
                        if ((offset >= h_div) && (blockb->data[offset] <= -10 ) && (blockb->data[offset-h_div] > 10)){
                            edgeCount_ch2++;
                        }
                    }else _memory[1][mem_length - count - 1 ] = 0;
 
                    if ((offset >= h_div) && (block->data[offset] <= -10 ) && (block->data[offset-h_div] > 10)){
                        edgeCount++;
                    }
                }
                offset++;
            }
            
            
            if (count == 0){
                //Serial.println(edgeCount);
                    //only update the values if data is available
                    if(peakValue >0){
                        if((edgeCount < 8) && (auto_h_div < 16)) auto_h_div++;
                        if((edgeCount > 11) && (auto_h_div > 1)) auto_h_div--;
                        //calculate the dot product if dual channel
                        if (isDualChannel ){
                            q63_t lastDelta;
                            lastDelta= dotDelta;
                            dotLast = dot/1000000;  
                            arm_dot_prod_q15(&_memory[0][0],&_memory[1][0],mem_length,&dot);
                            dot = dot /1000000;
                            dotDelta = ((dot) - (dotLast));
                            dotAccel = ((dotDelta)-(lastDelta));        
                            dotAvg = (dotAvg/2) + (dot/2);
                            dotAvgSlow = (dotAvg/2) + (dotAvgSlow/2);
                            dotMACD = ((dotAvg) - (dotAvgSlow));
                            //(dotMACD>0)?:dotMACD*=-1;
                            dotDeltaMACD = ((dotMACD) - (dotDeltaMACD));
                            memcpy(&memory[1],&_memory[1],sizeof(_memory[1]));
                        }
                        //buffered outputs
                        memcpy(&memory[0],&_memory[0],sizeof(_memory[0]));
                        edgeCount_output = edgeCount;
                        edgeCount_ch2_output = edgeCount_ch2;
                        dot_output=dot;
                        dotAvg_output=dotAvg;
                        dotLast_output=dotLast;
                        dotAvgSlow_output=dotAvgSlow;
                        dotDelta_output = dotDelta;
                        dotAccel_output=dotAccel;
                        dotDeltaMACD_output=dotDeltaMACD;
                        dotMACD_output=dotMACD;
                        edgeDelay_output=edgeDelay;
                        edgeDelay2_output=edgeDelay2;
                        peakValue_output = peakValue;
                    }
                isAvailable = true;
                if (autoTrigger){
                    trigger();
                }else state = STATE_IDLE;
                trigger_wait_count = 0;
            }
            break;
 
          default: // STATE_IDLE
            offset = AUDIO_BLOCK_SAMPLES;
            break;
        }
    }
    release(block);
    if(isDualChannel) release(blockb);
}

References auto_h_div, autoTrigger, count, audio_block_struct::data, dot, dot_output, dotAccel, dotAccel_output, dotAvg, dotAvg_output, dotAvgSlow, dotAvgSlow_output, dotDelta, dotDelta_output, dotDeltaMACD, dotDeltaMACD_output, dotLast, dotLast_output, dotMACD, dotMACD_output, edgeCount, edgeCount_ch2, edgeCount_ch2_output, edgeCount_output, edgeDelay, edgeDelay2, edgeDelay2_output, edgeDelay_output, edgeTimer, edgeTimer2, h_div, h_div_count, isAvailable, mem_length, peakValue, peakValue_output, AudioStream::receiveReadOnly(), AudioStream::release(), state, trigger(), and trigger_wait_count.

Here is the call graph for this function: