void NSFOSThread::sleep(UInt32 sleepTime)
{
static cyg_resolution_t timerResolution = cyg_clock_get_resolution(cyg_real_time_clock());
// Assumes cyg_clock_get_resolution(cyg_real_time_clock()).divisor is in Hz (ticks/sec), as per documentation.
cyg_thread_delay(((sleepTime * timerResolution.divisor) + 999) / 1000);
}
void init_scheduler(void)
{
int rtc_ticks_per_sec;
/* get handle to the system realtime clock */
rtclock = cyg_real_time_clock ();
rtc_resolution = cyg_clock_get_resolution ( rtclock );
rtc_ticks_per_sec = rtc_resolution.divisor;
cyg_clock_to_counter ( rtclock, &rtc_counter );
// Real time clock frequency must be changed in eCos configuration, as there is another
// macro that depends on its value.
//fprintf ( stderr, "cyg_realtime_clock() resolution: dividend=%d, \t divisor=%d\n", rtc_resolution.dividend, rtc_resolution.divisor );
// Create alarms
cyg_alarm_create ( rtc_counter, alarm_handlerfn_daq,0,&alarm_hdl[0],&alarm_obj[0] );
cyg_alarm_create ( rtc_counter, alarm_handlerfn_actuators,0,&alarm_hdl[1],&alarm_obj[1] );
cyg_alarm_create ( rtc_counter, alarm_handlerfn_thread1,0,&alarm_hdl[2],&alarm_obj[2] );
// Initialize conditional variables
pthread_cond_init (&trigger_daq, NULL);
pthread_cond_init (&trigger_actuators, NULL);
pthread_cond_init (&trigger_thread1, NULL);
// Start alarms
// DAQ, executes at t0 + 0.0000
cyg_alarm_initialize ( alarm_hdl[0], DAQ_OFFSET*rtc_ticks_per_sec, rtc_ticks_per_sec/BASE_HZ );
// ACTUATORS, executes at t0 + 0.014
cyg_alarm_initialize ( alarm_hdl[1], ACTUATORS_OFFSET*rtc_ticks_per_sec, rtc_ticks_per_sec/BASE_HZ);
// Thread1, executes at t0 + 0.0130
cyg_alarm_initialize ( alarm_hdl[2], THREAD1_OFFSET*rtc_ticks_per_sec, rtc_ticks_per_sec/THREAD1_HZ );
}
/*
* sys_init - System-dependent initialization.
*/
void
sys_init()
{
if( sockfd == -1 )
{
/* Get an internet socket for doing socket ioctl's on. */
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
syslog(LOG_ERR, "Couldn't create IP socket: %d",errno);
die(1);
}
}
ppp_tty.pppd_wakeup = 0;
ppp_tty.pppd_thread_running = true;
ppp_rtc = cyg_real_time_clock();
ppp_rtc_resolution = cyg_clock_get_resolution( ppp_rtc );
cyg_alarm_create( ppp_rtc,
wait_input_alarm,
(cyg_addrword_t)&ppp_tty,
&ppp_tty.alarm,
&ppp_tty.alarm_obj);
}
void kclock0_main(void)
{
CYG_TEST_INIT();
CHECK(flash());
CHECK(flash());
cyg_counter_create( &counter0, &counter0o);
CHECK( 0 == cyg_counter_current_value( counter0 ) );
cyg_counter_tick(counter0);
CHECK( 1 == cyg_counter_current_value(counter0) );
cyg_counter_tick(counter0);
CHECK( 2 == cyg_counter_current_value(counter0) );
cyg_counter_set_value( counter0, 0xffffffff );
CHECK( 0xffffffff == cyg_counter_current_value(counter0) );
cyg_counter_tick(counter0); // Overflows 32 bits
CHECK( 0x100000000ULL == cyg_counter_current_value(counter0) );
cyg_counter_set_value(counter0, 11);
CHECK( 11 == cyg_counter_current_value(counter0) );
/* the call_me functions cause the "called" bits to toggle
// checking the value of called checks the parity of # of calls
// made by each alarm.
*/
cyg_alarm_create(counter0,
call_me, (cyg_addrword_t)0x1, &alarm0, &alarmo[0]);
cyg_alarm_create(counter0,
call_me, (cyg_addrword_t)0x2, &alarm1, &alarmo[1]);
cyg_alarm_create(counter0,
call_me2, (cyg_addrword_t)0x4, &alarm2, &alarmo[2]);
CHECK( 0x00 == called );
cyg_alarm_initialize(alarm0, 12,3);
cyg_alarm_initialize(alarm2, 21,2);
CHECK( 0x00 == called );
cyg_counter_tick(counter0); /* 12 a0 */
CHECK( 0x01 == called );
cyg_alarm_initialize(alarm1, 13,0);
cyg_counter_tick(counter0); /* 13 a1 */
CHECK( 0x03 == called );
cyg_alarm_initialize(alarm1, 17,0);
cyg_counter_tick(counter0); /* 14 */
CHECK( 0x03 == called );
cyg_counter_tick(counter0); /* 15 a0 */
CHECK( 0x02 == called );
cyg_counter_tick(counter0); /* 16 */
cyg_counter_tick(counter0); /* 17 a1 */
CHECK( 0x00 == called );
cyg_counter_tick(counter0); /* 18 a0 */
CHECK( 0x01 == called );
cyg_counter_tick(counter0); /* 19 */
cyg_counter_tick(counter0); /* 20 */
cyg_counter_tick(counter0); /* 21 a0 a2 */
CHECK( 0x14 == called );
cyg_counter_tick(counter0); /* 22 */
cyg_counter_tick(counter0); /* 23 a2 */
CHECK( 0x00 == called );
cyg_alarm_disable(alarm2);
cyg_counter_tick(counter0); /* 24 a0 */
cyg_counter_tick(counter0); /* 25 */
CHECK( 0x01 == called );
cyg_alarm_enable(alarm2); /* a2 (enabled at 25) */
CHECK( 0x15 == called );
cyg_counter_tick(counter0); /* 26 */
CHECK( 0x15 == called );
cyg_counter_tick(counter0); /* 27 a0 a2 */
cyg_counter_tick(counter0); /* 28 */
CHECK( 0x00 == called );
cyg_counter_tick(counter0); /* 29 a2 */
cyg_counter_tick(counter0); /* 30 a0 */
cyg_counter_tick(counter0); /* 31 a2 */
CHECK( 0x01 == called );
res0.dividend = 100;
res0.divisor = 3;
cyg_clock_create( res0, &clock0, &clock0o );
res1 = cyg_clock_get_resolution(clock0);
CHECK( res0.dividend == res1.dividend );
CHECK( res0.divisor == res1.divisor );
res1.dividend = 12;
res1.divisor = 25;
cyg_clock_set_resolution(clock0, res1);
res0 = cyg_clock_get_resolution(clock0);
CHECK( res0.dividend == res1.dividend );
CHECK( res0.divisor == res1.divisor );
cyg_clock_to_counter(clock0, &counter1);
CHECK( 0 == cyg_counter_current_value( counter1 ) );
CHECK( 0 == cyg_current_time() );
cyg_counter_tick(counter1);
CHECK( 1 == cyg_counter_current_value(counter1) );
res0 = cyg_clock_get_resolution(cyg_real_time_clock());
/* Current time should be 0 as interrupts will still be disabled */
CHECK( 0 == cyg_current_time() );
CYG_TEST_PASS_FINISH("Kernel C API Clock 0 OK");
}
