Mindboards

m-goldberg wrote:To be a little more exact, when one task acquires a mutex, any other tasks that try to acquire the same mutex are blocked until the first task releases the mutex. At that time, one of the blocked tasks will acquire the mutex and proceed. The other blocked tasks remain blocked.

m-goldberg wrote:To be a little more exact...

ronmcrae wrote: Exactly right.

#define mutex bool // so mutex is equivalent to saying bool
//typedef bool mutex; // if you're insane, you could also say this instead of the #define


#define FREE 0
#define USED 1


// Not using safecall, because that would imply recursion... I'll leave the geniuses to figure out that cryptic statement
/*safecall*/ inline void Acquire(mutex &var)
{
// Wait till var == FREE
    while(var == USED);
// Claim it for the task that calls this
    var = USED;
}


/*safecall*/ inline void Release(mutex &var)
{
    var = FREE;
}

mutex mMotorA;


task GoForward()
{
    while(1)
    {
        Acquire(mMotorA);
        OnFwd(OUT_A, 100);
        Wait(1000);
        Release(mMotorA);
    }
}

task GoBackward()
{
    while(1)
    {
        Acquire(mMotorA);
        OnRev(OUT_A, 100);
        Wait(1000);
        Release(mMotorA);
    }
}

task main()
{
    // Start tasks
    Precedes(GoForward, GoBackward);
}

muntoo wrote:Here is how you would use it:

Code: Select all

mutex mMotorA;


task GoForward()
{
    while(1)
    {
        Acquire(mMotorA);
        OnFwd(OUT_A, 100);
        Release(mMotorA);
    }
}

task GoBackward()
{
    while(1)
    {
        Acquire(mMotorA);
        OnRev(OUT_A, 100);
        Release(mMotorA);
    }
}

task main()
{
    // Start tasks
    Precedes(GoForward, GoBackward);
}

mattallen37 wrote:

muntoo wrote:Here is how you would use it:

Code: Select all

mutex mMotorA;


task GoForward()
{
    while(1)
    {
        Acquire(mMotorA);
        OnFwd(OUT_A, 100);
        Release(mMotorA);
    }
}

task GoBackward()
{
    while(1)
    {
        Acquire(mMotorA);
        OnRev(OUT_A, 100);
        Release(mMotorA);
    }
}

task main()
{
    // Start tasks
    Precedes(GoForward, GoBackward);
}

Although, in that example, there aren't any wait functions, so it would change direction way too fast to go much of anywhere.

ronmcrae wrote:Exactly right. However I wanted to point out that Mutexes are largely used behind-the-scenes by the NXC/NBC compiler so that you program does what you intend it to do when multiple tasks access the same resource. In all the NXC programming I have done I have never had to use a Mutex at the user level. Sure, there are likely legitimate reasons it would be needed, but generally it's not something you need to know about.