// "Default" should be replaced by the name of the network.
  // Defines NN_Instance_Default and NN_Interface_Default with network.c informations
  LL_ATON_DECLARE_NAMED_NN_INSTANCE_AND_INTERFACE(Default) 

void LL_ATON_RT_RuntimeInit(void);
void LL_ATON_RT_RuntimeDeInit(void);

void LL_ATON_RT_Init_Network(NN_Instance_TypeDef *nn_instance);
void LL_ATON_RT_DeInit_Network(NN_Instance_TypeDef *nn_instance);

LL_ATON_RT_RetValues_t LL_ATON_RT_RunEpochBlock(NN_Instance_TypeDef *nn_instance);

void LL_ATON_RT_SetEpochCallback(TraceEpochBlock_FuncPtr_t epoch_block_callback, NN_Instance_TypeDef *nn_instance);   // will be deprecated
void LL_ATON_RT_SetNetworkCallback(NN_Instance_TypeDef *nn_instance, TraceEpochBlock_FuncPtr_t epoch_block_callback);
void LL_ATON_RT_SetRuntimeCallback(TraceRuntime_FuncPtr_t rt_callback);

  ...
  // Epoch callback setup
  LL_ATON_RT_SetEpochCallback ( EpochBlock_TraceCallBack , nn_instance_pnt ) ; // deprecated in future releases
  LL_ATON_RT_SetNetworkCallback ( nn_instance_pnt, EpochBlock_TraceCallBack ) ;
....


void EpochBlock_TraceCallBack ( LL_ATON_RT_Callbacktype_t ctype , const NN_Instance_TypeDef *nn_instance , const EpochBlock_ItemTypeDef *eb )
{
  switch ( ctype ) {
           case LL_ATON_RT_Callbacktype_PRE_START :
                TOGGLE_EPOCH_PIN ; // Trace epoch pin for oscilloscope
           break ;
           case LL_ATON_RT_Callbacktype_POST_END :

                // If needed dump intermediate activations
                checkEpochOutputs ( eb -> epoch_num ) ;
           break ;
           case LL_ATON_RT_Callbacktype_NN_Init :

                // Capture network start time
                inferenceBaseTime = dwtGetCycles() ;
           break ;
           default :
                return ;
           break ;
  } /* endswitch */
} // end of EpochBlock_TraceCallBack() function

void checkEpochOutputs ( uint32_t epochNum )
{
  for ( int idx = 0 ; idx < bufferListlen ; idx++ ) {

        if ( bufferList [ idx ] -> epoch == epochNum ) {
             // print the activations info and/or the activation data related to the current epoch
             // It is expected that bufferList and bufferListlen have been previously initialized
             printBuffer ( bufferList [ idx ]  ) ;
        } /* endif */
  } /* endfor */
  
} // end of checkEpochOutputs() function

const LL_Buffer_InfoTypeDef *LL_ATON_Output_Buffers_Info(const NN_Instance_TypeDef *nn_instance);
const LL_Buffer_InfoTypeDef *LL_ATON_Input_Buffers_Info(const NN_Instance_TypeDef *nn_instance);
const LL_Buffer_InfoTypeDef *LL_ATON_Internal_Buffers_Info(const NN_Instance_TypeDef *nn_instance);
// And utilities:
unsigned char *LL_Buffer_addr_start(const LL_Buffer_InfoTypeDef *buf);
unsigned char *LL_Buffer_addr_end(const LL_Buffer_InfoTypeDef *buf);
uint32_t LL_Buffer_len(const LL_Buffer_InfoTypeDef *buf);

// Inputs
LL_ATON_User_IO_Result_t LL_ATON_Set_User_Input_Buffer(const NN_Instance_TypeDef *nn_instance, uint32_t num, void *buffer, uint32_t size);
void *LL_ATON_Get_User_Input_Buffer(const NN_Instance_TypeDef *nn_instance, uint32_t num);
// Outputs
LL_ATON_Set_User_Output_Buffer(const NN_Instance_TypeDef *nn_instance, uint32_t num, void *buffer, uint32_t size);
void *LL_ATON_Get_User_Output_Buffer(const NN_Instance_TypeDef *nn_instance, uint32_t num);

void LL_ATON_RT_Main(NN_Instance_TypeDef *network_instance);

void LL_ATON_RT_Main(NN_Instance_TypeDef *network_instance)
{
  LL_ATON_RT_RetValues_t ll_aton_rt_ret;

  /*** Start of user initialization code ***/

  /*** End of user initialization code ***/

  assert(network_instance != NULL);
  assert(network_instance->network != NULL);
  LL_ATON_RT_RuntimeInit();                  // Initialize runtime
  LL_ATON_RT_Init_Network(network_instance); // Initialize passed network instance object

  do
  {
    /* Execute first/next step of Cube.AI/ATON runtime */
    ll_aton_rt_ret = LL_ATON_RT_RunEpochBlock(network_instance);

    /*** Start of user event handling code ***/

    /*** End of user event handling code ***/

    /* Wait for next event */
    if (ll_aton_rt_ret == LL_ATON_RT_WFE)
    { /*** subject to change to fit also user code requirements ***/
      LL_ATON_OSAL_WFE();
    }
  } while (ll_aton_rt_ret != LL_ATON_RT_DONE); /*** subject to change to fit also user code requirements ***/

  LL_ATON_RT_DeInit_Network(network_instance); // De-initialize the network instance object
  LL_ATON_RT_RuntimeDeInit();                  // De-initialize runtime

  /*** Start of user de-initialization code ***/

  /*** End of user de-initialization code ***/
}

/* Define mutex and threads attributes */

osMutexId_t mutex_id ;

const osMutexAttr_t mutex_attr = {
    "myMutex",  // name of the mutex
    0,          // attr_bits
    NULL,       // memory for control block
    0           // size for control block
} ;

osThreadId_t Thread1Handle;
const osThreadAttr_t Thread1_attributes = {
  .name = "A",
  .priority = (osPriority_t) osPriorityNormal,
  .stack_size = 256 * 8
};

osThreadId_t Thread2Handle;
const osThreadAttr_t Thread2_attributes = {
  .name = "B",
  .priority = (osPriority_t) osPriorityNormal,
  .stack_size = 256 * 8
};

// Main thread

void mainthread_func(void* arg)
{
  mutex_id = osMutexNew ( &mutex_attr ) ;

  if ( mutex_id == NULL ) {
       while ( 1 ) ;
  }
  
  Thread1Handle = osThreadNew ( thread1_func , NULL , &Thread1_attributes ) ;
  Thread2Handle = osThreadNew ( thread2_func , NULL , &Thread2_attributes ) ;
  
  while ( 1 ) ;
}

// thread 1: intialize and handle atonn_mnist network

void thread1_func(void* arg)
{
  int   testok ;
  void* output_buffer ;
  void* input_buffer ;
  int   output_buffer_len ;
  int   input_buffer_len ;
  LL_ATON_RT_RetValues_t ll_aton_rt_ret ;

  LL_ATON_DECLARE_NAMED_NN_INSTANCE_AND_INTERFACE ( atonn_mnist ) ; // Network instance

  /* Get Input/Output buffers */

  input_buffer      = (void*)(inbufs[0].addr_base.i + inbufs[0].offset_start);
  input_buffer_len  = inbufs[0].offset_end - outbufs[0].offset_start;
  output_buffer     = (void*)(outbufs[0].addr_base.i + outbufs[0].offset_start);
  output_buffer_len = outbufs[0].offset_end - outbufs[0].offset_start;

  LL_ATON_RT_Init_Network ( &NN_Instance_atonn_mnist ) ;

  testok = 1 ;

  while ( testok ) {

          get_atonn_mnist_features ( input_buffer , input_buffer_len ) ;

          LL_ATON_RT_Reset_Network ( &NN_Instance_atonn_mnist ) ;

          do {
               ll_aton_rt_ret = LL_ATON_RT_RunEpochBlock ( &NN_Instance_atonn_mnist ) ;

               if ( ll_aton_rt_ret  == LL_ATON_RT_WFE ) {
                    LL_ATON_OSAL_WFE();
               }
          } while ( ll_aton_rt_ret != LL_ATON_RT_DONE ) ;

          post_process_atonn_mnist_inference ( output_buffer , output_buffer_len ) ;
  }
}

void thread2_func(void* arg)
{
  int   testok ;
  void* output_buffer ;
  void* input_buffer ;
  int   output_buffer_len ;
  int   input_buffer_len ;
  LL_ATON_RT_RetValues_t ll_aton_rt_ret ;

  LL_ATON_DECLARE_NAMED_NN_INSTANCE_AND_INTERFACE ( atonn_mnist5x5 ) ; // Network instance

  /* Get Input/Output buffers */
  const LL_Buffer_InfoTypeDef *inbufs  = LL_ATON_Input_Buffers_Info_atonn_mnist5x5();
  const LL_Buffer_InfoTypeDef *outbufs = LL_ATON_Output_Buffers_Info_atonn_mnist5x5();

  input_buffer      = (void*)(inbufs[0].addr_base.i + inbufs[0].offset_start);
  input_buffer_len  = inbufs[0].offset_end - outbufs[0].offset_start;
  output_buffer     = (void*)(outbufs[0].addr_base.i + outbufs[0].offset_start);
  output_buffer_len = outbufs[0].offset_end - outbufs[0].offset_start;

  LL_ATON_RT_Init_Network ( &NN_Instance_atonn_mnist5x5 ) ;

  testok = 1 ;

  while ( testok ) {

          get_atonn_mnist5x5_features ( input_buffer , input_buffer_len ) ;

          LL_ATON_RT_Reset_Network ( &NN_Instance_atonn_mnist5x5 ) ;

          do {
               ll_aton_rt_ret = LL_ATON_RT_RunEpochBlock ( &NN_Instance_atonn_mnist5x5 ) ;

               if ( ll_aton_rt_ret  == LL_ATON_RT_WFE ) {
                    LL_ATON_OSAL_WFE();
               }
          } while ( ll_aton_rt_ret != LL_ATON_RT_DONE ) ;

          post_process_atonn_mnist5x5_inference ( output_buffer , output_buffer_len ) ;
  }
}

    osMutexAcquire ( mutex_id , osWaitForever ) ;
    ....
    osMutexRelease ( mutex_id ) ;