[JS]
[DE]
[PLUGIN] ../../build/hacktimer.plugin
[PLUGIN] ../../build/jam.plugin
[PLUGIN] ../../build/popup.plugin
[PLUGIN] ../../build/file.plugin
[PLUGIN] ../../build/math.plugin
[TITLE] MCWS mit JAM 
[AUTHOR] Stefan Bosse
[VERSION] 7.2020

# Mobiles Crowdsensing mit JAM Agenten

## Einführung

### Vorbereitung

1. Starte die JAM WEB App [APP](https://ag-0.de/software/jamapp.html?link=ag-0.de:30001&secure=12:34:56:78&proto=https&sensors=gps5) im Browser (Smartphone, Dekstop Rechner, Notebook)
2. Optional für die Experimentierfreudigen: Starte einen Tor Browser mit Proxykette und lade auch dort die JAM WEB App
3. Die JAM WEB App muss nicht wieter bedient werden (ist hier nur Kommunikationendpunkt)

## JAM Plattform Shell

- Die Shell (jamsh) ist ein Interpreter auf der JavaScript Agent Machine (JAM) und erlaubt einen programmatischen Zugriff auf die Agentenplattform
  + Erzeugung von Kommunikationsports
  + Herstellung von Channels (Kommunikationsverbindungen mit anderen JAM Plattformen)
  + Erzeugung von Agenten
  + uvm.
  
> In diesem Notebook ist eine vollständige JAM Plattform und eine JAM Shell eingebaut!

- Die Agentenplattform stellt alle nötigen Dienste für Agenten zur Verfügung
  + Ausführung des Agenten
  + Sandkasten (Isolierung und Entkopplung der Agenten von der Plattform)
  + Kommunikations (Signale, Tuple)
  + Migration
  + Replikation

- Die zentrale Schnittstelle zwischen der Hostapplikation (dieses Notebook und die JAM Shell) und den Agenten  ist das Agent Input-Output Systeme AIOS
  + Im AIOS werden die Agenten über einen Scheduler in einem geschützen Bereich (Sandkasten) ausgeführt und den Agenten eine eingeschränkte operative Schnittstelle zur Vefrügung gestellt (also Funktionen und Operationen die der Agent ausführen darf, wie Kommunikation und Migration)
  + Das AIOS stellt über die Agenten API
  + Die JAM Shell greift über eine weitere API Schicht (jamlib) direkt auf das AIOS zu
  
![#aios width=70%](images/aiosSH.png)

- Zuerst muss eine JAM Shell erzeugt werden:

[CODE] Eine Shell erzeugen { lines:10 }
```js
Shell({
  verbose:1
});
```

- Dann muss wenigstens ein Kommunikationsport (i.a. IP) hinzugefügt werden
  + Channels (Links) werden über Ports verbunden
  
[JAM] Shell Initialisierung { lines:10 }
```js
port(DIR.IP('https://localhost:*'));
locate(print);
start()
```

- Und schließlich wird ein Channel zu dem im Internet sichtbaren JAM Relais hergestellt

[JAM] Shell verbinden { lines:4 }
```js
connect(DIR.IP('https://ag-0.de:30001?secure=12:34:56:78'));
```

- Es können jederzeit Status- und Statistikinformationen der eigenen JAM Plattform abgerufen werden

- Einige Beispiele sind nachfolgend gezeigt

[JAM] Shell Status { lines:20 }
```js
print('conn:')
print(stats("conn"));
print('node:')
print(Table([stats("node")]));
print(connected(DIR.IP('%')));
print(connected(DIR.IP('*')));
```

## Geolokalisation

- Ein wichtiger Sensor im Mobilen Crowdsensing ist die geografische Position (meistens in Polarkoordinaten mit Längen- (lon) und Breitengrad (lat) angegeben)

- Neben der physikalischen geografischen Position ist der Ortskontext von Interesse (Ortsbeschreibung wie Straßenname und Stadt)

- Die Erlangung der aktuellen geografischen Position eines mobilen Gerätes wie ein Smartphone erfolgt meistens direkt mittels Funkwellen und GPS

- Die direkte Ableitung der Position über die Internetgeräteadresse ist schwierig da i.A. nur der Standort des Internetserviceproviders (ISP) ermittelt werden kann
  + Aber mittels vorherigen Crowdsensing kann aus kollektiver Information und Fusion mit Nutzungsdaten (wie häufige Seitenaufrufe mit Ortsbezug, DNS Nutzung!, usw.) eine genauere Ortslokalisierung der öffentlich sichtbaren IP Adresse erfolgen

- JAM verwendet ein mehrstufiges Verfahren um den Standort seiner Hostplattform zu ermitteln:

1. Über die öffentliche IP Adresse und einer ISP Datenbank (Genauigkeit zwischen 10-500km) und Verwendung des ISP Datenbankservers `http:\\ip-api.com` (Achtung: Ad-Blocker in WEB Browser verhindern den Zugriff auf diesen Datenbankservice). Diese Geolokalisation verwendet keine Daten aus Tracking und Tracing (kein Crowdsensing)!

2. Über die öffentliche IP Adresse und einen Lokalisationservice von Mozilla `https:\\location.services.mozilla.com`. Dieser verwendet zur Bestimmung der Nutzerposition (Breiten- und Längengrad) Daten aus Crowdsensing (kollektive Mittelwertdaten, vermutlich nicht personalisiert) und  `https://api.opencagedata.com` zur Bestimmung des Ortskontextes (Ort, Land).

3. Wenn vorhanden und nutzbar GPS sowie im WEB Browser den HTML5 GeoLocation Service (über diesen wird dann auch GPS des Gerätes verwendet).

## Ein einfacher Explorationsagent

- Im agentenbasierten mobilen Crowdsensing nehmen mobile Agenten (also mobiler Code/Software) möglichst slebständig die Erhebung von sensorischen Daten und die Durchführung von Umfragen durch

- Beipiel ist folgender Explorationsagent, der
  + In diesem Notebook erzeugt wird,
  + Auf einen externen im Internet sichtbaren JAM Knoten migriert (das Relais),
  + Von dort aus neue mit diesem JAM Knoten verbundene JAM Knoten besucht (sowohl die JAM WEB App als auch dieses Notebook!)
  + Auf diesen Knoten/Rechnern sensorische Informationen erhebt,
  + Dann wieder zum Relaisknoten zurückkehrt und solange neue Knoten besucht bis es keine neuen Knoten mehr gibt (und/oder ein Zeitintervall abgelaufen ist),
  + Schließlich kehrt der Explorationsagent zu seinem Usrprungsknoten - also diesem Notebook - zurück und liefert die Erhebungsergebnisse über den Tupelraum zurück
  
  
![#websur width=70%](images/jamsur.png)

### Die Verhaltensbeschreibung des Agentens (Code)

- Ein Agent gehört initial zu einer Agentenklasse die in JAM/AgentJS als Konstruktionsfunktion (eines Agentenobjekts) programmiert wird

- In AgentJS besteht die Agentenbeschreibung aus
  + Körpervariablen `this.data=value;`
  + Aktivitäten, die Mikroziele und Absichten des Agenten darstellen
  + Übergänge zwischen Aktivitäten (Transitionen, Änderung des Kontrollzustandes des Agenten)
  + Optional Signalhandler
  + Und einer speziellen Körpervariable `this.next=ai`, die initial die erste auszuführende Aktivität bezeichnet (beim Start des Agenten)

#### Aktivitäten

*init*

- Der Agent startet und initialisiert sich. Dazu wird hier nur der aktuelle JAM Knotenname in der Variable *rootNode* vermerkt (zu diesem Knoten soll der Agent nach der Ehebung zurückkeheren)
- In der Variable *path* wird der aktuelle Pfad an Knoten gespeichert (vorwärts gehen vergrößert die Liste, rückwärts gehen verkleinert sie entsprechend)

*percept*

- Auf jedem (auch den Startknoten) werden sensorische Informationen erhobe und in der Variable *collect* gespeichert
- Weiterhin werden neue Knoten gesucht und randomisiert einer aus der neuen List ausgewählt
- Der aktuell besuchte Knoten wird in der Liste *visited* gespeichert

*explore*

- In dieser Aktivität wird zum nächsten Knoten migriert. Der Agent nimmt seinen Code und all seine Daten mit!

*goback*

- Falls keine neuen noch nicht besuchten Knoten mehr gefunden werden geht es wieder einen Schitt zurück entlang des bereits durchlaufenen Pfades (*path*)

*deliver*

- Wenn der Wurzelknoten wieder erreicht wurde (nach einem goback) werden die Erhebnungsergebnisse im Tupelraum (dann des Notebooks) übertragen
- Das Erhebungstupel kann hier im Notebook dann wieder über die Shell ausgelesen werden

[JAM] Agent { lines:20 }
```js
function explorer (options) {
  // 1. Körpervariablen (Inhalte sind mobil)
  this.rootNode=null;
  this.visited=[];
  this.collect=[];
  this.verbose = 1;
  this.currentNode = null;
  this.path = [];
  this.nextNode = null;
  this.hops = 0;
  this.maxHops = 200;

// 2. Aktivitäten
  this.act = {
    init : function () {
      this.rootNode = myNode();
      log('Starting on '+this.rootNode);
      this.path.push(this.rootNode);
    },

percept : function () {
      var loc;
      this.currentNode = myNode();
      log('PERCEPT on '+this.currentNode);
      if (!contains(this.visited,this.currentNode)) {
        // Neuer Knoten
        this.visited.push(this.currentNode);
        var sensors = {};
        sensors.clock=clock(true);
        sensors.path=copy(this.path);
        sensors.node=this.currentNode;
        // Infos von der aktuellen Plattform?
          loc=info('node').location;
          if (loc && loc.gps) 
            sensors.gps=[loc.gps.lat,loc.gps.lon,'@IP'];
          loc=info('node').location;
          if (loc && loc.gps5) 
            sensors.gps5=[loc.gps5.lat,loc.gps5.lon];
          loc=info('node').location;
          if (loc && loc.geo)
            sensors.location=[loc.geo.city,
                              loc.geo.zip,
                              _,_,
                              loc.geo.country];
          loc=info('node').location;
          if (loc && loc.geo5)
            sensors.location5=[loc.geo5.city,
                               loc.geo5.zip,
                               loc.geo5.street,
                               loc.geo5.number,
                               loc.geo5.country];
        this.collect.push(sensors);
      }
      var next = filter(link(DIR.IP('%')),this.visited);
      if (next.length) {
      	// explore next node
        this.nextNode=random(next);
      } else {
      	// go one step back
        this.nextNode=null;
      }
    },

explore : function () {
      if (link(DIR.NODE(this.nextNode))) {
        log('GO to '+this.nextNode);
        this.hops++;
        this.path.push(this.nextNode);
      	moveto(DIR.NODE(this.nextNode));
      } else this.nextNode==null;
    },

goback : function () {
      var next = this.path.pop();
      if (next==this.currentNode) next = this.path.pop();
      if (next && link(DIR.NODE(next))) {
        log('GOBACK to '+next);
        this.hops++;
        this.path.push(next);
      	moveto(DIR.NODE(next));
      }
    },

deliver : function () {
      log('DELIVER '+this.collect.length);
      out(['COLLECT',me(),this.collect]);
    },

end : function () {
      log('END');
      kill();
    }
  }

// 3. Übergänge
  this.trans = {
    init : 'percept',
    percept : function () {
      if (!this.nextNode && this.path.length==0 && this.currentNode==this.rootNode)
        return 'deliver';
      if (this.hops==this.maxHops ||
          (!this.nextNode && this.path.length==0)) 
        return 'end';
      return this.nextNode?'explore':'goback';
    },
    explore : 'percept',
    goback : 'percept',
    deliver:'end',
  }

this.on = {

}

// Erforderlich: Angabe der Startaktivität
  this.next = 'init';
}
// Die Agentenkosntruktionsfunktion prüfen und in der Plattform installieren
compile(explorer,{verbose:1})
```

### Den Agent starten

- Wenn eine Agentenklasse mit der Konstruktionsfunktion in der Plattform verfügbar ist (mittels *compile*). können Agenten von dieser Klasse instantiiert werden.

- Dazu wird die *create* Operation ausgeführt. Das erste Argument gibt den Namen der Agentenklasse an (identisch mit dem Namen der Konstruktionsfunktion), optionalen Argumenten, und den Privilegienlevel des Agentens (1: Standard, 2: Privilegiert).

- Der Agent start unmittelbar nach seiner Ezeugung

[JAM] Agent { lines:20 }
```js
create('explorer',{},1);
```

### Ergebnisse abrufen

- Nachdem der Explorationsagent wieder hier zurück gekehrt ist (siehe Meldungen im Startfenster, `DELIVER #`) können die Ergebenisse aus dem Tupelraum entnommen werden

[JAM] Agent { lines:20 }
```js
var results = inp(['COLLECT',_,_]);
if (results) results=results[2];
global.results=results;
print(results);
```

### Ergebnisse darstellen

[CODE] Ergebnisse { lines:20 }
```js
Table(global.results,
      ['location','location5','gps','gps5','clock',
       'mobile','browser','os','path','node']);
```

### Ergebnisse speichern

[CODE] Speichern { lines:4 }
```js
if (typeof counter == 'undefined') counter=0;
counter++;
Save(globale.results,'survey'+counter+'.json')
```

## Aufgabe

[INFO] Hinweise
- Wenn daten über die JAM Shell gelesen werden (z.B. über die Tupeloepration inp) müssen die daten einer globalen Variable (also `global.foo` zugewiesen werden, damit sie hier später analysiert werden können!
- Ob es sich um eine generische JavaScript Konsole oder um die JAM Shell Konsole handelt sieht man indem man den Zieger über die Überschrift des Code Snippets zieht

[EXERCISE]

1. Bei der Exploration soll der Agent Markierungen auf jedem besuchten Knoten hinterlassen (aber nicht doppelt). Ergänze obigen Agentecode mit Tupelraumoperationen. Die Lebenszeit der Markierungen soll 600 Sekunden betragen. Die Tupel müssen die ID des Agenten (abfragen mot `me()`), die Uhrzeit (abfragen mit `clock(true)`, und sein bisherigen Pfad enthalten (also die Variable *path*). Bei Doppelbesuchen nicht zweimal markieren (vorher testen).

2. Bei der Exploration soll nach fremden Spuren (also Markierungen anderer Agenten) gesucht werden. Diese sollen genauso wie die Sensordaten erfasst werden.

3. Die Ergebnisse der Agentensuche sollen erfasst und analysiert werden.

4. Die Pfade sollen als zeitaufgelöste Trajektorie mit Zeitstempeln versehen werden und aufgezeichnet werden (also der gesamte Pfad vom Start bis zur Rückkehr). Dazu eine neue Variable *trace* im Agenten anlegen. Wo liegt das Problem bei den Zeistempeln (mittels *clock* im ms)?

5. Optional: Wie kann man eine monotone und normierte Zeitserie in einer Trajektorie erstellen? Stichwort Uhrensynchronisation. Nicht trivial!

[INPUT] Antworten

[CODE] Analyse hier { lines:10 } 
```js
// global.foo benutzen
```

[EXERCISE]

Mobiles Crowdsensing mit JAM Agenten

Einführung

Vorbereitung

Starte die JAM WEB App APP im Browser (Smartphone, Dekstop Rechner, Notebook)
Optional für die Experimentierfreudigen: Starte einen Tor Browser mit Proxykette und lade auch dort die JAM WEB App
Die JAM WEB App muss nicht wieter bedient werden (ist hier nur Kommunikationendpunkt)

JAM Plattform Shell

Die Shell (jamsh) ist ein Interpreter auf der JavaScript Agent Machine (JAM) und erlaubt einen programmatischen Zugriff auf die Agentenplattform
- Erzeugung von Kommunikationsports
- Herstellung von Channels (Kommunikationsverbindungen mit anderen JAM Plattformen)
- Erzeugung von Agenten
- uvm.

In diesem Notebook ist eine vollständige JAM Plattform und eine JAM Shell eingebaut!

Die Agentenplattform stellt alle nötigen Dienste für Agenten zur Verfügung
- Ausführung des Agenten
- Sandkasten (Isolierung und Entkopplung der Agenten von der Plattform)
- Kommunikations (Signale, Tuple)
- Migration
- Replikation

Die zentrale Schnittstelle zwischen der Hostapplikation (dieses Notebook und die JAM Shell) und den Agenten ist das Agent Input-Output Systeme AIOS
- Im AIOS werden die Agenten über einen Scheduler in einem geschützen Bereich (Sandkasten) ausgeführt und den Agenten eine eingeschränkte operative Schnittstelle zur Vefrügung gestellt (also Funktionen und Operationen die der Agent ausführen darf, wie Kommunikation und Migration)
- Das AIOS stellt über die Agenten API
- Die JAM Shell greift über eine weitere API Schicht (jamlib) direkt auf das AIOS zu

#aios

Zuerst muss eine JAM Shell erzeugt werden:

Eine Shell erzeugen

Shell({
  verbose:1
});

▸

✗

Dann muss wenigstens ein Kommunikationsport (i.a. IP) hinzugefügt werden
- Channels (Links) werden über Ports verbunden

Shell Initialisierung

port(DIR.IP('https://localhost:*'));
locate(print);
start()

▸

✗

Und schließlich wird ein Channel zu dem im Internet sichtbaren JAM Relais hergestellt

Shell verbinden

connect(DIR.IP('https://ag-0.de:30001?secure=12:34:56:78'));

▸

✗

Es können jederzeit Status- und Statistikinformationen der eigenen JAM Plattform abgerufen werden
Einige Beispiele sind nachfolgend gezeigt

Shell Status

print('conn:')
print(stats("conn"));
print('node:')
print(Table([stats("node")]));
print(connected(DIR.IP('%')));
print(connected(DIR.IP('*')));

▸

✗

Geolokalisation

Ein wichtiger Sensor im Mobilen Crowdsensing ist die geografische Position (meistens in Polarkoordinaten mit Längen- (lon) und Breitengrad (lat) angegeben)
Neben der physikalischen geografischen Position ist der Ortskontext von Interesse (Ortsbeschreibung wie Straßenname und Stadt)
Die Erlangung der aktuellen geografischen Position eines mobilen Gerätes wie ein Smartphone erfolgt meistens direkt mittels Funkwellen und GPS
Die direkte Ableitung der Position über die Internetgeräteadresse ist schwierig da i.A. nur der Standort des Internetserviceproviders (ISP) ermittelt werden kann
- Aber mittels vorherigen Crowdsensing kann aus kollektiver Information und Fusion mit Nutzungsdaten (wie häufige Seitenaufrufe mit Ortsbezug, DNS Nutzung!, usw.) eine genauere Ortslokalisierung der öffentlich sichtbaren IP Adresse erfolgen
JAM verwendet ein mehrstufiges Verfahren um den Standort seiner Hostplattform zu ermitteln:

Über die öffentliche IP Adresse und einer ISP Datenbank (Genauigkeit zwischen 10-500km) und Verwendung des ISP Datenbankservers http:\\ip-api.com (Achtung: Ad-Blocker in WEB Browser verhindern den Zugriff auf diesen Datenbankservice). Diese Geolokalisation verwendet keine Daten aus Tracking und Tracing (kein Crowdsensing)!
Über die öffentliche IP Adresse und einen Lokalisationservice von Mozilla https:\\location.services.mozilla.com. Dieser verwendet zur Bestimmung der Nutzerposition (Breiten- und Längengrad) Daten aus Crowdsensing (kollektive Mittelwertdaten, vermutlich nicht personalisiert) und https://api.opencagedata.com zur Bestimmung des Ortskontextes (Ort, Land).
Wenn vorhanden und nutzbar GPS sowie im WEB Browser den HTML5 GeoLocation Service (über diesen wird dann auch GPS des Gerätes verwendet).

Ein einfacher Explorationsagent

Im agentenbasierten mobilen Crowdsensing nehmen mobile Agenten (also mobiler Code/Software) möglichst slebständig die Erhebung von sensorischen Daten und die Durchführung von Umfragen durch
Beipiel ist folgender Explorationsagent, der
- In diesem Notebook erzeugt wird,
- Auf einen externen im Internet sichtbaren JAM Knoten migriert (das Relais),
- Von dort aus neue mit diesem JAM Knoten verbundene JAM Knoten besucht (sowohl die JAM WEB App als auch dieses Notebook!)
- Auf diesen Knoten/Rechnern sensorische Informationen erhebt,
- Dann wieder zum Relaisknoten zurückkehrt und solange neue Knoten besucht bis es keine neuen Knoten mehr gibt (und/oder ein Zeitintervall abgelaufen ist),
- Schließlich kehrt der Explorationsagent zu seinem Usrprungsknoten - also diesem Notebook - zurück und liefert die Erhebungsergebnisse über den Tupelraum zurück

#websur

Die Verhaltensbeschreibung des Agentens (Code)

Ein Agent gehört initial zu einer Agentenklasse die in JAM/AgentJS als Konstruktionsfunktion (eines Agentenobjekts) programmiert wird
In AgentJS besteht die Agentenbeschreibung aus
- Körpervariablen this.data=value;
- Aktivitäten, die Mikroziele und Absichten des Agenten darstellen
- Übergänge zwischen Aktivitäten (Transitionen, Änderung des Kontrollzustandes des Agenten)
- Optional Signalhandler
- Und einer speziellen Körpervariable this.next=ai, die initial die erste auszuführende Aktivität bezeichnet (beim Start des Agenten)

Aktivitäten

init

Der Agent startet und initialisiert sich. Dazu wird hier nur der aktuelle JAM Knotenname in der Variable rootNode vermerkt (zu diesem Knoten soll der Agent nach der Ehebung zurückkeheren)
In der Variable path wird der aktuelle Pfad an Knoten gespeichert (vorwärts gehen vergrößert die Liste, rückwärts gehen verkleinert sie entsprechend)

percept

Auf jedem (auch den Startknoten) werden sensorische Informationen erhobe und in der Variable collect gespeichert
Weiterhin werden neue Knoten gesucht und randomisiert einer aus der neuen List ausgewählt
Der aktuell besuchte Knoten wird in der Liste visited gespeichert

explore

In dieser Aktivität wird zum nächsten Knoten migriert. Der Agent nimmt seinen Code und all seine Daten mit!

goback

Falls keine neuen noch nicht besuchten Knoten mehr gefunden werden geht es wieder einen Schitt zurück entlang des bereits durchlaufenen Pfades (path)

deliver

Wenn der Wurzelknoten wieder erreicht wurde (nach einem goback) werden die Erhebnungsergebnisse im Tupelraum (dann des Notebooks) übertragen
Das Erhebungstupel kann hier im Notebook dann wieder über die Shell ausgelesen werden

Agent

function explorer (options) {
  // 1. Körpervariablen (Inhalte sind mobil)
  this.rootNode=null;
  this.visited=[];
  this.collect=[];
  this.verbose = 1;
  this.currentNode = null;
  this.path = [];
  this.nextNode = null;
  this.hops = 0;
  this.maxHops = 200;

  // 2. Aktivitäten
  this.act = {
    init : function () {
      this.rootNode = myNode();
      log('Starting on '+this.rootNode);
      this.path.push(this.rootNode);
    },

    percept : function () {
      var loc;
      this.currentNode = myNode();
      log('PERCEPT on '+this.currentNode);
      if (!contains(this.visited,this.currentNode)) {
        // Neuer Knoten
        this.visited.push(this.currentNode);
        var sensors = {};
        sensors.clock=clock(true);
        sensors.path=copy(this.path);
        sensors.node=this.currentNode;
        // Infos von der aktuellen Plattform?
          loc=info('node').location;
          if (loc && loc.gps) 
            sensors.gps=[loc.gps.lat,loc.gps.lon,'@IP'];
          loc=info('node').location;
          if (loc && loc.gps5) 
            sensors.gps5=[loc.gps5.lat,loc.gps5.lon];
          loc=info('node').location;
          if (loc && loc.geo)
            sensors.location=[loc.geo.city,
                              loc.geo.zip,
                              _,_,
                              loc.geo.country];
          loc=info('node').location;
          if (loc && loc.geo5)
            sensors.location5=[loc.geo5.city,
                               loc.geo5.zip,
                               loc.geo5.street,
                               loc.geo5.number,
                               loc.geo5.country];
        this.collect.push(sensors);
      }
      var next = filter(link(DIR.IP('%')),this.visited);
      if (next.length) {
      	// explore next node
        this.nextNode=random(next);
      } else {
      	// go one step back
        this.nextNode=null;
      }
    },

    explore : function () {
      if (link(DIR.NODE(this.nextNode))) {
        log('GO to '+this.nextNode);
        this.hops++;
        this.path.push(this.nextNode);
      	moveto(DIR.NODE(this.nextNode));
      } else this.nextNode==null;
    },

    goback : function () {
      var next = this.path.pop();
      if (next==this.currentNode) next = this.path.pop();
      if (next && link(DIR.NODE(next))) {
        log('GOBACK to '+next);
        this.hops++;
        this.path.push(next);
      	moveto(DIR.NODE(next));
      }
    },

    deliver : function () {
      log('DELIVER '+this.collect.length);
      out(['COLLECT',me(),this.collect]);
    },

    end : function () {
      log('END');
      kill();
    }
  }

  // 3. Übergänge
  this.trans = {
    init : 'percept',
    percept : function () {
      if (!this.nextNode && this.path.length==0 && this.currentNode==this.rootNode)
        return 'deliver';
      if (this.hops==this.maxHops ||
          (!this.nextNode && this.path.length==0)) 
        return 'end';
      return this.nextNode?'explore':'goback';
    },
    explore : 'percept',
    goback : 'percept',
    deliver:'end',
  }

  this.on = {

  }

  // Erforderlich: Angabe der Startaktivität
  this.next = 'init';
}
// Die Agentenkosntruktionsfunktion prüfen und in der Plattform installieren
compile(explorer,{verbose:1})

▸

✗

Den Agent starten

Wenn eine Agentenklasse mit der Konstruktionsfunktion in der Plattform verfügbar ist (mittels compile). können Agenten von dieser Klasse instantiiert werden.
Dazu wird die create Operation ausgeführt. Das erste Argument gibt den Namen der Agentenklasse an (identisch mit dem Namen der Konstruktionsfunktion), optionalen Argumenten, und den Privilegienlevel des Agentens (1: Standard, 2: Privilegiert).
Der Agent start unmittelbar nach seiner Ezeugung

Agent

create('explorer',{},1);

▸

✗

Ergebnisse abrufen

Nachdem der Explorationsagent wieder hier zurück gekehrt ist (siehe Meldungen im Startfenster, DELIVER #) können die Ergebenisse aus dem Tupelraum entnommen werden

Agent

var results = inp(['COLLECT',_,_]);
if (results) results=results[2];
global.results=results;
print(results);

▸

✗

Ergebnisse darstellen

Ergebnisse

Table(global.results,
      ['location','location5','gps','gps5','clock',
       'mobile','browser','os','path','node']);

▸

✗

Ergebnisse speichern

Speichern

if (typeof counter == 'undefined') counter=0;
counter++;
Save(globale.results,'survey'+counter+'.json')

▸

✗

Aufgabe

Information. Hinweise

Wenn daten über die JAM Shell gelesen werden (z.B. über die Tupeloepration inp) müssen die daten einer globalen Variable (also global.foo zugewiesen werden, damit sie hier später analysiert werden können!
Ob es sich um eine generische JavaScript Konsole oder um die JAM Shell Konsole handelt sieht man indem man den Zieger über die Überschrift des Code Snippets zieht

Aufgabe.

Bei der Exploration soll der Agent Markierungen auf jedem besuchten Knoten hinterlassen (aber nicht doppelt). Ergänze obigen Agentecode mit Tupelraumoperationen. Die Lebenszeit der Markierungen soll 600 Sekunden betragen. Die Tupel müssen die ID des Agenten (abfragen mot me()), die Uhrzeit (abfragen mit clock(true), und sein bisherigen Pfad enthalten (also die Variable path). Bei Doppelbesuchen nicht zweimal markieren (vorher testen).
Bei der Exploration soll nach fremden Spuren (also Markierungen anderer Agenten) gesucht werden. Diese sollen genauso wie die Sensordaten erfasst werden.
Die Ergebnisse der Agentensuche sollen erfasst und analysiert werden.
Die Pfade sollen als zeitaufgelöste Trajektorie mit Zeitstempeln versehen werden und aufgezeichnet werden (also der gesamte Pfad vom Start bis zur Rückkehr). Dazu eine neue Variable trace im Agenten anlegen. Wo liegt das Problem bei den Zeistempeln (mittels clock im ms)?
Optional: Wie kann man eine monotone und normierte Zeitserie in einer Trajektorie erstellen? Stichwort Uhrensynchronisation. Nicht trivial!

Antworten
Analyse hier

// global.foo benutzen

▸

✗

Created by the NoteBook Compiler Ver. 1.3.9 (c) Dr. Stefan Bosse (Wed Jul 15 2020 18:30:02 GMT+0200 (CET))