home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 1 / GoldFishApril1994_CD2.img / d4xx / d477 / irmaster / irc.c < prev    next >
C/C++ Source or Header  |  1991-04-17  |  27KB  |  1,055 lines
  1. /*------------------------------- i r c . c  -------------------------------*/
  2. /* Experimental interrupt handler.                                          */
  3. /* This routine sets up a level 2 interrupt server that is triggered by the */
  4. /* ACK pin of the parallel port going low.  The interrupt server then uses  */
  5. /* Timer B in CIA-B to time reading in data from the parallel port.         */
  6. /* The ACK and one data input pin on the parallel port are tied             */
  7. /* together by the hardware I built.  Initially the ACK interrupt is        */
  8. /* enabled and the software sits and waits for something to happen.         */
  9. /*                                                                          */
  10. /* NEED TO CHECK RESOURCES  ---- FREEMEM!!!!!!!!!!!!!!!!*/
  11. /*--------------------------------------------------------------------------*/
  12.  
  13. /*--- Includes and Defines. */
  14.  
  15. #include "irc.h"
  16. #include "IRMaster.h"   /* Definitions of Screen, Window and gadgets. */
  17.  
  18. /* DBG = 1 --> Turn on debug printf's, DBG = 0 --> Turn off debug printf's. */
  19. #define DBG 1
  20. /* Set DEBUG to 0 to comment out code related to opening screen and window.*/
  21. #define DEBUG 1
  22.  
  23. #define NOERROR 0
  24. #define ERROR 1
  25. /*--- NSAMPLES is the number of data samples to be read into buffer. */
  26. #define NSAMPLES 3000
  27. /*--- TOLERENCE is the number of samples difference that is tolerated in */
  28. /*--- order to match two patterns. */
  29. #define TOLERENCE 50
  30.  
  31. /*--- External system variables. */
  32.  
  33. extern struct Custom custom;
  34. extern struct CIA ciab;
  35.  
  36. extern struct GfxBase *GfxBase;
  37. extern struct IntuitionBase *IntuitionBase;
  38. extern struct WBStartup *WBenchMsg;  /* For Workbench startup. */
  39.  
  40. /**********************************************************/  
  41. /***************** Timer B Interrupt code *****************/
  42. /**********************************************************/  
  43. /*
  44.    Update Timer every TIME_SLICE microseconds.
  45.    TIME_SLICE = 1.397 * (desired # of microseconds) [71 = 100us]
  46.    71, 50 work.
  47. */
  48. #define TIME_SLICE ((unsigned short)35)
  49.  
  50. /* Defines to make the code more readable. */
  51.  
  52. #define ciatlo        ciab.ciatblo
  53. #define ciathi        ciab.ciatbhi
  54. #define ciacr        ciab.ciacrb
  55. #define ciaicr        ciab.ciaicr
  56.  
  57. int TimerSigBit = -1;   /* Allocated signal bit. */
  58. ULONG TimerSigMask;      /* TimerSigBit converted into a mask. */
  59. static struct Library *CIAResource = NULL;
  60. struct Task *thisTask;
  61.  
  62. int NSamples;           /* Number of samples in buffer. */
  63.  
  64. int SetUpTimer()
  65. {
  66.    char temp;
  67.    unsigned short micros;
  68.  
  69.    /*--- Check to see if timer B in CIA-B is already in use. */
  70.    /*--- If START bit is set timer is probably being used. */
  71.  
  72. #if DBG
  73.    printf("\n Timer B control register = %X",ciab.ciacrb);
  74. #endif
  75.    if(ciab.ciacrb & 0x01)
  76.    {
  77.       printf("\n Timer B is already allocated.  Proceding anyway.");
  78.    }
  79.  
  80.    /*--- Set latched value for timer to count down from. */
  81.  
  82.    micros = TIME_SLICE;
  83. #if DBG
  84.    printf("\n Sampling interval = %d * 1.397 microseconds", micros);
  85. #endif
  86.    ciatlo = micros & 0xFF;
  87.    ciathi = micros >> 8;
  88.  
  89.    /*--- Get ID for this task so can send it a signal. */
  90.  
  91.    thisTask = NULL;
  92.    thisTask = FindTask(NULL);
  93.    if(thisTask == NULL)
  94.    {
  95.       printf("\n Error - Can't find this task ID.");
  96.       return(ERROR);
  97.    }
  98.  
  99.    /*--- Get a signal bit. */
  100.  
  101.    if((TimerSigBit = AllocSignal(-1L)) == -1)
  102.    {
  103.       printf("\n Timer: AllocSignal failed.");
  104.       StopTime();  /* Deallocate resources. */
  105.       return(ERROR);
  106.    }
  107.    TimerSigMask = 1L << TimerSigBit;
  108.  
  109.    /*--- Open the CIA resource. */
  110.  
  111.    if((CIAResource = OpenResource(CIABNAME)) == NULL)
  112.    {
  113.       printf("\n Timer: Couldn't open %s.", CIABNAME);
  114.       StopTime();  /* Deallocate resources. */
  115.       return(ERROR);
  116.    }
  117.  
  118.    /*--- Interrupts have been enabled so may already */
  119.    /*--- have an interrupt.  So do this... */
  120.  
  121.    ciab.ciacrb &= ~CIACRBF_START;    /* stop timer */
  122.  
  123.    temp = ciaicr;  /* Read IRC register to clear interrupt. */
  124.  
  125.    SetSignal(0, TimerSigMask);    /* clear signal */
  126.  
  127. #if DBG
  128.    printf("\n About to set RUNMODE");
  129. #endif
  130.    ciacr &= ~CIACRBF_RUNMODE; /* Set it to reload upon underflow. */
  131.    ciacr &= ~CIACRBF_PBON; /* Output line PB7 is left alone. */
  132.    ciacr &= ~CIACRBF_INMODE0; /* Count clock pulses. */
  133.    ciacr &= ~CIACRBF_INMODE1; /* Count clock pulses. */
  134.  
  135. #if DBG
  136.    printf("\n About to strobe LOAD");
  137. #endif
  138.    ciacr |= CIACRBF_LOAD; /* Strobe Load to latch in countdown value. */
  139.  
  140. #if DBG
  141.    printf("\n About to enable timer b interrupts");
  142. #endif
  143.    ciaicr = 0x7D;  /* Disable all other CIA-B interrupts. */
  144.    ciaicr = CIAICRF_SETCLR|CIAICRF_TB;  /* Enable timer B interrupts. */
  145. #if DBG
  146.    printf("\n Enabled timer b interrupts");
  147. #endif
  148.  
  149.    return(NOERROR);
  150. }
  151.  
  152. int StopTime()
  153. {
  154.    if(thisTask != NULL)
  155.    {
  156.       /*--- Disable timer B interrupts. */
  157.  
  158. #if DBG
  159.       printf("\n Stopping timer B.");
  160. #endif
  161.       ciaicr = CIAICRF_TB;
  162.  
  163.       /*--- Halt timer. */
  164.  
  165.       ciacr &= ~CIACRBF_START;
  166.  
  167.       /*--- Free resources. */
  168.  
  169.       if(TimerSigBit != -1)
  170.       {
  171. #if DBG
  172.          printf("\n Freeing signal bit.");
  173. #endif
  174.          FreeSignal(TimerSigBit);
  175.       }
  176.    }
  177.  
  178.    return(NOERROR);
  179. }
  180.  
  181. /**********************************************************/  
  182. /***************** LEVEL 2 Interrupt code *****************/
  183. /**********************************************************/  
  184.  
  185. extern void ircserver();
  186. struct Interrupt intrpt;
  187.  
  188. int AddINT2Server()
  189. {
  190.    /*--- init NODE structure */
  191.  
  192.    intrpt.is_Node.ln_Type = NT_INTERRUPT;
  193.    /* Was 0 but glasses flickered.  3 fixed it. */
  194.    intrpt.is_Node.ln_Pri  = 127;
  195.    intrpt.is_Node.ln_Name = "WWB";
  196.    intrpt.is_Code        = ircserver;
  197.    intrpt.is_Data        = NULL;
  198.  
  199. #if DBG
  200.    printf("\n About to add interrupt server...");
  201. #endif
  202.  
  203.    AddIntServer(INTB_PORTS, &intrpt);        /* Add server to chain */
  204.  
  205. #if DBG
  206.    printf("\n Added interrupt server.");
  207. #endif
  208.  
  209.    return(NOERROR);
  210. }
  211.  
  212.  
  213. int RemoveServer()
  214. {
  215.    RemIntServer(INTB_PORTS, &intrpt);
  216.  
  217.    return(NOERROR);
  218. }
  219.  
  220.  
  221. /**********************************************************/  
  222. /************************** MAIN **************************/
  223. /**********************************************************/  
  224.  
  225. unsigned char *buffer;  /* Pointer to storage for data to be read in. */
  226. unsigned char zuffer[NSAMPLES];  /* Storage for data to be read in. */
  227. unsigned char pattern[20][NSAMPLES];  /* Stored signal patterns. */
  228. char *address, mask;
  229.  
  230. struct Screen *Screen = NULL;
  231. struct Window *Window = NULL;
  232. struct RastPort *WRPort;
  233. struct ViewPort *WVPort;
  234.  
  235. struct IntuiMessage *message;
  236. ULONG class;
  237. USHORT code;
  238. struct Gadget *igad;
  239. USHORT gadget_id;
  240. extern int BackGround();
  241. int helptxt();
  242. int IRButtonOff();                 /* Unhighlight button. */
  243. int IRButtonOn();                  /* Highlight button. */
  244. int IRButtonLabel();               /* Relabel button. */
  245. int GetPattern();                  /* Get signal pattern. */
  246. int DisplayPattern();              /* Draw the signal pattern. */
  247. int DPattern();                    /* Debug. */
  248.  
  249. /*--- Buffers for area fill and text. */
  250.  
  251. WORD chip areaArray[100];  /* Max of 20 vertices times 5 words per vertex. */
  252. struct AreaInfo myAreaInfo;
  253. PLANEPTR workspace;
  254. struct TmpRas myTmpRas;
  255.  
  256. #define NOTHING 0
  257. int active[21] =  /* Used to remember which buttons have patterns. */
  258. { 
  259.    FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, 
  260.    FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, 
  261.    FALSE
  262. };
  263.  
  264.  
  265.  
  266.  
  267. main(argc, argv)
  268. int argc;
  269. char **argv;
  270. {
  271.    int it, error, iz, is, try;
  272.    int diff[4], match, smallest;
  273.    BOOL exitflag;
  274.    int mode;  /* Current mode of program (LEARN, NOTHING, etc. ) */
  275.    int IRButtonSelected = -1;         /* Index of button currently selected. */
  276.  
  277.    /*--- Ignore CTRL-C and CTRL-D. */
  278.  
  279.    signal(SIGINT, SIG_IGN);
  280.  
  281.    /*--- Open graphics and Intuition Libraries. */
  282.  
  283.    GfxBase = NULL;
  284.    GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 33);
  285.    if(GfxBase == NULL)
  286.    {
  287.       printf("\n Error opening graphics library.");
  288.       goto ShutDown;
  289.    }
  290.  
  291.    IntuitionBase = NULL;
  292.    IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 33);
  293.    if(IntuitionBase == NULL)
  294.    {
  295.       printf("\n Error opening Intuition library.");
  296.       goto ShutDown;
  297.    }
  298.  
  299.    /*--- Open a new screen. */
  300.  
  301.    Screen = (struct Screen *) OpenScreen(&NewScreenStructure); 
  302.    if(Screen == 0L)
  303.    {
  304.       printf("\n Error opening a new screen.");
  305.       goto ShutDown;
  306.    }
  307.  
  308. #if DEBUG
  309.    /*--- Open window in screen. */
  310.  
  311.    NewWindowStructure1.Screen = Screen;
  312.  
  313.    Window = (struct Window *) OpenWindow(&NewWindowStructure1);
  314.  
  315.    if(Window == 0L)
  316.    {
  317.       printf("\nError opening a new window");
  318.       goto ShutDown;
  319.    }
  320.  
  321.    /*--- Get pointers to window structures. */
  322.  
  323.    WRPort = Window->RPort;   /* Get pointer to windows' RastPort. */
  324.    WVPort = (struct ViewPort *)ViewPortAddress(Window); /* Get pointer to window viewport. */
  325.  
  326.    /*--- Set up area fill and text work buffers. */
  327.  
  328.    InitArea(&myAreaInfo, &areaArray[0], 20);
  329.    WRPort->AreaInfo = &myAreaInfo;
  330.  
  331.    workspace = AllocRaster(640, 200);
  332.    if(workspace == 0)
  333.    {
  334.       printf("\n Error - No space for temporary raster.");
  335.       goto ShutDown;
  336.    } else
  337.    {
  338.       InitTmpRas(&myTmpRas, workspace, RASSIZE(640,200));
  339.       WRPort->TmpRas = &myTmpRas;
  340.    }
  341.  
  342.    /*--- Set color map. */
  343.  
  344.    LoadRGB4(WVPort, Palette, (SHORT)16);
  345.  
  346.    /*--- Draw raised background areas. */
  347.  
  348.    BackGround();
  349.  
  350.    /*--- Redraw the gadgets on top of the raised background. */
  351.  
  352.    RefreshGadgets(&ARexx, Window, 0);
  353. #endif /*DEBUG*/
  354.  
  355.    /*--- Allocate the parallel port resource so that other tasks know it  */
  356.    /*--- is taken. (This might not be a good idea.  Online! allocates the */
  357.    /*--- the parallel port and this prevents me from doing                */
  358.    /*--- "copy file to par:" in a seperate window.  So leave it out for   */
  359.    /*--- now.  User will know if one program walks over another.          */
  360.  
  361.    /*****************
  362.    MR_ALLOCMISCRESOURCE(MR_PARALLELPORT, "IRMaster");
  363.    MR_ALLOCMISCRESOURCE(MR_PARALLELBITS, "IRMaster");
  364.    *****************/
  365.  
  366.    /*--- Set up pointer to data buffer for SoftHandler(). */
  367.    /*--- Assembler doesn't seem to recognize zuffer but DOES buffer. */
  368.  
  369.    buffer = &zuffer[0];
  370. #if DBG
  371.    printf("\n buffer = %X", buffer);
  372. #endif
  373.  
  374.    /*--- Set up all the interrupt servers. */
  375.  
  376.    AddINT2Server();
  377.  
  378.    error = SetUpTimer();
  379.    if(error)goto Fini;
  380.  
  381.    /*--- Explicitly enable level6 and level2 interrupts (even though */
  382.    /*--- they already seem to be enabled by default).                */
  383.  
  384. /********* Causes sometimes guru.
  385.    Disable();
  386.    custom.intena |= INTF_SETCLR | INTF_EXTER;
  387.    custom.intena |= INTF_SETCLR | INTF_SOFTINT;
  388.    Enable();
  389. *********/
  390.  
  391. #if DBG
  392.    /* This is slightly dangerous since it might clear any pending interrupts. */
  393.    /*printf("\n Enabled interrupts are: %X", custom.intenar);*/
  394. #endif
  395.  
  396.    /*--- Set address for IRC register (used in GetSample.) */
  397.  
  398.    address = (char *)0xBFED01;/* Address of the Interrupt Control Register in 8520-A */
  399.  
  400.    /*--- MAIN PROGRAM LOOP. */
  401.    /*--- Get messages from window until user presses CloseWindow gadget. */
  402.  
  403. #if DEBUG
  404.    exitflag = FALSE;
  405.    mode = NOTHING;
  406.    while(exitflag == FALSE)
  407.    {
  408.       /*--- If in DOIT mode wait for IR input. */
  409.  
  410.       if(mode == DOIT)
  411.       {
  412.          /*--- Wait for user to press a button. */
  413.  
  414.          GetSample();
  415.  
  416.          /*--- Match input to stored samples. */
  417.  
  418.          match = find_match();
  419.       }
  420.  
  421.       /*--- Check for user action. */
  422.  
  423.       message = (struct IntuiMessage *)GetMsg(Window->UserPort);
  424.       if(message != 0)
  425.       {
  426.          class = message->Class;
  427.          code = message->Code;
  428.          igad = (struct Gadget *)message->IAddress;/*get pointer to gadget */
  429.          ReplyMsg((struct Message *)message);
  430.  
  431.          if(class == GADGETUP)
  432.          {
  433.             gadget_id = igad->GadgetID;   /* get my gadget code */
  434.             switch(gadget_id)
  435.             {
  436.                case COMMANDSTR3:
  437. #if DBG
  438.                   printf("COMMANDSTR3\n");
  439. #endif
  440.                   break;
  441.  
  442.                case COMMANDSTR1:
  443. #if DBG
  444.                   printf("COMMANDSTR1 = %s\n", commandstr1SIBuff);
  445. #endif
  446.                   /*--- Change the label on the button. */
  447.  
  448.                   IRButtonLabel(commandstr1SIBuff, IRButtonSelected);
  449.  
  450.                   /*--- Prompt user for next action. */
  451.  
  452.                   helptxt("Now press the button on your handheld IR remote control",
  453.                      "that you want memorized.");
  454.  
  455.                   /*--- Get verified signal sample from the IR receiver. */
  456.  
  457.                   GetPattern(IRButtonSelected);
  458.  
  459.                   /*--- Remember which buttons have patterns stored. */
  460.  
  461.                   active[IRButtonSelected] = TRUE;
  462.  
  463.                   /*--- Unhighlight the control button. */
  464.  
  465.                   IRButtonOff(&IRButtonSelected);
  466.                   mode = NOTHING;
  467.  
  468.                   break;
  469.  
  470.                case COMMANDSTR2:
  471. #if DBG
  472.                   printf("COMMANDSTR2\n");
  473. #endif
  474.                   break;
  475.  
  476.               default:
  477.                   break;
  478.             } /* switch(gadget_id) */
  479.          } /* if(GADGETUP) */
  480.  
  481.          if(class == GADGETDOWN)
  482.          {
  483.             gadget_id = igad->GadgetID;   /* get my gadget code */
  484.             switch(gadget_id)
  485.             {
  486.                case EXIT:
  487. #if DBG
  488.                   printf("EXIT\n");
  489. #endif
  490.                   goto Fini;
  491.                   break;
  492.  
  493.                case AUTHOR:
  494. #if DBG
  495.                   printf("AUTHOR\n");
  496. #endif
  497.                   break;
  498.  
  499.                case DOIT:
  500. #if DBG
  501.                   printf("DOIT\n");
  502. #endif
  503.                   mode = DOIT;
  504.                   break;
  505.  
  506.                case GETSET:
  507. #if DBG
  508.                   printf("GETSET\n");
  509. #endif
  510.                   break;
  511.  
  512.                case SAVESET:
  513. #if DBG
  514.                   printf("SAVESET\n");
  515. #endif
  516.                   break;
  517.  
  518.                case LEARN:
  519. #if DBG
  520.                   printf("LEARN\n");
  521. #endif
  522.                   helptxt("Press one of the twenty control buttons above.","");
  523.                   mode = LEARN;
  524.                   break;
  525.  
  526.                case AREXX:
  527. #if DBG
  528.                   printf("AREXX\n");
  529. #endif
  530.                   break;
  531.  
  532.                case IR20:
  533.                case IR19:
  534.                case IR18:
  535.                case IR17:
  536.                case IR16:
  537.                case IR15:
  538.                case IR14:
  539.                case IR13:
  540.                case IR12:
  541.                case IR11:
  542.                case IR10:
  543.                case IR9:
  544.                case IR8:
  545.                case IR7:
  546.                case IR6:
  547.                case IR5:
  548.                case IR4:
  549.                case IR3:
  550.                case IR2:
  551.                case IR1:
  552.                   /*--- Unhighlight any currently selected button. */
  553.  
  554.                   IRButtonOff(&IRButtonSelected);
  555.  
  556.                   /*--- Set current button to highlight and highlight it. */
  557.  
  558.                   IRButtonSelected = (gadget_id - IR1) + 1;
  559.  
  560.                   IRButtonOn(IRButtonSelected);
  561. #if DBG
  562.                   printf("IR-%d\n", (gadget_id - IR1) + 1);
  563. #endif
  564.                   if(mode == LEARN)
  565.                   {
  566.                      /*--- Prompt user. */
  567.  
  568.                      helptxt("Enter the label name for the control button,",
  569.                         "then press RETURN.");
  570.                   } else
  571.                   {
  572.                      helptxt("Please choose a function button first.", "");
  573.                   }
  574.                   break;
  575.  
  576.  
  577.                default:
  578.                   mode = NOTHING;
  579.                   printf("Error - Got a hit on an unknown gadget\n");
  580.                   printf(" Gadget id was: hex: %X  decimal: %d\n", gadget_id,
  581.                      gadget_id);
  582.                   break;
  583.             } /* switch(gadget_id) */
  584.          } /* if(message) */
  585.       } /* if(class...) */
  586.    } /* while(GetMsg) */
  587. #endif /*DEBUG*/
  588.  
  589.  
  590. #if DBG
  591.    printf("\n Timer B control register = %X",ciab.ciacrb);
  592.    printf("\n buffer = %X", buffer);
  593. #endif
  594.  
  595.    /*--- Shut down timer B */
  596.  
  597. Fini:
  598.    StopTime();
  599.  
  600.    /*--- Turn off the 8520's recognition of the ACK as an interrupt. */
  601.  
  602.    mask = 0x10; /* Hex 10 = 00010000 Should disable the 8520 FLAG interrupt. */
  603.    *address = mask;  /* Disable the interrupt. */
  604.  
  605.    /*--- Remove the level2 interrupt server from server chain. */
  606.  
  607.    RemoveServer();
  608.  
  609.    /*--- Exit cleanly. */
  610.  
  611. ShutDown:
  612.  
  613.    /*--- Deallocate parallel port resource. Commented out for reasons above. */
  614.  
  615.    /*****************
  616.    MR_FREEMISCRESOURCE(MR_PARALLELPORT);
  617.    MR_FREEMISCRESOURCE(MR_PARALLELBITS);
  618.    *****************/
  619.  
  620.    /*--- Close window and screen. */
  621.  
  622. #if DEBUG
  623.    if(Window)CloseWindow(Window);
  624.    if(Screen)CloseScreen(Screen);
  625. #endif /*DEBUG*/
  626.  
  627.    /*--- Close libraries. */
  628.  
  629.    if(GfxBase)CloseLibrary((struct Library *)GfxBase);
  630.    if(IntuitionBase)CloseLibrary((struct Library *)IntuitionBase);
  631.  
  632.    /*--- Free allocated memory. */
  633. #if DEBUG
  634.    if(workspace != 0)FreeRaster(workspace, 640, 200);
  635. #endif /*DEBUG*/
  636.  
  637.    return(0);  /* To keep compiler happy. */
  638. } /* End of main(). */
  639.  
  640.  
  641.  
  642. int GetSample()
  643. {
  644.    int idx;
  645.  
  646.    /*--- Set up for taking another sample. */
  647.  
  648. #if DBG
  649.    printf("\n Setting up for next sample.");
  650. #endif
  651.    for(idx=0; idx<NSAMPLES; idx++)zuffer[idx] = 0; /* Zero the buffer. */
  652.    NSamples = NSAMPLES;  /* Reset sample counter. */
  653.    buffer = &zuffer[0];  /* Reset pointer to start of buffer. */
  654.  
  655.    ciacr |= CIACRBF_LOAD; /* Strobe Load to latch in countdown value. */
  656.    ciaicr = CIAICRF_SETCLR|CIAICRF_TB;  /* Enable timer B interrupts. */
  657.    mask = *address;  /* Clear any pending interrupts. */
  658.    mask = 0x90;  /* Hex 90 = 10010000 Should enable the 8520 FLAG interrupt. */
  659.    *address = mask;  /* Enable the ACK interrupt. */
  660.  
  661.    /*--- Interrupts are now all armed and dangerous.  */
  662.    /*--- Wait until data is ready. */
  663.  
  664. #if DBG
  665.    printf("\n Waiting...press a button.");
  666. #endif
  667.    Wait(TimerSigMask);  /* Wait for full buffer. */
  668.  
  669.    /*--- Stop timer B from counting. */
  670.  
  671. #if DBG
  672.    printf("\n Stopping timer B");
  673. #endif
  674.    ciacr &= ~CIACRBF_START;
  675.  
  676.    /*--- Wait until user lets go of button. */
  677.  
  678.    LetGo();
  679.  
  680.    return(0);
  681. }
  682.  
  683. #if DEBUG
  684. /*-------------------- h e l p t x t . c ------------------------*/
  685. /* This routine clears the help message area and writes a new    */
  686. /* message into it.                                              */
  687. /*---------------------------------------------------------------*/
  688.  
  689. int helptxt(msg1, msg2)
  690.   char *msg1, *msg2;
  691. {
  692.  
  693.    /*--- Erase any old text that exists. */
  694.  
  695.    SetAPen(WRPort, 0);
  696.    RectFill(WRPort, 24, 163, 617, 188);
  697.  
  698.    /*--- Write new text. */
  699.  
  700.  
  701.    SetAPen(WRPort, 1);
  702.    Move(WRPort, 25, 173);
  703.    Text(WRPort, msg1, strlen(msg1));
  704.    Move(WRPort, 25, 185);
  705.    Text(WRPort, msg2, strlen(msg2));
  706.  
  707.    return(0);
  708. }
  709.  
  710. /*---------------------- I R B u t t o n s O f f . c ---------------------*/
  711. /* This routine unhighlights any currently selected control button.       */
  712. /*------------------------------------------------------------------------*/
  713.  
  714. int IRButtonOff(button)
  715.   int *button;  /* Button to turn off. */
  716. {
  717.    USHORT position;
  718.  
  719.    if((*button >= 1) && (*button <= 20))
  720.    {
  721.       /*--- Remove currently selected gadget from list. */
  722.  
  723.       position = RemoveGList(Window, IR[*button-1], 1L);
  724.  
  725.       /*--- Unselect the gadget. */
  726.  
  727.       IR[*button-1]->Flags &= (~SELECTED);
  728.  
  729.       /*--- Put the gadget back into the same place in the list. */
  730.  
  731.       AddGList(Window, IR[*button-1], (LONG)position, 1L, NULL);
  732.  
  733.       /*--- Refresh gadgets on display. */
  734.  
  735.       RefreshGList(IR[*button-1], Window, NULL, 1L);
  736.  
  737.       /*--- Set currently selected gadget to none. */
  738.  
  739.       *button = -1;
  740.    }
  741.  
  742.    return(TRUE);
  743. }
  744.  
  745.  
  746. /*---------------------- I R B u t t o n s O n . c -----------------------*/
  747. /* This routine highlights the currently selected control button.         */
  748. /*------------------------------------------------------------------------*/
  749.  
  750.  
  751. int IRButtonOn(button)
  752.   int button;  /* Button number to highlight. */
  753. {
  754.    USHORT position;
  755.  
  756.    if((button >= 1) && (button <= 20))
  757.    {
  758.       /*--- Remove the selected gadget from list. */
  759.  
  760.       position = RemoveGList(Window, IR[button-1], 1L);
  761.  
  762.       /*--- Select the gadget. */
  763.  
  764.       IR[button-1]->Flags |= SELECTED;
  765.  
  766.       /*--- Put the gadget back into the same place in the list. */
  767.  
  768.       AddGList(Window, IR[button-1], (LONG)position, 1L, NULL);
  769.  
  770.       /*--- Refresh gadgets on display. */
  771.  
  772.       RefreshGList(IR[button-1], Window, NULL, 1L);
  773.    }
  774.  
  775.    return(TRUE);
  776. }
  777.  
  778. /*------------------- I R B u t t o n L a b e l . c -------------------*/
  779. /* This routine relabels the selected button.                          */
  780. /*---------------------------------------------------------------------*/
  781.  
  782. int IRButtonLabel(buffer, button)
  783.   UBYTE *buffer;
  784.   int button;
  785. {
  786.    USHORT position;
  787.  
  788.    if((button >= 1) && (button <= 20))
  789.    {
  790.       /*--- Remove the selected gadget from list. */
  791.  
  792.       position = RemoveGList(Window, IR[button-1], 1L);
  793.  
  794.       /*--- Change the label. */
  795.  
  796.       strncpy(IR[button-1]->GadgetText->IText , (char *)buffer, 7);
  797.  
  798.       /*--- Put the gadget back into the same place in the list. */
  799.  
  800.       AddGList(Window, IR[button-1], (LONG)position, 1L, NULL);
  801.  
  802.       /*--- Refresh gadgets on display. */
  803.  
  804.       RefreshGList(IR[button-1], Window, NULL, 1L);
  805.    }
  806.  
  807.    return(TRUE);
  808. }
  809.  
  810.  
  811. /*------------------ G e t P a t t e r n . c ---------------------*/
  812. /* This routine gets a signal sample from the IR receiver and     */
  813. /* then tries up to four times to verify it.                      */
  814. /*----------------------------------------------------------------*/
  815.  
  816. GetPattern(button)
  817.   int button;  /* Currently selected control button. */
  818. {
  819.    int it, iz, is, try;
  820.    int diff[4], match, smallest;
  821.  
  822. #if DBG
  823.    printf("\n\n **** Storing pattern %d ****", button);
  824. #endif
  825.  
  826.    /*--- Get a sample. */
  827.  
  828.    GetSample();
  829.  
  830.    /*--- Plot data on screen. */
  831.  
  832.    helptxt("Data received.", "");
  833.    /*DPattern(button, 1);*/
  834.    DisplayPattern(button, 0);
  835.  
  836. #if DBG
  837.    printf("\n NSamples=%d", NSamples);
  838. #endif
  839.  
  840.    /*--- Transfer data to storage. */
  841.  
  842. #if DBG
  843.    printf("\n Xferring to pattern memory.");
  844. #endif
  845.    for(iz=0; iz<NSAMPLES; iz++)
  846.    {
  847.       pattern[button-1][iz] = zuffer[iz] & 0x01;
  848. #if DBG
  849. /*
  850.       if(pattern[button-1][iz] == 1)printf("|");
  851.       if(pattern[button-1][iz] == 0)printf("_");
  852. */
  853. #endif
  854.    }
  855.  
  856.    helptxt("Press the button again to verify the pattern.", "");
  857.  
  858.    match = 0;
  859.    for(try=0; try<4; try++)  /* Try four times to get a match. */
  860.    {
  861.       GetSample(); /* Read IR signal again. */
  862.  
  863.       helptxt("Data received.  Verifying match.", "");
  864. /*   DPattern(button, try+2);*/
  865.       DisplayPattern(button, 1);
  866.  
  867.       /*--- Find number of cells that don't match. */
  868.  
  869.       diff[try] = 0;
  870.       smallest = NSAMPLES+10;
  871.       for(iz=0; iz<NSAMPLES; iz++)
  872.       {
  873.          zuffer[iz] = zuffer[iz] & 0x01;
  874.          if(pattern[button-1][iz] != zuffer[iz])
  875.          {
  876.             diff[try]++;
  877.          }
  878. #if DBG
  879. /*
  880.          if(zuffer[iz] == 1)printf("|");
  881.          if(zuffer[iz] == 0)printf("_");
  882. */
  883. #endif
  884.       }
  885.       if(diff[try] > TOLERENCE)
  886.       {
  887. #if DBG
  888.          printf("\n Samples do not match:%d  Please try again.",diff[try]);
  889. #endif
  890.          helptxt("Samples do not match.  Please press button again.", "");
  891.          if(diff[try] < smallest)
  892.          {
  893.             /*--- Store the best pattern so far. */
  894.             smallest = diff[try];
  895.             for(iz=0; iz<NSAMPLES; iz++)
  896.             {
  897.                pattern[button-1][iz] = zuffer[iz];
  898.             }
  899.          }
  900.       } else
  901.       {
  902.          match = 1;
  903.          break;
  904.       }
  905.    }
  906.    if(match == 0)
  907.    {
  908.       helptxt("Could not verify pattern.  Will use the best match of four tries.", "");
  909. #if DBG
  910.       printf("\n Could not verify pattern.  Will use the best match.");
  911.       printf("\n Try the analyzer to verify compatability of your unit.");
  912. #endif
  913.    } else
  914.    {
  915.       helptxt("Successful pattern match!", "");
  916.       DisplayPattern(button, 0);
  917.    }
  918.  
  919.    return(TRUE);
  920. }
  921.  
  922.  
  923. /*-------------------- D i s p l a y P a t t e r n . c ------------------*/
  924. /* This routine draws the acquired pattern on the screen in the help     */
  925. /* message area.                                                         */
  926. /*-----------------------------------------------------------------------*/
  927.  
  928. int DisplayPattern(button, mode)
  929.   int button;  /* Currently selected control button. */
  930.   int mode;    /* 0 = draw pattern, 1 = draw difference. */
  931. {
  932.    int it;
  933.    SHORT row;
  934.  
  935.    /*--- Any old text or pattern that existed should have been erased with */
  936.    /*--- a help message. */
  937.  
  938.    /*--- Draw pattern. X range = 24 to 617 */
  939.  
  940.    SetAPen(WRPort, 1);
  941.    row = 0;
  942.    for(it=0; it<NSAMPLES; it++)
  943.    {
  944.       if(mode == 0)
  945.       {
  946.          if((zuffer[it] & 0x01) == 1)
  947.          {
  948.             Move(WRPort, 26 + (SHORT)(it%590), 175 + row);
  949.             Draw(WRPort, 26 + (SHORT)(it%590), 175 + row);
  950.          }
  951.       } else
  952.       {
  953.          if((zuffer[it] & 0x01) != pattern[button-1][it])
  954.          {
  955.             Move(WRPort, 26 + (SHORT)(it%590), 175 + row);
  956.             Draw(WRPort, 26 + (SHORT)(it%590), 175 + row);
  957.          }
  958.       }
  959.  
  960.       /*--- Space the data in rows. */
  961.  
  962.       if((it%590 == 0) &&(it != 0))row = row + 2;
  963.    }
  964. #if DBG
  965.    printf("\n Drew the pattern.");
  966. #endif
  967.  
  968.    return(TRUE);
  969. }
  970.  
  971.  
  972.  
  973. int DPattern(button, mode)
  974.   int button;  /* Currently selected control button. */
  975.   int mode;    /* 0 = draw pattern, 1 = draw difference. */
  976. {
  977.    int it;
  978.    SHORT row;
  979.  
  980.    /*--- Any old text or pattern that existed should have been erased with */
  981.    /*--- a help message. */
  982.  
  983.    /*--- Draw pattern. X range = 24 to 617 */
  984.  
  985.    SetAPen(WRPort, 1);
  986.    row = 0;
  987.    for(it=0; it<NSAMPLES; it++)
  988.    {
  989.       if((zuffer[it] & 0x01) == 1)
  990.       {
  991.          Move(WRPort, 26 + (SHORT)(it%590), 175 + row - mode*20);
  992.          Draw(WRPort, 26 + (SHORT)(it%590), 175 + row - mode*20);
  993.       }
  994.  
  995.       /*--- Space the data in rows. */
  996.  
  997.       if((it%590 == 0) &&(it != 0))row = row + 2;
  998.    }
  999.  
  1000.    return(TRUE);
  1001. }
  1002. #endif /*DEBUG*/
  1003.  
  1004. /*-------------------- f i n d _ m a t c h . c ----------------------*/
  1005. /*  Find pattern which is the closest match to the one just read in. */
  1006. /*-------------------------------------------------------------------*/
  1007.  
  1008. int find_match()
  1009. {
  1010.    int match, it, smallest;
  1011.    int diff, pat;
  1012.  
  1013. #if DBG
  1014.    printf("\n Matching patterns...");
  1015. #endif
  1016.  
  1017.    /*--- Mask of bit of interest in zuffer. */
  1018.  
  1019.    for(it=0; it<NSAMPLES; it++)zuffer[it] = zuffer[it] & 0x01;
  1020.  
  1021.    /*--- Compare data to stored patterns. */
  1022.  
  1023.    match = -1;
  1024.    smallest = NSAMPLES+10;
  1025.    for(pat=0; pat<20; pat++)  /* Step through all stored patterns. */
  1026.    {
  1027.       if(active[pat+1])  /* Only examine active patterns to save time. */
  1028.       {
  1029.          diff = 0;
  1030.          for(it=0; it<NSAMPLES; it++)
  1031.          {
  1032.             if(pattern[pat][it] != zuffer[it])diff++;
  1033.          }
  1034.       }
  1035.       if(diff < smallest)
  1036.       {
  1037.          smallest = diff;
  1038.          match = pat;
  1039.       }
  1040. #if DBG
  1041.       printf("\n diff(%d)=%d", pat, diff);
  1042. #endif
  1043.    }
  1044.  
  1045. #if DBG
  1046.    printf("\n Best match is pattern %d", match);
  1047.    if(match == -1)
  1048.    {
  1049.       printf("\n No match for pattern!");
  1050.    }
  1051. #endif
  1052.  
  1053.    return(match);
  1054. }
  1055.