00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #include <stdio.h>
00012 #include <string.h>
00013 #include <stdio.h>
00014 #include <ctype.h>
00015 #include "unistd.h"
00016 #include "vppg.h"
00017
00018 int ddd=1;
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
00046
00047
00048
00049
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
00059
00060
00061
00062
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
00077
00078
00079
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
00104
00105
00106
00107
00108
00109
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);
00118 mvme_set_dmode(mvme, MVME_DMODE_D8);
00119
00120 mvme_get_am(mvme, &localam);
00121 mvme_set_am(mvme, MVME_AM_A16_ND);
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;
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);
00132 mvme_set_am(mvme, localam);
00133
00134 return (BYTE)myval;
00135 }
00136
00137
00138
00139
00140
00141
00142
00143
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);
00151 mvme_set_dmode(mvme, MVME_DMODE_D8);
00152
00153 mvme_get_am(mvme, &localam);
00154 mvme_set_am(mvme, MVME_AM_A16_ND);
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);
00162 mvme_set_am(mvme, localam);
00163 return (BYTE) value;
00164 }
00165
00166
00167
00168
00169
00170
00171
00172
00173 void VPPGInit(MVME_INTERFACE *mvme, const DWORD base_adr)
00174 {
00175 VPPGPolmskWrite(mvme, base_adr, VPPG_DEFAULT_PPG_POL_MSK );
00176
00177
00178 VPPGPolzCtlPPG(mvme, base_adr);
00179 VPPGBeamCtlPPG(mvme, base_adr);
00180
00181
00182 VPPGDisableExtTrig(mvme, base_adr);
00183
00184 return;
00185 }
00186
00187
00188
00189
00190
00191
00192
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
00232
00233
00234
00235
00236
00237 void VPPGBeamOn(MVME_INTERFACE *mvme, const DWORD base_adr)
00238 {
00239
00240 VPPGRegWrite(mvme, base_adr,VPPG_VME_BEAM_CTL , 1);
00241
00242 return;
00243 }
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253 void VPPGBeamOff(MVME_INTERFACE *mvme, const DWORD base_adr)
00254 {
00255 VPPGRegWrite(mvme, base_adr,VPPG_VME_BEAM_CTL , 0);
00256
00257 return;
00258 }
00259
00260
00261
00262
00263
00264
00265
00266
00267 void VPPGBeamCtlPPG(MVME_INTERFACE *mvme, const DWORD base_adr)
00268 {
00269 VPPGRegWrite(mvme, base_adr,VPPG_VME_BEAM_CTL , 3);
00270
00271 return;
00272 }
00273
00274
00275
00276
00277
00278
00279
00280
00281 void VPPGPolzCtlVME(MVME_INTERFACE *mvme, const DWORD base_adr)
00282 {
00283 VPPGRegWrite(mvme, base_adr, VPPG_POLZ_SOURCE_CONTROL , 0);
00284
00285 return;
00286 }
00287
00288
00289
00290
00291
00292
00293
00294 void VPPGPolzCtlPPG(MVME_INTERFACE *mvme, const DWORD base_adr)
00295 {
00296 VPPGRegWrite(mvme, base_adr, VPPG_POLZ_SOURCE_CONTROL , 2);
00297
00298 return;
00299 }
00300
00301
00302
00303
00304
00305
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
00323
00324
00325
00326
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
00338
00339
00340
00341
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
00352
00353
00354
00355
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
00368
00369
00370
00371
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
00381
00382
00383
00384
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
00399
00400
00401
00402
00403
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
00426
00427
00428
00429
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
00456
00457
00458
00459
00460
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
00484
00485
00486
00487
00488
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
00501
00502
00503
00504
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
00525
00526
00527
00528
00529
00530 PARAM lineRead(FILE *infile)
00531 {
00532 PARAM data_struct;
00533 unsigned int temp;
00534
00535
00536
00537
00538
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
00552
00553
00554
00555
00556
00557 int VPPGLoad(MVME_INTERFACE *mvme, const DWORD base_adr, char *file)
00558 {
00559
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
00573 unsigned short port_address;
00574
00575 printf("Opening file: %s ... ",file);
00576 ppginput = fopen(file,"r");
00577 sleep(1) ;
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
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);
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
00715 VPPGRegWrite(mvme, base_adr, VPPG_LOAD_MEM,0x00);
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);
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
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
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
00765
00766
00767
00768
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
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",®_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",®_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
00906
00907
00908
00909
00910
00911
00912
00913
00914
00915
00916
00917 status = mvme_close(mvme);
00918 return 1;
00919 }
00920 #endif
00921