home *** CD-ROM | disk | FTP | other *** search
/ CD Exchange / CD Exchange - Volume 1.iso / utils / misc / scan8800 / example_in_c / scan8800_2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-28  |  7.5 KB  |  279 lines
  1. /**************************************************************************/
  2. /*** Programmname: "SCAN8800_2.c"     MIF-90                            ***/
  3. /*** Update      : vom 17.02.91                                         ***/
  4. /*** Beschreibung: Simple Steuerung des Empfängers FRG-8800 von YAESU   ***/
  5. /***               über das Interface MINIX MIF-90.                     ***/
  6. /*** Autor       : Rainer Redweik Kattowitzer Str. 7  D-3180 Wolfsburg 1***/
  7. /*** Version     : 1.0                                                  ***/
  8. /*** Computer    : AMIGA 500 / 1000 / 2000  mit Kickstart 1.3           ***/
  9. /*** Compiler    : Aztec C V-5.0 with precompiled includefiles          ***/
  10. /***             : cc -ff -ps -so -wp -wu -hiInclude16.pre SCAN8800_1.c ***/
  11. /***             : ln SCAN8800_1.o +q -lmf16 -lc16                      ***/
  12. /**************************************************************************/
  13.  
  14.  
  15. #include <functions.h>
  16. #include <stdio.h>
  17. #include <stdlib.h>
  18. #include <string.h>
  19.  
  20. #define WARTE           200L
  21. #define UNIT_NUMBER       0L  /* Multiple serial port */
  22. #define SER_BUFFER_SIZE   5
  23.  
  24.  
  25. /***************PROTOTYPES****************************************************/
  26. void oeffnen(void);
  27. void schliessen(void);
  28. void Serial_Read(void);
  29. void Serial_Write(void);
  30. LONG Freq_to_Buffer(LONG);
  31. void Set_Freq(LONG);
  32. /***************STRUCTUREN****************************************************/
  33. struct MsgPort       *SerialMP = 0L;       /* Für serial.device              */
  34. struct IOExtSer      *SerialIO = 0L;       /* Für serial.device              */
  35. /********************VARIABLE*************************************************/
  36. TEXT  SerialBuffer[SER_BUFFER_SIZE] = "";
  37. LONG  OpenDevErr = -1;
  38.  
  39. /********************FUNCTIONEN***********************************************/
  40.  
  41. void main(void)
  42. {
  43.  LONG i;
  44.  
  45.  oeffnen();
  46.  printf("\fBaud: %ld\n\n", SerialIO->io_Baud);
  47.  
  48.  /* Fernb. ON */
  49.  sprintf((char*)SerialBuffer, "%1c%1c%1c%1c%1c",  0x01,0x01,0x01,0x00,0x00);
  50.  Serial_Write();
  51.  Serial_Write();  /* Zur Sicherheit zweimal senden */
  52.  
  53.  /* Netz   ON */
  54.  sprintf((char*)SerialBuffer, "%1c%1c%1c%1c%1c",  0x01,0x01,0x01,0xfe,0x80);
  55.  Serial_Write();
  56.  
  57.  /* AM wide   */
  58.  sprintf((char*)SerialBuffer, "%1c%1c%1c%1c%1c",  0x01,0x01,0x01,0x00,0x80);
  59.  Serial_Write();
  60.  
  61.  
  62.  printf("S   3   5   7    9  +20  +40  +60 dB\n");
  63.  
  64.  for(i = 0L; i < 180L; i++)
  65.    Set_Freq(756000L);
  66.  
  67.  printf("\n\n");
  68.  
  69.  
  70.  /* Netz   OFF */
  71.  sprintf((char*)SerialBuffer, "%1c%1c%1c%1c%1c",  0x01,0x01,0x01,0xff,0x80);
  72.  Serial_Write();
  73.  
  74.  /* Fernb. OFF */
  75.  sprintf((char*)SerialBuffer, "%1c%1c%1c%1c%1c",  0x01,0x01,0x01,0x80,0x00);
  76.  Serial_Write();
  77.  
  78.  schliessen();
  79. }/* main() end*/
  80.  
  81.  
  82.  
  83. void oeffnen(void)
  84. {
  85.  if(!(SerialMP = CreatePort(0,0)))
  86.    {
  87.     printf("CreatePort failed \n");
  88.     schliessen();
  89.    }
  90.  
  91.  if(!(SerialIO = (struct IOExtSer *)CreateExtIO(SerialMP, sizeof(struct IOExtSer))))
  92.    {
  93.     printf("CreateExtIO failed \n");
  94.     schliessen();
  95.    }
  96.  
  97.  SerialIO->io_SerFlags = SERF_SHARED | SERF_XDISABLED;
  98.  
  99.  if((OpenDevErr = OpenDevice(SERIALNAME, UNIT_NUMBER, (struct IORequest *)SerialIO, 0L)) != 0L)
  100.    {
  101.     printf("Open-Device Error #%4lx  IOERR_OPENFAIL: %ld\n", OpenDevErr, (LONG)IOERR_OPENFAIL);
  102.     schliessen();
  103.    }
  104.  
  105.  
  106.  SerialIO->IOSer.io_Command = CMD_RESET;
  107.  SendIO((struct IORequest *)SerialIO);
  108.  
  109.  SerialIO->IOSer.io_Command = SDCMD_SETPARAMS;
  110.  SerialIO->io_Baud          = 4800L;
  111.  SerialIO->io_ReadLen       = SerialIO->io_WriteLen = 8;
  112.  SerialIO->io_StopBits      = 2;
  113.  SendIO((struct IORequest *)SerialIO);
  114. }/* oeffnen() end */
  115.  
  116.  
  117.  
  118. void schliessen(void)
  119. {
  120.  if(SerialIO)
  121.    {
  122.     if(OpenDevErr == 0L)
  123.       {
  124.        AbortIO    ((struct IORequest *)SerialIO);
  125.        WaitIO     ((struct IORequest *)SerialIO);
  126.        CloseDevice((struct IORequest *)SerialIO);
  127.       }
  128.     DeleteExtIO((struct IORequest *)SerialIO);
  129.    }
  130.  
  131.  if(SerialMP) DeletePort((struct MsgPort*)SerialMP);
  132.  
  133.  exit(0);
  134. }/* schliessen() end */
  135.  
  136.  
  137.  
  138. void Serial_Read(void)
  139. {
  140.  LONG Temp;
  141.  ULONG WaitMask = SIGBREAKF_CTRL_C | 1L << SerialMP->mp_SigBit;
  142.  
  143.  SerialIO->IOSer.io_Command = CMD_FLUSH;
  144.  DoIO((struct IORequest *)SerialIO);
  145.  
  146.  /* Listing aus 'AMIGA ROMKERNEL Libraries&Devices Seite 863' */
  147.  SerialIO->IOSer.io_Command = CMD_READ;
  148.  SerialIO->IOSer.io_Length  = SER_BUFFER_SIZE;
  149.  SerialIO->IOSer.io_Data    = (APTR)&SerialBuffer[0];
  150.  SendIO((struct IORequest *)SerialIO);
  151.  
  152.  while(1)
  153.    {
  154.     Temp = Wait(WaitMask);
  155.  
  156.     if(SIGBREAKF_CTRL_C & Temp)
  157.       {
  158.        printf("Abbruch durch CTRL-C\n");
  159.        break;
  160.       }
  161.  
  162.     if( CheckIO((struct IORequest *)SerialIO) )
  163.       {
  164.        WaitIO((struct IORequest *)SerialIO);
  165. /*       printf("%ld bytes received\n", SerialIO->IOSer.io_Actual);*/
  166.        break;
  167.       }
  168.    }
  169.  
  170.  AbortIO((struct IORequest *)SerialIO);
  171.  WaitIO((struct IORequest *)SerialIO);
  172. }/* Serial_Read() end */
  173.  
  174.  
  175.  
  176. void Serial_Write(void)
  177. {
  178. /*************************************************************************/
  179. /* I am not glad about this part, but without this the programm dosn't   */
  180. /* work correct: only a few frequency-changes are possible.              */
  181.  
  182.  SerialIO->IOSer.io_Command = CMD_RESET;
  183.  DoIO((struct IORequest *)SerialIO);
  184.  
  185.  SerialIO->IOSer.io_Command = SDCMD_SETPARAMS;
  186.  SerialIO->io_Baud          = 4800L;                        /* Baud Rate */
  187.  SerialIO->io_ReadLen       = SerialIO->io_WriteLen = 8;    /* Bits      */
  188.  SerialIO->io_StopBits      = 2;                            /* Stop-Bits */
  189.  DoIO((struct IORequest *)SerialIO);
  190. /*************************************************************************/
  191.  
  192.  Delay(7L);
  193.  
  194.  SerialIO->IOSer.io_Command = CMD_WRITE;
  195.  SerialIO->IOSer.io_Length  = 5;
  196.  SerialIO->IOSer.io_Data    = (APTR)SerialBuffer;
  197.  DoIO((struct IORequest *)SerialIO);
  198. }/* Serial_Write() end */
  199.  
  200.  
  201.  
  202. LONG Freq_to_Buffer(LONG freq) /* Frequenz in die 4 Bytes umrechnen */
  203. {
  204.  int b1, b2, b3, b4, b5 = 1;
  205.  int zehner,  liByte, reByte = 1;
  206.  
  207.    /* Frequency limits */
  208.  if     (freq <    150000L) freq = 150000L;
  209.  else if(freq < 100000000L)
  210.    {
  211.     if(freq > 29999900L) freq = 29999900L;
  212.    }
  213.  else
  214.    {
  215.     if     (freq < 144000000L) freq = 144000000L;
  216.     else if(freq > 146000000L) freq = 146000000L;
  217.    }
  218.  
  219.  zehner = (int)(freq % 100L);
  220.  
  221.  if     (zehner < 13) {reByte = 1; freq = freq / 100L * 100L +  0L;}
  222.  else if(zehner < 38) {reByte = 2; freq = freq / 100L * 100L + 25L;}
  223.  else if(zehner < 68) {reByte = 4; freq = freq / 100L * 100L + 50L;}
  224.  else if(zehner < 88) {reByte = 8; freq = freq / 100L * 100L + 75L;}
  225.  else freq = freq / 100L * 100L + 100L;
  226.  
  227.  liByte = (int)((freq %   1000L) /      100L);   /* 100 Hz */
  228.  b1 = (liByte << 4) | reByte;
  229.  b2 = (int)((freq %     100000L) /     1000L);
  230.  b3 = (int)((freq %   10000000L) /   100000L);
  231.  b4 = (int)((freq % 1000000000L) / 10000000L);
  232.  
  233.  b2 = ((b2 / 10) << 4) + b2 % 10;  /* Umwandeln : Hex -> Dez */
  234.  b3 = ((b3 / 10) << 4) + b3 % 10;
  235.  b4 = ((b4 / 10) << 4) + b4 % 10;
  236.  
  237.  sprintf((char*)SerialBuffer, "%1c%1c%1c%1c%1c",  b1, b2, b3, b4, b5);
  238.  return(freq);
  239. }/* Freq_to_Buffer() end */
  240.  
  241.  
  242.  
  243. void Set_Freq(LONG freq) /* Frequenz einstellen und Werte auslesen */
  244. {
  245.  float sm;
  246.  LONG frequenz;
  247.  int i, j;
  248.  
  249.  frequenz = Freq_to_Buffer(freq);
  250.  
  251.  Serial_Write();
  252.  Serial_Read();
  253.  
  254.  
  255.   /* Squelch erst beim 2ten Wert ermitteln, da der erste Wert unzuverlässig */
  256.  
  257.  if(SerialBuffer[1] & 64 == 0)
  258.   {
  259.    printf("ZU\n");
  260.    return;
  261.   }
  262.  
  263.  i = (SerialBuffer[1] & 63) / 2;
  264.  
  265.  for(j = 0; j < i; j++)
  266.    printf("*");
  267.  
  268.  for(j = 1; j <= 63 - i; j++)
  269.    printf(" ");
  270.  
  271.  
  272. if((sm = (SerialBuffer[1] & 63) / 4.0F) > 9.0F)
  273.   printf(": %3d   9 +%2d\r", SerialBuffer[1] & 63, (int)(((sm - 9.0F) * 10.0F) + 2.5F) / 5 * 5);
  274. else
  275.   printf(": %3d  %2d    \r", SerialBuffer[1] & 63, (int)sm);
  276.  
  277. fflush(stdout);
  278. }/* Set_Freq() end */
  279.