error.c

Go to the documentation of this file.

#include <includes.h>

#ifndef __VERSION_0_1__
#warning RangerOS mismatch, expected v0.1. 
#endif


static volatile ERROR_BUFFER er_buffer; 
static volatile ERROR_INFO* er_active; 
static VOID_VOID_F er_transmit = voidvoid; 
static INT_VOID_F er_get_timestamp = intvoid; 
static BOARD_ID er_board_id; 
static int er_is_init = 0; 
static const int er_length = ((int)(ERROR_LAST_ID)/32)+1; 
static volatile unsigned int er_flags[er_length]; 
void error_init(VOID_VOID_F transmit_function, INT_VOID_F timestamp_function, BOARD_ID board_id)
{
  er_buffer.first = 0;
  er_buffer.next = 0;
  er_buffer.overflows = 0;
  er_buffer.empty = 1;
  er_transmit = transmit_function;
  er_get_timestamp = timestamp_function;
  er_board_id = board_id;
  er_is_init = 1;
}

MUTEX er_mutex;
void error_occurred(ERROR_ID error_code)
{
  volatile int index, bit;
  if (er_is_init){//make sure error module has been initialized first
    volatile int index, bit;
    if (!mutex_check(&er_mutex)){
      mutex_lock(&er_mutex);
      index = (int)(error_code) / 32;
      bit = (int)(error_code) % 32;
      er_flags[index] |= (1<<bit);
   //   mcu_led_red_blink(100);
      mutex_unlock(&er_mutex);
    } else {
    }
  }
}

MUTEX er_irq_mutex;
void error_occurred_irq(ERROR_ID error_code)
{
  volatile int index, bit;
  if (er_is_init){//make sure error module has been initialized first
    if (!mutex_check(&er_irq_mutex)){
      mutex_lock(&er_irq_mutex);
      index = (int)(error_code) / 32;
      bit = (int)(error_code) % 32;
      er_flags[index] |= (1<<bit);
   //   mcu_led_red_blink(100);
      mutex_unlock(&er_irq_mutex);
    } else {
    }
  }
}
MUTEX er_fiq_mutex;
void error_occurred_fiq(ERROR_ID error_code)
{
  volatile int index, bit;
  if (er_is_init){ //make sure error module has been initialized first
    if (!mutex_check(&er_fiq_mutex)){
      mutex_lock(&er_fiq_mutex);
      index = (int)(error_code) / 32;
      bit = (int)(error_code) % 32;
      er_flags[index] |= (1<<bit);
   //   mcu_led_red_blink(100);
      mutex_unlock(&er_fiq_mutex);
    } else {
    }
  }
}

void error_update(void){
  int chunk, bit;
  int index;
  int found = 0;
  ERROR_ID error_code;
  volatile ERROR_BUFFER* buf;
  volatile ERROR_INFO new_error; 
  
  if (er_is_init){ //make sure error module has been initialized first
    for (chunk = 0; chunk < er_length; chunk++){
      if (er_flags[chunk]){
        for (bit = 0; bit < 32; bit++){
          if (er_flags[chunk] & (1<<bit)){
            error_code = (ERROR_ID)(bit + (32 * chunk));
            
            buf = &er_buffer;
            
            // ********* CHECK IF ERROR ALREADY OCCURRED ***********
            if (!(buf->empty)){ //only traverse if the buffer has stuff in it
              index = buf->first;
              while (index != buf->next) { //traverse the buf of errors to see if this error has already been generated
                if (buf->errors[index].error_id == error_code) { //we've had this error before since the last time we sent info
                  buf->errors[index].frequency++; //if it has, increase the frequency
                  found = 1;
                  break;
                }
                if (index + 1 >= ERR_BUF_SIZE){
                  index = 0;
                } else {
                  index++;
                }
              }
            }
            
            // ********** ADD NEW ERROR TO BUFFER *********
            if (!found) { //we haven't seen this error before, add it to the ring buffer
              new_error.error_id = error_code;
              new_error.frequency = 1;
              new_error.time_occurred = er_get_timestamp(); //will hold actual value when sent out; this is just the initial time
              error_push(buf, new_error); //will new_error be out of scope here and be meaningless? TOMMY HELP!!
            } 
          }
        }
        er_flags[chunk] = 0;
      }  
    } 
  } 
}

static void error_push(volatile ERROR_BUFFER* buffer, volatile ERROR_INFO new_error)
{ 
  // ****** CHECK FOR OVERFLOW ******
  if ((buffer->next == buffer->first) && !(buffer->empty)){ //the front has caught up to the tail!! it's eating itself!! nooooo
    buffer->overflows++;
    if (buffer->first + 1 >= ERR_BUF_SIZE){
      buffer->first = 0;
    } else {
      buffer->first++;
    }
  }
  // ****** ADD NEW DATA ****** 
  buffer->errors[buffer->next] = new_error;
  if (buffer->next + 1 >= ERR_BUF_SIZE){
    buffer->next = 0;
  } else {
    buffer->next++;
  }
  buffer->empty = 0; //buffer now has stuff in it
}

static volatile ERROR_INFO* error_pop(volatile ERROR_BUFFER* buffer)
{
  volatile ERROR_INFO* err = 0;
  if (!buffer->empty){
    err = &(buffer->errors[buffer->first]);
    if (buffer->first + 1 >= ERR_BUF_SIZE){
      buffer->first = 0;
    } else {
      buffer->first++;
    }
    buffer->overflows = 0;    
    if (buffer->first == buffer->next){
      buffer->empty = 1;
    }
  } 
  return err;
}

int error_get_time(void)
{
  if (er_is_init){ //make sure error module has been initialized first
    return (int)(er_active->time_occurred); 
  } else {
    return 0;
  }
}
int error_get_info(void)
{
  if (er_is_init){ //make sure error module has been initialized first
    long int info = (er_active->error_id & 0xFFFF) | ((er_board_id & 0x3F) << 16) | ((er_active->frequency & 0x3FF) << 22);
    return info;
  } else {
    return 0;
  }
}

BOARD_ID error_get_board(void)
{
  return er_board_id;
}

ERROR_ID error_get_id(void)
{
  if (er_is_init){ //make sure error module has been initialized first
    return (ERROR_ID)er_active->error_id;
  } else {
    return ERROR_DEFAULT;
  }
}

int error_get_frequency(void)
{
  if (er_is_init){ //make sure error module has been initialized first
    return er_active->frequency;
  } else {
    return 0;
  }
}
 
void error_send_next(void)
{
  if (er_is_init){ //make sure error module has been initialized first
    if (!er_buffer.empty){
      er_active = error_pop(&er_buffer);
      if (er_active != 0){
        er_transmit();
      }
    }
  }
}