Question

So, I have worked on large systems in the past, like an iso stack session layer, and something like that is too big for what I need, but I do have some understanding of the big picture. What I have now is a serial point to point communications link, where some component is dropping data (often).

So I am going to have to write my own, reliable delivery system using it for transport. Can someone point me in the directions for basic algorithms, or even give a clue as to what they are called? I tried a Google, but end up with post graduate theories on genetic algorithms and such. I need the basics. e.g. 10-20 lines of pure C.

Answer 1

on the sending side;

/////////////////////////////////////////  XBee logging
void dataLog(int idx, int t, float f)
{
    ubyte stx[2] = { 0x10, 0x02 };
    ubyte etx[2] = { 0x10, 0x03 };

    nxtWriteRawHS(stx, 2, 1);
    wait1Msec(1);

    nxtWriteRawHS(idx, 2, 1);
    wait1Msec(1);

    nxtWriteRawHS(t, 2, 1);
    wait1Msec(1);

    nxtWriteRawHS(f, 4, 1);
    wait1Msec(1);

    nxtWriteRawHS(etx, 2, 1);
    wait1Msec(1);
}

on the receiving side

void XBeeMonitorTask()
        {
            int[] lastTick = Enumerable.Repeat<int>(int.MaxValue, 10).ToArray();
            int[] wrapCounter = new int[10];


            while (!XBeeMonitorEnd)
            {
                if (XBee != null && XBee.BytesToRead >= expectedMessageSize)
                {
                    // read a data element, parse, add it to collection, see above for message format
                    if (XBee.BaseStream.Read(XBeeIncoming, 0, expectedMessageSize) != expectedMessageSize)
                        throw new InvalidProgramException();

                    //System.Diagnostics.Trace.WriteLine(BitConverter.ToString(XBeeIncoming, 0, expectedMessageSize));

                    if ((XBeeIncoming[0] != 0x10 && XBeeIncoming[1] != 0x02) ||  // dle stx
                        (XBeeIncoming[10] != 0x10 && XBeeIncoming[11] != 0x03))   // dle etx
                    {
                        System.Diagnostics.Trace.WriteLine("recover sync");
                        while (true)
                        {
                            int b = XBee.BaseStream.ReadByte();
                            if (b == 0x10)
                            {
                                int c = XBee.BaseStream.ReadByte();
                                if (c == 0x03)
                                    break;     // realigned (maybe)
                            }
                        }
                        continue;   // resume at loop start
                    }

                    UInt16 idx = BitConverter.ToUInt16(XBeeIncoming, 2);
                    UInt16 tick = BitConverter.ToUInt16(XBeeIncoming, 4);
                    Single val = BitConverter.ToSingle(XBeeIncoming, 6);

                    if (tick < lastTick[idx])
                        wrapCounter[idx]++;
                    lastTick[idx] = tick;

                    Dispatcher.BeginInvoke(DispatcherPriority.ApplicationIdle, new Action(() => DataAdd(idx, tick * wrapCounter[idx], val)));
                }
                Thread.Sleep(2);  // surely we can up with the NXT
            }
        }