step9.c

嵌入式程序

#include <stdio.h>
#include "includes.h"
#include "altera_avalon_pio_regs.h"
#include "system.h"
#include "sys/alt_alarm.h"
#include "io.h"
#include "sys/alt_irq.h"

volatile int edge_capture;

/* Definition of Tast Stacks */
#define   TASK_STACKSIZE    2048
OS_STK    initialize_task_stk[TASK_STACKSIZE];
OS_STK    HighPriorityTraffic[TASK_STACKSIZE];
OS_STK    LowPriorityTraffic[TASK_STACKSIZE];
OS_STK    Output[TASK_STACKSIZE];

/* Definiton of Task Priorities */
#define INITIALIZE_TASK_PRIORITY    6;
#define HIGH_PRIORITY_TRAFFIC_PRIORITY 7;
#define LOW_PRIORITY_TRAFFIC_PRIORITY  8;
#define OUTPUT_TASK_PRIORITY        9;

/* Definition of Message Queue */
#define QUEUELENGTH 10
OS_EVENT  *msgqueue;
void      *msgqueueTbl[QUEUELENGTH];

/* Definition of Message Queue Buffer */
OS_MEM  *msgbuffer;
INT8U  msgPart[20][40];

/* Definition of Semaphore */
OS_EVENT *msgsem;
OS_EVENT *msgwrr;
/* Definition of Message Structure */
typedef struct message_type {
  char prio;
  char id;
} message;

/* Definition of Mail Box */
OS_EVENT *mailbox;
OS_EVENT *mailbutton;
message mailboxcontent;
message buttoncontent[4];

/* Interrupts handler */
static void handle_button_interrupts(void* context,alt_u32 id)
{
  void act_on_button();
  //read the edge_capture register's value
  volatile int* edge_capture_ptr=(volatile int*)context;
  *edge_capture_ptr=IORD_ALTERA_AVALON_PIO_EDGE_CAP(BUTTON_PIO_BASE);
  //reset edege_capture register
  IOWR_ALTERA_AVALON_PIO_EDGE_CAP(BUTTON_PIO_BASE,0);
  //set the interrupt_mask register to 1001 in order to make system only respond the sw0 and sw3 
  IOWR_ALTERA_AVALON_PIO_IRQ_MASK(BUTTON_PIO_BASE,0xf);
  act_on_button();
}

alt_u32 tick_sender()
{
  INT8U err;
  mailboxcontent.prio = 8;
  mailboxcontent.id = alt_nticks();
  err = OSMboxPost(mailbox,(void*)&mailboxcontent);
  
  return alt_ticks_per_second();
}

//response button action
void act_on_button()
{
  INT8U err;
  switch (edge_capture) {
      case 0x1:      
          buttoncontent[0].prio = 7;
          buttoncontent[0].id = 'R';
          err = OSMboxPost(mailbutton,(void*)&buttoncontent[0]);
          break;
      case 0x2:
          buttoncontent[1].prio = 7;
          buttoncontent[1].id = 'U';
          err = OSMboxPost(mailbutton,(void*)&buttoncontent[1]);
          break;
      case 0x4:
          buttoncontent[2].prio = 7;
          buttoncontent[2].id = 'D';
          err = OSMboxPost(mailbutton,(void*)&buttoncontent[2]);
          break;
      case 0x8:
          buttoncontent[3].prio = 7;
          buttoncontent[3].id = 'S';
          printf("Button 4 pressed\n");
          err = OSMboxPost(mailbutton,(void*)&buttoncontent[3]);
          break;
  }
  return;
}

    

void high_priority_traffic(void* pdata)
{
  //INT8U memerr;
  INT8U msgerr;
  INT8U semerr;
  INT8U mberr;
  //INT8U id = 1;
  //INT8U i = 0;
  //message* msgori;
  message* msg;
  //msgori = (message*) OSMemGet (msgbuffer,&memerr);
  //msg = msgori;
  
  while (1)
  {
    
    //printf("Mem allocated\n");
    if (msg != NULL ) {
      //msg->prio = HIGH_PRIORITY_TRAFFIC_PRIORITY;
      //msg->id = id++;
      msg = OSMboxPend(mailbutton,0,&mberr);
      OSSemPend(msgwrr,0,&semerr);
      OSSemPend(msgsem,0,&semerr);
      msgerr = OSQPost(msgqueue,(void*)msg);
      printf("1 Msg sent\n");
      /*
      if (i==19) {
        i =0;
        msg = msgori;
      }
      else {
          i++;
          msg++;
      }
      */
    }        
  }
}

void low_priority_traffic(void* pdata)
{
  INT8U memerr;
  INT8U msgerr;
  INT8U semerr;
  INT8U mberr;
  //INT8U id = 1;
  INT8U j;
  INT8U i = 0;
  message* msg;
  message* msgori;
  message* mail;
  msgori = (message*) OSMemGet (msgbuffer,&memerr);
  msg = msgori;
  
  while (1)
  {
    
    if (msg != NULL) {
      mail = (message*) OSMboxPend(mailbox,0,&mberr);
      msg->prio = LOW_PRIORITY_TRAFFIC_PRIORITY;
      msg->id = mail->id;
      OSSemPend(msgsem,0,&semerr);     
      msgerr = OSQPost(msgqueue,(void*)msg);
      printf("2 Msg sent\n");
      OSSchedLock();
       for(j=0;j<5;j++) {
        OSSemPost(msgwrr);
      }
      OSSchedUnlock();
      if (i ==19){
         i =0;
         msg = msgori;
      }
      else {
        i++;
        msg++;
      }
    }
  }
}

void output(void* pdata)
{
  OS_STK_DATA data;
  INT8U msgerr;
  INT8U err;
  INT8U second=0;
  INT8S i=1;
  INT8U pr;
  INT8U digit,t,x;
  message* msg;
  
  while (1)
  {
    msg = OSQPend (msgqueue,0,&msgerr);
    if (msgerr==OS_NO_ERR) {
      if(msg->prio==7) {
        switch (msg->id){
          case 'R':
            second = 0;
            break;
          case 'U':
            i = 1;
            break;
          case 'D':
            i = -1;
            break;
          case 'S':
            i = 0;
            printf("Reach here\n");
            break;
        }
      }
      else {
        if(i == 1) {
          if(second == 59) {
            second =0;
          }
          else{
            second++;
          }
        }
        if(i ==-1){
          if(second ==0) {
            second = 59;
          }
          else{
            second--;
          }
        }
        
        for(pr=6;pr<=9;pr++)
        {
          err = OSTaskStkChk(pr,&data);
          if(err==OS_NO_ERR)
          {
            printf("%4ld      %4ld        %4ld\n",
                   data.OSFree+data.OSUsed,
                   data.OSFree,
                   data.OSUsed);
          }
        }
      }
    }
        
      printf("%d,%d\n",msg->prio,msg->id);
      printf("%d\n",second);     
      printf("%d\n",OSCPUUsage); 
      t = second/10;
      x = second - t*10;
      digit = t<<4;
      digit = digit|x;
      IOWR_ALTERA_AVALON_PIO_DATA(SEG7_DISPLAY_BASE,digit);
      
      OSSemPost(msgsem);
    }
}

void initCreateTasks(void)
{
  INT8U err;
  
  err = OSTaskCreateExt (high_priority_traffic,
                         NULL,
                         (void*)&HighPriorityTraffic[TASK_STACKSIZE],
                         7,
                         7,
                         HighPriorityTraffic,
                         TASK_STACKSIZE,
                         NULL,
                         OS_TASK_OPT_STK_CHK|OS_TASK_OPT_STK_CLR);
  err = OSTaskCreateExt (low_priority_traffic,
                         NULL,
                         (void*)&LowPriorityTraffic[TASK_STACKSIZE],
                         8,
                         8,
                         LowPriorityTraffic,
                         TASK_STACKSIZE,
                         NULL,
                         OS_TASK_OPT_STK_CHK|OS_TASK_OPT_STK_CLR);
  err = OSTaskCreateExt (output,
                         NULL,
                         (void*)&Output[TASK_STACKSIZE],
                         9,
                         9,
                         Output,
                         TASK_STACKSIZE,
                         NULL,
                         OS_TASK_OPT_STK_CHK|OS_TASK_OPT_STK_CLR);
  return ;
}                                                
 
void initialize_task(void* pdata)
{
  INT8U err;
  OSStatInit();
  initCreateTasks();
  
  err = OSTaskDel(OS_PRIO_SELF);
  while (1);
}

int main ()
{
  INT8U err;
  static alt_alarm alarm;
  msgqueue = OSQCreate(&msgqueueTbl[0],QUEUELENGTH);
  msgbuffer = OSMemCreate (msgPart,20,40,&err);
  if(err==OS_MEM_INVALID_ADDR) printf("ADDR\n");
  if(err==OS_MEM_INVALID_PART) printf("PART\n");
  if(err==OS_MEM_INVALID_BLKS) printf("BLKS\n");
  if(err==OS_MEM_INVALID_SIZE) printf("SIZE\n");
  
  msgsem = OSSemCreate(QUEUELENGTH);
  msgwrr = OSSemCreate(5);
  mailbox = OSMboxCreate((void*)NULL);
  mailbutton = OSMboxCreate((void*)NULL);
  
  //register isr
  //reset edege_capture register
  IOWR_ALTERA_AVALON_PIO_EDGE_CAP(BUTTON_PIO_BASE,0);
  //set the interrupt_mask register to 1001 in order to make system only respond the sw0 and sw3 
  IOWR_ALTERA_AVALON_PIO_IRQ_MASK(BUTTON_PIO_BASE,0xf);
  alt_irq_register(BUTTON_PIO_IRQ,(void*)&edge_capture,handle_button_interrupts);
  
  //set timer
  if(alt_alarm_start(&alarm,alt_ticks_per_second(),tick_sender,NULL)<0) {
    printf("No system clock available\n");
  }
  err = OSTaskCreateExt(initialize_task,
                        NULL,(void *)&initialize_task_stk[TASK_STACKSIZE],
                        6,
                        6
                        ,initialize_task_stk,
                        TASK_STACKSIZE, 
                        NULL,
                        OS_TASK_OPT_STK_CHK|OS_TASK_OPT_STK_CLR);               
  OSStart();
  return 0;
}