I've often found myself in this situation (having an instance of an object, and needing an array). A couple of examples of where one might encounter this situation:

• DataModels that need to be mapped to a db table (for use in queries with prepared statements)
• Objects that represent data that is coming from/or will be sent to a service through an API (XML or JSON are common formats)
• NoSQL databases like mongodb

Either way, after blundering along and producing awful code, trying to find the best way of doing this, I've often found that extending my model from an abstract class that has a final public function toArray() is more than enough (9/10 times).
This does require you to write classes in a disciplined fashion, which actually is a good thing, but no matter...

Provided your class properties are not private, and each property has an appropriate getter, I tend to add this method:

final public function toArray($asBind = false)
{
    $properties = get_object_vars($this);//only visible, non-statics
    $array = array();
    foreach ($properties as $name => $val)
    {
        if ($asBind === true)
            $array[':'.$name] = $val;
        else
            $array[$name] = $val;
    }
    return $array;
}

If you want this applied to your case, just define the four properties you need in that array as protected or public, and the rest of the properties as private and this'll work.
Alternatively, you can add an $arrayMap property to the abstract level, that you call from the constructor:

abstract class ArrayAble
{
    private $arrayMap = array();
    final protected function setArrayMap(array $map)
    {
        $this->arrayMap = $map;
        return $this;
    }
    final public function toArray($asBind = false)
    {
        $array = array();
        foreach ($arrayMap as $name)
        {
            if ($asBind === true)
                $array[':'.$name] = $this->{$name};
            else
                $array[$name] = $this->{$name};
        }
        return $array;
    }
}
class YourModel extends ArrayAble
{
    protected $foo = 'array-value'
    private $bar = 'invisible';
    public function __construct()
    {
        $this->setArrayMap(array('foo'));
    }
}
$x = new YourModel();
var_dump($x->toArray());//array('foo' => 'array-value');

Ok, so we've got this working, but you've probably noticed that this requires you to know how the toArray method works, and how it does what it does. Chances are you'll forget sooner or later.
If someone else starts working on this code, it becomes even more likely this will bite you.

What we actually want, is for an object to behave like an array. You need a class, to offer an array-like programming interface.

Enter: Interfaces

PHP has a couple of interfaces as standard that allow you to do just that. All of the interfaces that extend from the generic (non-usable) Traversable interface.
The interfaces you might want to use are

• ArrayAccess: Easy to implement, but makes object overloading dangerously easy
• Iterator: Powerful, relatively easy, but requires some "constructor magic" to set up on each instance. Harder to maintain

• IteratorAggregate: Very easy to work with, albeit at the cost of reduced performance. However: micro-optimization is the root of all evil. I'd recommend you use this interface:

  abstract class BaseClass implements IteratorAggregate
  {
      /**
       * Implement interface, abstract implementation
       * means private properties of child remain hidden
       * @return ArrayIterator
       */
      public function getIterator()
      {
          return new ArrayIterator($this);
      }
  }
  

Extend all your models from this abstract class, and you can then loop over them using a foreach construct:

class SomeClass extends Base
{
    protected $foo = 'hello';
    protected $bar = 'World';
    private $spy = 'You can\'t see me!';
}
$x = new SomeClass;
foreach ($x as $k => $v)
    echo $k, ' => ', $v, PHP_EOL;
//output:
foo => hello
bar => world

Notice, private properties remain hidden, if you need those to be visible, you'll have to override the getIterator method in the child class itself.

More details here

On the Iterator interface:
As I've mentioned above: it's slightly trickier to implement. Looking at the PHP documentation, this would seem to be an absurd claim. However: all of the examples rely on a single array storing all the data that otherwise would have been separate properties.

I won't get all boring and go into too much detail, but distinct properties are faster, safer, and enforce a coding style that gives more control/safety (through setters that check the values etc...).
An example of data-models implementing the Iterator interface, without relying on an array to carry the actual data is this class.
It's still being developed, but the child classes can all be traversed using a foreach loop. I thought I'd share this link here, in case you were thinking of implementing the Iterator interface somewhere down the line. Perhaps the code I put on github can serve as inspiration.

Other niggles

Just some minor remarks on the rest of the code:

• As always, I urge you, and everybody else, to subscribe to the most widely accepted coding standard. It's not official (yet), but all major players subscribe to it. As should you.
• fopen + fwrite + fclose, as you use them could easily be replaced with file_put_contents('file.json',json_encode($array));. It's 1 line instead of 3.
• Why create all those instances, and assign them to separate variables? I take it this is not your actual code, but in case it is: arrays are meant to hold related data. All these instances represent data that belongs together. Your code should reflect that.
• Why are you casting the outer array (assigned to $Cycle) to an instance of stdClass? You're json_encoding it. Get rid of the cast, or assign the json-encoded string to $Cycle, write it to the file, and then write $Cycle = json_decode($Cycle);. Decoding has the advantage of creating objects recursively (a cast only casts the outer array to an object).
• Use meaningful names, for variables, properties, and methods: $machine21->Data() doesn't mean anything to me.