app.c~

pmc板的上层应用程序 操作两个pmc板和一个dsp 并和VXI机箱通信

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/mman.h>
//#include <linux/poll.h>
#include <errno.h>
#include <fcntl.h>
#include <dirent.h>
#include <signal.h>
#include "apue.h"
#include <sys/wait.h>
//#include <errno.h>
#include <stdarg.h>

//#include <vxi.h>

#include "app.h"

int fd = 0;

int buffer[42];
int buffer2[42];
//void ParsePacket(VXI_Packet *In_Packet);
//void ARM_CMD_Parse(VXI_Packet *In_Packet);
static void readpacket(int signo);
static void err_doit(int errnoflag,const char* fmt,va_list ap);
//错误处理机制函数
void err_sys(const char *fmt, ...)
{
    va_list ap;
    va_start(ap,fmt);
    err_doit(1,fmt,ap);
    va_end(ap);
    exit(1);
}

void err_dump(const char *fmt, ...)
{
    va_list ap;
    va_start(ap,fmt);
    err_doit(1,fmt,ap);
    va_end(ap);
    abort();
    exit(1);
}

static void err_doit(int errnoflag,const char* fmt,va_list ap)
{
int errno_save;
char buf[MAXLINE];
errno_save=errno;
vsprintf(buf,fmt,ap);
if(errnoflag)
    sprintf(buf+strlen(buf),":%s",strerror(errno_save));
strcat(buf,"\n");
fflush(stdout);
fputs(buf,stderr);
fflush(NULL);
return;
}

/*调用VXI驱动接收数据包*/
int GetPacket()
{

  int i;
//打开要调用的驱动设备
fd = open("/dev/plx",O_RDWR);

if(fd == -1)
{
	printf("open error:%s\n",strerror(errno));
	return -1;
}

printf("open success!\n");

for(i=0;i<41;i++) 
    { 
   buffer[i]=1;	
     }
buffer[0]=2;
buffer[1]=7;
buffer[2]=5;
buffer[3]=2;
buffer[4]=1;

write(fd,buffer,5);
read(fd,buffer2,5);

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

  printf("buffer is %d\n",buffer2[i]);

//通过信号检测中断的发生
//if(signal(SIGIO,readpacket) == SIG_ERR)
//   err_sys("can't catch SIGIO");
//for(;;)
//    pause();
}

static void readpacket(int signo)
{
       int i=0;
//捕捉到信号以后响应
      if(signo == SIGIO)
          printf("received SIGIO\n");
      else
          err_dump("received signal %d\n",signo);

//  read(fd,buffer,42,42);
  for(i=0;i<42;i++) 
    printf("buffer is %c\n",buffer[i]);
}

void ParsePacket(VXI_Packet * In_Packet)
{
ARM_CMD_Parse(In_Packet);
}


int ARM_CMD_Parse(VXI_Packet * In_Packet)
{
int i;
printf("packet data addr is 0x%x\n",In_Packet->DATA);
	if(In_Packet->HEAD==0)  //DSP操作
	{
	 DSP_ARGUMENT * Parameter;
         int a,b,c,d;
         a=In_Packet->ARGUMENT[0];
         b=In_Packet->ARGUMENT[1];
         c=In_Packet->ARGUMENT[2];
         d=In_Packet->ARGUMENT[3];
         Parameter->LENGTH = (a<<24)+(b<<16)+(c<<8)+d;//In_Packet->ARGUMENT[0]<<24+In_Packet->ARGUMENT[1]<<16+In_Packet->ARGUMENT[2]<<8+In_Packet->ARGUMENT[3]; 
         Parameter->DATA = malloc(Parameter->LENGTH);
            //In_Packet->DATA;
         for(i=0;i<Parameter->LENGTH;i++)
           {
         	Parameter->DATA[i] = In_Packet->DATA[i];         
		printf("data number is %d\n",Parameter->DATA[i]); 
}
//=( DSP_ARGUMENT *)In_Packet->ARGUMENT;   
	//通过VXI总线传输数据
	if(In_Packet->CMD==0x00)							  VXI_to_DSP_program_Load(Parameter->DATA,Parameter->LENGTH);
        else if(In_Packet->CMD==0x01)
          VXI_to_DSP_data_Send(Parameter->DATA,Parameter->LENGTH);
        else if(In_Packet->CMD==0x02)
          VXI_to_DSP_data_Get(Parameter->DATA,Parameter->LENGTH);
        else if(In_Packet->CMD==0x03)
          {
            Parameter->DSP_OPERATE_MODE=1;
            VXI_to_DSP_data_FFT(Parameter->DATA,Parameter->DSP_OPERATE_MODE,Parameter->LENGTH);
          }
       else if(In_Packet->CMD==0x04)
          {
            Parameter->DSP_OPERATE_MODE=2;
            VXI_to_DSP_data_DFT(Parameter->DATA,Parameter->DSP_OPERATE_MODE,Parameter->LENGTH);
          }
       else if(In_Packet->CMD==0x05)
         {
            Parameter->DSP_OPERATE_MODE=3;
            VXI_to_DSP_data_FHT(Parameter->DATA,Parameter->DSP_OPERATE_MODE,Parameter->LENGTH);
         }
       else if(In_Packet->CMD==0x06)
         {
            Parameter->DSP_OPERATE_MODE=4;
            VXI_to_DSP_data_Convolution(Parameter->DATA,Parameter->DSP_OPERATE_MODE,Parameter->LENGTH);
         }
       else if(In_Packet->CMD==0x07)
         {
            Parameter->DSP_OPERATE_MODE=5;
            VXI_to_DSP_data_SmoothFilter(Parameter->DATA,Parameter->DSP_OPERATE_MODE,Parameter->LENGTH);
          }
   }
   else if(In_Packet->HEAD==1)  //PMC操作
       {
          PMC_ARGUMENT * Parameter=( PMC_ARGUMENT *)In_Packet->ARGUMENT;
          if(In_Packet->CMD==0x08)
          VXI_to_PMC_data_Send(Parameter->DATA,Parameter->LENGTH,Parameter->PMC_ID);
           else if(In_Packet->CMD==0x09)
          VXI_to_PMC_data_Get(Parameter->DATA,Parameter->LENGTH,Parameter->PMC_ID);
   }
    else 
       return ERROR;  
  return 1;

}

void VXI_to_DSP_program_Load(BYTE *data,int length)
{
//调用PCI驱动操作DSP设备完成程序下载
MCU_to_DSP_program_Load(data,length);
}


void VXI_to_DSP_data_Send(BYTE *data,int length)
{
//调用PCI驱动操作DSP设备，实现VXI传递相应的数据到DSP存储器中
MCU_to_DSP_data_Send(data,length);
}

void VXI_to_DSP_data_Get(BYTE *data,int length)
{
//调用PCI驱动操作DSP设备，实现从DSP存储器读取并通过VXI传递相应的数据
MCU_to_DSP_data_Get(data,length);
}

void VXI_to_DSP_data_FFT(BYTE *data,int DSP_OPERATE_MODE,int length)
{
//调用PCI驱动操作DSP设备，传递数据给DSP做FFT;
MCU_to_DSP_data_FFT(data,DSP_OPERATE_MODE,length);
}

void VXI_to_DSP_data_DFT(BYTE *data,int DSP_OPERATE_MODE,int length)
{
//调用PCI驱动操作DSP设备，传递数据给DSP做DFT;
MCU_to_DSP_data_DFT(data,DSP_OPERATE_MODE,length);
} 

void VXI_to_DSP_data_FHT(BYTE *data,int DSP_OPERATE_MODE,int length)
{
//调用PCI驱动操作DSP设备，传递数据给DSP做FHT;
MCU_to_DSP_data_FHT(data,DSP_OPERATE_MODE,length);
}

void VXI_to_DSP_data_Convolution(BYTE *data,int DSP_OPERATE_MODE,int length)
{
//调用PCI驱动操作DSP设备，传递数据给DSP做卷积;
MCU_to_DSP_data_Convolution(data,DSP_OPERATE_MODE,length);
}

void VXI_to_DSP_data_SmoothFilter(BYTE *data,int DSP_OPERATE_MODE,int length)
{
//调用PCI驱动操作DSP设备，传递数据给DSP做平滑滤波;
MCU_to_DSP_data_SmoothFilter(data,DSP_OPERATE_MODE,length);
}

void VXI_to_PMC_data_Send(BYTE *data,int length,int PMC_id)
{
//调用PCI驱动操作PMC设备，VXI将DSP相应的数据传送到PMC模块进行数据输出。
MCU_to_PMC_data_Send(data,length,PMC_id);
}

void VXI_to_PMC_data_Get(BYTE *data,int length,int PMC_id)
{
//调用PCI驱动操作PMC设备，VXI从PMC模块读取相应的数据传输到DSP进行处理。
MCU_to_PMC_data_Get(data,length,PMC_id);
}


//DSP与PMC设备直接通过PCI总线传送数据
void DSP_to_PMC_data_Sent(BYTE *data,int length,int PMC_id)
{
//直接调用驱动实现DSP传递一定数据到PMC模块

}

void DSP_to_PMC_data_Get(BYTE *data,int length,int PMC_id)
{
//直接调用驱动实现DSP读取PMC模块的数据到DSP存储器
}

void MCU_to_DSP_program_Load(BYTE *data,int length)
{

 /* fd = open ("/dev/vxi", O_RDWR);
      if (fd == -1)
	{
	  printf ("open error: %s\n", strerror (errno));
	  return -1;
	}
	//开始设置传输控制位，标志变量为1，写入数据
	ioctl (fd, SET_TRANSFER_SIZE, &length);
  write(pdev, pdev->rom_base_reg, &addr);*/

}

void MCU_to_DSP_data_Send(BYTE *data,int length)
{
//write(fd,data,length);
}

void MCU_to_DSP_data_Get(BYTE *data,int length)
{
}

void MCU_to_DSP_data_FFT(BYTE *data,int DSP_OPERATE_MODE,int length)
{
printf("operate mode is %d\n",DSP_OPERATE_MODE);
printf("data length is %d\n",length);
}

void MCU_to_DSP_data_DFT(BYTE *data,int DSP_OPERATE_MODE,int length)
{
}

void MCU_to_DSP_data_FHT(BYTE *data,int DSP_OPERATE_MODE,int length)
{
}

void MCU_to_DSP_data_Convolution(BYTE *data,int DSP_OPERATE_MODE,int length)
{
printf("operate mode is %d\n",DSP_OPERATE_MODE);
}

void MCU_to_DSP_data_SmoothFilter(BYTE *data,int DSP_OPERATE_MODE,int length)
{

}

void MCU_to_PMC_data_Send(BYTE *data,int length,int PMC_id)
{

}

void MCU_to_PMC_data_Get(BYTE *data,int length,int PMC_id)
{

}

int main()
{
GetPacket();

/*BYTE data[2];
int i,length;
data[0]=1;
data[1]=2;
VXI_Packet packet;
packet.HEAD=0;
packet.CMD=0x03;
packet.ARGUMENT[0]=0;
packet.ARGUMENT[1]=0;
packet.ARGUMENT[2]=0;
packet.ARGUMENT[3]=2;
//packet.ARGUMENT[4]=2;
length=2; 
packet.DATA=malloc(sizeof(BYTE)*length);
for(i=0;i<length;i++)
  packet.DATA[i]=data[i];

printf("Get packet over!\n");

ParsePacket(&packet);                                                                                                               
return 1;*/
}