home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 5 / FreshFish_July-August1994.bin / bbs / dev / rkrm.lha / RKRM / Serial / Complex_Serial.c next >
Encoding:
C/C++ Source or Header  |  1992-09-03  |  8.6 KB  |  256 lines
  1. /*
  2.  * Copyright (c) 1992 Commodore-Amiga, Inc.
  3.  * 
  4.  * This example is provided in electronic form by Commodore-Amiga, Inc. for 
  5.  * use with the "Amiga ROM Kernel Reference Manual: Devices", 3rd Edition, 
  6.  * published by Addison-Wesley (ISBN 0-201-56775-X).
  7.  * 
  8.  * The "Amiga ROM Kernel Reference Manual: Devices" contains additional 
  9.  * information on the correct usage of the techniques and operating system 
  10.  * functions presented in these examples.  The source and executable code 
  11.  * of these examples may only be distributed in free electronic form, via 
  12.  * bulletin board or as part of a fully non-commercial and freely 
  13.  * redistributable diskette.  Both the source and executable code (including 
  14.  * comments) must be included, without modification, in any copy.  This 
  15.  * example may not be published in printed form or distributed with any
  16.  * commercial product.  However, the programming techniques and support
  17.  * routines set forth in these examples may be used in the development
  18.  * of original executable software products for Commodore Amiga computers.
  19.  * 
  20.  * All other rights reserved.
  21.  * 
  22.  * This example is provided "as-is" and is subject to change; no
  23.  * warranties are made.  All use is at your own risk. No liability or
  24.  * responsibility is assumed.
  25.  *
  26.  *****************************************************************************
  27.  *
  28.  *
  29.  * Complex_Serial.c
  30.  *
  31.  * Complex tricky example of serial.device usage
  32.  *
  33.  * Compile with SAS C 5.10  lc -b1 -cfistq -v -y -L
  34.  *
  35.  * Run from CLI only
  36.  */
  37.  
  38. #include <exec/types.h>
  39. #include <exec/memory.h>
  40. #include <dos/dos.h>
  41. #include <devices/serial.h>
  42.  
  43. #include <clib/exec_protos.h>
  44. #include <clib/alib_protos.h>
  45.  
  46. #include <stdio.h>
  47.  
  48. #ifdef LATTICE
  49. int CXBRK(void) { return(0); }  /* Disable Lattice CTRL/C handling */
  50. int chkabort(void) { return(0); }  /* really */
  51. #endif
  52.  
  53. VOID main(VOID);
  54.  
  55. void main()
  56. {
  57. struct MsgPort  *SerialMP;          /* Define storage for one pointer */
  58. struct IOExtSer *SerialIO;         /* Define storage for one pointer */
  59.  
  60. #define READ_BUFFER_SIZE 32
  61. char SerialReadBuffer[READ_BUFFER_SIZE]; /* Reserve SIZE bytes of storage */
  62.  
  63. struct IOExtSer *SerialWriteIO = 0;
  64. struct MsgPort  *SerialWriteMP = 0;
  65.  
  66. ULONG Temp;
  67. ULONG WaitMask;
  68.  
  69. if (SerialMP=CreatePort(0,0) )
  70.     {
  71.     if (SerialIO=(struct IOExtSer *)
  72.                  CreateExtIO(SerialMP,sizeof(struct IOExtSer)) )
  73.         {
  74.         SerialIO->io_SerFlags=0;    /* Example of setting flags */
  75.  
  76.         if (OpenDevice(SERIALNAME,0L,SerialIO,0) )
  77.             printf("%s did not open\n",SERIALNAME);
  78.         else
  79.             {
  80.             SerialIO->IOSer.io_Command  = SDCMD_SETPARAMS;
  81.             SerialIO->io_SerFlags      &= ~SERF_PARTY_ON;
  82.             SerialIO->io_SerFlags      |= SERF_XDISABLED;
  83.             SerialIO->io_Baud           = 9600;
  84.             if (Temp=DoIO(SerialIO))
  85.                 printf("Error setting parameters - code %ld!\n",Temp);
  86.  
  87.             SerialIO->IOSer.io_Command  = CMD_WRITE;
  88.             SerialIO->IOSer.io_Length   = -1;
  89.             SerialIO->IOSer.io_Data     = (APTR)"Amiga.";
  90.             SendIO(SerialIO);
  91.             printf("CheckIO %lx\n",CheckIO(SerialIO));
  92.             printf("The device will process the request in the background\n");
  93.             printf("CheckIO %lx\n",CheckIO(SerialIO));
  94.             WaitIO(SerialIO);
  95.  
  96.  
  97.             SerialIO->IOSer.io_Command  = CMD_WRITE;
  98.             SerialIO->IOSer.io_Length   = -1;
  99.             SerialIO->IOSer.io_Data     = (APTR)"Save the whales! ";
  100.             DoIO(SerialIO);             /* execute write */
  101.  
  102.  
  103.             SerialIO->IOSer.io_Command  = CMD_WRITE;
  104.             SerialIO->IOSer.io_Length   = -1;
  105.             SerialIO->IOSer.io_Data     = (APTR)"Life is but a dream.";
  106.             DoIO(SerialIO);             /* execute write */
  107.  
  108.             SerialIO->IOSer.io_Command  = CMD_WRITE;
  109.             SerialIO->IOSer.io_Length   = -1;
  110.             SerialIO->IOSer.io_Data     = (APTR)"Row, row, row your boat.";
  111.             SerialIO->IOSer.io_Flags = IOF_QUICK;
  112.             BeginIO(SerialIO);
  113.  
  114.             if (SerialIO->IOSer.io_Flags & IOF_QUICK )
  115.                 {
  116.  
  117.                 /*
  118.                  * Quick IO could not happen for some reason; the device processed
  119.                  *  the command normally.  In this case BeginIO() acted exactly
  120.                  * like SendIO().
  121.                  */
  122.  
  123.                 printf("Quick IO\n");
  124.                 }
  125.             else
  126.                 {
  127.  
  128.                 /* If flag is still set, IO was synchronous and is now finished.
  129.                  * The IO request was NOT appended a reply port.  There is no
  130.                  * need to remove or WaitIO() for the message.
  131.                  */
  132.  
  133.                 printf("Regular IO\n");
  134.                 }
  135.  
  136.             WaitIO(SerialIO);
  137.  
  138.  
  139.             SerialIO->IOSer.io_Command  = CMD_UPDATE;
  140.             SerialIO->IOSer.io_Length   = -1;
  141.             SerialIO->IOSer.io_Data     = (APTR)"Row, row, row your boat.";
  142.             SerialIO->IOSer.io_Flags = IOF_QUICK;
  143.             BeginIO(SerialIO);
  144.  
  145.             if (0 == SerialIO->IOSer.io_Flags & IOF_QUICK )
  146.                 {
  147.  
  148.                 /*
  149.                  * Quick IO could not happen for some reason; the device processed
  150.                  * the command normally.  In this case BeginIO() acted exactly
  151.                  * like SendIO().
  152.                  */
  153.  
  154.                 printf("Regular IO\n");
  155.  
  156.                 WaitIO(SerialIO);
  157.                 }
  158.             else
  159.                 {
  160.  
  161.                 /* If flag is still set, IO was synchronous and is now finished.
  162.                  * The IO request was NOT appended a reply port.  There is no
  163.                  * need to remove or WaitIO() for the message.
  164.                  */
  165.  
  166.                 printf("Quick IO\n");
  167.                 }
  168.  
  169.  
  170.             /* Precalculate a wait mask for the CTRL-C, CTRL-F and message
  171.              * port signals.  When one or more signals are received,
  172.              * Wait() will return.  Press CTRL-C to exit the example.
  173.              * Press CTRL-F to wake up the example without doing anything.
  174.              * NOTE: A signal may show up without an associated message!
  175.              */
  176.  
  177.             WaitMask = SIGBREAKF_CTRL_C|
  178.                         SIGBREAKF_CTRL_F|
  179.                          1L << SerialMP->mp_SigBit;
  180.  
  181.             SerialIO->IOSer.io_Command  = CMD_READ;
  182.             SerialIO->IOSer.io_Length   = READ_BUFFER_SIZE;
  183.             SerialIO->IOSer.io_Data     = (APTR)&SerialReadBuffer[0];
  184.             SendIO(SerialIO);
  185.  
  186.             printf("Sleeping until CTRL-C, CTRL-F, or serial input\n");
  187.  
  188.             while (1)
  189.                    {
  190.                    Temp = Wait(WaitMask);
  191.                    printf("Just woke up (YAWN!)\n");
  192.  
  193.                    if (SIGBREAKF_CTRL_C & Temp)
  194.                        break;
  195.  
  196.                    if (CheckIO(SerialIO) ) /* If request is complete... */
  197.                        {
  198.                        WaitIO(SerialIO);   /* clean up and remove reply */
  199.  
  200.                        printf("%ld bytes received\n",SerialIO->IOSer.io_Actual);
  201.                        break;
  202.                        }
  203.                    }
  204.  
  205.             AbortIO(SerialIO);  /* Ask device to abort request, if pending */
  206.             WaitIO(SerialIO);   /* Wait for abort, then clean up */
  207.  
  208.  
  209.             /*
  210.              * If two tasks will use the same device at the same time, it is preferred
  211.              * use two OpenDevice() calls and SHARED mode.  If exclusive access mode
  212.              * is required, then you will need to copy an existing IO request.
  213.              *
  214.              * Remember that two separate tasks will require two message ports.
  215.              */
  216.  
  217.             SerialWriteMP = CreatePort(0,0);
  218.             SerialWriteIO = (struct IOExtSer *)
  219.                             CreateExtIO( SerialWriteMP,sizeof(struct IOExtSer) );
  220.  
  221.             if (SerialWriteMP && SerialWriteIO )
  222.                 {
  223.  
  224.                 /* Copy over the entire old IO request, then stuff the
  225.                  * new Message port pointer.
  226.                  */
  227.  
  228.                 CopyMem( SerialIO, SerialWriteIO, sizeof(struct IOExtSer) );
  229.                 SerialWriteIO->IOSer.io_Message.mn_ReplyPort = SerialWriteMP;
  230.  
  231.                 SerialWriteIO->IOSer.io_Command  = CMD_WRITE;
  232.                 SerialWriteIO->IOSer.io_Length   = -1;
  233.                 SerialWriteIO->IOSer.io_Data     = (APTR)"A poet's food is love and fame";
  234.                 DoIO(SerialWriteIO);
  235.                 }
  236.  
  237.             if (SerialWriteMP)
  238.                 DeletePort(SerialWriteMP);
  239.  
  240.             if (SerialWriteIO)
  241.                 DeleteExtIO(SerialWriteIO);
  242.  
  243.             CloseDevice(SerialIO);
  244.             }
  245.  
  246.         DeleteExtIO(SerialIO);
  247.         }
  248.     else
  249.         printf("Unable to create IORequest\n");
  250.  
  251.     DeletePort(SerialMP);
  252.     }
  253. else
  254.     printf("Unable to create message port\n");
  255. }
  256.