Jak uruchomić symulator VxSim

Skopiować na komputer lokalny plik kss-lab.zip W archiwum znajduje się kilka przykładów programów w języku C dla platformy VxWorks oraz pliki tornado oraz  tlaunch

Wszystkie te pliki należy przesłać w trybie tekstowym na swoje konto na komputerze nova.ia.agh.edu.pl (np.: za pomocą WindowsCommandera)
Ustawić zmienne systemowe dla Tornado wydać komendę 
source tornado

W pliku tornado ustawiane są następujące zmienne:

setenv WIND_BASE /usr/local/wind
setenv WIND_REGISTRY nova
setenv WIND_HOST_TYPE sun4-solaris2
setenv LD_LIBRARY_PATH /usr/local/wind/host/sun4-solaris2/lib			
setenv PATH /usr/local/wind/host/sun4-solaris2/bin:/usr/openwin/bin:$PATH
Uruchomić tornado

Dokładny opis procedury uruchamiani jest dostępny w wind-docs/getStart_unix.pdf

 
/usr/local/wind/host/sun4-solaris2/bin/launch&

To samo polecenie jest wpisane do pliku tlaunch.
Stworzyć nowy projekt Peeker
  • W oknie Tornado-Launcher wybrać opcję Project
  • Wybrać opcję Create downloadable application
  • Zrealizować wszystkie kroki Wizarda
  • Dodać plik peeker.c do projektu (Opcja Add Files)

 
 Zbudować plik wyjściowy (Peeker.out) Z menu kontekstowego opcja Build
Uruchomić symulator VxWorks
  • W oknie Tornado-Launcher wybrać opcję VxSim, następnie Confirm i Launch w kolejnych oknach dialogowych
  • Uruchomiany zostanie target server -- proces odpowiedzialny za komunikację pomiędzy narzedziami Tornado i wykonywaną aplikacją

 
Załadować skompilowany plik Peeker.out do symulatora Ustawic target na vxsim0@nova i wybrac opcję Download z menu kontektowego w oknie projektu. Plik Peeker.out zostanie dynamicznie skonsolidowany z symulatorem VxSim

 
Uruchomic shell VxSim Wybrac przycisk WindSh w oknie Launcher.

Shell programu VxSim jet interpreterem języka C. Posługując się nim można wywołac dowolna biblioteczną funkcję języka C, np.: printf, lub własną funkcję zaimplementowaną w uprzednio załadowanym module. 

 
Uruchomić funkcję inicjalizująca Funkcja inicjalizująca w module peeker.c nazywa się init. Uruchamia ona zadanie peeker -- odczytujące wartości dwóch zmiennych. 
int x=0;
int y=0;
void peeker()
{
    for(;;)
    {
        printf("x=%d,y=%d\n",x,y);
        taskDelay(200); 
    }
}

        

          
STATUS init()
{
int t_peeker;

t_peeker=taskSpawn("peeker",120,0,10000,(FUNCPTR)peeker,0,0,0,0,0,0,0,0,0,0);
return(OK);
}



															
      

      
      Zadanie peeker rozpocznie działanie wypisując okresowo wartości
      zmiennych x i y.
      
    		
  

  

    Zmienić wartości zmiennych 
      
 

    W module zdefiniowano dodatkowo dwie funkcje
      
void pokeX(int _x)

      {

          x = _x;

      }

      void pokeY(int _y)

      {

          y = _y;

      }

      
 Wywołując je z shella możemy ustawić nowe wartości
      zmiennych x i y

      
 
    

  

  

    W podobny sposób uruchomić inne programy...
     
    
  




Peeker2.c


Program jest modyfikacją poprzedniego. Dodane zostało drugie zadanie poker,
które wpisuje kolejne wartości do zmiennych x i y


 
/*
  ------------------ includes ----------------- */



  #include "vxWorks.h"

  /*#include "msgQLib.h"*/

  #include "taskLib.h"

  #include <stdio.h>

  /* ------------------ defines ------------------ */





  /* ------------------ globals ------------------ */

  /**

  unprotected variables !

  */



  int x=0;

  int y=0;







  /* ----------- forward declarations ------------ */



  STATUS init();

  void peeker();

  void poker();



  void pokeX(int _x);

  void pokeY(int _y);





  /* ************************************************************************ */



  void peeker()

  {

  /* Local variables */



      for(;;)

      {

          printf("x=%d,y=%d\n",x,y);

          taskDelay(200); 

      }

  }





  /* ************************************************************************ */



  void poker()

  {

  /* Local variables */



      int i;

      for(i=0;;i++,i%=200)

      {

          pokeX(i);

          taskDelay(150); 

          pokeY(i);

          taskDelay(150); 

      }

  }







  /* ------------------------------------------------------------------------ */



  STATUS init()

  {

      int t_peeker;

      int t_poker;



      t_peeker=taskSpawn("peeker",120,0,10000,(FUNCPTR)peeker,0,0,0,0,0,0,0,0,0,0);

      if (t_peeker==ERROR)

      return(ERROR);



      t_poker=taskSpawn("poker",120,0,10000,(FUNCPTR)poker,0,0,0,0,0,0,0,0,0,0);

      if (t_poker==ERROR)

      return(ERROR);



      return(OK);

  }





  /* ------------------------------------------------------------------------ */





  void pokeX(int _x)

  {

      x = _x;

  }

  
void pokeY(int _y)

  {

      y = _y;

  }





rw.c i rw2.c


Program pokazuje problem czytelników i pisarzy (w rw.c tylko jeden pisarz).


Funkcja writer jest uruchamiana jako zadanie "writer"


Funkcja reader jest uruchamiana pieciokrotnie jako kolejni czytelnicy.


 
/* ------------------ includes ----------------- */

  

  #include "vxWorks.h"

  /*#include "msgQLib.h"*/

  #include "taskLib.h"

  #include <stdio.h>

  /* ------------------ defines ------------------ */

  

  

  /* ------------------ globals ------------------ */

  /**

	unprotected variables !

  */

  

  int x=0;

  int y=0;

  

  

  

  /* ----------- forward declarations ------------ */

  

  STATUS init();

  void reader(int num);

  void writer();

  

  void writeX(int _x);

  void writeY(int _y);

  

  

  /* ************************************************************************ */

  

  void reader(int num)

  {

  /* Local variables */

  

   for(;;)

	  {

		printf("Reader#%d: x=%d,y=%d\n",num,x,y);

		taskDelay(200); 

	  }

  }

  

  

  /* ************************************************************************ */

  

  void writer()

  {

  /* Local variables */

  

   int i;

   for(i=0;;i++,i%=200)

   {

	writeX(i);

	printf("Writer.writeX(%d)\n",i);

	taskDelay(75); 

	writeY(i);

	printf("Writer.writeY(%d)\n",i);

	taskDelay(75); 

   }

  }

  

  

  

  /* ------------------------------------------------------------------------ */

  

  STATUS init()

  {

   int t_reader;

   int t_writer;

   int i;

  

   	t_writer=taskSpawn("writer",120,0,10000,(FUNCPTR)writer,0,0,0,0,0,0,0,0,0,0);

   	if (t_writer==ERROR)

      		return(ERROR);

  

	for(i=0;i<5;i++){

   		t_reader=taskSpawn("reader",120,0,10000,(FUNCPTR)reader,i,0,0,0,0,0,0,0,0,0);

   		if (t_reader==ERROR)

      			return(ERROR);

	}

  

   return(OK);

  }

  

  

  /* ------------------------------------------------------------------------ */

  

  

  void writeX(int _x)

  {

	x = _x;

  }

  void writeY(int _y)

  {

	y = _y;

  }





r-s.c


W programie  dwa zadania receiver i sender komunikują się
za pośrednictwem kolejki komunikatów.


		/************************************************

		 LA4 to VxWorks translator - version 1.21 -

				r-s.c

		************************************************/

  

  

  /* ------------------ includes ----------------- */

  

  #include "vxWorks.h"

  #include "msgQLib.h"

  #include "taskLib.h"

  #include <stdio.h>

  /* ------------------ defines ------------------ */

  

  #define reciver_OPT	0

  #define reciver_STK	10000

  #define sender_OPT	0

  #define sender_STK	10000

  

  /* ------------------ globals ------------------ */

  

  

  /* #error Code Not Completed: lack of members of message structure */

  typedef struct tagMSG_TYPE_receiver_mbx

  {

	/*char dummy;*/

	long msg_no;

	/* message structure declaration for mailbox receiver_mbx */

  }	MSG_TYPE_receiver_mbx;

  

  

  MSG_Q_ID	m_receiver_mbx;

  int		t_reciver;

  int		t_sender;

  

  /* ----------- forward declarations ------------ */

  

  void reciver();

  STATUS receiver_init();

  STATUS init();

  void sender();

  

  

  /* ************************************************************************ */

  

  void reciver()

  {

  /* Local variables */

      MSG_TYPE_receiver_mbx msgFrom_receiver_mbx_Mbx;

  

      for(;;)

      {

      /* inserted */

      printf("receiver: executes WAIT_ON_MBX msgQReceive()\n");

      /* inserted */

      if (msgQReceive(m_receiver_mbx, (char*)&msgFrom_receiver_mbx_Mbx,sizeof(msgFrom_receiver_mbx_Mbx), 

           WAIT_FOREVER)==ERROR)

      taskSuspend(0);

      /* inserted */

     		 printf("receiver: message #%d was received\n",msgFrom_receiver_mbx_Mbx.msg_no);

      /* inserted */

      }

  }

  

  

  /* ------------------------------------------------------------------------ */

  

  STATUS receiver_init()

  {

      m_receiver_mbx=msgQCreate(50, sizeof(MSG_TYPE_receiver_mbx), MSG_Q_FIFO);

      if (m_receiver_mbx==NULL)

      return(ERROR);

        t_reciver=taskSpawn("reciver",100,reciver_OPT,reciver_STK,(FUNCPTR)reciver,0,0,0,0,0,0,0,0,0,0);

      if (t_reciver==ERROR)

      return(ERROR);

      return(OK);

  }

  

  

  /* ------------------------------------------------------------------------ */

  

  STATUS init()

  {

      receiver_init();

        t_sender=taskSpawn("sender",120,sender_OPT,sender_STK,(FUNCPTR)sender,0,0,0,0,0,0,0,0,0,0);

      if (t_sender==ERROR)

           return(ERROR);

      return(OK);

  }

  

  

  /* ------------------------------------------------------------------------ */

  

  void sender()

  {

  /* Local variables */

      MSG_TYPE_receiver_mbx	msg;

      msg.msg_no = 0;

      for(;;)

      {

          msg.msg_no++;

          printf("sender: willing to send message
  #%ld\n",msg.msg_no);

          if (msgQSend(m_receiver_mbx,(char*)&msg,sizeof(msg),WAIT_FOREVER,MSG_PRI_NORMAL)==ERROR)

          taskSuspend(0);

          /* inserted */

         	  printf("sender: message #%ld was
  sent\n",msg.msg_no);

  

          taskDelay(200);

          /* inserted */ 

      }

  }

  

  

  /* ------------------------------------------------------------------------ */