vppg.c

Go to the documentation of this file.
00001 /*********************************************************************
00002 
00003   Name:         vppg.c
00004   Created by:   
00005         based on v292.c and trPPG.c Pierre-Andre Amaudruz
00006 
00007   Contents:     PPG Pulse Programmer
00008                 
00009   $Id: vppg.c 3638 2007-03-02 01:35:35Z amaudruz $
00010 *********************************************************************/
00011 #include <stdio.h>
00012 #include <string.h>
00013 #include <stdio.h>
00014 #include <ctype.h>
00015 #include "unistd.h" // for sleep
00016 #include "vppg.h"
00017 
00018 int ddd=1; //debug
00019 FILE  *ppginput;
00020 /*****************************************************************/
00021 
00022 /*------------------------------------------------------------------*/
00023 
00024 void ppg(void)
00025 {
00026    printf("       PPG function support\n");
00027    printf("A Init               B Load\n");
00028    printf("C StopSequencer      E StartSequencer\n");
00029    printf("F EnableExtTrig      G DisableExtTrig\n");
00030    printf("H ExtTrigRegRead     I StatusRead\n");
00031    printf("J PolmskRead         K PolmskWrite\n");
00032    printf("L RegWrite           M RegRead\n");
00033    printf("N StartpatternWrite  O PolzSet\n");
00034    printf("Q PolzRead           R PolzFlip\n");
00035    printf("S PolzCtlPPG         T PolzCtlVME\n");
00036    printf("U BeamOn             V BeamOff \n");
00037    printf("W BeamCtlPPG         Y BeamCtlRegRead\n");
00038    printf("D debug (toggles)    P print this list\n");
00039    printf("X exit \n");
00040    printf("\n");
00041 }
00042 
00043 
00044 /*------------------------------------------------------------------*/
00045 /** ppgPolzSet
00046     Set Polarization bit to a given value.
00047     @memo Write PPG.
00048     @param base\_adr PPG VME base addroless
00049     @param value (8bit)
00050 */
00051 void VPPGPolzSet(MVME_INTERFACE *mvme, const DWORD base_adr, BYTE value)
00052 {
00053    VPPGRegWrite(mvme, base_adr,  VPPG_VME_POLZ_SET, value); 
00054    return;
00055 }
00056 
00057 /*------------------------------------------------------------------*/
00058 /** ppgPolzRead
00059     Read Polarization bit.
00060     @memo Read PPG.
00061     @param base\_adr PPG VME base addroless
00062     @return value (8bit)
00063 */
00064 BYTE  VPPGPolzRead(MVME_INTERFACE *mvme, const DWORD base_adr)
00065 {
00066   DWORD value;
00067   value = VPPGRegRead(mvme, base_adr, VPPG_VME_POLZ_SET);
00068   value &= 0xFF;
00069 
00070   if (ddd) printf("Read addr 0x%lx  data=%lu\n", (DWORD)(base_adr +VPPG_VME_POLZ_SET),value  );
00071 
00072   return (BYTE)value;
00073 }
00074 
00075 /*------------------------------------------------------------------*/
00076 /** VPPGPolzFlip
00077     Flip the polarization bit.
00078     @memo Read PPG.
00079     @param base\_adr PPG VME base address
00080 */
00081 BYTE  VPPGPolzFlip(MVME_INTERFACE *mvme, const DWORD base_adr)
00082 {
00083   DWORD value;
00084 
00085   value = (0xFF & (VPPGPolzRead(mvme, base_adr)));
00086  
00087   if(ddd)printf("VPPGPolzFlip: read back %lu, now flipping \n",value);
00088   if(value) {
00089     VPPGPolzSet(mvme, base_adr, 0);
00090   }  
00091   else {
00092     VPPGPolzSet(mvme, base_adr, 1);
00093   }
00094   value = (0xFF & (VPPGPolzRead(mvme, base_adr)));
00095   if(ddd)printf("VPPGPolzFlip: after flip, read back %lu \n",value); 
00096 
00097  
00098 
00099   return (BYTE)value;
00100 }
00101 
00102 /*------------------------------------------------------------------*/
00103 /** VPPGRegWrite
00104     Write into PPG register.
00105     @memo Write PPG.
00106     @param base\_adr PPG VME base address
00107     @param reg\_offset PPG register
00108     @param value (8bit)
00109     @return status register
00110 */
00111 BYTE VPPGRegWrite(MVME_INTERFACE *mvme, const DWORD base_adr, DWORD reg_offset, BYTE value)
00112 {
00113 
00114   DWORD myval,myreg;
00115   int  cmode, localam;
00116   
00117   mvme_get_dmode(mvme, &cmode);  // remember present VME data mode
00118   mvme_set_dmode(mvme, MVME_DMODE_D8); // set D8 for PPG
00119 
00120   mvme_get_am(mvme, &localam); // remember present VME addressing mode
00121   mvme_set_am(mvme, MVME_AM_A16_ND); // set A16 for PPG
00122 
00123   myreg =  base_adr + reg_offset;
00124   myval = (DWORD)value;
00125   mvme_write_value(mvme, myreg, value);
00126   if (ddd) printf("Writing 0x%x to 0x%lx\n", value, myreg );
00127   myval = 0x1BAD1BAD; // set to a different value
00128   myval = mvme_read_value(mvme, myreg);
00129   if(ddd)printf("mvme_read_value returns 0x%lx (%lu)\n",myval,myval);
00130 
00131   mvme_set_dmode(mvme, cmode); // restore VME data mode
00132   mvme_set_am(mvme, localam); // restore VME addressing mode
00133 
00134   return (BYTE)myval;
00135 }
00136 
00137 /*------------------------------------------------------------------*/
00138 /** VPPGRegRead
00139     Read PPG register.
00140     @memo Read PPG.
00141     @param base\_adr PPG VME base addroless
00142     @param reg\_offset PPG register
00143     @return status register (8 bit)
00144 */
00145 BYTE VPPGRegRead(MVME_INTERFACE *mvme, const DWORD base_adr, DWORD reg_offset)
00146 {
00147   DWORD value,myreg;
00148   int  cmode, localam;
00149   
00150   mvme_get_dmode(mvme, &cmode); // store present data mode
00151   mvme_set_dmode(mvme, MVME_DMODE_D8); // set D8 for PPG
00152 
00153   mvme_get_am(mvme, &localam); // store present addressing mode
00154   mvme_set_am(mvme, MVME_AM_A16_ND); // set A16 for PPG
00155 
00156   myreg =  base_adr + reg_offset;
00157   if (ddd) printf("Reading from address 0x%lx\n", myreg );
00158   value = mvme_read_value(mvme, myreg );
00159   printf("Read back 0x%lx (%lu)\n",value,value);
00160 
00161   mvme_set_dmode(mvme, cmode);// restore data mode
00162   mvme_set_am(mvme, localam);// restore addressing mode
00163   return (BYTE) value;
00164 }
00165 
00166 /*------------------------------------------------------------------*/
00167 /** VPPGInit
00168     Initialize the PPG
00169     @memo Initialize PPG
00170     @param base\_adr PPG VME base address
00171     @return void
00172 */
00173 void VPPGInit(MVME_INTERFACE *mvme, const DWORD base_adr)
00174 {
00175   VPPGPolmskWrite(mvme, base_adr, VPPG_DEFAULT_PPG_POL_MSK );
00176 
00177   //by default PPG controls these outputs (Titan)
00178   VPPGPolzCtlPPG(mvme, base_adr);
00179   VPPGBeamCtlPPG(mvme, base_adr);
00180 
00181   // default.. external trigger input disabled 
00182   VPPGDisableExtTrig(mvme, base_adr); 
00183 
00184   return;
00185 }
00186 
00187 /*------------------------------------------------------------------*/
00188 /** VPPGStatusRead
00189     Read Status register.
00190     @memo Read status.
00191     @param base\_adr PPG VME base address
00192     @return status register
00193 */
00194 BYTE VPPGStatusRead(MVME_INTERFACE *mvme, const DWORD base_adr)
00195 {
00196   BYTE value,itmp;
00197   value = VPPGRegRead(mvme, base_adr, VPPG_VME_READ_STAT_REG );
00198     if (value & 1)
00199       printf("Pulseblaster IS reset\n");
00200     else
00201       printf("Pulseblaster is NOT  reset\n");
00202    if (value & 2)
00203      printf("Pulseblaster IS running \n");
00204    else
00205      printf("Pulseblaster NOT running \n");
00206    if (value & 4)
00207      printf("Pulseblaster IS stopped \n");
00208    else
00209      printf("Pulseblaster is NOT stopped \n");
00210 
00211    itmp =  (value & 0x18)>> 4;
00212      printf("VME polarization source control bits = 0x%x\n",itmp);
00213 
00214    if (value & 20)
00215      printf("VME Polarization control: ACTIVE \n");
00216    else
00217      printf("VME Polarization control: OFF \n");
00218    if (value & 40)
00219      printf("External clock IS present \n");
00220    else
00221      printf("External clock NOT present \n");
00222 
00223    if (value & 80)
00224      printf("External  Polarization control: ACTIVE \n");
00225    else
00226      printf("External  Polarization control: OFF \n");
00227 
00228   return (BYTE)value;
00229 }
00230 /*------------------------------------------------------------------*/
00231 /** VPPGBeamOn
00232     Directly set Beam On signal.
00233     @memo Set Beam On (independent of ppg script)
00234     @param base\_adr PPG VME base address
00235     @return void
00236 */
00237   void VPPGBeamOn(MVME_INTERFACE *mvme, const DWORD base_adr)
00238 {
00239  
00240   VPPGRegWrite(mvme, base_adr,VPPG_VME_BEAM_CTL , 1);
00241    /* channel 14 (beam on/off) set to ON; ignores ppg pulseblaster script */
00242   return;
00243 }
00244 
00245 
00246 /*------------------------------------------------------------------*/
00247 /** VPPGBeamOff
00248     Directly set Beam Off signal.
00249     @memo Set Beam Off (independent of PPG script)
00250     @param base\_adr PPG VME base address
00251     @return void
00252 */
00253   void VPPGBeamOff(MVME_INTERFACE *mvme, const DWORD base_adr)
00254 {
00255   VPPGRegWrite(mvme, base_adr,VPPG_VME_BEAM_CTL , 0);
00256  /* channel 14 (beam on/off) set to OFF; ignores ppg pulseblaster script */
00257   return;
00258 }
00259 
00260 /*------------------------------------------------------------------*/
00261 /** VPPGBeamCtlPPG
00262     PPG controls the Beam On/Off signal.
00263     @memo Give PPG script control of Beam On/Off signal (ch14)
00264     @param base\_adr PPG VME base address
00265     @return void
00266 */
00267   void VPPGBeamCtlPPG(MVME_INTERFACE *mvme, const DWORD base_adr)
00268 {
00269   VPPGRegWrite(mvme, base_adr,VPPG_VME_BEAM_CTL , 3);
00270  /* channel 14 (beam on/off) follows ppg pulseblaster script */ 
00271   return;
00272 }
00273 
00274 /*------------------------------------------------------------------*/
00275 /** VPPGPolzCtlVME
00276     VME controls the Pol On/Off signal for helicity
00277     @memo Give VME control of Pol On/Off signal (DRV POL) (PPG script ignored) 
00278     @param base\_adr PPG VME base address
00279     @return void
00280 */
00281   void VPPGPolzCtlVME(MVME_INTERFACE *mvme, const DWORD base_adr)
00282 {
00283   VPPGRegWrite(mvme, base_adr, VPPG_POLZ_SOURCE_CONTROL , 0);
00284  /* DRV POL (helicity) independent of ppg pulseblaster script */ 
00285   return;
00286 }
00287 /*------------------------------------------------------------------*/
00288 /** VPPGPolzCtlPPG
00289     PPG controls the Pol On/Off signal for helicity
00290     @memo Give PPG script control of Pol On/Off signal (DRV POL) which now follows ch15  
00291     @param base\_adr PPG VME base address
00292     @return void
00293 */
00294   void VPPGPolzCtlPPG(MVME_INTERFACE *mvme, const DWORD base_adr)
00295 {
00296   VPPGRegWrite(mvme, base_adr, VPPG_POLZ_SOURCE_CONTROL , 2);
00297  /* DRV POL (helicity) follows ch15 and ppg pulseblaster script */ 
00298   return;
00299 }
00300 /*------------------------------------------------------------------*/
00301 /** VPPGBeamCtlRegRead
00302     Read the Beam Control Register
00303     @memo Read the Beam Control Register
00304     @param base\_adr PPG VME base address
00305     @return void
00306 */
00307 BYTE VPPGBeamCtlRegRead(MVME_INTERFACE *mvme, const DWORD base_adr)
00308 {
00309   BYTE data;
00310   data =  (0xFF &  (VPPGRegRead(mvme, base_adr,  VPPG_VME_BEAM_CTL)));
00311   if(ddd)printf("VPPGBeamCtlRegRead: read back %d \n",data);
00312   if(data == 0)
00313     printf("Beam off independent of PPG script\n");
00314   else if(data == 1)
00315     printf("Beam on independent of PPG script\n");
00316   else
00317     printf("PPG script controls Beam output\n");
00318   return(data);
00319 }
00320 
00321 /*------------------------------------------------------------------*/
00322 /** VPPGStartSequencer
00323     Start the PPG sequencer (internal trigger)
00324     @memo start the PPG sequencer.
00325     @param base\_adr PPG VME base address
00326     @return void
00327 */
00328   void VPPGStartSequencer(MVME_INTERFACE *mvme, const DWORD base_adr)
00329 {
00330 
00331   VPPGPolmskWrite(mvme, base_adr, VPPG_DEFAULT_PPG_POL_MSK);
00332   VPPGRegWrite(mvme, base_adr, VPPG_PPG_START_TRIGGER  , 0);
00333   return;
00334 }
00335 
00336 /*------------------------------------------------------------------*/
00337 /** VPPGStopSequencer
00338     Stop the PPG sequencer.
00339     @memo Stop the PPG sequencer.
00340     @param base\_adr PPG VME base address
00341     @return void
00342 */
00343   void VPPGStopSequencer(MVME_INTERFACE *mvme, const DWORD base_adr)
00344 {
00345   VPPGRegWrite(mvme, base_adr,  VPPG_VME_RESET  , 0);
00346   return;
00347 }
00348 
00349 
00350 /*------------------------------------------------------------------*/
00351 /**  VPPGEnableExtTrig(ppg_base)
00352     Enable front panel trigger input so external inputs can start the sequence
00353     @memo Enable external trigger  input so external inputs can start the sequence
00354     @param base\_adr PPG VME base address
00355     @return data
00356 */
00357 BYTE  VPPGEnableExtTrig(MVME_INTERFACE *mvme, const DWORD base_adr)
00358 {
00359   BYTE data;
00360   data = VPPGRegWrite(mvme, base_adr,  VPPG_VME_TRIG_CTL  , 0);
00361    return data;
00362 }
00363 
00364 
00365 
00366 /*------------------------------------------------------------------*/
00367 /**  VPPGDisableExtTrig(ppg_base)
00368     Disable front panel trigger input so external inputs cannot start the sequence
00369     @memo Disable external trigger  input so external inputs cannot start the sequence
00370     @param base\_adr PPG VME base address
00371     @return data
00372 */
00373 BYTE VPPGDisableExtTrig(MVME_INTERFACE *mvme, const DWORD base_adr)
00374 {
00375   return VPPGRegWrite(mvme, base_adr,  VPPG_VME_TRIG_CTL  , 1);
00376 }
00377 
00378 
00379 /*------------------------------------------------------------------*/
00380 /** VPPGExtTrigRegRead
00381     Read external trig register (bit 0 int/ext trigger is enabled bit 1 trigger active/inactive)
00382     @memo Read PPG.
00383     @param base\_adr PPG VME base addroless
00384     @return value (8bit)
00385 */
00386   BYTE  VPPGExtTrigRegRead(MVME_INTERFACE *mvme, const DWORD base_adr)
00387 {
00388   BYTE data;
00389   data = (BYTE) VPPGRegRead(mvme, base_adr,  VPPG_VME_TRIG_CTL);
00390   if(data == 0)
00391     printf("External trigger is ENABLED\n");
00392   else
00393     printf("External trigger is DISABLED\n");
00394   return(data);
00395 }
00396 
00397 /*------------------------------------------------------------------*/
00398 /** VPPG\_polmsk\_write
00399     Write the Polarity mask.
00400     @memo Write and read back polarity mask.
00401     @param base\_adr PPG VME base address
00402     @param pol polarity (24bit)
00403     @return polarity (24bit)
00404 */
00405   DWORD VPPGPolmskWrite(MVME_INTERFACE *mvme, const DWORD base_adr, const DWORD pol)
00406 {
00407   BYTE temp;
00408 
00409   temp  = *((BYTE *) &pol + 2);
00410   if(ddd)printf("write high bits : 0x%x\n",temp);
00411   VPPGRegWrite(mvme, base_adr, VPPG_OUTP_POL_MASK_HI, temp); 
00412 
00413   temp  = *((BYTE *) &pol + 1);
00414   if(ddd)printf("write mid bits : 0x%x\n",temp);
00415   VPPGRegWrite(mvme, base_adr, VPPG_OUTP_POL_MASK_MID, temp); 
00416 
00417   temp  = *((BYTE *) &pol + 0);
00418   if(ddd)printf("write low bits : 0x%x\n",temp);
00419   VPPGRegWrite(mvme, base_adr, VPPG_OUTP_POL_MASK_LO, temp); 
00420 
00421   return VPPGPolmskRead(mvme,base_adr);
00422 }
00423 
00424 /*------------------------------------------------------------------*/
00425 /** VPPGPolmskRead 
00426     Read the Polarity mask.
00427     @memo Read polarity mask.
00428     @param base\_adr PPG VME base address
00429     @return polarity (24bit)
00430 */
00431   DWORD VPPGPolmskRead(MVME_INTERFACE *mvme, const DWORD base_adr)
00432 {
00433   BYTE temp;
00434   DWORD  pol;
00435   pol = 0;
00436   temp = (BYTE)(VPPGRegRead(mvme, base_adr,   VPPG_OUTP_POL_MASK_HI));
00437   if(ddd)printf("read high bits : 0x%x\n",temp);
00438   pol |= (temp & 0xFF) << 16;
00439   if(ddd)printf("pol =  0x%lx\n",pol);
00440 
00441   temp =(BYTE)(VPPGRegRead(mvme, base_adr,   VPPG_OUTP_POL_MASK_MID));
00442   if(ddd)printf("read mid bits : 0x%x\n",temp);
00443   pol |= (temp & 0xFF) <<  8;
00444   if(ddd)printf("pol =  0x%lx\n",pol);
00445 
00446   temp =(BYTE)(VPPGRegRead(mvme, base_adr,   VPPG_OUTP_POL_MASK_LO));
00447   if(ddd)printf("read low bits : 0x%x\n",temp);
00448   pol |= (temp & 0xFF);
00449   printf("pol =  0x%lx\n",pol);
00450 
00451   return pol;
00452 }
00453 
00454 /*------------------------------------------------------------------*/
00455 /** ppg\_startpattern\_write    ?????????????????????
00456     Write the Start(Power up or Reset)Pattern.
00457     @memo Write and read back startup pattern.
00458     @param base\_adr PPG VME base address
00459     @param pol polarity (24bit)
00460     @return polarity (24bit)
00461 */
00462   DWORD VPPGStartpatternWrite(MVME_INTERFACE *mvme, const DWORD base_adr, 
00463                              const DWORD pol)
00464 {
00465   
00466   VPPGRegWrite(mvme, base_adr, VPPG_PPG_RESET_REG,0);
00467   VPPGRegWrite(mvme, base_adr, VPPG_BYTES_PER_WORD,0x0A);
00468   VPPGRegWrite(mvme, base_adr, VPPG_TOGL_MEM_DEVICE,0);
00469   VPPGRegWrite(mvme, base_adr, VPPG_CLEAR_ADDR_COUNTER,0x55);
00470   VPPGRegWrite(mvme, base_adr, VPPG_PROGRAMMING_FIN,7);
00471   VPPGRegWrite(mvme, base_adr, VPPG_PPG_START_TRIGGER,7);
00472   VPPGRegWrite(mvme, base_adr, VPPG_PPG_RESET_REG,1);
00473   VPPGRegWrite(mvme, base_adr, VPPG_BYTES_PER_WORD,3);
00474   VPPGRegWrite(mvme, base_adr, VPPG_CLEAR_ADDR_COUNTER,0);
00475   VPPGRegWrite(mvme, base_adr, VPPG_LOAD_MEM,*((BYTE *) &pol + 1));
00476   VPPGRegWrite(mvme, base_adr, VPPG_LOAD_MEM,*((BYTE *) &pol + 2));
00477   VPPGRegWrite(mvme, base_adr, VPPG_LOAD_MEM,*((BYTE *) &pol + 3));
00478   VPPGRegWrite(mvme, base_adr,0x05,0);
00479   VPPGRegWrite(mvme, base_adr,0x05,0);
00480   return VPPGPolmskRead(mvme, base_adr);
00481 }
00482 /*------------------------------------------------------------------*/
00483 /** byteOutputOrder
00484     byte swap for output
00485     @memo byte swap for PPG.
00486     @param data 
00487     @param array 
00488     @return void
00489 */
00490   void byteOutputOrder(PARAM data, char *array)
00491 {
00492 #define LOW_MASK        0x000000FF
00493 #define LOW_MID_MASK    0x0000FF00
00494 #define HIGH_MID_MASK   0x00FF0000
00495 #define HIGH_MASK       0xFF000000
00496 #define BRANCH1_MASK    0X000FF000
00497 #define BRANCH2_MASK    0X00000FF0
00498 #define BRANCH3_MASK    0X0000000F
00499   
00500   //unsigned long total_bits;
00501   //unsigned int *test;
00502   
00503   /*total_bits = data.opcode_width + data.branch_width + data.delay_width  */
00504   /*                     + data.flag_width;            */
00505   
00506   array[0] = (char)( (data.flags & HIGH_MID_MASK) >> 16);
00507   array[1] = (char)( (data.flags & LOW_MID_MASK) >> 8);
00508   array[2] = (char)( (data.flags & LOW_MASK));
00509   
00510   if (ddd) printf("branch = %lx\n",data.branch_addr);
00511 
00512   array[3] = (char)( (data.branch_addr & BRANCH1_MASK) >> 12);
00513   array[4] = (char)( (data.branch_addr & BRANCH2_MASK) >> 4);
00514   array[5] = (char)((data.branch_addr & BRANCH3_MASK) << 4);
00515   array[5] = array[5] | (char)(data.opcode & BRANCH3_MASK);
00516   
00517   array[6] = (char)( (data.delay & HIGH_MASK) >> 24);
00518   array[7] = (char)( (data.delay & HIGH_MID_MASK) >> 16);
00519   array[8] = (char)( (data.delay & LOW_MID_MASK) >> 8);
00520   array[9] = (char)( (data.delay & LOW_MASK));
00521 }
00522 
00523 /*------------------------------------------------------------------*/
00524 /** lineRead
00525     Read line of input file
00526     @memo read line.
00527     @param *input FILE pointer
00528     @return PARAM data structure
00529 */
00530   PARAM lineRead(FILE *infile)
00531 {
00532   PARAM data_struct;
00533   unsigned int temp;
00534   //  char line[128];
00535 
00536   /*
00537   fgets(line, 128, infile);
00538   printf("line:%s\n", line);
00539   */
00540   fscanf(infile,"%x",&temp);
00541   data_struct.opcode = (char)temp;
00542   
00543   fscanf(infile,"%lx",&(data_struct.branch_addr));
00544   fscanf(infile,"%lx",&(data_struct.delay));
00545   fscanf(infile,"%lx",&(data_struct.flags));
00546 
00547   return(data_struct);
00548 }
00549 
00550 /*------------------------------------------------------------------*/
00551 /** ppgLoad
00552     Load PPG file into sequencer.
00553     @memo Load file PPG.
00554     @param base\_adr PPG VME base address
00555     @return 1=SUCCESS, -1=file not found
00556 */
00557 int VPPGLoad(MVME_INTERFACE *mvme, const DWORD base_adr, char *file)
00558 {
00559   /*  Local Variables  */
00560   long    j,i;
00561   int   index = 0;
00562   char  text[100];
00563   char  num_instructions;
00564   char  flag_size;
00565   char  delay_size;
00566   char  branch_size;
00567   char  opcode_size;
00568   unsigned char array[12];
00569   PARAM  command_info;
00570   unsigned int  temp;
00571   unsigned char result;
00572   //  FILE  *ppginput;
00573   unsigned short port_address;
00574   
00575   printf("Opening file: %s   ...  ",file);
00576   ppginput = fopen(file,"r");
00577   sleep(1) ; // sleep 1s
00578   if(ppginput == NULL){
00579     printf("ppgLoad: Byte code file %s could not be opened. [%p]\n", file, ppginput);
00580     printf("  If file is present, problem may be too many rpc processes.  Reboot ppc and retry\n");
00581     return -1;
00582   }
00583   
00584   fscanf(ppginput,"%s",text);
00585   index = strcmp(text,"Op_Code");
00586   if(index == 0){
00587     fscanf(ppginput,"%s",text);
00588     index = strcmp(text,"Size");
00589     if(index == 0){
00590       fscanf(ppginput,"%s",text);
00591     }
00592     else {
00593       printf("ppgLoad: Input file has wrong format. Aborting procedure.\n");
00594       return -1;
00595     }
00596   }
00597   opcode_size = (char)atol(text);
00598   
00599   fscanf(ppginput,"%s",text);
00600   index = strcmp(text,"Branch");
00601   if(index == 0){
00602     fscanf(ppginput,"%s",text);
00603     index = strcmp(text,"Size");
00604     if(index == 0){
00605       fscanf(ppginput,"%s",text);
00606     }
00607     else {
00608       printf("ppgLoad: Input file has wrong format. Aborting procedure.\n");
00609       return -1;
00610     }
00611   }
00612   branch_size = (char)atol(text);
00613   
00614   fscanf(ppginput,"%s",text);
00615   index = strcmp(text,"Delay");
00616   if(index == 0){
00617     fscanf(ppginput,"%s",text);
00618     index = strcmp(text,"Size");
00619     if(index == 0){
00620       fscanf(ppginput,"%s",text);
00621     }
00622     else {
00623       printf("ppgLoad: Input file has wrong format. Aborting procedure.\n");
00624       return -1;
00625     }
00626   }
00627   delay_size = (char)atol(text);
00628   
00629   fscanf(ppginput,"%s",text);
00630   index = strcmp(text,"Flag");
00631   if(index == 0){
00632     fscanf(ppginput,"%s",text);
00633     index = strcmp(text,"Size");
00634     if(index == 0){
00635       fscanf(ppginput,"%s",text);
00636     }
00637     else {
00638       printf("ppgLoad: Input file has wrong format. Aborting procedure.\n");
00639       return -1;
00640     }
00641   }
00642   flag_size = (char)atol(text);
00643   
00644   fscanf(ppginput,"%s",text);
00645   index = strcmp(text,"Instruction");
00646   if(index == 0){
00647     fscanf(ppginput,"%s",text);
00648     index = strcmp(text,"Lines");
00649     if(index == 0){
00650       fscanf(ppginput,"%s",text);
00651     }
00652     else {
00653       printf("ppgLoad: Input file has wrong format. Aborting procedure.\n");
00654       return -1;
00655     }
00656   }
00657   num_instructions = (char)atol(text);
00658   if (ddd) printf("instruction lines = %d\n",num_instructions);
00659   
00660   fscanf(ppginput,"%s",text);
00661   index = strcmp(text,"Port");
00662   if(index == 0){
00663     fscanf(ppginput,"%s",text);
00664     index = strcmp(text,"Address");
00665     if(index == 0){
00666       fscanf(ppginput,"%hx",&port_address);
00667     }
00668     else {
00669       printf("ppgLoad: Input file has wrong format. Aborting procedure.\n");
00670       return -1;
00671     }
00672   }
00673   if (ddd) printf("Base Address = %lx\n",base_adr);
00674   
00675   if (ddd) printf("Reading byte code file...\n");
00676   
00677   
00678   command_info.opcode_width = opcode_size;
00679   command_info.branch_width = branch_size;
00680   command_info.delay_width = delay_size;
00681   command_info.flag_width = flag_size;
00682   
00683   /* init ISA BUS Controller  */
00684   VPPGRegWrite(mvme, base_adr, VPPG_PPG_RESET_REG,0x00);
00685   VPPGRegWrite(mvme, base_adr, VPPG_BYTES_PER_WORD,0x0A);
00686   VPPGRegWrite(mvme, base_adr, VPPG_TOGL_MEM_DEVICE,0x00);/*Is this still active?*/
00687   VPPGRegWrite(mvme, base_adr, VPPG_CLEAR_ADDR_COUNTER,0x00);
00688   
00689   for(i=0;i<num_instructions;i++){
00690     command_info = lineRead(ppginput);
00691     if (ddd)
00692       {
00693         printf("%1x ",command_info.opcode);
00694         printf("%5lx ",command_info.branch_addr);
00695         printf("%8lx ",command_info.delay);
00696         printf("%6lx ",command_info.flags);
00697         printf("\n");
00698       }
00699     byteOutputOrder(command_info,array);
00700     
00701     for(j=0;j<10;j++){
00702       result = array[j];
00703       temp = (unsigned int) result;
00704       if (ddd) printf("%x ",temp);
00705     }
00706     if (ddd) printf("\n");
00707     
00708     for(j=0;j<10;j++)
00709       {
00710         VPPGRegWrite(mvme, base_adr, VPPG_LOAD_MEM, array[j]);
00711       }
00712   }
00713   
00714   /* arm controller        */
00715   VPPGRegWrite(mvme, base_adr, VPPG_LOAD_MEM,0x00);/*writes the stop command */
00716   VPPGRegWrite(mvme, base_adr, VPPG_LOAD_MEM,0x00);
00717   VPPGRegWrite(mvme, base_adr, VPPG_LOAD_MEM,0x00);
00718   VPPGRegWrite(mvme, base_adr, VPPG_LOAD_MEM,0x00);
00719   VPPGRegWrite(mvme, base_adr, VPPG_LOAD_MEM,0x00);
00720   VPPGRegWrite(mvme, base_adr, VPPG_LOAD_MEM,0x01);
00721   VPPGRegWrite(mvme, base_adr, VPPG_LOAD_MEM,0x00);
00722   VPPGRegWrite(mvme, base_adr, VPPG_LOAD_MEM,0x00);
00723   VPPGRegWrite(mvme, base_adr, VPPG_LOAD_MEM,0x00);
00724   VPPGRegWrite(mvme, base_adr, VPPG_LOAD_MEM,0x02);   /*End of stop command     */
00725   
00726   
00727   VPPGRegWrite(mvme, base_adr, VPPG_PROGRAMMING_FIN,0x00);
00728   fclose(ppginput);
00729   if(ddd) printf("Programming ended, controller armed");
00730   return 1;
00731 }
00732 
00733 /*****************************************************************/
00734 /*-PAA- For test purpose only */
00735 #ifdef MAIN_ENABLE
00736 int main (int argc, char* argv[]) {
00737 
00738 
00739   DWORD PPG_BASE = 0x8000;
00740   
00741   MVME_INTERFACE *mvme;
00742 
00743   int status;
00744   DWORD ival;
00745   BYTE data,value;
00746   char cmd[]="hallo";
00747   int s;
00748   char filename[128];
00749 
00750   DWORD rpol,pol,reg_offset;
00751 
00752   if (argc>1) {
00753     sscanf(argv[1],"%lx",&PPG_BASE);
00754   }
00755 
00756   // Test under vmic   
00757   status = mvme_open(&mvme, 0);
00758   if(status != SUCCESS)
00759     {
00760       printf("failure after mvme_open, status = %d\n",status);
00761       return status;
00762     }
00763 
00764   // Set am to A16 non-privileged Data
00765   // Set in the read/write functions
00766   //  mvme_set_am(mvme, MVME_AM_A16_ND);
00767   // Set dmode to D8
00768   //  mvme_set_dmode(mvme, MVME_DMODE_D8);
00769 
00770   VPPGStatusRead(mvme,PPG_BASE);
00771   data = VPPGExtTrigRegRead(mvme, PPG_BASE);
00772   printf("External trigger register = 0x%x\n",data);
00773 
00774 
00775 
00776   ppg();
00777   while ( isalpha(cmd[0]) )
00778     {
00779       printf("\nEnter command (A-Y) X to exit?  ");
00780       scanf("%s",cmd);
00781       //  printf("cmd=%s\n",cmd);
00782       cmd[0]=toupper(cmd[0]);
00783       s=cmd[0];
00784       
00785       switch(s)
00786         {
00787         case ('A'):
00788           VPPGInit(mvme, PPG_BASE);
00789           break;
00790         case ('B'):
00791           printf("Enter PPG filename : ");
00792           scanf("%s",filename);
00793           VPPGLoad(mvme, PPG_BASE, filename);
00794           break;
00795         case ('C'):
00796           VPPGStopSequencer(mvme, PPG_BASE);
00797           break;
00798         case ('E'):
00799           VPPGStartSequencer(mvme, PPG_BASE);
00800           break;
00801         case ('F'):
00802           data = VPPGEnableExtTrig(mvme, PPG_BASE);
00803           printf("Read back data = %d  expect 0 \n",data);
00804           break;
00805         case ('G'):
00806           data = VPPGDisableExtTrig(mvme, PPG_BASE);
00807           printf("Read back data = %d expect 1 \n",data);
00808           break;
00809         case ('H'):
00810           data=VPPGExtTrigRegRead(mvme, PPG_BASE);
00811           printf("Read back data =0x%x\n",data);
00812           break;
00813         case ('I'):
00814           data = VPPGStatusRead(mvme, PPG_BASE);
00815           printf("Read back data =0x%x\n",data);
00816           break;
00817         case ('J'):
00818           rpol = VPPGPolmskRead(mvme, PPG_BASE);
00819           printf("Read back Pol Mask=0x%lx\n",rpol);
00820           break;
00821         case ('K'):
00822           printf("Enter Mask value to write :0x");
00823           scanf("%lx",&pol);
00824           printf("Writing Pol Mask=0x%lx\n",pol);
00825           rpol = VPPGPolmskWrite(mvme, PPG_BASE, pol);
00826           printf("Read back Pol Mask=0x%lx\n",rpol);
00827           break;
00828         case ('L'):
00829           printf("Enter PPG register offset : 0x");
00830           scanf("%lx",&reg_offset);
00831           printf("Enter data to write: 0x");
00832           scanf("%lx",&ival);
00833           value=ival & 0xFF;
00834           reg_offset = reg_offset & 0xFF;
00835           printf("Writing 0x%x (%d) to register offset 0x%lx (%lu)\n",
00836                  value,value,reg_offset,reg_offset);
00837           data=VPPGRegWrite(mvme, PPG_BASE, reg_offset, value);
00838           printf("Read back from offset 0x%lx (%lu)  data = 0x%x (%d)\n",
00839                  reg_offset,reg_offset,data,data);
00840           break;
00841         case ('M'):
00842           printf("Enter PPG register offset : 0x");
00843           scanf("%lx",&reg_offset);
00844           reg_offset = reg_offset & 0xFF;
00845 
00846           data=VPPGRegRead(mvme, PPG_BASE, reg_offset);
00847           printf("Read back from offset 0x%lx (%lu)    data = 0x%x (%d)\n ",
00848                  reg_offset,reg_offset,data,data);
00849           break;
00850         case ('N'):
00851           printf("Enter Pol Mask : 0x");
00852           scanf("%lx",&ival);
00853           VPPGStartpatternWrite(mvme, PPG_BASE, ival);
00854           break;
00855         case ('O'):
00856           printf("Enter value to set (0 or 1):\n");
00857           scanf("%lx",&ival);
00858           value = ival && 0xFF;
00859           VPPGPolzSet(mvme, PPG_BASE, value);
00860           break;
00861         case ('Q'):
00862           data = VPPGPolzRead(mvme, PPG_BASE);
00863           printf("data = %d\n",data);
00864           break;
00865         case ('R'):
00866           data = VPPGPolzFlip(mvme, PPG_BASE);
00867           printf("read back = %d\n",data);
00868           break;
00869         case ('S'):
00870           VPPGPolzCtlPPG(mvme, PPG_BASE);
00871           break;
00872         case ('T'):
00873           VPPGPolzCtlVME(mvme, PPG_BASE);
00874           break;
00875         case ('U'):
00876           VPPGBeamOn(mvme, PPG_BASE);
00877           break;
00878         case ('V'):
00879           VPPGBeamOff(mvme, PPG_BASE);
00880           break;
00881         case ('W'):
00882           VPPGBeamCtlPPG(mvme, PPG_BASE);
00883           break;
00884         case ('Y'):
00885           data=VPPGBeamCtlRegRead(mvme, PPG_BASE);
00886           printf("Read back data =0x%x\n",data);
00887           break;
00888         case ('D'):
00889           if (ddd)
00890             ddd=0;
00891           else
00892             ddd=1;
00893           break;
00894         case ('P'):
00895           ppg();
00896           break;
00897         case ('X'):
00898           return 1;
00899         default:
00900           break;
00901         }
00902     }
00903 
00904   /*
00905   VPPGStatusRead(mvme,PPG_BASE);
00906   data = VPPGExtTrigRegRead(mvme, PPG_BASE);
00907   printf("External trigger register = 0x%x\n",data);
00908 
00909   printf("\nmain: calling VPPGInit; sets POL mask=0x%x and VME controls hel\n",
00910          VPPG_DEFAULT_PPG_POL_MSK);
00911   VPPGInit(mvme, PPG_BASE);
00912   VPPGStatusRead(mvme,PPG_BASE);
00913   data = VPPGExtTrigRegRead(mvme, PPG_BASE);
00914   printf("External trigger register = 0x%x\n",data);
00915   */
00916 
00917   status = mvme_close(mvme);
00918   return 1;
00919 }       
00920 #endif
00921 

Midas DOC Version 2.0.2 ---- PSI Stefan Ritt ----
Contributions: Pierre-Andre Amaudruz - Sergio Ballestrero - Suzannah Daviel - Doxygen - Peter Green - Qing Gu - Greg Hackman - Gertjan Hofman - Paul Knowles - Exaos Lee - Rudi Meier - Glenn Moloney - Dave Morris - John M O'Donnell - Konstantin Olchanski - Renee Poutissou - Tamsen Schurman - Andreas Suter - Jan M.Wouters - Piotr Adam Zolnierczuk