Difference between revisions of "Xenomai:Blinking LEDs"

From ArmadeusWiki
Jump to: navigation, search
(Links)
(some corretions)
Line 1: Line 1:
This tutorial explain how to create a simple xenomai application. This application has to goal to doing blinking the led.
+
This tutorial explains how to create a simple Xenomai application. This application will blink the DevFull LED.
  
 
== Application code ==
 
== Application code ==
Line 58: Line 58:
 
}
 
}
 
</source>
 
</source>
This source is so equivalent to a classical application with threads and nanosleep() function.<br>
+
 
The only differences are on the task creation using API xenomai.
+
This source looks very like a classical Linux application with threads and nanosleep() function.<br>
 +
The only differences are on the task creation using Xenomai API:
 +
* Create a new task with ''stksize'' stack size, ''prio'' level of priority and ''mode'' type of creation:
 +
<source lang="C">
 
  int rt_task_create(RT_TASK * task, const char * name, int stksize, int prio, int mode)
 
  int rt_task_create(RT_TASK * task, const char * name, int stksize, int prio, int mode)
Create a new task with stksize size of stack, prio level of priority and mode type of creation.
+
</source>
 +
* Launch the new task with ''entry'' function and ''cookie'' parameters:
 +
<source lang="C">
 
  int rt_task_start (RT_TASK *task, void(*entry)(void *cookie), void *cookie)
 
  int rt_task_start (RT_TASK *task, void(*entry)(void *cookie), void *cookie)
Launch the new task with entry function and cookie parameter.
+
</source>
  int rt_task_set_periodic (RT_TASK *task, RTIME idate, RTIME period)  
+
* set for the ''task'' periodic, idate time for the first release (time in nanoseconds)
set for the ''task'' periodic, idate time for the first release, time on nanoseconds
+
<source lang="C">
 +
  int rt_task_set_periodic (RT_TASK *task, RTIME idate, RTIME period)
 +
</source>
 +
* To block the task during the previously set period:
 +
<source lang="C">
 
  int rt_task_wait_period (unsigned long *overruns_r)
 
  int rt_task_wait_period (unsigned long *overruns_r)
To block the task during a period of TIMESLEEP ns.
+
</source>
  
 
== Makefile ==
 
== Makefile ==
Line 119: Line 128:
 
rm -rf $(DEST_DIR)/$(EXEC)
 
rm -rf $(DEST_DIR)/$(EXEC)
 
</source>
 
</source>
'' ''ARMADEUS_BASE_DIR'' has needed to be adapted to the correct path on where is installed the Armadeus buildroot.''<br>
+
 
'' DEST_DIR assume you used an nfs mount on tftpboot/local for /usr/local on the board.''
+
''ARMADEUS_BASE_DIR'' needs to be adapted to the correct path where the Armadeus buildroot is installed.<br>
 +
''DEST_DIR'' assumes you used an [[NFS]] mount on ''/tftpboot/local'' as ''/usr/local'' on the board.
  
 
== Compilation, installation and run ==
 
== Compilation, installation and run ==
For to have the application installed on your board, you need to type :
+
<pre class="host">
 +
$ make
 +
</pre>
 +
If you setup the NFS as indicated above, you can install the application on your board with :
 +
<pre class="host">
 
  $ make install
 
  $ make install
 +
</pre>
 +
Otherwise you can manually copy ''blink_led_xeno_userspace'' exe to your board (''/usr/local/bin/'').
 +
 
=== Running ===
 
=== Running ===
On your board, you must you placed on ''/usr/local/bin'' and type :
+
On your APF, you must change directory to ''/usr/local/bin'' and type :
  $ xeno-load blink_led_xeno_userspace
+
<pre class="apf">
 +
  # xeno-load blink_led_xeno_userspace
 +
</pre>
 +
 
 
== Links ==
 
== Links ==
 
* [[Xenomai | Xenomai install instructions]]
 
* [[Xenomai | Xenomai install instructions]]

Revision as of 18:21, 29 March 2009

This tutorial explains how to create a simple Xenomai application. This application will blink the DevFull LED.

Application code

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <signal.h>
#include <sys/mman.h>

#include <native/task.h>
#include <native/timer.h>

#define TIMESLEEP 1000000000
#define LED "/dev/gpio/PD31"

RT_TASK blink_task;
int fd;

void blink(void *arg){
  int iomask = 0x00;
  
  rt_task_set_periodic(NULL, TM_NOW, TIMESLEEP);
  
  while(1){
	rt_task_wait_period(NULL);
        write(fd,&iomask,sizeof(iomask));
        iomask^=1;
  }
}

void catch_signal() {}

int main(int argc, char **argv) {
  
  signal(SIGTERM, catch_signal);
  signal(SIGINT, catch_signal);
  
  /* Avoids memory swapping for this program */
  mlockall(MCL_CURRENT|MCL_FUTURE);

  /* led device opening */
  if ((fd = open(LED, O_WRONLY))<0) {
    printf("Open error on %s\n",LED);
    exit(0);
  }
  /* Task Creation */
  rt_task_create(&blink_task, "blinkLed", 0, 99, 0);  
  rt_task_start(&blink_task, &blink, NULL);
  getchar();
  rt_task_delete(&blink_task);
  close(fd);
  return 0;
}

This source looks very like a classical Linux application with threads and nanosleep() function.
The only differences are on the task creation using Xenomai API:

  • Create a new task with stksize stack size, prio level of priority and mode type of creation:
 int rt_task_create(RT_TASK * task, const char * name, int stksize, int prio, int mode)
  • Launch the new task with entry function and cookie parameters:
 int rt_task_start (RT_TASK *task, void(*entry)(void *cookie), void *cookie)
  • set for the task periodic, idate time for the first release (time in nanoseconds)
 int rt_task_set_periodic (RT_TASK *task, RTIME idate, RTIME period)
  • To block the task during the previously set period:
 int rt_task_wait_period (unsigned long *overruns_r)

Makefile

The second step is to create a Makefile with specific Xenomai includes.

 ###### CONFIGURATION ######
 DEST_DIR=/tftpboot/local/bin
 ARMADEUS_BASE_DIR=../
 include $(ARMADEUS_BASE_DIR)/Makefile.in

 XENO=$(ARMADEUS_ROOTFS_DIR)/usr/xenomai

 CC= arm-linux-gcc
 LD= arm-linux-ld
 CXX= arm-linux-g++
 AS= arm-linux-as
 NM= arm-linux-nm
 AR= arm-linux-ar
 SIZE= arm-linux-size
 OBJCOPY= arm-linux-objcopy

 EXEC=blink_led_xeno_userspace

 SRC= $(wildcard *.c)
 OBJ= $(SRC:.c=.o)
 EXEC= $(APPLICATIONS)
 CFLAGS=-g -W -Wall -I$(XENO)/include -I$(XENO)/include/native  -I$(XENO)/include/rtdm -D_GNU_SOURCE -D_REENTRANT
 LDFLAGS=-L$(XENO)/lib -Xlinker -rpath $(XENO)/lib -Xlinker $(XENO)/lib/libnative.a $(XENO)/lib/librtdm.a -     lpthread -lnative -lrtdm
 $(EXEC) : $(OBJ)
	$(CC) -o $@ $^ $(LDFLAGS)
 $(OBJ): $(SRC)
	$(CC) $(CFLAGS) -o $@ -c $<

 .PHONY: all
 all: $(EXEC)
 .PHONY: clean 
 clean:
	rm -rf $(OBJ)
	rm -rf $(EXEC)
	rm -f *.c~ *.h~ Makefile~
 .PHONY: install
 install: $(EXEC)
        mkdir $(DEST_DIR)/$(EXEC)
        echo "$(EXEC):native:!./$(EXEC);popall:control_c" > /$(DEST_DIR)/$(EXEC)/.runinfo
	cp $(EXEC) $(DEST_DIR)/$(EXEC)

 .PHONY: mrproper
 mrproper: clean
	rm -rf $(DEST_DIR)/$(EXEC)

ARMADEUS_BASE_DIR needs to be adapted to the correct path where the Armadeus buildroot is installed.
DEST_DIR assumes you used an NFS mount on /tftpboot/local as /usr/local on the board.

Compilation, installation and run

 $ make

If you setup the NFS as indicated above, you can install the application on your board with :

 $ make install

Otherwise you can manually copy blink_led_xeno_userspace exe to your board (/usr/local/bin/).

Running

On your APF, you must change directory to /usr/local/bin and type :

 # xeno-load blink_led_xeno_userspace

Links