Main Site Documentation

[Fez Mini] Application works while debugging, hangs when not


#1

Hi, I have a rather interesting problem at my hands now. I have an application which runs perfectly fine when I run from visual studio which means:
Open Visual Studio, Select Project, Hit F5 :slight_smile:
After starting application that way, even if I stop debugging and close visual studio my application continues running. But if I plug out the usb cable and plug it back in it hangs at a specific point, which is reading from a buffer that holds the data from the serial port. I am logging everything happening in a SD Card so that I know my application hangs at the line gpsStr = gps.GetGPSsentence("$GPGGA"); I can’t upload the whole project to public access due to some privacy issues(its for a competition, after the competition I will gladly upload the project here to help people that might have the same issue.) but I can send it over personally if needed.

I am using 2 COMs, COM3 for gps and COM2 for a wireless module. The code for gps part is down here:

GPS Class


    class GPS_NMEA
    {

        public static SerialPort UART;
        private SerialBuffer sbuffer;

        public GPS_NMEA(String Com, Int32 Baud) 
        {
            UART = new SerialPort(Com, 9600); 
            sbuffer = new SerialBuffer(1024);
            UART.DataReceived += new SerialDataReceivedEventHandler(UART_DataReceived);
        }

        public int GPSOpen()
        {
            UART.Open();
            return 0;
        }

        void UART_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            sbuffer.LoadSerial(UART);
        }

        public void PrintGPSsentence()
        {
            Debug.Print(sbuffer.ReadLine());
        }

        public string GetGPSsentence(string type) 
        {
            try
            {
                string temp;
                //   int dolarindex;
                int tayp;
                do
                {
                    temp = sbuffer.ReadLine();
                    Thread.Sleep(10);
                } while ((temp.IndexOf(type) < 0));
                Thread.Sleep(10);
                tayp = temp.IndexOf(type);
                sbuffer.Read(sbuffer.DataSize);
                // dolarindex = temp.IndexOf('$');
                if ((temp.IndexOf(type) < 0))
                {
                    return "$GPGGA,211449.891,4106.0406,N,02901.3695,E,1,03,8.5,-39.5,M,39.5,M,,0000*46";
                }
                return temp;
            }
            catch (Exception)
            {
                return "$GPGGA,211449.891,4106.0406,N,02901.3695,E,1,03,8.5,-39.5,M,39.5,M,,0000*46";
            }
        }
    }


SerialBuffer: This one is derived from this link, but I changed a lot in it:
http://code.tinyclr.com/project/130/serialbuffer-simple-fast-way-to-read-serial-data/



public class SerialBuffer
{
    private System.Text.Decoder decoder = System.Text.UTF8Encoding.UTF8.GetDecoder();
    private byte[] buffer;
    private int startIndex = 0;
    private int endIndex = 0;
    private char[] charBuffer;

    public SerialBuffer(int initialSize)
    {
        buffer = new byte[initialSize];
        charBuffer = new char[256];
    }

    public void LoadSerial(SerialPort port)
    {
        int bytesToRead = port.BytesToRead;
        if (buffer.Length < endIndex + bytesToRead) // do we have enough buffer to hold this read? 
        {
            // if not, look and see if we have enough free space at the front 
            if (buffer.Length - DataSize >= bytesToRead)
            {
                ShiftBuffer();
            }
            else
            {
                // not enough room, we'll have to make a bigger 
                ExpandBuffer(DataSize + bytesToRead);
            }
        }
        port.Read(buffer, endIndex, bytesToRead); //out of range yedi
        endIndex += bytesToRead;

    }


    private void ShiftBuffer()
    {
        // move the data to the left, reclaiming space from the data already read out 
        Array.Copy(buffer, startIndex, buffer, 0, DataSize);
        endIndex = DataSize;
        startIndex = 0;
    }

    private void ExpandBuffer(int newSize)
    {
        byte[] newBuffer = new byte[newSize];
        Array.Copy(buffer, startIndex, newBuffer, 0, DataSize);
        buffer = newBuffer;
        endIndex = DataSize;
        startIndex = 0;
    }

    public byte[] Buffer
    {
        get
        {
            return buffer;
        }
    }

    public int DataSize
    {
        get
        {
            return endIndex - startIndex;
        }
    }

    public string ReadLine()
    {
        try
        {
            lock (buffer)
            {
                int lineStartPos;
                do
                {
                    lineStartPos = Array.IndexOf(buffer, '$', startIndex);
                }
                while (lineStartPos < 0);
                {
                    int lineEndPos;
                    do
                    {
                        lineEndPos = Array.IndexOf(buffer, '\n', lineStartPos);
                    } while (lineEndPos < 0);


                    int lineLength = lineEndPos - lineStartPos;
                    if (charBuffer.Length < lineLength)  // do we have enough space in our char buffer? 
                    {
                        charBuffer = new char[lineLength];
                    }
                    int bytesUsed, charsUsed;
                    bool completed;
                    decoder.Convert(buffer, lineStartPos, lineLength, charBuffer, 0, lineLength, true, out bytesUsed, out charsUsed, out completed);
                    string line = new string(charBuffer, 0, lineLength);
                    startIndex = lineEndPos + 1;

                    return line;
                }
            }
        }
        catch (Exception)
        {
            return "$GPGGA,211449.891,4106.0406,N,02901.3695,E,1,03,8.5,-39.5,M,39.5,M,,0000*46";
        }
    }

    public byte[] Read(int length)
    {
        lock (buffer)
        {
            int lineEndPos = startIndex + length;
            int oldStartIndex = startIndex;
            if (buffer.Length > 0)
            {
                int lineLength = length;
                Byte[] returnBuffer = new Byte[length];
                if (charBuffer.Length < lineLength)
                {
                    charBuffer = new char[lineLength];
                }

                startIndex = lineEndPos; //+1;

                Array.Copy(buffer, oldStartIndex, returnBuffer, 0, length);
                return returnBuffer;
            }
            else
            {
                return null;
            }
        }
    }
}

To add, I get messages like this from debug window when my applications is running:
Type 0F (STRING ): 372 bytes
Type 11 (CLASS ): 3024 bytes
Type 12 (VALUETYPE ): 96 bytes
Type 13 (SZARRAY ): 4944 bytes
Type 15 (FREEBLOCK ): 26820 bytes
Type 17 (ASSEMBLY ): 12720 bytes
Type 18 (WEAKCLASS ): 48 bytes
Type 19 (REFLECTION ): 24 bytes
Type 1B (DELEGATE_HEAD ): 288 bytes
Type 1D (OBJECT_TO_EVENT ): 192 bytes
Type 1E (BINARY_BLOB_HEAD ): 11544 bytes
Type 1F (THREAD ): 1152 bytes
Type 20 (SUBTHREAD ): 144 bytes
Type 21 (STACK_FRAME ): 1332 bytes
Type 27 (FINALIZER_HEAD ): 312 bytes
Type 31 (IO_PORT ): 288 bytes
Type 34 (APPDOMAIN_HEAD ): 72 bytes
Type 36 (APPDOMAIN_ASSEMBLY ): 1008 bytes
Failed allocation for 268 blocks, 3216 bytes

I don’t know what that means but the word Failed made me suspect :).
+
I added try-catches with hopes to solve the problem, normally they weren’t there, and I run the application for hours without any problems or exceptions in debug mode.

Thanks for all your help in advance.


#2

There is queue built in NETMF. I think it would make things run smoother if you use it.


#3

You mean using the queue instead of buffer right? I will give it a shot. But I am also interested in what might be causing the problem, I read it might be a timing problem so I throwed delays everywhere but no joy :slight_smile:


#4

You might want to look to your outboard power supply. I wasted two hours this afternoon trying to sort out a similar problem. Switched to a regulated 1700ma 9v power supply and all the problems went away. The SD cards make some serious power demands from time to time.


#5

Well, I’m using same power supply for both which is USB so I don’t think thats the problem but I will try plugging it to a proper power supply.