da bst du wschl nicht so ganz auf dem Stand der Nerven- und Hirnforschung, und auch nicht so ganz auf dem Stand der KI-Forschung.Zitat von Rumgucker
Aber nur zu!
da bst du wschl nicht so ganz auf dem Stand der Nerven- und Hirnforschung, und auch nicht so ganz auf dem Stand der KI-Forschung.
Aber nur zu!
Hallo HaWe,
ich ahne, was Dir wohl eher auf der Zunge lag.....
Jedes dahergelaufene Greenhorn, das die KI nicht mal ansatzweise überblickt, versucht aus Unwissen heraus, das Rad neu zu erfinden. Aber schon nach kurzer Zeit verschwinden sie wieder reihenweise in der Versenkung des Nicht-Verstehens und des Nicht-Könnens. Bzw. benutzen dann doch die fertigen Tools - ohne sie jedoch wirklich zu begreifen. Derartige Typen würden mich an Deiner Stelle genauso nerven.
Anfänglich sieht das alles nach dem gleichen Grünzeug aus und raschelt auf gleiche Weise im Wind. Aber erst nach der Ernte trennt man Spreu von Weizen. Und erst dann stellt sich raus, ob ich Spreu oder Weizen bin.
Deswegen lass mich mal noch etwas reifen, bevor wir die Ernte prüfen können.
Viele Grüße
Wolfgang
da hast du meine Zielrichtung falsch verstanden:
Deine obigen Aussagen über Nerven, Augen, Gehirn, ihren Aufbau, ihre Funktionen und Funktionsprinzipien sind einfach (lange) nicht auf dem heutigen Stand, und gleiches gilt für die grundsätzliche Lernfähigkeit von KNN. Die Vorraussetzungen (Bedingungen), auf Grund derer du bestimmte Schlüsse ziehst, stimmen also einfach nicht.
Dennoch schließt das nicht aus, dass du trotz falscher Vorraussetzungen auch funktionierende Programme schreiben kannst: Sie funktionieren dann aber nicht WEGEN, sondern TROTZ einer falschen Wissensbasis.
Aber ich schrieb ja: Nur zu! Schreib deine Programme, und wenn du dann etwas entwickelt hast, was wirklich funktioniert, dann zeige es uns!
Das von mir aber schon erwähnte Q-Learning ist ebenfalls lauffähig auf sehr anspruchslosen Prozessoren, und es würde mich überhaupt nicht überraschen, wenn dann das von dir "from the scratch" entwickelte Programm genau solchen Q-learning-Algorithmen entspricht - es wäre ein um so größerer Erfolg für dich, wenn du das selber entwickelt hast ohne abzuschreiben.
Also, nochmal:
Nur zu!
Geändert von HaWe (17.11.2019 um 14:55 Uhr)
Hallo,
so langsam wächst und gedeiht das System:
Der 12F629 hat 1 kWorte Flash, wovon ich zur Zeit 13% benutze. Bis aufs "Verlernen", "Reflexe" und "Schlafen" (= Zellen-Erregungen wieder normalisieren) ist alles schon programmiert.CC5X Version 3.5, Copyright (c) B Knudsen Data, Norway 1992-2014
--> FREE edition, 8-16 bit int, 24 bit float, 32k code, reduced optim.
Warning : Main file extension should be '.c'
gi.cp:
Chip = 12F629
RAM: 00h : -------- -------- -------- --------
RAM: 20h : =====7.. ........ ........ ........
RAM: 40h : ....**** ******** ******** ********
RAM usage: 36 bytes (5 local), 28 bytes free
Optimizing - removed 1 instructions (-0 %)
File 'gi.pic'
File 'gi.lst'
File 'gi.hex'
Total of 135 code words (13 %)
Der PIC hat 64 Byte RAM, von denen ich 36 nutze. Damit verwalte ich 30 Neuronen ("Zellen"). Die 128 Byte des EEPROMs werden für Dendriten benutzt, die ich "Links" nenne.
Die Anzahl der Zellen wird vorgegeben. Die Links organisieren sich vollständig alleine. Sie bilden Korrelations-Cluster. Man kann beim GI-System auch nicht von Zell-"Schichten", starren Matrizen oder Deep Learning sprechen. Jede Zelle kann potentiell mit jeder Zelle verlinkt sein. Links können verstärkt werden. Das entspricht der klassischen Gewichtung oder auch vollständig verkümmern. Propagation ist in alle Richtungen möglich. Das System kann sich selbst organisieren, optimieren und anpassen, muss also nicht einem Training unterzogen werden. Kann aber.
Enthalten ist auch schon das "Gehirnknistern" (Stochastik), "Hunger", vier Sensoren und zwei Aktoren.
Neu ist auch die Art des Feuerns. Bei mir wird gefeuert, wenn Deltas auftreten. Dadurch und durch die dynamische Anzahl von Links hab ich auch bei starken System-Erregungen nur eine relativ geringe Anzahl von Operationen abzuleisten.
Das flutscht schon alles ganz gut. Morgen mach ich das Gegenstück dazu: den Umwelt-PIC.
Es wird, es wird.... ich tippe auf ersten laufenden Prototypen am WE.
Viele Grüße
Wolfgang
Geändert von Rumgucker (15.11.2019 um 19:23 Uhr)
Hallo,
es lebt...
Zu sehen sind EEPROM-Bytes, die die 3-Byte-"Links" (Dentriten) beinhalten. Die führenden Nullen sind der Galep-Anzeige geschuldet. Und die letzten beiden Bytes werden wegen der 3-Byte-boundaries nicht verwendet.
Spannend ist, dass sich ein Dendrit gebildet hat, der die Sinneszelle "x00" mit einem Neuron "x0D" verbunden hat und noch "00" Nutzen brachte. Dass der Dendrit sich am Ende des Speichers gebildet hat, hat den Grund, dass der PIC das ganze EEPROM komplett durchsucht hatte und keinen mit der Sinneszelle verbundenen Dendriten finden konnte.
Nach einem Durchlauf hab ich das System angehalten, damit ich das EEPROM analysieren kann. Die Zellen kann man nicht sehen, weil die im RAM versteckt sind.
Aber mir zeigen die drei Byte an, dass alles komplett erfolgreich durchgelaufen ist. Jetzt nehm ich alle Bremsen raus und lass das System sich komplett vernetzen.
Ich rechne mit Sekundenbruchteilen.
Viele Grüße
Wolfgang
----------------------------------
Tatsache: 256-mal alles komplett durchgerechnet. Gesamtlaufzeit dafür vilelleicht 1/4 Sekunde.
Nun ist die Sinneszelle 0x00 (nur die war aktiv) mit acht Links an andere Zellen x19, x11 x09 x07 x17 x0F x15 x0D angeschlossen. Alle Verbindungen konnten ihre Nützlichkeit noch nicht beweisen, weil es nur einen einzigen Lichtblitz gab.
Sobald weitere Lichtblitze erscheinen, werden die zur Zeit noch verkümmerten Links wachsen. Es können sich auch gänzlich neue Links anlegen. Das Dingens sollte sich selbst belohnen können und deep-learning machen. Schon deshalb, weil die Zellen nicht in festen Schichten, sondern sich in dynamischen Clustern organisieren.
Das alles ohne jegliche Matrizen oder Multiplikationen.
Die Weichware sieht auch schon richtig hübsch aus. Zwar spezieller PIC-C-Slang. Aber kurz und knackig. Mit Debug-Code beleg ich zur Zeit 29% des 1 k Flashs.
So richtig große Dinge hab ich wohl nicht vergessen. Da kommt fast nichts mehr dazu. Sensor- und Aktoren-Treiber sind auch schon drin. Es fehlt nur noch die Logik der beiden Zellen für "Hunger" und "Gehirnknistern". Aber das ist beides trivial.
GI-Sourcenvorstellung am WE könnte was werden.
Viele Grüße
Wolfgang
- - - Aktualisiert - - -
Jepp,
Motoren laufen. Sieht schrecklich intelligent aus. Ein zuckeln und ruckeln. Er hat ja noch kein Feedback. Die Umwelt erscheint ihm völlig statisch. Singularität.
Aber das System hat sich in Clustern organisiert. Der Nutzen in den Links läuft hoch (ich hab nen Endanschlag vergessen). Außerdem wird er noch nicht verrechnet, nur geschriebnen. Zellen feuren synchron
Ein Beispiel: die beiden Motorzellen heißen x1C und x1D.
x1D hat sich zweimal direkt mit dem einzigen aktiven Sensor verkoppelt. Offensichtlich war die Motor-Zelle gerade nicht feuerbereit, als der Sensor wieder einen Lichtblitz erzeugte. Welcher der beiden Links sich schließlich durchsetzen kann, ist noch nicht klar.
x1C hatte am Anfang auch geruckelt. Wurde dann aber immer schwächer und seine Dendriten verkümmerten. Zur Zeit ist er taub. Mit nur einer Sinneszelle wird sich daran auch erst dann was ändern können, wenn die Stochastik hilt (Gehirnknistern) oder wenn x1D nicht alle Ereignisse vom Sensor mitbekommt.
Die restlichen Zellen haben sich untereinander vernetzt. Worüber die wohl nachdenken? Vielleicht weden sich die die nächste Zeit mit dem tauben Motor verkoppeln?
Es hat was. Streckenweise läuft es mir etwas kalt den Rücken runter. Ich könnte ein Programm gebrauchen, was mir in einem grafischen 3D-Netz die Zellen als Kugeln und die Links als Verbindungen darstellt. Feuerbereite Kugeln müssten größer sein. Und nützliche Links dicker sein.
Da das ganze aber atmet (lebt) und schon in den nächsten Millisekunden ganz neue Verbindungen schlagen kann, müsste man sowas eigentlich kontinierlich darstellen.
Ich glaub, ich hab was ganz Spannendes erdacht. Die Interpretation ist so komplex, dass man geneigt ist, dem Ding zuzutrauen, dass es schon eine Lösung finden wird. Früher oder später. Aber in jedem Fall in wenigen Millisekunden.
Soll ich die Source mal zeigen. Noch ohne Abfabgen des Nutzen-Überlaufs und ohne Logik für Hunger und Knistern.
Ich machs mal einfach:
Wie gesagt: noch Kleinkram dran zu machen.Code:#include "allpic.h" #pragma config = 0b000110000100 // hex-datei: fuses des 12F629 #define EE_ROM // eeprom nutzen #include "pic_mem.h" #include "timeloop.h" // timer-routinen #define IN_0 0 // GPIO-Eingänge #define IN_1 1 // #define IN_2 2 // #define IN_3 3 // #define OUT_0 4 // GPIO-Ausgänge #define OUT_1 5 // //** alle sensoren, aktoren, triebe und neuronen nach abstraktion gestaffelt ****** uns8 zellen[30]; // zellen im RAM anlegen #define FIRE_REQ 7 // fire_req bit in der zelle #define FIRE_LIMIT 10 // fire_limit #define SENS_0 0 // spezialzellen definieren #define SENS_1 1 // Sensoren #define SENS_2 2 #define SENS_3 3 #define TIMER 4 // Timer-Zelle #define HUNGER 5 // Hunger-Zelle #define FIRST_NEURON 6 // davor nur read-only-zellen #define AKT_0 (sizeof(zellen) - 2) #define AKT_1 (sizeof(zellen) - 1) //******* verbunden werden zellen mit vielen links (dendriten) ********* #define NO_LINK -1 #define MAX_LINKS (128 / sizeof(struct _link))// viele links im EEPROM struct _link { // struktur eines EEPROM-links uns8 src; // leerer link: src_zelle == NO_LINK uns8 dst; // verbindet source- mit dest-zelle uns8 use; // nützlichkeit dieses links }; // LINK-Zugriffe #define LINK_RD(a,m) ee_read((a) + offsetof(struct _link,m)) #define LINK_WR(a,m,v) ee_write((a) + offsetof(struct _link,m),v) static uns8 rand_link; // randomize link static void gi_denke(void) // die genesis { uns8 zell_ind = 0, link, free, buf; BOOL hit; do { // Suche feuernde zellen rand_link++; // randomize link FSR = zellen + zell_ind; // pointer auf zelle /**** sensoren, aktoren und triebe sind besondere zellen *****/ if(zell_ind <= SENS_3) { // Sensoren abfragen buf = _BV(zell_ind); // bit-maske entwickeln if(GPIO & buf) { if(!(INDF.0)) INDF = FIRE_LIMIT + _BV(FIRE_REQ);} else INDF.0 = 0 // FIRE_REQ bearbeiten } // nun die aktoren else if(zell_ind == AKT_0) GPIO.OUT_0 = INDF.FIRE_REQ; else if(zell_ind == AKT_1) GPIO.OUT_1 = INDF.FIRE_REQ; if(INDF.FIRE_REQ == FALSE) continue;// zelle möchte nicht feuern /***** wenn zelle feuern will, verfolge die links *************/ INDF.FIRE_REQ = FALSE; // zelle möchte feuern free = NO_LINK; link = 0; hit = FALSE; do { // alle links durchsuchen rand_link++; // randomize link buf = LINK_RD(link,src); // linkbyte lesen if(buf == NO_LINK) free = link;// leeren link merken else if(buf == zell_ind) {// link gefunden FSR = zellen + LINK_RD(link,dst);// pointer auf dst-zelle lesen if((++INDF == FIRE_LIMIT)&&(!(INDF.FIRE_REQ))) {// will dst feuern? INDF.FIRE_REQ = TRUE; // feuer_req schon mal vormerken buf = LINK_RD(link,use);// zwei zellen feuern synchron LINK_WR(link,use,++buf);// dadurch wird der link nuetzlicher hit = TRUE; // zumindest ein nützlicher link } } link += sizeof(struct _link);// nächsten link adressieren } while(link < MAX_LINKS * sizeof(struct _link)); /** wenn kein nützlicher link gefunden und platz ist: erzeuge neuen link **/ if((!hit)&&(free != NO_LINK)) { LINK_WR(free,src,zell_ind);// link neu erzeugen buf = rand_link % sizeof(zellen); // randomize verlinken, aber eingrenzen if(buf < FIRST_NEURON) buf += FIRST_NEURON; // keine read-only-zellen if(buf == zell_ind) buf++; // zellen nicht direkt rückkoppeln LINK_WR(free,dst,buf); LINK_WR(free,use,0); // ob der link nützlich wird, weiß keiner } } while(++zell_ind < sizeof(zellen)); // nächste zelle } #define DELETE 0 #define REDUCE 1 #define SLEEP 2 static void gi_links(uns8 steuer) // links abschwächen { uns8 link = 0, buf; do { // alle links durchsuchen if(LINK_RD(link,src) != NO_LINK) { // gelöschte ignorieren if(steuer == DELETE) buf = 0; else { buf = LINK_RD(link,use); // nuetzlichkeit lesen if(buf) LINK_WR(link,use,--buf);// langsam verlernen } if(!buf) LINK_WR(link,src,NO_LINK);// link ganz löschen } link += sizeof(struct _link); // nächster link } while(link < MAX_LINKS * sizeof(struct _link)); if(steuer == DELETE) rand_link = 0; } static void gi_zellen(uns8 steuer)// zell-erregungen abschwächen { uns8 zell_ind = 0; do { // Suche zellen FSR = zellen + zell_ind; // zellerregung lesen if(steuer == DELETE) INDF = 0; if(INDF) INDF--; if((steuer == SLEEP)&&(INDF > FIRE_LIMIT)) INDF = FIRE_LIMIT - 1; } while(++zell_ind < sizeof(zellen));// nächste zelle } void main(void) { RP0 = 1; // erstmal alle Spezialregister... #asm DW /*CALL*/ 0x2000 + /*ADRESSE*/ 0x03FF // oscal abholen #endasm OSCCAL = W; // und Oszillatorkalibrierung speichern OPTION = 0; // global weak-pullup ein (je 20kOhm) WPU = _BV(IN_0) | _BV(IN_1) | _BV(IN_2) /*| _BV(IN_3)*/; TRISIO = _BV(IN_0) | _BV(IN_1) | _BV(IN_2) | _BV(IN_3);// eingänge RP0 = 0; // normale register und ram CMCON = 0x07; // komparator aus timeloop_init(); // timer initialisieren gi_links(DELETE); // alle links löschen gi_zellen(DELETE); // zellerregungen löschen uns8 loop = 0; FOREVER { gi_denke(); if(!++loop) { gi_links(REDUCE); // links langsam verlernen gi_zellen(SLEEP); // schlafen } else if(!(loop & 0x1F)) // alle 32 durchläufe gi_zellen(REDUCE); // zellerregungen vermindern } } /* ENDE */
Viele Grüße
Wolfgang
Geändert von Rumgucker (15.11.2019 um 21:29 Uhr)
Herzlichen Glückwunsch zu deinen Fortschritten. Es wäre schön, wenn Du irgendwann eine gaphische Darstellung machst, bei dem man den Systemaufbau auf einen Blick erkennen kann.
Die kleinen Roboter machen sehr schnell den Eindruck, dass sie "belebt" sind.
Vielleicht braucht dein Roboter ja auch einen Partnerroboter, damit er sich nicht zu einsam fühlt.
Vor etwa 10 Jahren hatte ich hier im Forum mal einiges mit den Asuros gemacht.
Hier zeigt sich schön, wie sie in Wechselwirkung treten:
Komisch: Das eingebetete Video wird nur bei mir im Editor Fenster angezeigt.
Ich hänge es mal noch in Rohform an:
https://www.youtube.com/watch?v=oscbdxMhX_4
Geändert von stochri (16.11.2019 um 08:37 Uhr) Grund: Video wird nicht angezeigt
@Rumgucker:
worin besteht jetzt die Intelligenz oder Lernfähigkeit?
Welche Reiz-Reaktionsmuster kann es lernen, sich merken oder neu/umlernen,
wer oder was trainiert es zu den gewünschten Lernzielen,
und wie erkennt es, dass es sein/e Lernziel/e erreicht hat?
Und nochmals zum Aufbau deines Netzes:
wieviele Eingänge / welche möglichen Eingangszustände hat das Netz,
und wieviele Ausgänge / welche möglichen Ausgangszustände hat das Netz?
Ähäm, naja ... Ich hab's mal im Rahmen der Möglichkeiten für einen Arduino-Uno "Arduinofiziert".Wie gesagt: noch Kleinkram dran zu machen.
Es lebt tatsächlich, aber im wesentlichen von den Softwarefehlern.
Code:/* #include "allpic.h" #pragma config = 0b000110000100 // hex-datei: fuses des 12F629 #define EE_ROM // eeprom nutzen #include "pic_mem.h" #include "timeloop.h" // timer-routinen */ // PIC C-Compiler compatibility typedef int8_t uns8; // stdint compatibility typedef bool BOOL; #define FALSE false #define TRUE false /* #define IN_0 0 // GPIO-Eingänge #define IN_1 1 // #define IN_2 2 // #define IN_3 3 // #define OUT_0 4 // GPIO-Ausgänge #define OUT_1 5 // */ //** alle sensoren, aktoren, triebe und neuronen nach abstraktion gestaffelt ****** #define NUMBEROFNEURONS 30 uns8 zellen[NUMBEROFNEURONS]; // zellen im RAM anlegen #define FIRE_REQ 7 // fire_req bit in der zelle #define FIRE_LIMIT 10 // fire_limit #define SENS_0 0 // spezialzellen definieren #define SENS_1 1 // Sensoren #define SENS_2 2 #define SENS_3 3 #define TIMER 4 // Timer-Zelle #define HUNGER 5 // Hunger-Zelle #define FIRST_NEURON 6 // davor nur read-only-zellen #define AKT_0 (sizeof(zellen) - 2) #define AKT_1 (sizeof(zellen) - 1) //******* verbunden werden zellen mit vielen links (dendriten) ********* #define NO_LINK -1 //#define MAX_LINKS (128 / sizeof(struct _link))// viele links im EEPROM #define MAX_LINKS 32 struct _link { // struktur eines EEPROM-links uns8 src; // leerer link: src_zelle == NO_LINK uns8 dst; // verbindet source- mit dest-zelle uns8 use; // nützlichkeit dieses links }; #define LINK_SRC 0 #define LINK_DST 1 #define LINK_USE 2 /* uint8_t src; uint8_t dst; uint8_t use; */ // LINK-Zugriffe im PIC // #define LINK_RD(a,m) ee_read((a) + offsetof(struct _link,m)) // #define LINK_WR(a,m,v) ee_write((a) + offsetof(struct _link,m),v) _link Simulated_EEPROM[NUMBEROFNEURONS]; uns8 LINK_RD(uns8 address, uns8 component) { uns8 value = 0; if (component == LINK_SRC) value = Simulated_EEPROM[address].src; if (component == LINK_DST) value = Simulated_EEPROM[address].dst; if (component == LINK_USE) value = Simulated_EEPROM[address].use; return value; } void LINK_WR(uns8 address, uns8 component, uns8 value) { if (address < NUMBEROFNEURONS) { if (component == LINK_SRC) Simulated_EEPROM[address].src = value; if (component == LINK_DST) Simulated_EEPROM[address].dst = value; if (component == LINK_USE) Simulated_EEPROM[address].use = value; } else { Serial.print("Error: link address out of range "); Serial.println(address); delay(100); } } static uns8 rand_link = 0; // randomize link /* void gpio_out(uint8_t pin) { } */ uint16_t FSR; //pointer auf zelle uint16_t INDF; // ? static void gi_denke(void) // die genesis { uns8 zell_ind = 0, link=0, freeLink=0, buf=0; BOOL hit; do { // Suche feuernde zellen rand_link++; // randomize link FSR = zellen + zell_ind; // pointer auf zelle /**** sensoren, aktoren und triebe sind besondere zellen *****/ /* if (zell_ind <= SENS_3) { // Sensoren abfragen buf = _BV(zell_ind); // bit-maske entwickeln if (GPIO & buf) { if (!(INDF.0)) INDF = FIRE_LIMIT + _BV(FIRE_REQ); } else INDF.0 = 0 // FIRE_REQ bearbeiten } // nun die aktoren else if (zell_ind == AKT_0) GPIO.OUT_0 = INDF.FIRE_REQ; else if (zell_ind == AKT_1) GPIO.OUT_1 = INDF.FIRE_REQ; if (INDF.FIRE_REQ == FALSE) continue; // zelle möchte nicht feuern */ /***** wenn zelle feuern will, verfolge die links *************/ // INDF.FIRE_REQ = FALSE; // zelle möchte feuern INDF &= ~(1 << FIRE_REQ); freeLink = NO_LINK; link = 0; hit = FALSE; do { // alle links durchsuchen rand_link++; // randomize link buf = LINK_RD(link, LINK_SRC); // linkbyte lesen if (buf == NO_LINK) freeLink = link; // leeren link merken else if (buf == zell_ind) { // link gefunden FSR = zellen + LINK_RD(link, LINK_DST); // pointer auf dst-zelle lesen //if ((++INDF == FIRE_LIMIT) && (!(INDF.FIRE_REQ))) { // will dst feuern? if ((++INDF == FIRE_LIMIT) && (!(INDF & (1 << FIRE_REQ)))) { // will dst feuern? //INDF.FIRE_REQ = TRUE; // feuer_req schon mal vormerken INDF |= (1 << FIRE_REQ); buf = LINK_RD(link, LINK_USE); // zwei zellen feuern synchron LINK_WR(link, LINK_USE, ++buf); // dadurch wird der link nuetzlicher hit = TRUE; // zumindest ein nützlicher link } } //link += sizeof(struct _link);// nächsten link adressieren link++;// the link pointer is only an address } while (link < MAX_LINKS); //while (link < MAX_LINKS * sizeof(struct _link)); /** wenn kein nützlicher link gefunden und platz ist: erzeuge neuen link **/ if ((!hit) && (freeLink != NO_LINK)) { LINK_WR(freeLink, LINK_SRC, zell_ind); // link neu erzeugen buf = rand_link % sizeof(zellen); // randomize verlinken, aber eingrenzen if (buf < FIRST_NEURON) buf += FIRST_NEURON; // keine read-only-zellen if (buf == zell_ind) buf++; // zellen nicht direkt rückkoppeln LINK_WR(freeLink, LINK_DST, buf); LINK_WR(freeLink, LINK_USE, 0); // ob der link nützlich wird, weiß keiner } } while (++zell_ind < sizeof(zellen)); // nächste zelle } #define DELETE 0 #define REDUCE 1 #define SLEEP 2 static void gi_links(uns8 steuer) // links abschwächen { uns8 link = 0, buf; do { // alle links durchsuchen if (LINK_RD(link, LINK_SRC) != NO_LINK) { // gelöschte ignorieren if (steuer == DELETE) buf = 0; else { buf = LINK_RD(link, LINK_USE); // nuetzlichkeit lesen if (buf) LINK_WR(link, LINK_USE, --buf); // langsam verlernen } if (!buf) LINK_WR(link, LINK_SRC, NO_LINK); // link ganz löschen } //link += sizeof(struct _link); // nächster link link++; } while (link < MAX_LINKS); //while (link < MAX_LINKS * sizeof(struct _link)); if (steuer == DELETE) rand_link = 0; } static void gi_zellen(uns8 steuer)// zell-erregungen abschwächen { uns8 zell_ind = 0; do { // Suche zellen FSR = zellen + zell_ind; // zellerregung lesen if (steuer == DELETE) INDF = 0; if (INDF) INDF--; if ((steuer == SLEEP) && (INDF > FIRE_LIMIT)) INDF = FIRE_LIMIT - 1; } while (++zell_ind < sizeof(zellen)); // nächste zelle } void showLinks(uint8_t adr) { Serial.print(adr); Serial.print(" -"); Serial.print(" src:"); Serial.print(Simulated_EEPROM[adr].src); Serial.print(" dst:"); Serial.print(Simulated_EEPROM[adr].dst); Serial.print(" use:"); Serial.print(Simulated_EEPROM[adr].use); Serial.println(); } void showAll() { Serial.println("list Neurons:"); for (int n = 0; n < MAX_LINKS; n++) { showLinks(n); } Serial.println(); } void setup() { Serial.begin(115200); Serial.println("Gugi ;-)"); delay(1000); gi_links(DELETE); // alle links löschen gi_zellen(DELETE); // zellerregungen löschen } uns8 loopCounter = 0; // FOREVER { void loop() { Serial.println("gi_denke"); gi_denke(); if (!++loopCounter) { Serial.println("gi_links"); gi_links(REDUCE); // links langsam verlernen Serial.println("gi_zellen"); gi_zellen(SLEEP); // schlafen } else if (!(loopCounter & 0x1F)) // alle 32 durchläufe { Serial.println("gi_zellen"); gi_zellen(REDUCE); // zellerregungen vermindern showAll(); delay(1000); } }
Hallo stochri,
ich wusste nicht, dass Du "arduinifizieren" wolltest. Die Freitags-Version war noch sehr krank. Hier die aktuelle Sonntags-Version:
gi.txt
----
Zu Deinen "Arduinifizierungen":
FALSE ist bei mir 0
TRUE ist bei mir 1
Der FSR, INDF-Mechanismus ist ein PIC-Feature und zentral. Ich denke an den Konstrukt:
static unsigned char* FSR;
#define INDF (*FSR)
Du solltest auch keinesfalls mit 16-Bit-Werten arbeiten. Dann scheitern Schleifen, Offsets und Bit-Dröseleien.
Ich rechne damit, dass die Anzahl meiner Links eh nicht reichen wird, um Dekoder zu errichten. Dann muss ich sowieso auf Tiny85 umsteigen. Dann gibts naturgemäß kein "Arduinifizierungs"-Problem mehr.
Ich hatte den PIC lediglich genommen, weil er mich gleich zum sparsamen Umgang mit allen Ressourcen anhalten sollte. Mal gucken, wie weit ich damit noch komme....
Ich wäre dafür, dass wir weiterhin gemütlich bleiben. In der Ruhe liegt die Kraft. Zum Nachbauen oder gar zum Konvertieren auf andere Plattformen ist es m.E. noch zu früh. Ich kümmere mich noch nicht um Versionenpflege und Administration und will das zur Zeit auch keinesfalls im Hinterkopf haben. Auch die Anzahl meiner "Links" und Zellen ist beschränkt...
Viele Grüße
Wolfgang
Geändert von Rumgucker (18.11.2019 um 06:24 Uhr)
Berechtigungen
Lesezeichen