1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:

void Sende_Daten(char *daten_ptr)
{
  int i;

  stat_outbuf.status = HST_BUF_WRITING;

  /* Daten in Puffer */
  for (i=0;(i<=(int)strlen((char *)daten_ptr))&&(i<BLOCKSTRGMAX);i++)
    stat_outbuf.buffer[i]=blockstrg_ptr[i];
  stat_outbuf.buffer[i]=0;

  stat_outbuf.byt_cnt=(word)strlen((char *)(&stat_outbuf.buffer[0]));
  if (stat_outbuf.byt_cnt!=0)
    stat_outbuf.byt_cnt--;

  /* Sendung anstossen */
  events[COM_FLGS] = (byte)(events[COM_FLGS] | CMS4_FLG);
  events[GLBL_FLGS] = (byte)(events[GLBL_FLGS] | EVENT_FLG);
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:

/****************************************************************************/
/*   BESCHREIBUNG : Interrupt Service Routine fuer das Sender von Daten.    */
/*                  Diese Routine ist auf Geschwindigkeit getrimmt.         */
/*                  Die Kommunikation mit den hoeheren Schichten findet     */
/*                  mit "stat_inbuf...status" statt.                        */
/*                                                                          */
/****************************************************************************/

void  Stat_ISR_Send(void) {

static byte out_byte;                              /* static wg. Debugger */
static byte last_out_byte;                           /* static wg. Debugger */

  /* Beim 1. Endezeichen ist Datenfeldende erreicht !  */

  last_out_byte=out_byte;
  out_byte = *stat_outdat_ptr++;

  if (*stat_outcnt_ptr==0) {
       stat_out_strg_cnt++;
  }
  switch (stat_out_strg_cnt) {
          case 0:   /* Header und Datenfeld senden */
                    if ((*stat_outcnt_ptr)-- <=  0)  { /* Byte's zaehlen */
                        out_byte=0;
                        *stat_outstat_ptr = STAT_BUF_ERR_DAT_LEN;        /* Fehler melden  */
      events[COM_FLGS] = (byte)(events[COM_FLGS] | CMG4_FLG);
      events[GLBL_FLGS] = (byte)(events[GLBL_FLGS] | EVENT_FLG);
                    }
                    else {
      stat_out_chk_wert = (byte)((byte)(0x7F) & (byte)(stat_out_chk_wert ^out_byte));
                        /* Byte auf Port schreiben */
      _outp(stat_com_base_adr, out_byte);
                    }
                    break;
          case 1:
                    out_byte=0;
                    *stat_outstat_ptr = STAT_BUF_OUTDAT_OK;         /* Zustand    */
        events[COM_FLGS] = (byte)(events[COM_FLGS] | CMG4_FLG);
        events[GLBL_FLGS] = (byte)(events[GLBL_FLGS] | EVENT_FLG);
                    break;                                    /* melden     */
          default:  *stat_outstat_ptr = STAT_BUF_ERR_FATAL;         /* nicht      */
        events[COM_FLGS] = (byte)(events[COM_FLGS] | CMG4_FLG);
        events[GLBL_FLGS] = (byte)(events[GLBL_FLGS] | EVENT_FLG);
                    break;                                    /* moeglich   */
  }
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

/****************************************************************************/
/*   BESCHREIBUNG : Das 1. Zeichen aus dem Ausgabebuffer wird gesendet;     */
/*                  Die ISR uebernimmt das Senden der restlichen Daten.     */
/*                  Die Kommunikation mit der ISR findet ueber die globalen */
/*                  Variablen statt.                                        */
/*                                                                          */
/****************************************************************************/

void  __far Send_OutBuf_Stat(void) {

    ClrEventFlag(COM_FLGS,CMS4_FLG);

    /* Initialisieren ... */
    stat_outstat_ptr  = &stat_outbuf.status;
    stat_outcnt_ptr   = &stat_outbuf.byt_cnt;
    stat_outdat_ptr   = &stat_outbuf.buffer[0];        /* 1. Byte          */
    stat_out_chk_wert = (byte)(stat_out_strg_cnt = 0);
    *stat_outstat_ptr = STAT_BUF_SENDING;                     /* senden melden    */

    /* ... und Ausgabe starten */
    _outp(stat_com_base_adr, (*stat_outdat_ptr++));

}					

1:

_outp(stat_com_base_adr, (*stat_outdat_ptr++));					

1:
2:
3:
4:
5:
6:
7:
8:

BOOL WriteFile(

    HANDLE hFile,  // handle to file to write to 
    LPCVOID lpBuffer,  // pointer to data to write to file 
    DWORD nNumberOfBytesToWrite,  // number of bytes to write 
    LPDWORD lpNumberOfBytesWritten,  // pointer to number of bytes written 
    LPOVERLAPPED lpOverlapped   // pointer to structure needed for overlapped I/O
   );