This is the mail archive of the
ecos-discuss@sourceware.org
mailing list for the eCos project.
how to get minimum resolution
- From: sandip <sandip at masibus dot com>
- To: <ecos-discuss at ecos dot sourceware dot org>
- Date: Sat, 11 Aug 2007 09:32:33 +0530
- Subject: [ECOS] how to get minimum resolution
dear friend ,
here i send my code, using alarm i am going to drive seven segment display.
cyg_alarm_initialize(test_alarmH, cyg_current_time()+1, 1);
using this i provide minimum delay and function call in short time.but i
didn't get small delay.
i think test_alarm_func() awke every 30 milisecond.
how can i reduce time of alarm.
In our other product we are using timer interrupt for update seven-segment
at 50HZ
and how to use timer interrupt in ECOS.
#include <cyg/kernel/kapi.h>
#include <stdio.h>
#include <cyg/io/io.h>
#include <cyg/hal/hal_arch.h>
#include <cyg/io/serialio.h>
# include <cyg/hal/hal_platform_ints.h>
#define NTHREADS 1
#define STACKSIZE 4096
#define alfabets 0x00000057
#define alfabeta 0x000000cf
#define alfabetn 0x0000004c
#define alfabetd 0x000000dc
#define alfabety 0x000000d6
#define anode1 0x00000100
#define anode2 0x00000200
#define anode3 0x00000400
#define anode4 0x00000800
#define anode5 0x00001000
static cyg_handle_t thread[NTHREADS];
static cyg_thread thread_obj[NTHREADS];
static char stack[NTHREADS][STACKSIZE];
cyg_uint32 i = 128;
cyg_uint32 j = 0;
cyg_uint32 k[5] = {0x00000057,0x000000cf ,0x0000004c ,0x000000dc
,0x000000d6 };
static void alarm_prog( cyg_addrword_t data );
/* we install our own startup routine which sets up
threads and starts the scheduler */
void cyg_user_start(void)
{
HAL_WRITE_UINT32(AT91_PIOB + AT91_PIO_PER,0x00ffffff);
HAL_WRITE_UINT32(AT91_PIOB + AT91_PIO_OER,0x00ffffff);
HAL_WRITE_UINT32(AT91_PIOB + AT91_PIO_SODR,0x00ffffff);
cyg_thread_create(4, alarm_prog, (cyg_addrword_t) 0,
"alarm_thread", (void *) stack[0],
STACKSIZE, &thread[0], &thread_obj[0]);
cyg_thread_resume(thread[0]);
}
/* we need to declare the alarm handling function (which is
defined below), so that we can pass it to
cyg_alarm_initialize() */
cyg_alarm_t test_alarm_func;
/* alarm_prog() is a thread which sets up an alarm which is then
handled by test_alarm_func() */
static void alarm_prog(cyg_addrword_t data)
{
cyg_handle_t test_counterH, system_clockH, test_alarmH;
cyg_tick_count_t ticks;
cyg_alarm test_alarm;
unsigned how_many_alarms = 0, prev_alarms = 0, tmp_how_many;
system_clockH = cyg_real_time_clock();
cyg_clock_to_counter(system_clockH, &test_counterH);
cyg_alarm_create(test_counterH, test_alarm_func,
(cyg_addrword_t) &how_many_alarms,
&test_alarmH, &test_alarm);
cyg_alarm_initialize(test_alarmH, cyg_current_time()+1, 1);
/* get in a loop in which we read the current time and
print it out, just to have something scrolling by */
for (;;) {
ticks = cyg_current_time();
//printf("Time is %llu\n", ticks);
/* note that we must lock access to how_many_alarms, since the
alarm handler might change it. this involves using the
annoying temporary variable tmp_how_many so that I can keep the
critical region short */
cyg_scheduler_lock();
tmp_how_many = how_many_alarms;
cyg_scheduler_unlock();
if (prev_alarms != tmp_how_many) {
//printf(" ---> alarm calls so far: %u\n", tmp_how_many);
prev_alarms = tmp_how_many;
}
cyg_thread_delay(30);
}
}
/* test_alarm_func() is invoked as an alarm handler, so
it should be quick and simple. in this case it increments
the data that is passed to it. */
void test_alarm_func(cyg_handle_t alarmH, cyg_addrword_t data)
{
++*((unsigned *) data);
HAL_WRITE_UINT32(AT91_PIOB + AT91_PIO_SODR,0x00ffffff);
HAL_WRITE_UINT32(AT91_PIOB + AT91_PIO_CODR,k[j]|i*2);
i=i*2;
if(i>2049)
i=128;
j++;
if(j == 5)
j=0;
}
-------------------------------------------------------
Masibus Process Instruments (P) Ltd, Gandhinagar, India
--
Before posting, please read the FAQ: http://ecos.sourceware.org/fom/ecos
and search the list archive: http://ecos.sourceware.org/ml/ecos-discuss