home *** CD-ROM | disk | FTP | other *** search
/ Amiga Developer CD v1.2 / amidev_cd_12.iso / reference / amiga_mail_vol1 / input / inputresource < prev    next >
Text File  |  1990-01-26  |  21KB  |  716 lines
  1. (c)  Copyright 1989 Commodore-Amiga, Inc.   All rights reserved.
  2. The information contained herein is subject to change without notice, and 
  3. is provided "as is" without warranty of any kind, either expressed or implied.  
  4. The entire risk as to the use of this information is assumed by the user.
  5.  
  6.  
  7.        
  8.                        Allocation of Input and 
  9.                        Other System Resources
  10.                
  11.                             by Bob Burns
  12.  
  13.     
  14. In most system designs there is a trade-off between ease of use and 
  15. performance.  The Amiga is no exception.  Historically, high performance 
  16. applications have resorted to taking over the machine in order to get direct 
  17. access to system resources.  This is something we would like to avoid because 
  18. once the machine is taken over, there is no exit.  The user must reboot. 
  19. The purpose of this article is to present some techniques that let games
  20. and other special applications take over those portions of the system that 
  21. they need, yet gracefully return them when no longer needed.
  22.  
  23.  
  24. Input Resources
  25. ---------------
  26.  
  27. The Input Task 
  28.  
  29. A useful metaphor for describing the input task on the Amiga is the 
  30. "food-chain".  Raw input events are passed through a linked list of handlers.
  31. Each handler processes the input events it receives and returns a new set to 
  32. be "consumed" by the next input handler in the chain.  
  33.  
  34. The primal input events are designated RAWKEY, RAWMOUSE, TIMER and  DISK.  
  35. The RAWKEY, RAWMOUSE and TIMER input events are started up the food chain by 
  36. the input.device itself in response to its continuing IO requests to the 
  37. keyboard, gameport, and timer devices.  The DISK events are inserted into 
  38. the chain by the DOS.
  39.  
  40. The two standard consumers in the food chain are Intuition and the console 
  41. device.  Intuition in particular is prolific in the variety of new input 
  42. events it may produce in response to a primal event.  Another consumer often 
  43. found in the food chain is a generic hotkey program.  These insert themselves 
  44. in the food chain before either Intuition or the console.  
  45.  
  46. The food chain is implemented as a a prioritized list, with Intuition at a 
  47. priority of 50 and the console device at 20.  For more on input events, see 
  48. the devices/inputevents.h header.
  49.  
  50.  
  51. Input Device Commands
  52.  
  53. Let's quickly review the input device commands you can use to control the 
  54. food chain.  Insertion and removal of a new consumer in the input device food 
  55. chain is performed by the input.device commands AddHandler and RemHandler.
  56.  
  57. The command WriteEvent is used to propagate an event through the input food 
  58. chain without being on it.
  59.  
  60. The commands SetThresh and SetPeriod are used to modifiy the key repeat rate.
  61.  
  62. Finally, the commands SetMPort, SetMType, and SetMTrig are used to modify the 
  63. gameport controller that is to be used for mouse input.  The use of these 
  64. commands is illustrated in the example code shown below.
  65.  
  66. The joymouse.c example uses the commands to move the mouse to the second 
  67. gameport device so that the first gameport can be used with a lightpen.  This 
  68. is useful for owners of the original model A1000 and A2000s.  
  69.  
  70. The joymouse.c example also shows how to change the first gameport to work 
  71. with a joystick, or remove it from the input food chain entirely so both 
  72. ports can be used for other purposes.
  73.  
  74. You need only disable the mouse to use the gameports for your special purposes. 
  75. You don't need to take over the whole machine.  The gameport.device can then 
  76. be used to gather data from the port, or the hardware can be read directly.
  77.  
  78.  
  79.  
  80. Gameport Input
  81.  
  82. The gameport.device contains two units, one for each gameport.  The original 
  83. Amiga design called for game controllers to be allocated to applications as 
  84. follows:
  85.  
  86.         1.  Let multiple opens of gameport.device occur.
  87.  
  88.         2.  Follow a high level protocol for determining if the 
  89.             gameport is in use: check via AskCType for the flag
  90.             GPCT_NOCONTROLLER.  If set, then no one else is using it.
  91.  
  92. There are some problems with this scheme.  First, there is no protection 
  93. between SetCType and AskCType.  So two tasks can AskCType, see NO, and
  94. both SetCType.  Second, because games often go directly to the hardware, 
  95. the gameport.device became just a spoon-feeder to the input.device for mouse 
  96. input.
  97.     
  98. Despite these problems, the gameports can still be shared between applications
  99. in a system-compatible way.  Neither the SetCType nor AskCType commands are 
  100. deferred, nor do they wait and thus break a Forbid.   This means you can use 
  101. the following code to get a gameport:
  102.  
  103.         Forbid
  104.         AskCType
  105.         if(GPCT_NOCONTROLLER){
  106.             SetCType
  107.             owned = TRUE      }
  108.         else
  109.             owned = FALSE
  110.         endif
  111.         Permit
  112.  
  113. We normally try to discourage counting on this kind of side effect, but in 
  114. this case, it's the only way.  If the port is being allocated, but not for 
  115. one of the supported controller types, then set the controller to the 
  116. catch-all value GPCT_ALLOCATED.
  117.  
  118.  
  119.  
  120. Joysticks
  121.  
  122. To read a joystick, there are three choices.  The first is to change the 
  123. mouse port to a joystick port and capture events from the input device food 
  124. chain as a handler.  This is not recommended.
  125.     
  126. The second choice is to read the joystick port directly from the hardware 
  127. registers.  It's fairly easy to do and we cannot fault folks for doing it 
  128. this way - just make sure to allocate the gameport unit so other applications
  129. know you've got the port.  You should also allocate the POTGO resource bits 
  130. to acquire buttons 2 & 3.
  131.  
  132. The third choice is to use the gameport device.  This polls every vertical 
  133. blank and only satisfies requests when trigger conditions are met.  It's 
  134. advantages are that the polling runs out of the contention-free ROMs, and 
  135. when combined with certain reply port types (e.g. the direct call action), 
  136. can be efficient for your application.
  137.  
  138.  
  139.  
  140. Proportional Controller
  141.  
  142. Unfortunately, support for proportional controllers in the gameport device 
  143. was removed in one of the early code crunches.  This occurred after support 
  144. for Coleco-style controllers had already been removed.  The example program
  145. propjoy.c shown below demonstrates how to use the potgo resource and some 
  146. vblank interrupt routines to track proportional controllers.
  147.  
  148.  
  149.  
  150. Keyboard Input
  151.  
  152. The input device IO requests to the gameport can be shut down but IO requests 
  153. to the keyboard cannot.  If an application requests key events from the 
  154. keyboard, it will probably get about half of them: every other one going to 
  155. the input device.  So, to learn about all the key states an application can 
  156. either poll the keyboard with the ReadMatrix command, or insert itself as a 
  157. handler in the food chain.  If you use the ReadMatrix command, note that
  158. io_Length MUST be exactly 13.
  159.  
  160.  
  161.  
  162.  
  163. Other System Resources
  164. ----------------------
  165.  
  166. Misc
  167.  
  168. Whenever using serial or parallel port resources, they must be acquired from 
  169. the misc.resource.  The misc.resource oversees usage of the serial data port, 
  170. the serial communication bits, the parallel data and handshake port, and the 
  171. parallel communication bits.  The parallel communication bits double as the 
  172. Commodore serial bus interface bits for those who want to connect a 1541 to 
  173. the Amiga.
  174.  
  175. The serial and parallel devices both use the misc.resource.  If the Exec 
  176. device is opened and closed, the appropriate two misc resources will be 
  177. allocated then freed.  Unfortunately, if the DOS devices SER: or PAR: have
  178. been opened, they will open the device and thus the corresponding resource 
  179. pair forever.  For more information on this problem see the article on the
  180. parallel and serial resources elsewhere in this issue.
  181.  
  182.  
  183. Disk
  184.  
  185. Whenever using floppy disk resources, they must be acquired from the disk 
  186. resource.  The disk resource provides both a gross and a fine unit allocation
  187. scheme.  AllocUnit and FreeUnit are used to claim a unit for long term use, 
  188. and GetUnit and GiveUnit are used to claim a unit for shorter periods.
  189.  
  190. The trackdisk.device uses and abides by both allocation schemes.  Because a 
  191. trackdisk unit is never closed for Amiga 3.5" drives, since the file system 
  192. keeps them open, the associated resource units will always be allocated for 
  193. these drives.  GetUnit and GiveUnit can still be used, however, by other 
  194. applications that have not succeeded with AllocUnit.
  195.  
  196. It is therefore possible to prevent the trackdisk device from using units that
  197. have not been mounted yet by successfully performing an AllocUnit for that 
  198. unit.  It is also possible to starve trackdisk usage by performing a GetUnit.
  199. The appropriate companion routine (FreeUnit or GiveUnit) should be called to 
  200. restore the resource at the end of its use.
  201.  
  202.  
  203. CIA
  204.  
  205. CIA resources not associated with the misc and disk resources are the joystick
  206. fire buttons, which are acquired with the appropriate gameport.device unit, 
  207. the LED/audio filter, which is catch-as-catch-can, the memory overlay bit 
  208. and the keyboard serial interface, which is defined to be allocated by the 
  209. keyboard.device when it is running.  The CIAB timers are available to be 
  210. allocated and are associated with an interrupt.  It is therefore allocated by
  211. successfully adding a vector for that interrupt with AddICRVector.
  212.  
  213.  
  214.         Amiga CIA Timer Allocation
  215.  
  216.         CIAA (int 2)
  217.             timerA      Used for keyboard handshake
  218.             timerB      Used for uSec timer.device
  219.             TOD         Used for 60Hz timer.device
  220.  
  221.          CIAB (int 6)
  222.             timerA      Commodore serial bus communication, usually not used
  223.             timerB      Not used
  224.             TOD         Used for graphics.library beam counter
  225.  
  226.  
  227. By using the techniques outlined above, you can often avoid taking over the 
  228. whole system in your high-performance applications.  Allocate only the 
  229. resources you need and return them when you are done.
  230.  
  231.  
  232.   Copyright (c) 1988 Commodore-Amiga, Inc.
  233.  
  234.   Executables based on this information may be used in software
  235.   for Commodore Amiga computers.  All other rights reserved.
  236.  
  237.   This information is provided "as is"; no warranties are made.
  238.   All use is at your own risk, and no liability or responsibility is assumed.
  239.  
  240.  
  241. ;=============================================================
  242. ; makefile - requires Manx 3.6
  243. ;=============================================================
  244. ;
  245. ;joymouse:    joymouse.o32 iefa.o
  246. ;    ln joymouse.o32 iefa.o -lc32 -o joymouse
  247. ;
  248. ;joymouse.o32:    joymouse.c
  249. ;    cc +L +C +D +p -B -S -L100 -o joymouse.o32 joymouse.c
  250. ;
  251. ;iefa.o:        iefa.asm
  252. ;    as -o iefa.o iefa.asm
  253. ;
  254. ;=============================================================
  255. ; joymouse.c
  256. ;=============================================================
  257. ; 
  258. #define    DEBUG
  259. #include    "exec/types.h"
  260. #include    "exec/nodes.h"
  261. #include    "exec/lists.h"
  262. #include    "exec/ports.h"
  263. #include    "exec/interrupts.h"
  264. #include    "devices/gameport.h"
  265. #include    "devices/input.h"
  266. #include    "devices/inputevent.h"
  267. #include    "libraries/dos.h"
  268.  
  269. struct Task *FindTask();
  270.  
  271. struct MsgPort iorp = {
  272.     {0, 0, NT_MSGPORT, 0, 0}, 0, SIGF_SINGLE, 0, {0, 0, 0, 0, 0}
  273. };
  274.  
  275. struct IOStdReq ior = {
  276.     {{0, 0, NT_MESSAGE, 0, 0}, &iorp, 0},
  277.     0, 0, 0, 0, 0, 0, 0, 0, 0
  278. };
  279.  
  280. struct InputEvent nullEvent = {
  281.     NULL, IECLASS_NULL
  282. };
  283.  
  284. struct GamePortTrigger joyTrigger = {
  285.     GPTF_DOWNKEYS|GPTF_UPKEYS, 1, 1, 1
  286. };
  287.  
  288. struct GamePortTrigger mouseTrigger = {
  289.     GPTF_DOWNKEYS|GPTF_UPKEYS, 0, 1, 1
  290. };
  291.  
  292. extern VOID eventAFunction();
  293.  
  294. struct Interrupt inputHandler = {
  295.     {0, 0, NT_INTERRUPT, 100, 0}, 0, eventAFunction
  296. };
  297.  
  298. #define    MAXDELTA    255
  299. #define    DELTASHIFT    4
  300.  
  301. int deltaX = 0;
  302. int deltaY = 0;
  303.  
  304. struct InputEvent *
  305. eventFunction(event, data)
  306. struct InputEvent *event;
  307. {
  308.     struct InputEvent *loopevent;
  309.  
  310. #ifdef    DEBUG
  311. kprintf(".");
  312. #endif
  313.  
  314.     loopevent = event;
  315.     do {
  316.     if (loopevent->ie_Class == IECLASS_RAWMOUSE) {
  317.         /* handle X, then Y.  slow down faster than speed up */
  318.         /* this could use another iteration to get it to "feel" right */
  319.         if (loopevent->ie_X < 0) {
  320. #ifdef    DEBUG
  321. kprintf("<");
  322. #endif
  323.         if (deltaX <= 0) {
  324.             if (deltaX > -MAXDELTA) deltaX--;
  325.         }
  326.         else deltaX = deltaX/2;
  327.         }
  328.         else if (loopevent->ie_X > 0) {
  329. #ifdef    DEBUG
  330.  
  331. kprintf(">");
  332. #endif
  333.         if (deltaX >= 0) {
  334.             if (deltaX < MAXDELTA) deltaX++;
  335.         }
  336.         else deltaX = deltaX/2;
  337.         }
  338.         else if (loopevent->ie_Y != 0) {
  339.         if (deltaX != 0) deltaX += (deltaX<0)?1:-1;
  340.         }
  341.         else deltaX = deltaX/2;
  342.         if (deltaX < 0)
  343.         loopevent->ie_X = (deltaX-((1<<DELTASHIFT)+1))>>DELTASHIFT;
  344.         else
  345.         loopevent->ie_X = (deltaX+((1<<DELTASHIFT)-1))>>DELTASHIFT;
  346.  
  347.         if (loopevent->ie_Y < 0) {
  348. #ifdef    DEBUG
  349. kprintf("v");
  350. #endif
  351.         if (deltaY <= 0) {
  352.             if (deltaY > -MAXDELTA) deltaY--;
  353.         }
  354.         else deltaY = deltaY/2;
  355.         }
  356.         else if (loopevent->ie_Y > 0) {
  357. #ifdef    DEBUG
  358. kprintf("^");
  359. #endif
  360.         if (deltaY >= 0) {
  361.             if (deltaY < MAXDELTA) deltaY++;
  362.         }
  363.         else deltaY = deltaY/2;
  364.         }
  365.         else if (loopevent->ie_X != 0) {
  366.         if (deltaY != 0) deltaY += (deltaY<0)?1:-1;
  367.         }
  368.         else deltaY = deltaY/2;
  369.         if (deltaY < 0)
  370.         loopevent->ie_Y = (deltaY-((1<<DELTASHIFT)+1))>>DELTASHIFT;
  371.         else
  372.         loopevent->ie_Y = (deltaY+((1<<DELTASHIFT)-1))>>DELTASHIFT;
  373.     }
  374.     }
  375.     while ((loopevent = loopevent->ie_NextEvent) != 0);
  376.     return(event);
  377. }
  378.  
  379.  
  380. main(argc, argv)
  381. int argc;
  382. char *argv[];
  383. {
  384.     char c;
  385.     int result;
  386.  
  387.     NewList(&iorp.mp_MsgList);
  388.     iorp.mp_SigTask = (struct Task *) FindTask((char *) NULL);
  389.  
  390.     if (OpenDevice("input.device", 0, &ior, 0)) exit(20);
  391.  
  392.     /* free this controller */
  393.     c = GPCT_NOCONTROLLER;
  394.     ior.io_Command = IND_SETMTYPE;
  395.     ior.io_Length = 1;
  396.     ior.io_Data = (APTR) &c;
  397.     DoIO(&ior);
  398.  
  399.     /* wait for the SETM to take effect with a side effect */
  400.     ior.io_Command = IND_WRITEEVENT;
  401.     ior.io_Length = (LONG) sizeof(nullEvent);
  402.     ior.io_Data = (APTR) &nullEvent;
  403.     DoIO(&ior);
  404.  
  405.     /* switch to the right game port */
  406.     c = 1;
  407.     ior.io_Command = IND_SETMPORT;
  408.     ior.io_Length = 1;
  409.     ior.io_Data = (APTR) &c;
  410.     DoIO(&ior);
  411.  
  412.     /* set this controller to a joystick */
  413.     c = GPCT_ABSJOYSTICK;
  414.     ior.io_Command = IND_SETMTYPE;
  415.     ior.io_Length = 1;
  416.     ior.io_Data = (APTR) &c;
  417.     DoIO(&ior);
  418.  
  419.     /* set the trigger for the joystick */
  420.     ior.io_Command = IND_SETMTRIG;
  421.     ior.io_Length = (LONG) sizeof(joyTrigger);
  422.     ior.io_Data = (APTR) &joyTrigger;
  423.     DoIO(&ior);
  424.  
  425.     /* insert the accellerator handler into the food chain */
  426.     ior.io_Command = IND_ADDHANDLER;
  427.     ior.io_Data = (APTR) &inputHandler;
  428.     ior.io_Length = (LONG) sizeof(struct Interrupt);
  429.     DoIO(&ior);
  430.  
  431.     /* wait for this program to terminate */
  432.     Wait(SIGBREAKF_CTRL_C);
  433.  
  434.     /* free this controller */
  435.     c = GPCT_NOCONTROLLER;
  436.     ior.io_Command = IND_SETMTYPE;
  437.     ior.io_Length = 1;
  438.     ior.io_Data = (APTR) &c;
  439.     DoIO(&ior);
  440.  
  441.     /* remove the accellerator handler from the food chain */
  442.     ior.io_Command = IND_REMHANDLER;
  443.     ior.io_Data = (APTR) &inputHandler;
  444.     ior.io_Length = (LONG) sizeof(struct Interrupt);
  445.     DoIO(&ior);
  446.  
  447.     /* switch to the left game port */
  448.     c = 0;
  449.     ior.io_Command = IND_SETMPORT;
  450.     ior.io_Length = 1;
  451.     ior.io_Data = (APTR) &c;
  452.     result = DoIO(&ior);
  453.  
  454.     /* set the trigger for a mouse */
  455.     ior.io_Command = IND_SETMTRIG;
  456.     ior.io_Length = sizeof(mouseTrigger);
  457.     ior.io_Data = (APTR) &mouseTrigger;
  458.     DoIO(&ior);
  459.  
  460.     /* set this controller to a mouse */
  461.     c = GPCT_MOUSE;
  462.     ior.io_Command = IND_SETMTYPE;
  463.     ior.io_Length = 1;
  464.     ior.io_Data = (APTR) &c;
  465.     result = DoIO(&ior);
  466. }
  467.  
  468. ;=============================================================
  469. ; iefa.asm
  470. ;=============================================================
  471. ;
  472. ; Copyright (c) 1988 Commodore-Amiga, Inc.
  473. ;
  474. ; Executables based on this information may be used in software
  475. ; for Commodore Amiga computers.  All other rights reserved.
  476. ;
  477. ; This information is provided "as is"; no warranties are made.
  478. ; All use is at your own risk, and no liability or responsibility is assumed.
  479. ;
  480.     XREF        _eventFunction
  481.  
  482.     XDEF        _eventAFunction
  483. _eventAFunction:
  484.         MOVEM.L    A0/A1,-(A7)
  485.         JSR    _eventFunction
  486.         ADDQ.L    #8,A7
  487.         RTS
  488.  
  489.         END
  490.  
  491.  
  492. /******************************************************************************
  493. *
  494. *   Source Control
  495. *   --------------
  496. *   $Header: propjoy.c,v 34.1 85/11/24 17:59:44 bart Exp $
  497. *
  498. *   $Locker:  $
  499. *
  500. *   $Log:   propjoy.c,v $
  501. *   Revision 34.1  85/11/24  17:59:44  bart
  502. *   be system compatible
  503. *   
  504. *   Revision 34.0  86/11/21  16:35:51  bart
  505. *   added to rcs for updating
  506. *
  507. * Copyright (c) 1988 Commodore-Amiga, Inc.
  508. * 
  509. * Executables based on this information may be used in software
  510. * for Commodore Amiga computers.  All other rights reserved.
  511. * 
  512. * This information is provided "as is"; no warranties are made.
  513. * All use is at your own risk, and no liability or responsibility is assumed.
  514. *
  515. ******************************************************************************/
  516.  
  517. /* main.c - test program for add/rem tof task - bart - 05.19.86 */
  518. /* propjoy.c modified program for proportional controller - bart - 11.21.86 */
  519.  
  520. ;=============================================================
  521. ; propjoy.c
  522. ;=============================================================
  523.  
  524. #include <exec/types.h>
  525. #include <exec/nodes.h>
  526. #include <exec/execbase.h>
  527. #include <exec/execname.h>
  528.  
  529. #include <graphics/gfxbase.h>
  530. #include <graphics/graphint.h>
  531.  
  532. #include <hardware/cia.h>
  533. #include <hardware/custom.h>
  534. #include <hardware/intbits.h>
  535.  
  536. #include <resources/potgo.h>
  537.  
  538. #define V1_POINT_2  33
  539.  
  540. #define NUM_SERVERS 2
  541.  
  542. #define MAX_COUNT   (UWORD)~1        /* do it for a while */
  543.  
  544. /* use system defined hard addresses */
  545.  
  546. extern struct Custom custom;
  547.  
  548. /* use system defined addresses for potgo and pot1dat */
  549.  
  550. #define POTGO        &custom.potgo
  551. #define POT0DAT        &custom.pot0dat
  552. #define POT1DAT        &custom.pot1dat
  553.  
  554. /* vertical blank interrupt server priority   */
  555.  
  556. #define HIGHINTPRI 127L        /* needs to be replaced with priority relative */
  557. #define LOWINTPRI -127L        /* needs to be replaced with priority relative */
  558.  
  559. /* bit number defines for potgo ... */
  560.  
  561. #define START_B        0    
  562.  
  563. #define DATRX_B        8    
  564. #define DATRY_B        10
  565.  
  566. #define DATLX_B        12    
  567. #define DATLY_B        14
  568.  
  569. /* masks ... */
  570.  
  571. #define START_F        (1L << START_B)
  572. #define DATRX_F        (1L << DATRX_B)
  573. #define DATRY_F        (1L << DATRY_B) 
  574. #define DATLX_F        (1L << DATLX_B)
  575. #define DATLY_F        (1L << DATLY_B) 
  576.  
  577. #define RPOTX        (START_F | DATRX_F) 
  578. #define RPOTY        (START_F | DATRY_F) 
  579. #define RPOTXY        (START_F | DATRX_F | DATRY_F) 
  580.  
  581. #define LPOTX        (START_F | DATLX_F) 
  582. #define LPOTY        (START_F | DATLY_F) 
  583. #define LPOTXY        (START_F | DATLX_F | DATLY_F) 
  584.  
  585. struct ExecBase *ExecBase = NULL;
  586. struct GfxBase *GfxBase = NULL;
  587. struct PotgoBase *PotgoBase = NULL;
  588.  
  589. /* global storage for potdat */
  590.  
  591. UWORD oldbits = NULL;
  592. UWORD potbits = NULL;
  593. ULONG potdat = NULL;
  594.  
  595. /* create server-task to read the proportional joysticks,*/ 
  596. /* update potdat, and then poke potgo to start next data read */
  597.  
  598. /* reserve space for the interrupt servers */
  599. struct Isrvstr server[NUM_SERVERS] = {NULL};
  600.  
  601. first_server(i)
  602. int i;
  603. {
  604.     /* read previous proportional joystick values */
  605.     potdat = *(ULONG *)POT0DAT;
  606.  
  607.     /* poke potgo, restore old bits */
  608.     WritePotgo(oldbits,((~1)<<8)|oldbits);
  609.  
  610.     /* be nice -- let other servers run, too */
  611.     return(NULL);
  612. }
  613.  
  614. second_server(i)
  615. int i;
  616. {
  617.     /* poke potgo, start prop joystick read  */
  618.     WritePotgo(potbits,((~1)<<8)|potbits);
  619.  
  620.     /* be nice -- let other servers run, too */
  621.     return(NULL);
  622. }
  623.  
  624.  
  625. main()
  626. {
  627.     LONG error = FALSE;
  628.     struct Isrvstr *iserver[NUM_SERVERS];
  629.     LONG i;
  630.  
  631.     /* set server priorities */ 
  632.     server[0].is_Node.ln_Pri = HIGHINTPRI;  
  633.     server[1].is_Node.ln_Pri = LOWINTPRI;   
  634.  
  635.     /* set up server pointers */
  636.     iserver[0] = &server[0];
  637.     iserver[1] = &server[1];
  638.  
  639.     if((ExecBase = (struct ExecBase *)OpenLibrary(EXECNAME,V1_POINT_2)) != NULL)
  640.     {
  641.     if((GfxBase = (struct GfxBase *)
  642.         OpenLibrary("graphics.library",V1_POINT_2)) != NULL)
  643.     {
  644.  
  645.         if((PotgoBase = OpenResource(POTGONAME,V1_POINT_2)) != NULL)
  646.         {
  647.  
  648.         /* remember currently used bits */
  649.         oldbits = ~(AllocPotBits(~1));
  650.  
  651.         /* restore previous state of bit allocation */
  652.         FreePotBits(~oldbits);
  653.  
  654.         /* now attempt to allocate start potbit */
  655.         potbits = AllocPotBits(START_F);
  656.  
  657.         Forbid();   
  658.  
  659.         /* add interrupt servers */
  660.  
  661.         AddTOF(iserver[0],first_server,0);
  662.  
  663.         AddTOF(iserver[1],second_server,1);
  664.  
  665.         Permit();
  666.  
  667.         /* loop until done */
  668.  
  669.         for(i=0; i < MAX_COUNT; i++)
  670.         {
  671.             /* wait for server to update pot values */
  672.             WaitTOF();
  673.  
  674.             /* only output information once every second */
  675.             if(!(i %  ExecBase->VBlankFrequency))
  676.             {
  677.             }
  678.         }
  679.  
  680.         Forbid();   
  681.  
  682.         for(i=0; i < NUM_SERVERS; i++)
  683.         {
  684.             RemTOF(iserver[i]);
  685.         }
  686.  
  687.         Permit();
  688.  
  689.         /* free potbits */
  690.  
  691.         FreePotBits(potbits);
  692.  
  693.         CloseLibrary(GfxBase);
  694.         }
  695.         else
  696.         {
  697.         error = TRUE;
  698.         }
  699.     }
  700.     else
  701.     {
  702.         error = TRUE;
  703.     }
  704.  
  705.     CloseLibrary(ExecBase);
  706.  
  707.     }
  708.     else
  709.     {
  710.     error = TRUE;
  711.     }
  712.  
  713.     /* return error code */
  714.     exit(error);
  715. }
  716.