Base class for singletons
Not a Singleton


class Database extends Singleton
{
    public function __construct(){

    }
}



This is not a singleton.  Add the following code:  

$bd7 = new Config();


You have a new Config object.  

class Config extends Singleton {

    protected function __construct() {

    }

}


This is a singleton.  It will give an error if you try to create a Config object directly.  Or 

class Database extends Singleton {

}


Is a singleton that gives an error if you create a Database object directly as it inherits its constructor from its parent.  

Registry

You don't need to use inheritance to get this functionality.  


    public static function getInstance(){
        $class = get_called_class();
        if(!isset(self::$instance[$class]) || !self::$instance[$class] instanceof $class){
            self::$instance[$class] = new static(); // create and instance of child class which extends Singleton super class
            echo "new ". $class . PHP_EOL; // remove this line after testing
            return  self::$instance[$class]; // remove this line after testing
        }
        echo "old ". $class . PHP_EOL; // remove this line after testing
        return static::$instance[$class];
    }



Change to 

    public static function getInstance($class, $object = null) {
        if (!isset(self::$instance[$class]) &amp;&amp; $object != null) {
            self::$instance[$class] = $object;
        }

        return static::$instance[$class];
    }


or just 

    public static function getInstance($key) {
        return static::$instance[$key];
    }


with 

    public static function setInstance($key, $object) {
        static::$instance[$key] = $object;
    }


And change 


$bd1 = Database::getInstance(); // new



to 

Registry::setInstance('database', new Database());
$bd1 = Registry::getInstance('database');


Now, it's possible that in a real application you would make more use of what inheritance gives you.  But in this toy application, you don't.  

I changed the name from Singleton to Registry, as better fitting this pattern.  

You lose the just-in-time instantiation of the original, but you gain control over how it is instantiated.  An advantage of this form is that you can also do things like 

Registry::setInstance('database', new MockDatabase());


Your original form prevented this, exacerbating the Singleton pattern's problems with user testing.  

Nitpicks


/**
 * @dosc allows only one instance for each extending class
 * @example use it for database connection, config setup...
 * Be aware, singleton pattern is consider to be an antipatern and becaouse of it build it is hard to debug.
 * In most cases you do not need to use singleton patern so make a longer moment to think about it befor you use it.
 */



Without the spelling errors:  

/**
 * @dosc allows only one instance for each extending class
 * @example use it for database connection, config setup...
 * Be aware, the singleton pattern is consider to be an anti-pattern
 * because it can be hard to debug.
 * In most cases you do not need to use singleton pattern
 * so take a longer moment to think about it before you use it.
 */


I also changed the wording a bit and broke up two lines so that they don't cause scrolling (at least in my browser).