update()

void FLASHMEM AppManager::update

(

)

this is the main update loop for ErisCore

AppManager update executes single update of the state machine.

Definition at line 148 of file AppManager.cpp.

                                {
    elapsedMicros app_time;
    uint32_t heapTop;
    uint32_t drt;
    bool touch_updated;
    bool update_analog;
    AppBaseClass *node;
    bool monitor_update;
    int32_t te; 
    
    te = touched_elapsed;
    
    monitor_update = (monitor_dd_update_timer > APPMANAGER_MONITOR_DD_UPDATE_RATE_MSEC);
    cycle_time=0;
    drt = display_refresh_time; 
    touch_updated = false;
    update_analog = false;
    node = root;
 
    //requestArmSetClock(CPU_BASE_FREQ);
 
    if (node == 0){
      Serial.println(F("AppManager::update called without an application initalized"));
      return;
    }
 
    //update loop is directed by the state variable 
    switch(state){
      case redraw_background:
        app_time=0;
        if (!draw.busy() || 1){
            data->update(RENDER,(int32_t)0);
          if (animated_wallpaper.getNextFrameChunk()){
              requestArmSetClock(CPU_BOOST_MAX_FREQ);
              draw.bltSDAnimationFullScreen(&animated_wallpaper);
              data->update(AM_REDRAW_BG,(int32_t)app_time);
              requestArmSetClock(CPU_BASE_FREQ);
          } else Serial.println(F("M bad chunk"));
        }
        if ((data->read(RENDER) == 0) && animated_wallpaper.isFrameComplete()){
          data->update(RENDER,(int32_t)1);
          state = redraw_objects;
        }
        break;
        
      case redraw_wait://idle render time to give the screen refresh a head start
        if(exclusive_app_render && (draw.busy()==false || drt > 40)) state = redraw_objects;
        else if(!exclusive_app_render && (draw.busy()==false || drt > 24)) state = redraw_background;
        //execute on next state transition
        if (state != redraw_wait){
          //update analog inputs
          update_analog = analog.update();
          touch.update();
          touch_updated = true;    
          //note: this is  a good place for application manager housekeeping tasks where screen access is not required
          data->update(AM_AUDIO_CPU_MAX,(float32_t)AudioProcessorUsageMax());
          float32_t cpu;
          cpu = AudioProcessorUsage();
          data->update(AM_AUDIO_CPU,(float32_t)cpu);
          data->update(AM_AUDIO_MEM_MAX,(int32_t)AudioMemoryUsageMax());
          data->update(AM_AUDIO_MEM,(int32_t)AudioMemoryUsage());
        }
        break;
 
      case redraw_render:
        PXP_finish(); //make sure any PXP operations are complete
        //draw.updateScreenAsync(false);
        if(draw.busy()==false){
          draw.updateScreenAsyncFrom(&draw,false);
          data->update(RENDER_PERIOD,(int32_t)drt);
          data->update(RENDER,(int32_t)4);
          data->increment(RENDER_FRAME);
          app_time=0;
          state = redraw_wait;
          display_refresh_time = 0;
        }
        break;
 
      case redraw_objects:      
        node = root;
        if (exclusive_app_render == false){
          do{
              app_time=0;
              if (node->et_render_period > node->render_period_max) node->render_period_max = node->et_render_period;
              node->render(); //update active window
              node->render_cpu_time = app_time;
              if (node->render_cpu_time > node->render_cpu_time_max){
                  node->render_cpu_time_max = node->render_cpu_time;
              }
              //update the data dictionary
              node->et_render_period =0;
              node=node->next_app_node;//check next node
            }while(node !=NULL);
        };
        data->update(RENDER,(int32_t)2);
        data->increment(UPDATE_CALLS);
        state = redraw_popup;
        break;
 
      case redraw_popup:
        app_time=0;
        //draw any popups
        if (!app_popup_stack_index==0 && app_popup_stack[app_popup_stack_index-1] != 0){
          node = getApp(app_popup_stack[app_popup_stack_index-1]);
          if (node != 0){
            //Serial.println(F("AppManager::redraw_popup"));
            node->render();
          }
        }
        data->update(RENDER,(int32_t)3);
        state = redraw_render;     
        break;
    }
    //always call the apps updateRT function on every loop
    
    data->increment(RT_CALLS);
    node = root;
    bool isactive_child;
    do{
      app_time=0;
      if (node->update_priority > node->update_priority_counter){
        node->update_priority_counter++;
      }else{
        node->update_priority_counter = 0;
        if (node->et_update_period > node->update_period_max) node->update_period_max = node->et_update_period;
        node->update(); //real time update (always called)
        node->update_cpu_time = app_time;
        if (node->update_cpu_time > node->update_cpu_time_max) node->update_cpu_time_max = node->update_cpu_time;
        node->et_update_period =0;
      }
      isactive_child = false;
      if (node->id == active_app_id && !draw.busy()) {
          if (p_active_app != node){
            if (p_active_app != 0) p_active_app->onFocusLost();
            node->onFocus();
            p_active_app = node;
          }
      }
      if (node->parent_node!=NULL){if(node->parent_node->id == active_app_id){isactive_child = true;}}; //send event triggers to any child apps
      if (node->id == active_app_id || isactive_child) {
          //Serial.print("AppManager::updating active application");Serial.println(active_app_id);
          //trigger any events and then call the update function for this 'active' app or child node
          if (update_analog){
            data->update(AM_AN1,(int32_t)analog.readAN1());
            data->update(AM_AN2,(int32_t)analog.readAN2());
            data->update(AM_AN3,(int32_t)analog.readAN3());
            data->update(AM_AN4,(int32_t)analog.readAN4());
            
            node->onAnalog1(analog.readAN1(),analog.freadAN1());
            node->onAnalog2(analog.readAN2(),analog.freadAN2());
            node->onAnalog3(analog.readAN3(),analog.freadAN3());
            node->onAnalog4(analog.readAN4(),analog.freadAN4());
          }
          data->update("TOUCHED_ELAPSED",(int32_t)te);
          if (touch_updated == true && touch.touched()) {
            p = touch.getPoint();
            data->update("TOUCH_Z",(int32_t)p.z);
            
            if ((node->touch_state == 0) && (te > 250) ){
                node->onTouch(p.x, p.y);
                node->touch_state=1;
                touched_elapsed = 0;
            } else{
                node->onTouchDrag(p.x, p.y);
            }
          } else if (node->touch_state==1){
            node->touch_state=0;
            node->onTouchRelease(p.x, p.y);
          }
      }
      node->cycle_time = cycle_time;
      if (node->cycle_time > node->cycle_time_max){
          node->cycle_time_max = node->cycle_time;
      }
      node=node->next_app_node;//check next node
    }while(node !=NULL);
 
    if (cycle_time > cycle_time_max){
      cycle_time_max = cycle_time;
    } else{
      //delayMicroseconds((cycle_time_max - cycle_time)/100);
    }
    
    if(monitor_update){
      monitor_dd_update_timer = 0;
      data->update(AM_LOOP_TIME,(int32_t)cycle_time_max);
      data->update(AM_SERIAL_AVAIL,(int32_t)Serial.availableForWrite());
      //data->update("FRAME_PTR1",(int32_t)draw.getFrameAddress());
      //data->update("FRAME_PTR2",(int32_t)render.getFrameAddress());
      int32_t free_mem;
      void* htop;
      free_mem = 1000;
      cycle_time_max*=0.999;
      htop = malloc(1000);
      while (htop){
        //memset(htop,0x5A,1000);
        heapTop = (uint32_t) htop;
        free(htop);
        free_mem += 1000;
        htop = malloc(free_mem);
      }
      
      data->update(FREE_MEM,(int32_t)(free_mem - 1000));
      data->update(FREE_HEAP,(int32_t)(0x20280000 - heapTop));
      data->update(FREE_LOCAL,(int32_t)(0x2007F000 - (uint32_t)(&heapTop)));
      data->update(FREE_STACK,(int32_t)FreeStack());
       
      heapTop = 0;
      data->update(CPU_TEMP,(float32_t)tempmonGetTemp());
      AudioProcessorUsageMaxReset();
      AudioMemoryUsageMaxReset();    
    }
};

References active_app_id, analog, animated_wallpaper, app_popup_stack, app_popup_stack_index, ILI9341_t3_ERIS::bltSDAnimationFullScreen(), ILI9341_t3_ERIS::busy(), AppBaseClass::cycle_time, cycle_time, AppBaseClass::cycle_time_max, cycle_time_max, data, display_refresh_time, draw, AppBaseClass::et_render_period, AppBaseClass::et_update_period, exclusive_app_render, AnalogInputs::freadAN1(), AnalogInputs::freadAN2(), AnalogInputs::freadAN3(), AnalogInputs::freadAN4(), getApp(), Animation::getNextFrameChunk(), Touch::getPoint(), AppBaseClass::id, SvcDataDictionary::increment(), Animation::isFrameComplete(), monitor_dd_update_timer, AppBaseClass::next_app_node, AppBaseClass::onAnalog1(), AppBaseClass::onAnalog2(), AppBaseClass::onAnalog3(), AppBaseClass::onAnalog4(), AppBaseClass::onFocus(), AppBaseClass::onFocusLost(), AppBaseClass::onTouch(), AppBaseClass::onTouchDrag(), AppBaseClass::onTouchRelease(), p, p_active_app, AppBaseClass::parent_node, PXP_finish(), SvcDataDictionary::read(), AnalogInputs::readAN1(), AnalogInputs::readAN2(), AnalogInputs::readAN3(), AnalogInputs::readAN4(), redraw_background, redraw_objects, redraw_popup, redraw_render, redraw_wait, AppBaseClass::render(), AppBaseClass::render_cpu_time, AppBaseClass::render_cpu_time_max, AppBaseClass::render_period_max, requestArmSetClock(), root, state, touch, AppBaseClass::touch_state, Touch::touched(), touched_elapsed, AnalogInputs::update(), AppBaseClass::update(), Touch::update(), SvcDataDictionary::update(), AppBaseClass::update_cpu_time, AppBaseClass::update_cpu_time_max, AppBaseClass::update_period_max, AppBaseClass::update_priority, AppBaseClass::update_priority_counter, and ILI9341_t3_ERIS::updateScreenAsyncFrom().

Referenced by loop().

Here is the call graph for this function:

Here is the caller graph for this function: