need help regarding node js async infinite loop

setTimeout is used for calling something once after a predetermined time. It is, however the best way to call an infinite loop using a technique called recursion. Example:

var foo = function() {
  setTimeout(function() {
    // do stuff that may take time

    foo()
  }, 3000)  
}

Don't use setInterval as it will call again, even if it hasn't completed other actions in the function.

may you need to use

setInterval(function(){
    callback();
}, 3000)

setTimeout(), run once.

You can do it recursively:

asyncTasks.push(function (callback){
  var count = 0;

  myTask(function fn(err) {
    if(err || count >= 5) return callback(err);
    count++;
    myTask(fn);
  });
});

or

asyncTasks.push(function task(callback){
    if(err || taskCount >= 5) return callback(err);
   // assuming taskCount is in the outer scope
    taskCount++; 
    task(callback);
});

Edit

Most of the functions you'll be writing will have a callback since Node.js is a continuation-passing style language and I/O is asynchronous.

There's a pattern for node.js asynchronous functions where functions apart from any number of params take an extra function with the following signature:

// results is optional
function(err,[results]){}

So a function declaration should look something like:

// next() here is the function described above
SensorTag.registerEvent = function(event,next) {
  // Do stuff...
  // Do more stuf...

  if(stuffFailed){
    // If first param is truthy
    // something went wrong
    return next("Some error")
  } 

  // null as first param mean
  // implicitly that everything went ok
  next(null,["some","result"]);
};

If you get and error you explicitly return before the code below gets executed. Eg:

var getCurrentUser = function(callback){
  DB.findCurrentUser({ foo: 'always' },function(err,user) {
    if(err){
      return callback(err);
    }

    return callback(null,user);
  });
}

getCurrentUser(function(err,userProfile) {
  if(err){
    console.log(err);
    return;
  }

  console.log('OK! We got user: %s',userProfile.id);
});

Async uses that pattern. It's a great library for control flow but you need to understand how to control the continuation flow.

In your function SensorTag.discover MUST take a callback as a second parameter to allow the continuation to keep going once you are done with that function. Also, all your other functions should have that same signature if you wanna plug them directly into async.

If all your functions (not posted) have that signature and you are handling errors correctly SensorTag.discover may look something like this:

// This function needs a callback if you wish
// to continue your program
SensorTag.discover(function(sensorTag) {
  console.log('discovered: ' + sensorTag);

  async.series([
    sensorTag.connectAndSetUp,
    sensorTag.readDeviceName,
    sensorTag.readSystemId
  ],function(err,tasksData) {
    if(err){
      console.error(err);
      return;
    }
    console.log('All tasks succedded!');
    // No external callback to continue
  });
});

If those three functions look like the getCurrentUser example from above that should work. The problem you are having may be in those internal functions.

Whilst is the same but it only takes 3 functions where the one that matters is the one in the middle and that's the one that should follow the callback(err) pattern. So:

SensorTag.discover(function(sensorTag) {
  console.log('discovered: ' + sensorTag);

  var count = 0;

  async.whilst(
    function () { return count < 5; },
    function (callback) {
      console.log('count === %d',count);
      async.series([
        sensorTag.connectAndSetUp,
        sensorTag.readDeviceName,
        sensorTag.readSystemId
      ],callback);
    },
    function (err) {
      // This is our continuation callback
      // But again, we don't have an external callback
    }
  );
});

I don't know what SensorTag.discover does but it looks like it's defined elsewhere and takes a function (?). I'm guessing it should look something like this maybe (to allow for continuation):

SensorTag.discover = function(sensorTag,next) {
  console.log('discovered: ' + sensorTag);

  var count = 0;

  async.whilst(
    function () { return count < 5; },
    function (callback) {
      console.log('count === %d',count);
      async.series([
        sensorTag.connectAndSetUp,
        sensorTag.readDeviceName,
        sensorTag.readSystemId
      ],callback);
    },
    function (err) {
      next(err);
    }
  );
});

// Then you call it externally
SensorTag.discover(mySensorTag,function(err) {
  if(err){
    console.error(err);
  }

  // Do more stuff...
});

I would suggest you read about Node.js and asynchronous programming patterns before diving deep into the async library. As I said before, async is very powerful but you need to understand those concepts or you'll be debugging forever.