SerialPort sport;
        byte[] output;
        int counter;
        byte[] fd;

        public Form1()
        {
            InitializeComponent();
            backgroundWorker1.DoWork += new DoWorkEventHandler(backgroundWorker1_DoWork);
        }

        void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            main();
        }

        delegate void uprtbdel(string data);

        void updateRichtextbox(string data)
        {
            if (this.InvokeRequired)
            {
                uprtbdel d = new uprtbdel(updateRichtextbox);
                this.Invoke(d, new object[] { data });
            }
            else
                richTextBox1.Text += data + "\r\n";
        }

        void write(byte[] buffer, int offset, int count)
        {
            try
            {
                sport.Write(buffer, offset, count);
            }
            catch (Exception ex)
            {

            }
        }

        bool open()
        {
            try
            {
                sport.Open();
                return true;
            }
            catch (System.IO.IOException ex)
            {
                updateRichtextbox(ex.Message.ToString() + "\r\n");
                return false;
            }
        }

        int read(byte[] buffer, int offset, int count)
        {
            try
            {
                return sport.Read(buffer, offset, count);
            }
            catch (Exception ex)
            {
                updateRichtextbox(ex.Message.ToString() + "\r\n");
            }
            return 0;
        }

        /* receive one byte and acknowledge it */

        byte kw1281_recv_byte_ack()
        {
           byte c, d;
           c = (byte)0; //hmm
           read (output, c, 1);
           d = (byte)(0xff-c);
           Thread.Sleep(10); // usleep (10000);
           write (fd, d, 1);
           read (fd, d, 1);
           if (0xff-c != d)
              updateRichtextbox("\r\nkw1281_recv_byte_ack: echo error (0x%02x != 0x%02x)\n" + (0xff-c) + d);
           return c;
        }

        void _set_bit(int bit)
        {
            sport.BreakState = true;
            sport.Write(new byte[] { (byte)bit }, 0, 1);
            sport.RtsEnable = true;
        }

        /* send one byte and wait for acknowledgement */

        void kw1281_send_byte_ack(byte c)
        {
           byte d;
           //int in;
           d = (byte)0; //hmmm

           Thread.Sleep(10); // Thread.Sleep(new TimeSpan(10000)); //usleep (10000);
           write (fd, c, 1);
           read (fd, d, 1);
           if (c != d)
              updateRichtextbox("kw1281_send_byte_ack: echo error (0x%02x0x%02x != 0x%02x)\n" + c + d);
           read (fd, d, 1);
           if (0xff-c != d)
              updateRichtextbox("kw1281_send_byte_ack: ack error (0x%02x != 0x%02x)\n" + (0xff-c) + d);
        }

        /* write 7O1 address byte at 5 baud and wait for sync/keyword bytes */

        void kw1281_init(int address)
        {
            byte c = 0x0;
           
            //Ohne Schleife, blöde nach Schema. :-)
            /*sport.BreakState = true;
            sport.RtsEnable = true;
            sport.DtrEnable = false;
            sport.BreakState = false;
            Thread.Sleep(200);
            sport.Write(new byte[] {(byte)1} , 0, 1);
            sport.RtsEnable = false;
            sport.BreakState = true;
            Thread.Sleep(200);
            sport.Write(new byte[] {(byte)0} , 0, 1);
            sport.RtsEnable = true;
            Thread.Sleep(200);
            sport.Write(new byte[] {(byte)0} , 0, 1);
            sport.RtsEnable = true;
            Thread.Sleep(200);
            sport.Write(new byte[] {(byte)0} , 0, 1);
            sport.RtsEnable = true;
            Thread.Sleep(200);
            sport.Write(new byte[] {(byte)0} , 0, 1);
            sport.RtsEnable = true;
            sport.Write(new byte[] {(byte)0} , 0, 1);
            sport.RtsEnable = true;
            Thread.Sleep(200);
            sport.Write(new byte[] {(byte)0} , 0, 1);
            sport.RtsEnable = true;
            Thread.Sleep(200);
            sport.Write(new byte[] {(byte)0} , 0, 1);
            sport.RtsEnable = true;
            Thread.Sleep(200);
            sport.BreakState = false;
            sport.Write(new byte[] {(byte)1} , 0, 1);
            sport.RtsEnable = false;
            Thread.Sleep(200);
            sport.DtrEnable = true;*/


            //Übersetzer Code vom obigen Link
            int p = 0;
           
           
            byte[] data = new byte[1];

            sport.BreakState = true;
            sport.RtsEnable = true;
            sport.DtrEnable = false;
            sport.BreakState = false;

           //Thread.Sleep(200);

           data[0] = 0x0;
           sport.Write(data, 0, 1);      /* start bit */
           sport.RtsEnable = false;
           Thread.Sleep(200);  /* 5 baud */

           for (int i=0; i<7; i++) {   /* address bits, lsb first */
               int bit = (address >> i) & 0x1;
               _set_bit(bit);
                p = p ^ bit;
                Thread.Sleep(200);
           }
           sport.BreakState = false;
           data[0] = (byte)p; /* odd parity */
           sport.Write(data, 0, 1);
           Thread.Sleep(200);
           data[0] = 0x1; /* stop bit */
           sport.Write(data, 0, 1);
           Thread.Sleep(200);

           read (fd, c, 1);
           if (c != 0x55)
              updateRichtextbox("kw1281_init: sync error (0x55 != 0x%02x)\n" + c);

           read (fd, c, 1);
           if (c != 0x01)
              updateRichtextbox("kw1281_init: keyword error (0x01 != 0x%02x)\n" + c);

           c = kw1281_recv_byte_ack ();
           if (c != 0x8a)
              updateRichtextbox("kw1281_init: keyword error (0x8a != 0x%02x)\n" + c);

           counter = 1;
        }

        /* receive a complete block */

        void kw1281_recv_block()
        {
           int i;
           byte c, l, t;
           char[] buf = new char[256];

           /* block length */
           l = kw1281_recv_byte_ack();

           c = kw1281_recv_byte_ack();
           if (c != counter) {
              updateRichtextbox("counter error (%d != %d)\n" + counter + c);

              updateRichtextbox("IN   OUT\t(block dump)\n");
              updateRichtextbox("0x%02x\n" + l);
              updateRichtextbox("     0x%02x\n0xff-l");
              updateRichtextbox("0x%02x\n" + c);
              updateRichtextbox("     0x%02x\n0xff-c");
              while (1==1) {
                 c = kw1281_recv_byte_ack();
                 updateRichtextbox("0x%02x\n" + c);
                 updateRichtextbox("     0x%02x\n" + "0xff-c");
           }   }

           t = kw1281_recv_byte_ack();
           switch (t) {
              case 0xf6:
                 updateRichtextbox("got ASCII block %d\n" + counter);
                 break;
              case 0x09:
                 updateRichtextbox("got ACK block %d\n" + counter);
                 break;
              default:
                 updateRichtextbox("block title: 0x%02x (block %d)\n" + t + counter);
                 break;
           }
           l -= 2;

           i = 0;
           for (int z = l; z > 0; z--)
           {
               c = kw1281_recv_byte_ack();
               buf[i++] = (char)c;
               updateRichtextbox("0x%02x " + c);
           }
           buf[i] = (char)0;
           if (t == 0xf6)
              updateRichtextbox("= \"%s\"\n" + buf);
           else
              updateRichtextbox("\n");

           /* read block end */
           read (fd, c, 1);
           if (c != 0x03)
              updateRichtextbox("block end error (0x03 != 0x%02x)\n" + c);

           counter++;
        }

        /* send an ACK block */

        void kw1281_send_ack() {
           byte c;

           updateRichtextbox("send ACK block %d\n" + counter);

           /* block length */
           kw1281_send_byte_ack (0x03);

           kw1281_send_byte_ack ((byte)counter++);

           /* ack command */
           kw1281_send_byte_ack (0x09);

           /* block end */
           c = 0x03;
           Thread.Sleep(10); //usleep (10000);
           write (fd, c, 1);
           read (fd, c, 1);
           if (c != 0x03)
              updateRichtextbox("echo error (0x03 != 0x%02x)\n" + c);
        }

        void main()
        {
            updateRichtextbox("Open Port\n");
            //richTextBox1.Text += ("Open Port\n");
            if (open())
            {

                updateRichtextbox("init\n");   /* ECU: 0x01, INSTR: 0x17 */
                kw1281_init(0x01);      /* send 5baud address, read sync byte + key word */

                updateRichtextbox("receive blocks\n");
                kw1281_recv_block();   /* controller ID */
                kw1281_send_ack();

                kw1281_recv_block();   /* component # */
                kw1281_send_ack();

                kw1281_recv_block();   /* software coding */
                kw1281_send_ack();

                kw1281_recv_block();   /* dealer part # */
                kw1281_send_ack();

                updateRichtextbox("main loop\n");
                while (1 == 1)
                {
                    kw1281_recv_block();
                    Thread.Sleep(100); // usleep (100000);
                    kw1281_send_ack();
                }
            }

           /* tcsetattr (fd, TCSANOW, &oldtio); */
        }


        private void button1_Click(object sender, EventArgs e)
        {
            if (comboBox1.SelectedItem != null && comboBox2.SelectedItem != null)
            {
                sport = new SerialPort(comboBox1.SelectedItem.ToString(), Convert.ToInt32(comboBox2.SelectedItem), Parity.None, 8, StopBits.One);

                backgroundWorker1.RunWorkerAsync();
            }
        }

        /// <summary>
        /// Receives one byte without acknowledgement, used for the end byte 0x03
        /// </summary>
        byte readbyte()
        {
            try
            {
                byte[] data = new byte[1];
                serialPort.Read(data, 0, 1);
                return data[0];
            }
            catch (Exception ex) { updateRichtextbox(ex.ToString()); }
            return 0x0;
        }

        /// <summary>
        /// Receives one byte and waits for acknowledgement
        /// </summary>
        byte kw1281_recv_byte_ack()
        {
            byte c = readbyte();

            byte d = (byte)(0xff - c);

            Thread.Sleep(10);
           
            serialPort.Write(new byte[] { d }, 0, 1);

            byte[] echo = new byte[1];
            serialPort.Read(echo, 0, 1);
            if (0xff - c != echo[0])
                updateRichtextbox(String.Format("kw1281_recv_byte_ack: echo error (0x{0:x2} != 0x{1:x2})",(0xff - c),echo[0]));
            return c;
        }

        /// <summary>
        /// Used for Initialization
        /// </summary>
        /// <param name="bit">0/1</param>
        void _set_bit(int bit)
        {
            if (bit == 1)
            {
                serialPort.BreakState = false;
                serialPort.RtsEnable = false;
                //updateRichtextbox("1");
            }
            else if (bit == 0)
            {
                serialPort.BreakState = true;
                serialPort.RtsEnable = true;
                //updateRichtextbox("0");
            }
        }

        /// <summary>
        /// Sends one byte and waits for acknowledgement
        /// </summary>
        /// <param name="c">Byte to send</param>
        void kw1281_send_byte_ack(byte c)
        {
            byte[] dataToWrite = new byte[] { c };
            byte[] receivedData = new byte[1];

            Thread.Sleep(10); // Thread.Sleep(new TimeSpan(10000)); //usleep (10000);
            serialPort.Write(dataToWrite, 0, 1);
            serialPort.Read(receivedData, 0, 1);
            if (dataToWrite[0] != receivedData[0])
                updateRichtextbox(String.Format("kw1281_send_byte_ack: echo error (0x{0:x2} != 0x{1:x2})",dataToWrite[0],receivedData[0]));
            serialPort.Read(receivedData, 0, 1);
            if (0xff - dataToWrite[0] != receivedData[0])
                updateRichtextbox(String.Format("kw1281_send_byte_ack: ack error (0x{0:x2} != 0x{1:x2})",(0xff - dataToWrite[0]),receivedData[0]));

        }

        void acuratesleep(int milliseconds)
        {
            System.Diagnostics.Stopwatch sw;
           
            int i = 0;

            sw = System.Diagnostics.Stopwatch.StartNew();

            while (sw.ElapsedMilliseconds < milliseconds)
            {
                if (sw.Elapsed.Ticks % 10 == 0)
                    i++;
            }
            sw.Stop();
            updateRichtextbox(sw.ElapsedMilliseconds.ToString());
        }

        /// <summary>
        /// Initializes the Connection, writes 7O1 adress byte at 5 baud and waits for sync / keyword bytes
        /// </summary>
        void kw1281_init(int address)
        {
            //0000 0001b
            serialPort.DataBits = 7;
            serialPort.Parity = Parity.Odd;
            int waittime = waitms;
            HiPerfTimer pt = new HiPerfTimer();
            pt.Start();

            serialPort.DtrEnable = false;
            serialPort.RtsEnable = false;

            updateRichtextbox("0");
            _set_bit(0);
            acuratesleep(waittime);
            int p = 1;
            for (int i = 0; i < 7; i++)
            {
                int bit = (address >> i) & 0x1;
                updateRichtextbox(bit.ToString());
                _set_bit(bit);
                p = p ^ bit;
                acuratesleep(waittime);
            }
            updateRichtextbox(p.ToString());
            _set_bit(p);
            acuratesleep(waittime);
            updateRichtextbox("1");
            _set_bit(1);

            //serialPort.RtsEnable = false;
            serialPort.DtrEnable = true;

            pt.Stop();
            updateRichtextbox("Duration: " + pt.Duration.ToString());
           
            try
            {
                serialPort.DataBits = databit;
                serialPort.Parity = getpar();
                byte z =  readbyte();
                if (z != 0x55)
                    updateRichtextbox(String.Format("kw1281_init: sync error (0x55 != 0x{0:x2})",z));
                else
                {
                    updateRichtextbox("init successful");
                }

                byte x = readbyte();
                if (x != 0x01)
                    updateRichtextbox(String.Format("kw1281_init: keyword error (0x01 != 0x{0:x2})",x));
                else
                    updateRichtextbox("keyword OK");

                byte c = kw1281_recv_byte_ack();

                if (c != 0x8a)
                    updateRichtextbox(String.Format("kw1281_init: keyword error (0x8a != 0x{0:x2})",c));

                serialPort.DataBits = 8;
                serialPort.Parity = Parity.None;
               
                counter = 1;

            }
            catch (Exception ex)
            {
                updateRichtextbox(ex.ToString());
            }
        }

        /// <summary>
        /// Receive an Data Block from the ECU
        /// </summary>
        void kw1281_recv_block()
        {
           int i;
           byte c, l, t;
           char[] buf = new char[256];

           /* block length */
           l = kw1281_recv_byte_ack();

           c = kw1281_recv_byte_ack();

           t = kw1281_recv_byte_ack();
           switch (t)
           {
               case 0xf6:
                   ascii = true;
                   updateRichtextbox("got ASCII block " + counter.ToString());
                   break;
               case 0x09:
                   ascii = false;
                   updateRichtextbox("got ACK block " + counter.ToString());
                   break;
               default:
                   ascii = false;
                   updateRichtextbox("block title: 0x" + t.ToString("x2") + " (block " + counter.ToString() + ")");
                   break;
           }
           l -= 3;

           i = 0;
           for (int z = l; z > 0; z--)
           {
               c = kw1281_recv_byte_ack();
               buf[i++] = (char)c;
               if (ascii && c <= 128)
               {
                   char[] characters = System.Text.Encoding.ASCII.GetChars(new byte[] { c });
                   updateRichtextbox("0x" + characters[0]);
               }
               else
                   updateRichtextbox(String.Format("0x{0:x2}",c));
           }
           buf[i++] = (char)0;
           string word = new string(buf);
           if (t == 0xf6)
              updateRichtextbox("= \"" + word.TrimEnd() + "\"\n");
           else
              updateRichtextbox("\n");

           // read block end
           byte[] end = new byte[1];
           serialPort.Read(end, 0, 1);
           c = end[0];

           if (c != 0x03)
               updateRichtextbox(String.Format("block end error (0x03 != 0x{0:x2}", c));
           else
               updateRichtextbox("-- block end reached --");

           counter++;
        }

        /// <summary>
        /// ACK Block, ECU answers with ACK Block or Data
        /// </summary>
        void kw1281_send_ack() {
           byte c;

           updateRichtextbox(String.Format("send ACK block {0:d}",counter));

           // block length
           kw1281_send_byte_ack (0x03);

           kw1281_send_byte_ack ((byte)counter++);

           // ack command
           kw1281_send_byte_ack (0x09);

           // block end
           c = 0x03;
           Thread.Sleep(10);

           serialPort.Write(new byte[] { c }, 0, 1);
           c = readbyte();
           if (c != 0x03)
              updateRichtextbox(String.Format("echo error (0x03 != 0x{0:x2})" ,c));
        }

        /// <summary>
        /// Requesting a Data Group
        /// </summary>
        void kw1281_request_group()
        {
            byte c;

            updateRichtextbox(String.Format("Requesting a Data Group {0:d}\n", counter));

            // block length
            kw1281_send_byte_ack(0x04);

            // counter
            kw1281_send_byte_ack((byte)counter++);

            // block title command
            kw1281_send_byte_ack(0x29);

            // group number
            kw1281_send_byte_ack(0x04);

            // block end
            c = 0x03;
            Thread.Sleep(10);

            serialPort.Write(new byte[] { c }, 0, 1);
            c = readbyte();
            if (c != 0x03)
                updateRichtextbox(String.Format("echo error (0x03 != 0x{0:x2})" ,c));
        }

        /// <summary>
        /// Receives one Data Group
        /// </summary>
        void kw1281_recv_group()
        {
            int i;
            byte c, l, t;
            char[] buf = new char[256];

            /* block length */
            l = kw1281_recv_byte_ack();

            c = kw1281_recv_byte_ack();

            t = kw1281_recv_byte_ack();
            switch (t)
            {
                case 0xe7:
                    updateRichtextbox("got group block " + counter.ToString() + "\n");
                    break;
                case 0x09:
                    updateRichtextbox("got ACK block " + counter.ToString() + "\n");
                    break;
                default:
                    updateRichtextbox("block title: 0x" + t.ToString("x2") + " (block " + counter.ToString() + ")\n");
                    break;
            }
            l -= 3;

            i = 0;
            for (int z = l; z > 0; z--)
            {
                c = kw1281_recv_byte_ack();
                buf[i++] = (char)c;
                updateRichtextbox(String.Format("0x{0:x2}", c));
            }
            buf[i++] = (char)0;
            string word = new string(buf);
                updateRichtextbox("\n");

            // read block end
            byte[] end = new byte[1];
            serialPort.Read(end, 0, 1);
            c = end[0];

            if (c != 0x03)
                updateRichtextbox(String.Format("block end error (0x03 != 0x{0:x2}\n", c));
            else
                updateRichtextbox("-- group block end reached --");

            counter++;
        }

void main()
        {
            updateRichtextbox("Open Port..\n");
            if (open())
            {
               
                updateRichtextbox("Port opened\n");

                updateRichtextbox("Flush existing data\n");
                updateRichtextbox(serialPort.ReadExisting());

                /* ECU: 0x01, INSTR: 0x17 */
                updateRichtextbox("Initialization\n");
                Thread.Sleep(500);
                kw1281_init(0x01);      /* send 5baud address, read sync byte + key word */

                updateRichtextbox("Receive Blocks\n");
                updateRichtextbox("Controller ID\n");
                kw1281_recv_block();   // controller ID
                kw1281_send_ack();


                updateRichtextbox("Component\n");
                kw1281_recv_block();   // component #
                kw1281_send_ack();

                updateRichtextbox("Software Coding\n");
                kw1281_recv_block();   // software coding
                kw1281_send_ack();

                updateRichtextbox("Dealer Part\n");
                kw1281_recv_block();   // dealer part #
                kw1281_send_ack();


                updateRichtextbox("Main Loop\n");

                kw1281_recv_block();
                kw1281_send_ack();

                kw1281_recv_block();
                Thread.Sleep(100);

                kw1281_request_group();
                kw1281_recv_group();
}

//Initialisierung des SerialPorts's:

serialPort = new SerialPort();
                serialPort.PortName = comboBox1.SelectedItem.ToString();
                serialPort.Handshake = Handshake.None;
                waitms = 200; (190-200);
                databit = 7 (bei Initialisierung, bzw. 8 danach)
                if (comboBox2.SelectedIndex != 0)
                    serialPort.BaudRate = Convert.ToInt32(comboBox2.SelectedItem.ToString()); //10400, 9600, ...


                serialPort.Parity = Parity.Odd; (Odd bei Initialisierung, bzw. None danach)


                        serialPort.Encoding = Encoding.ASCII;

#include <stdio.h>
#include <sys/signal.h>
#include <unistd.h>
#include <termios.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/ioctl.h>

#define kw1281_debug_dev
//#define kw1281_debug_dev_all

class kw1281{
   private:
      int fd;
      int counter;   /* kw1281 protocol block counter */
      
   public:
      
      int fetchGroup(unsigned char groupID){
         #ifdef kw1281_debug_dev
         printf("kw1281_fetchGroup: Requesting a Data Group {0x%d}\n", groupID);
         #endif
   
         kw1281_request_group(groupID);
         usleep(10000);
         kw1281_recv_group();
      }
      
      int fetchBlock(void){
         #ifdef kw1281_debug_dev
         printf ("kw1281_fetchBlock: Requesting Block %d\n", counter);
         #endif
         
         kw1281_send_ack();
         usleep(10000);
         kw1281_recv_block();
      }
   
   void destroy(void){
      close(fd);
   }
   
   void kw1281_start(char *serialDevice){
      unsigned char c;
      struct termios oldtio, newtio;
      struct sigaction saio;

      fd = open (serialDevice, O_SYNC | O_RDWR | O_NOCTTY);
      if (fd < 0) {
        printf("kw1281: couldn't open serial device");
      }

      tcgetattr (fd, &oldtio);

      newtio.c_cflag = B9600 | CS8 | CLOCAL | CREAD;
      newtio.c_iflag =  IGNPAR; // ICRNL provokes bogus replys after block 12
      newtio.c_oflag = 0;
      newtio.c_cc[VMIN] = 1;
      newtio.c_cc[VTIME] = 0;
      tcflush (fd, TCIFLUSH);
      tcsetattr (fd, TCSANOW, &newtio);
      #ifdef kw1281_debug_dev_all
      printf("kw1281: serial device opened");
      #endif
   }
      
   /* manually set serial lines */
   void _set_bit(int bit)
   {
      int flags;

      ioctl (fd, TIOCMGET, &flags);
      if (bit) {
        ioctl (fd, TIOCCBRK, 0);
        flags &= ~TIOCM_RTS;
      } else {
        ioctl (fd, TIOCSBRK, 0);
        flags |= TIOCM_RTS;
      }
      ioctl (fd, TIOCMSET, &flags);
   }

   /* receive one byte and acknowledge it */
   unsigned char kw1281_recv_byte_ack()
   {
      unsigned char c, d;

      read (fd, &c, 1);
      d = 0xff-c;
      usleep (10000);
      write (fd, &d, 1);
      read (fd, &d, 1);
      if (0xff-c != d)
        printf ("kw1281_recv_byte_ack: echo error (0x%02x != 0x%02x)\n", 0xff-c, d);
      return c;
   }

   /* send one byte and wait for acknowledgement */
   int kw1281_send_byte_ack(unsigned char c)
   {
      unsigned char d;
      int retValue = 1;

      usleep (10000);
      write (fd, &c, 1);
      read (fd, &d, 1);
      if (c != d){
        printf ("kw1281_send_byte_ack: echo error (0x%02x != 0x%02x)\n", c, d);
        retValue = -1;
     }
      read (fd, &d, 1);
      if (0xff-c != d){
        retValue = -2;
        printf ("kw1281_send_byte_ack: ack error (0x%02x != 0x%02x)\n", 0xff-c, d);
     }
       
      return retValue;
   }

   /* write 7O1 address byte at 5 baud and wait for sync/keyword bytes */
   void kw1281_init(int address)
   {
      int i, p, flags;
      unsigned char c;

      int out,in;
      
      
      /* prepare to send (clear dtr and rts) */
      ioctl (fd, TIOCMGET, &flags);
      flags &= ~(TIOCM_DTR | TIOCM_RTS);
      ioctl (fd, TIOCMSET, &flags);
      usleep (200000);

      _set_bit (0);      /* start bit */
      usleep (200000);   /* 5 baud */
      p = 1;
      for (i=0; i<7; i++) {   /* address bits, lsb first */
        int bit = (address >> i) & 0x1;
        _set_bit (bit);
        p = p ^ bit;
        usleep (200000);
      }
      _set_bit (p);      /* odd parity */
      usleep (200000);
      _set_bit (1);      /* stop bit */
      usleep (200000);

      /* set dtr */
      ioctl (fd, TIOCMGET, &flags);
      flags |= TIOCM_DTR;
      ioctl (fd, TIOCMSET, &flags);

      /* read bogus values, if any */
      ioctl(fd, FIONREAD, &in);
      while (in--) {
        read (fd, &c, 1);
        #ifdef kw1281_debug_dev_all
        printf ("ignore 0x%02x\n", c);
        #endif
      }

      read (fd, &c, 1);
      if (c != 0x55)
        printf ("kw1281_init: sync error (0x55 != 0x%02x)\n", c);

      read (fd, &c, 1);
      if (c != 0x01)
        printf ("kw1281_init: keyword error (0x01 != 0x%02x)\n", c);

      c = kw1281_recv_byte_ack ();
      if (c != 0x8a)
        printf ("kw1281_init: keyword error (0x8a != 0x%02x)\n", c);

      counter = 1;
      
      usleep(10000);
      kw1281_recv_block();
      
       fetchBlock(); /* controller ID */
      fetchBlock(); /* component # */
      fetchBlock(); /* software coding */
      fetchBlock(); /* dealer part # */
      fetchBlock();
   }

   /* receive a complete block */
   void kw1281_recv_block()
   {
      if(counter > 256) counter = 1;
            
      int i=0;
      unsigned char c, l, t;
      char buf[256];

      /* block length */
      l = kw1281_recv_byte_ack();
      l -= 2;

      c = kw1281_recv_byte_ack();
      
      if (c != counter) {
         printf ("kw1281_recv_block: counter error (%d != %d)\n", counter, c);
         printf ("IN   OUT\t(block dump)\n");
         printf ("0x%02x\n", l);
         printf ("     0x%02x\n", 0xff-l);
         printf ("0x%02x\n", c);
         printf ("     0x%02x\n", 0xff-c);
         while (1) {
            c = kw1281_recv_byte_ack();
            printf ("0x%02x\n", c);
            printf ("     0x%02x\n", 0xff-c);
         }   }

      t = kw1281_recv_byte_ack();
      
      #ifdef kw1281_debug_dev
      switch (t) {
        case 0xf6:
          printf ("kw1281_recv_block: got ASCII block %d\n", counter);
          break;
        #ifdef kw1281_debug_dev_all
        case 0x09:
          printf ("kw1281_recv_block: got ACK block %d\n", counter);
          break;
        default:
          printf ("kw1281_recv_block: block title: 0x%02x (block %d)\n", t, counter);
        #endif
      }
      #endif
      
      while (--l) {
        c = kw1281_recv_byte_ack();
        buf[i++] = c;
        #ifdef kw1281_debug_dev
        printf ("0x%02x ", c);
        #endif
      }
      buf[i] = 0;
      #ifdef kw1281_debug_dev
      if (t == 0xf6) printf ("= \"%s\"\n", buf);
      else printf ("\n");
      #endif

      /* read block end */
      read (fd, &c, 1);
      if (c != 0x03) printf ("kw1281_recv_block: block end error (0x03 != 0x%02x)\n", c);

      counter++;
   }

   /* send an ACK block */
   void kw1281_send_ack() {
      unsigned char c;

      /* block length */
      kw1281_send_byte_ack (0x03);

      kw1281_send_byte_ack (counter++);

      /* ack command */
      kw1281_send_byte_ack (0x09);

      /* block end */
      c = 0x03;
      usleep (10000);
      write (fd, &c, 1);
      read (fd, &c, 1);
      if (c != 0x03) printf ("echo error (0x03 != 0x%02x)\n", c);
   }

   /* request Data Group */
   void kw1281_request_group(unsigned char groupID)
   {
      unsigned char c;
   
          
      /* send block length */
      kw1281_send_byte_ack(0x04);

      /* send counter */
      kw1281_send_byte_ack(counter);

      /* send block title command */
      kw1281_send_byte_ack(0x29);

      /* send group number */
      kw1281_send_byte_ack(groupID);

      /* block end */
      c = 0x03;
      usleep(10000);

      write(fd, &c, 1);
      read (fd, &c, 1);
      if (c != 0x03)
         printf("kw1281_request_group: echo error (0x03 != 0x%d)\n" ,c);
   }

   // Receives one Data Group
   void kw1281_recv_group()
   {
      int i=0;
      unsigned char c, l, t;
      unsigned char buf[256];
      
      /* block length */
      l = kw1281_recv_byte_ack();
      l -= 3;
      
      c = kw1281_recv_byte_ack();
      
      t = kw1281_recv_byte_ack();
      
      #ifdef kw1281_debug_dev_all
      switch (t){
         case 0xe7:
            printf("recv_group: got group block\n");
            break;
         case 0x09:
            printf("recv_group: got ACK block\n");
            break;
         default:
            printf("recv_group: block title: 0x%d (l: %d c: %d)\n",t, l, c);
            break;
      }
      #endif

      for (int z = l; z > 0; z--){
         c = kw1281_recv_byte_ack();
         buf[i++] = c;
         if (t == 0xe7){
            printf("(%3d) 0x%02x ", c, c);
            if(i%3 == 0) {
               buf[i] = 0;
               #ifdef kw1281_debug_dev
               if (t == 0xe7) printf ("=\"%s\"", buf);
               #endif
               printf("\n");               
               i=0;
            }
         }
      }
            
      #ifdef kw1281_debug_dev
      if (t == 0xe7) printf("\n");
      #endif
               
      /* read block end */
      read (fd, &c, 1);
            
      if (c != 0x03)   printf("recv_group: block end error (0x03 != 0x%c\n", c);
      #ifdef kw1281_debug_dev_all
      else          printf("recv_group: -- group block end reached --\n");
      #endif
   }
      
   
};




int main(void) {
 
  kw1281 diags;
  diags.kw1281_start((char *) "/dev/ttyUSB0");
 
 
 
  int groupCounter = 0;

   diags.kw1281_init (0x17);      /* send 5baud address, read sync byte + key word, ECU: 0x01, CLUSTER: 0x17 */
 
   printf ("main loop\n");
   
   
   while (1) {
     if(groupCounter > 255) groupCounter = 0;
    
     diags.fetchBlock();
     
      diags.fetchGroup((char) groupCounter++);
     
   }

   diags.destroy();
}