Пример #1
0
void trtSignal(uint8_t semnbr) {

  uint8_t i;
  struct task *t;
  uint32_t minDeadline = 0xFFFFFFFF;
  uint8_t taskToReadyQ = 0;

  cli(); // disable interrupts

  for (i=1; i <= kernel.nbrOfTasks; i++) {
    t = &kernel.tasks[i];
    if (t->state == (semnbr + WAIT_OFFSET)) {
      if (t->deadline <= minDeadline) {
	taskToReadyQ = i;
	minDeadline = t->deadline;
      }
    }
  }

  if (taskToReadyQ == 0) {
    kernel.semaphores[semnbr-1]++;
  } else {
    kernel.tasks[taskToReadyQ].state = READYQ; // make task ready
    // call interrupt handler to schedule
	TIMER1_COMPA_vect();
  }

  sei(); // reenable interrupts
}
Пример #2
0
void Posixino::timerThread() {

    while (true) {

        usleep(1000);

        for (int n = 0; n < 3; n++) {
            if (interruptCounter[n] < 0) continue;

            interruptCounter[n] += 1000;
            if (interruptCounter[n] < interruptTiming[n]) continue;
            interruptCounter[n] -= interruptTiming[n];

            if (n == 0) {
# ifdef TIMER0
                TIMER0_COMPA_vect();
# endif
            }
            if (n == 1) {
# ifdef TIMER1
                TIMER1_COMPA_vect();
# endif
            }
            if (n == 2) {
# ifdef TIMER2
                TIMER2_COMPA_vect();
# endif
            }

        } // for interrupts
    } // forever

} // timerThread()
Пример #3
0
void trtTerminate(void) {

  cli();

  kernel.tasks[kernel.running].state = TERMINATED;

  // call interrupt handler to schedule
  TIMER1_COMPA_vect();
}
Пример #4
0
void trtSleepUntil(uint32_t release, uint32_t deadline) {

  struct task *t;

  t = &kernel.tasks[kernel.running];

  cli(); // turn off interrupts

  t->state = TIMEQ;
  t->release = release;
  t->deadline = deadline;
  
  // call interrupt handler to schedule
  TIMER1_COMPA_vect();
}
Пример #5
0
static void timer1_isr(void) {
  const uint8_t tr = timer_reason;
  if ( ! sim_interrupts) {
    // Interrupts disabled. Schedule another callback in 10us.
    schedule_timer(10);
    return;
  }
  timer_reason = 0;

  cli();

  #ifdef SIM_DEBUG
    uint64_t now = now_ns();
    static unsigned int cc_1s = 0, prev_1s = 0;

    if ( ! clock_counter_1s && prev_1s) ++cc_1s;
    prev_1s = clock_counter_1s;

    //uint16_t now = sim_tick_counter();
    uint64_t real = (now-begin) / 1000;
    uint64_t avr = cc_1s * 4 + clock_counter_1s;
    avr *= 250;
    avr += clock_counter_250ms * 10;
    avr += clock_counter_10ms;
    avr *= 1000 ;
    printf("test: Real: %us %u.%03ums   AVR: %us %u.%03ums    Real/AVR: %u\n",
           real / 1000000 , (real % 1000000)/1000 , real % 1000 ,
           avr / 1000000  , (avr  % 1000000)/1000 , avr  % 1000 ,
           real / (avr?avr:1) );
    printf("test: 10ms=%u 250ms=%u 1s=%u  total=%luns actual=%luns\n",
           clock_counter_10ms, clock_counter_250ms, clock_counter_1s,
           now - begin, now - then, sim_runtime_ns());
    //printf("          timer1_isr    tick_time=%04X  now=%04X  delta=%u  total=%u\n",
    //       TICK_TIME , now, now_us() - then, (now_us() - begin)/1000000 ) ;
    then = now;
  #endif

  if (tr & TIMER_OCR1A) TIMER1_COMPA_vect();
  if (tr & TIMER_OCR1B) TIMER1_COMPB_vect();

  sei();

  // Setup next timer
  sim_timer_set();
}
Пример #6
0
void trtWait(uint8_t semnbr) {

  struct task *t;
  uint8_t *s;

  t = &kernel.tasks[kernel.running];

  cli(); // disable interrupts

  s = &kernel.semaphores[semnbr-1];
  if ((*s) > 0) {
    (*s)--;
  } else {

    t->state = semnbr + WAIT_OFFSET; // waiting for Sem#semnbr
    // call interrupt handler to schedule
	TIMER1_COMPA_vect();
  }

  sei(); // reenable interrupts
}
Пример #7
0
void trtCreateTask(void (*fun)(void*), uint16_t stacksize, uint32_t release, uint32_t deadline, void *args) {

  uint8_t *sp;
  struct task *t;
  int i;

  cli(); // turn off interrupts

  ++kernel.nbrOfTasks;

  sp = kernel.memptr;
  kernel.memptr -= stacksize;  // decrease free mem ptr

  // initialize stack
  *sp-- = lo8(fun);       // store PC(lo)
  *sp-- = hi8(fun);       // store PC(hi)
  for (i=0; i<25; i++)    //WAS -- for (i=0; i<24; i++)
    *sp-- = 0x00;         // store SREG,r0-r1,r3-r23

  // Save args in r24-25 (input arguments stored in these registers)
  *sp-- = lo8(args);
  *sp-- = hi8(args);

  for (i=0; i<6; i++)
    *sp-- = 0x00;         // store r26-r31

  t = &kernel.tasks[kernel.nbrOfTasks];

  t->release = release;
  t->deadline = deadline;
  t->state = TIMEQ;

  t->spl = lo8(sp);       // store stack pointer
  t->sph = hi8(sp);
  
  // call interrupt handler to schedule
  TIMER1_COMPA_vect();

}
Пример #8
0
void sim_check_interrupts()
{
    unsigned int ticks = SDL_GetTicks();
    int tickDiff = ticks - prevTicks;
    prevTicks = ticks;
    
    if (!(SREG & _BV(SREG_I)))
        return;

#ifdef ENABLE_ULTILCD2
    if ((TWCR & _BV(TWEN)) && (TWCR & _BV(TWINT)) && (TWCR & _BV(TWIE)))
    {
        //Relay the TWI interrupt by 25ms one time till it gets disabled again. This fakes the LCD refresh rate.
        if (twiIntStart == 0)
            twiIntStart = SDL_GetTicks();
        if (SDL_GetTicks() - twiIntStart > 25)
        {
            cli();
            TWI_vect();
            _sei();
        }
    }
    if (!(TWCR & _BV(TWEN)) || !(TWCR & _BV(TWIE)))
    {
        twiIntStart = 0;
    }
#endif
    
    //if (tickDiff > 1)
    //    printf("Ticks slow! %i\n", tickDiff);
    if (tickDiff > 0)
    {
        ms_callback();
    
        cli();
        for(int n=0;n<tickDiff;n++)
        {
            if (TIMSK0 & _BV(OCIE0B))
                TIMER0_COMPB_vect();
            if (TIMSK0 & _BV(TOIE0))
                TIMER0_OVF_vect();
        }
        
        //Timer1 runs at 16Mhz / 8 ticks per second.
        unsigned int waveformMode = ((TCCR1B & (_BV(WGM13) | _BV(WGM12))) >> 1) | (TCCR1A & (_BV(WGM11) | _BV(WGM10)));
        unsigned int clockSource = TCCR1B & (_BV(CS12) | _BV(CS11) | _BV(CS10));
        unsigned int tickCount = F_CPU * tickDiff / 1000;
        unsigned int ticks = TCNT1;
        switch(clockSource)
        {
        case 0: tickCount = 0; break;
        case 1: break;
        case 2: tickCount /= 8; break;
        case 3: tickCount /= 64; break;
        case 4: tickCount /= 256; break;
        case 5: tickCount /= 1024; break;
        case 6: tickCount = 0; break;
        case 7: tickCount = 0; break;
        }
        tickCount *= 4;//For some reason the stepper speed is to slow, so cheat the timer routine.
        
        if (tickCount > 0 && OCR1A > 0)
        {
            ticks += tickCount;
            while(ticks > int(OCR1A))
            {
                ticks -= int(OCR1A);
                if (TIMSK1 & _BV(OCIE1A))
                    TIMER1_COMPA_vect();
            }
            TCNT1 = ticks;
        }
        _sei();
    }