Comments for Rustam's techno-feed

Comment on Ubuntu update 11.10 Oneric by Rustam Kulenov

Rustam Kulenov — Sat, 15 Oct 2011 20:48:53 +0000

And finally I received this:

After reboot my KMail stopped working, so now I don’t have email client.

Comment on C# implementation of Bezier curvature calculation by Jason

Jason — Wed, 10 Aug 2011 14:39:31 +0000

whoops,

I am assuming r1 would turn into
double r1 = System.Math.Sqrt(System.Math.Pow(d1.X * d1.X + d1.Y * d1.Y + d1.Z * d1.Z, 3));

Comment on C# implementation of Bezier curvature calculation by Jason

Jason — Wed, 10 Aug 2011 14:37:06 +0000

Hello,
Very good article and easy to follow code.
I am trying to implement this but for a 3d bezier curve. It seems mostly straight forward until the final curvature calculation:

double r1 = System.Math.Sqrt(System.Math.Pow(d1.X * d1.X + d1.Y * d1.Y, 3));
double r2 = System.Math.Abs(d1.X * d2.Y – d2.X * d1.Y);

I am assuming r1 would turn into
double r1 = System.Math.Sqrt(System.Math.Pow(d1.X * d1.X + d1.Y * d1.Y, 3));
but what about r2? Are you able to provide any insight?

Comment on Calculating tilt from acceleration by Rustam Kulenov

Rustam Kulenov — Fri, 05 Aug 2011 10:36:44 +0000

@Chi Yong
Sure, I will try to post source code this weekend.
Did you connect to the device and can you see Witilt’s data using console as shown on the following link?
http://blog.avangardo.com/2010/09/witilt-wireless-accelerometergyrotilt-controller/

Comment on Calculating tilt from acceleration by Chi Yong

Chi Yong — Fri, 05 Aug 2011 03:42:10 +0000

Im getting trouble of reading raw data fr witilt….
Can i have ur source code for reference?
Thanks…

Comment on Asynchronous VS synchronous UDP reads on a heavily loaded feeds. by Rustam Kulenov

Rustam Kulenov — Sun, 17 Apr 2011 19:02:50 +0000

internal abstract class UdpReader
{
    /// Maximum buffer size.
    private const int BUFFER_SIZE = 0xffff;

    #region Private fields
    /// Local interface that will receive messages sent to multicast group.
    private IPAddress _iface;

    /// IP address and port for connecting to the multicast group.
    private IPEndPoint _group;

    /// UDP socket to read data from.
    private Socket _socket;

    /// Asynchronous socket operation argument.
    private SocketAsyncEventArgs _socketAsyncArgs;

    /// Buffer which contains received data. The same buffer is provided
    /// for socket reading operation and for FIX/FAST processor.
    private byte[] _buffer = new byte[BUFFER_SIZE];

    /// A value indicating whenter parser is active and should process incoming data.
    private bool _working = false;

    /// This event is in signaled state when the parser is safe to be stopped.
    private ManualResetEvent _safeToStopEvent = new ManualResetEvent(true);

    /// Critical section used to protect parser state (during start and stop).
    private object _stateSync = new object();

    #endregion

    /// Initializes a new instance of the UdpReader" class.
    /// Local IP address used for reading UDP multicast messages.
    /// IP address and port of multicast group to listen to.
    public UdpReader(string iface, IPEndPoint multicastGroup)
    {
        _iface = IPAddress.Parse(iface);
        _group = multicastGroup;

        _socketAsyncArgs = _socketAsyncArgs = new SocketAsyncEventArgs();
        _socketAsyncArgs.Completed += receiveCallback;
        _socketAsyncArgs.SetBuffer(_buffer, 0, BUFFER_SIZE);
    }

    /// Starts the parser.
    public virtual void Start()
    {
        lock (_stateSync)
        {
            _working = true;

            if (!initSocket())
            {
                return;
            }

            _socket.ReceiveAsync(_socketAsyncArgs);
        }
    }

    /// Stops the parser.
    public virtual void Stop()
    {
        lock (_stateSync)
        {
            // stop working thread
            _working = false;
            Thread.Sleep(100);
            _safeToStopEvent.WaitOne(2000);
            releaseSocket();
        }
    }

    /// This callback method is called when new data is received via UDP.
    private void receiveCallback(object src, SocketAsyncEventArgs socketAsyncArgs)
    {
        if (!_working)
        {
            return;
        }

        _safeToStopEvent.Reset();
        try
        {            
            // TODO: Decode and process FAST here.
            // Note, that method called from here will be executed in ThreadPool's thread.
            // socketAsyncArgs.BytesTransferred shows number of bytes received via UDP

            // Read next UDP datagram.
            if (_working)
            {
                _socket.ReceiveAsync(socketAsyncArgs);
            }
        }
        finally
        {
            _safeToStopEvent.Set();
        }
    }

    /// Initializes the socket object and joins to the multicast group.
    private bool initSocket()
    {  }

    /// Leaves the multicast group and releases the socket object.
    private void releaseSocket()
    {  }
}

Comment on Asynchronous VS synchronous UDP reads on a heavily loaded feeds. by Rustam Kulenov

Rustam Kulenov — Sun, 17 Apr 2011 19:02:19 +0000

@Niru , as I can see decodeMessage() is private – is it your class method? Do you really have access to it? Moreover decodeMessage() shall be called right after EndReceive() before next call to BeginReceive(). You should also pay attention to threads synchronization, because receiveCallback() will be called from some ThreadPool’s thread.
I can show you how to implement this using .Net 3.5 specific methods, but it is very similar to .Net 2:

Comment on Asynchronous VS synchronous UDP reads on a heavily loaded feeds. by Niru

Niru — Sun, 17 Apr 2011 17:57:52 +0000

Hi Rustam Kulenov,

Thank you very much for your response.

My 3rd party lib call is like

private void decodeMessage(byte[] aBuf)
{
//…
}

Your code receiveCallback..

 	private void receiveCallback(IAsyncResult ar)
        {
            int bytesRead = _socket.EndReceive(ar);
            Counter += bytesRead;
            _socket.BeginReceive(buf, 0, MAX_UDP_PACKET, SocketFlags.None, receiveCallback, null);

            //can i call the decode method here and pass the Buf parameter?

            decodeMessage(buf);
        }

Is this okay? any issues do you find? Kindly advise.

Best regards,
Niru

Comment on Asynchronous VS synchronous UDP reads on a heavily loaded feeds. by Rustam Kulenov

Rustam Kulenov — Sun, 17 Apr 2011 15:36:12 +0000

@Niru unfortunattely I don't know what 3rd party library do you use and what interface does it have. Can it receive IStream as input? If yes, then you can create and provide MemoryStream.

Comment on Asynchronous VS synchronous UDP reads on a heavily loaded feeds. by Niru

Niru — Sat, 16 Apr 2011 17:08:46 +0000

Hi Rustam Kulenov,

Thank you very much for your response.

I have a third party component for decoding of FAST messages.

What I am looking is that how to pass the buf var as input to that third party component?

You have line in the receiveCallback

_socket.BeginReceive(buf, 0, MAX_UDP_PACKET, SocketFlags.None, receiveCallback, null);

Best regards,
Niru