home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD1.bin / useful / dev / c / cmanual / devices / serialdevice / example4.c < prev    next >
C/C++ Source or Header  |  1993-10-12  |  34KB  |  758 lines
  1. /***********************************************************/
  2. /*                                                         */
  3. /* Amiga C Encyclopedia (ACE) V3.0      Amiga C Club (ACC) */
  4. /* -------------------------------      ------------------ */
  5. /*                                                         */
  6. /* Book:    ACM Devices                 Amiga C Club       */
  7. /* Chapter: Serial Device               Tulevagen 22       */
  8. /* File:    Example4.c                  181 41  LIDINGO    */
  9. /* Author:  Anders Bjerin               SWEDEN             */
  10. /* Date:    92-04-26                                       */
  11. /* Version: 1.00                                           */
  12. /*                                                         */
  13. /*   Copyright 1992, Anders Bjerin - Amiga C Club (ACC)    */
  14. /*                                                         */
  15. /* Registered members may use this program freely in their */
  16. /*     own commercial/noncommercial programs/articles.     */
  17. /*                                                         */
  18. /***********************************************************/
  19.  
  20.  
  21.  
  22. /* This example does not do anything, but it consists of    */
  23. /* several useful functions that you can use yourself after */
  24. /* small modifications. The functions demonstrates all      */
  25. /* commands there exist for the serial device, so if you    */
  26. /* had problems in understanding how a command was used you */
  27. /* can look here.                                           */
  28.  
  29.  
  30.  
  31. #include <exec/types.h>
  32. #include <exec/errors.h>
  33. #include <devices/serial.h>
  34.  
  35.  
  36.  
  37. /* Declare the functions: */
  38.  
  39. UBYTE SetSerParams(
  40.   struct IOExtSer *ioreq, /* Pointer to our serial request block.          */
  41.   ULONG buffer_length,    /* Size of the Serial Device's own input buffer. */
  42.   ULONG baud_rate,        /* Baud rate (read and write). [110 - 292000]    */
  43.   ULONG break_time,       /* Break time in microseconds.                   */
  44.   UBYTE read_length,      /* Nr of bits, read (1-8). Parity not included.  */
  45.   UBYTE write_length,     /* Nr of bits, write (1-8). Parity not included. */
  46.   UBYTE stop_length,      /* Nr of bits, stop (1 or 2).                    */
  47.   UBYTE serial_flags,     /* Serial flags.                                 */
  48.   ULONG extended_flags,   /* Additional serial flags.                      */
  49.   UBYTE *eof_chars        /* Pointer to an array containing eight end-of-  */
  50.                           /* file characters.                              */
  51. );
  52.  
  53. void SerError( UBYTE error );
  54.  
  55. UBYTE SerWrite(
  56.   struct IOExtSer *ioreq, /* Pointer to our serial request block.     */
  57.   BYTE *data,             /* Pointer to the data you want to send.    */
  58.   ULONG length            /* The length of the data you want to send. */
  59. );
  60.  
  61. UBYTE SerRead(
  62.   struct IOExtSer *ioreq, /* Pointer to our serial request block. */
  63.   BYTE *data,             /* Where the data should be placed.     */
  64.   ULONG length            /* How many bytes you want to read.     */
  65. );
  66.  
  67. void SerWriteNoWait(
  68.   struct IOExtSer *ioreq, /* Pointer to our serial request block.     */
  69.   BYTE *data,             /* Pointer to the data you want to send.    */
  70.   ULONG length            /* The length of the data you want to send. */
  71. );
  72.  
  73. void SerReadNoWait(
  74.   struct IOExtSer *ioreq, /* Pointer to our serial request block. */
  75.   BYTE *data,             /* Where the data should be placed.     */
  76.   ULONG length            /* How many bytes you want to read.     */
  77. );
  78.  
  79. UBYTE SerBreak( struct IOExtSer *ioreq );
  80.  
  81. UBYTE SerClear( struct IOExtSer *ioreq );
  82.  
  83. UBYTE SerFlush( struct IOExtSer *ioreq );
  84.  
  85. UBYTE SerQuery( struct IOExtSer *ioreq );
  86.  
  87. UBYTE SerReset( struct IOExtSer *ioreq );
  88.  
  89. UBYTE SerStop( struct IOExtSer *ioreq );
  90.  
  91. UBYTE SerStart( struct IOExtSer *ioreq );
  92.  
  93.  
  94.  
  95. /* Very short main() module: */
  96. void main();
  97.  
  98. void main()
  99. {
  100.   printf( "See source code for more information..." );
  101. }
  102.  
  103.  
  104.  
  105. /*************************************/
  106. /* SERIAL DEVICE - SUPPORT FUNCTIONS */
  107. /*************************************/
  108.  
  109.  
  110.  
  111. /* SetSerParams() sets the serial parameters. It initializes a IOExtSer    */
  112. /* structure, and does a SDCMD_SETPARAMS commad. If everything is OK it    */
  113. /* returns NULL, else an error number is returned.                         */
  114. /*                                                                         */
  115. /* Synopsis: er = SetSerParams( io, bl, br, bt, rl, wl, sl, sf, ef, chr ); */
  116. /*                                                                         */
  117. /* er:       (UBYTE) SetSerParams() returns 0 if everything was OK, else   */
  118. /*           an error value is returned. See function SerError() for more  */
  119. /*           information.                                                  */
  120. /*                                                                         */ 
  121. /* io:       (struct IOExtSer *) Pointer to the serial request block you   */
  122. /*           want to initialize.                                           */
  123. /*                                                                         */
  124. /* bl:       (ULONG) Size of the internal serial buffer which will be used */
  125. /*           when you read data. Must be at least 512 (bytes), but more is */
  126. /*           recommended. The faster and more data you want to read, the   */
  127. /*           bigger should the internal buffer be. Some recommended sizes: */
  128. /*           512, 1024, 2048, 4096, 8192 or 16384.                         */
  129. /*                                                                         */
  130. /* br:       (ULONG) Baud rate. Can be anything between 110 and 292000.    */
  131. /*           (Up to 292000 is all right for the hardware, but the software */
  132. /*           can not cope with this, especially since other tasks may be   */
  133. /*           running at the same time. You should therefore not use baud   */
  134. /*           rates above 31250.) Some recommended values: 110, 300, 1200,  */
  135. /*           2400, 4800, 9600, 19200 or 31250 (the last is a bit though).  */
  136. /*                                                                         */
  137. /* bt:       (ULONG) Break time in micro seconds. All break requests will  */
  138. /*           be set to this time.                                          */
  139. /*                                                                         */
  140. /* rl:       (UBYTE) How many bits chould be read for each character.      */
  141. /*           Usually 7 or 8 bits.                                          */
  142. /*                                                                         */
  143. /* wl:       (UBYTE) How many bits chould be written for each character.   */
  144. /*           Usually 7 or 8 bits.                                          */
  145. /*                                                                         */
  146. /* sl:       (UBYTE) How many stop bits shoud be written or expected.      */
  147. /*           Normally set to 1, but you may set it to 2 if rl/wl = 7.      */
  148. /*                                                                         */
  149. /* sf:       (UBYTE) You may use the following serial flags:               */
  150. /*                                                                         */
  151. /*           SERF_PARTY_ON   Parity checking/writing is turned on. (The    */
  152. /*                           sum of all data bits are divided by two, and  */
  153. /*                           the remainder is the parity bit. If even      */
  154. /*                           parity is used the bit will be set to 1 if    */
  155. /*                           the remainder is even. If odd parity is used  */
  156. /*                           the parity bit will be set to 0 if the        */
  157. /*                           remainder is even.                            */
  158. /*                                                                         */
  159. /*           SERF_PARTY_ODD  Set this flag if you want to use odd parity.  */
  160. /*                           (The default setting is even parity.)         */
  161. /*                                                                         */
  162. /*           SERF_7WIRE      This flag should only be used when you call   */
  163. /*                           the OpenDevice(), and not by this function.   */
  164. /*                           If the flag is set,