Im 65C02 wurden einige Bugs gefixed, die der 6502 und auch dessen Nachfolger der 6510 hatte, außerdem ist er einfacher zu takten. Zudem hat der 65C02 einige spannende OpCodes und Adressierungsarten zusätzlich.
Siehe hier: http://www.6502.org/tutorials/65c02opcodes.html
Mit www.6502.org gibt es eine super Community mit Leuten die unheimlich viel Erfahrung mit diesen kleinen Käfern haben, quasi die Uwes der 6502 Szene  ( sorry den konnte ich mir nicht verkneifen).
Falls ich Gefallen an der Sache finde, wird ja evtl. irgendwann mal ein 6510 basierter SBC das Licht der Welt erblicken.

Mario.

Hey, nicht schlecht. Allerdings ist Sound in den ersten Ausbaustufen nicht das womit ich meine Zeit verbringen werde. Ich glaube ich werde genug mit Bus-Timings, Chip-Select Logic und simplen IO Problemen zu kämpfen haben. Da ich noch einen C64 im Keller herum dümpeln habe, würde ich ggf. auch den plündern und dem den originalen SID und ggf. das eine oder andere Bauteil mopsen.
Aber das ist höchstend Plan C oder Plan D. Erstmal muss die erste Version aus 65C02 CPU, einem 6522 VIA, 32k SRAM und 8k EEPROM mit 1MHz laufen. Danach sehen wir weiter :-)

Und wieder ein Stück weiter.
Seit heute gibt es einen einfachen Java-Client mit dem ich die Datenübertragung testen und an der Firmware arbeiten kann.

Meine Versuche Daten per "page write" (der schnellsten Übertragungsmethode) zu Schreiben, waren leider bisher noch nicht von Erfolg gekrönt. Aber da ich das ShiftOut() und das setzen der Datenleitungen drastisch beschleunigen konnte, ist nun auch das Schreiben einzelner Bytes schnell genug. (das shiftOut() der IDE ist irgendwie recht langsam)
Inkl. des gesamten Overheads beim Übertragen der Daten von der Java GUI, brauche ich (abhängig von der Baudrate) zwischen 0.98 und 1.3 Sekunden, um 1024 Bytes auf den EEPROM zu schreiben.
Sobald die Firmware auf dem Nano einen sinnvollen Stand erreicht hat, werde ich das hier veröffentlichen, falls jemand Teile des Codes für andere Projekte gebrauchen kann.

@Megaionstorm: Das Hive-Projekt kannte ich bisher noch nicht. Insgesamt scheint der Propeller-Chip eine spannende Sache zu sein. Da meine Wurzeln aber in den 65XX CPUs der 80er Jahre liegen und ich zumindest noch einige Synapsen-Reste zu deren Assembler-Programmierung in meinen Hirnwindungen aufspüren konnte  , liegt mein Fokus ganz klar auf einem System mit eine 65C02 CPU und allem was zu einem kleinen System dazu gehört. Allerdings werden wohl später einige Atmels für die Peripherie zuständig sein.

Nein, wir reden nicht aneinader vorbei.

Natürlich ist auf dem Arduino ein Sketch, der die Ventile und die Kamera bedient. Was Du willst, ist aber, das die Parameter für die Steuerung (wann welches Ventil und wann welche Kamera auslöst) anpassen, und zwar OHNE das Du den kompletten Sketch neu hochladen musst.
Genau davon rede ich ja die ganze Zeit.

Im Prinzip macht Dein Sketch auf dem Arduino 2 Dinge.

1.) Er wartet darauf, das der "Auslöser" an Pin 13 gedrückt wird, dann spult er sein Steuerprogramm ab (Ventile, Kamera ...). Danach wartet er wieder auf den Auslöser.
2.) Zusätzlich zum Warten auf den Auslöser, prüft der Sketch regelmäßig die serielle Schnittstelle, ob da Daten übertragen wurden. Wenn ja, nimmt er die Daten an und ersetzt damit die bisherigen Stuerdaten.

Das ist der Teil auf dem Arudino.


Dein PC-Programm macht dann nix anderes als über ein Formular (egal in welcher Sprache) die Daten eingeben zu lassen und beim Drücken auf den "Start"-Knopf die Daten seriell an den Arduino zu schicken.

In folgendem Thread hatten wir das Thema schon: http://arduino.cc/forum/index.php/topic,102817.0.html
Hier wurde eine TCP-Schnittstelle für ein externes PHP-Tool gebaut.
Für die PC Seite müßtest Du erstmal sagen in welcher Sprache Du das bauen willst.
Mario.

Also vom Ablauf her habe ich mir das so vorgestellt:
...
3. Datenübertragung an das Board
4. x ms warten (damit das Programm vollständig auf dem Board geladen wurde)
...

Natürlich kann ich das ganze auch über die Arduino-Software steuern und jedesmal den "Sketch" anpassen und dann übertragen.
Aber mit einer Eingabeoberfläche währe das ganze viel "schöner". Nur möchte ich dafür nicht extra ein EDV-Studium absolvieren müssen  

Genau darum geht es. Du sollst ja nicht jedesmal den Sketch anpassen und damit jedesmal ein angepasstes Programm auf den Arduino laden, sondern an ein auf dem Arduino laufendes Programm nur die Daten übergeben.

Das kann im einfachsten Fall sogar der serielle Monitor der IDE sein. Dort kannst Du ja einen String an den Arduino über die serielle Schnittstelle schicken.

Und mit dieser Software kann ich mir auch eingene Eingabeoberflächen gestalten? Wie? Habe dazu noch nichts im www gefunden. Da ist immer die Rede von ... GUI also "Ein Grafisches User Interface" was z.B. mit MS VB 2010 "geschrieben" ist. Genau so etwas möchte ich.

http://playground.arduino.cc/interfacing/processing
Hier wird die Integration von Arduino und Processing beschrieben.
und hier: http://raumfuehler.andreasmuxel.com/index.php/arduino-und-processing/kommunikation-arduino-board-zu-processing/
oder hier: http://www.heise.de/ct/projekte/machmit/processing

Also Firmata scheidet schonmal aus - da habe ich ja nur die Möglichkeit den Port auszuwählen und Low oder High vorzugeben (oder hab ich das falsch verstanden)?

Mir geht es hier jetzt auch nicht darum von euch die ganzen möglichen Programmiersprachen aufgelistet zu bekommen.

Ich möchte mir schnell und einfach eine Oberfläche zur Eingabe/Änderung der Parameter erstellen.

Ich glaube hier gibt es noch ein Verständnisproblem.
Eigentlich brauchst Du 2 Programme.

Ein Programm auf dem PC, mit Eingabefeldern für die Steuerzeiten Deiner Ventile und einem großen roten "START" Button.

Ein weiteres Programm brauchst Du auf dem Arduino, das die vom PC-Programm gelieferten Befehle umsetzt. (z.B. Firmata).

Die Frage dabei ist, in welchem Programm die Steuerlogik steckt. Steckt die Logik im PC-Programm, dann kannst Du Firmata verwenden, denn das Timing wann welches Pin geschaltet werden soll, macht dann das PC-Programm. Vorteil ist, das Du auf dem Arduino auf eine fertige Lösung setzen kannst. Nachteilig könnte sein ein exaktes Timing zu erreichen, da die Befehle seriell übermittelt werden, was Zeit kostet und hier ggf. schon Unterschiede im ms Bereich möglich wären.

Zweite Möglichkeit ist, das die Logik im Arduino-Programm steckt. Dann musst Du das vermutlich auch selbst schreiben. Du brauchst dann ein sinnvolles Protokoll, mit dem Du Steuerdaten übermittelst: z.b. als String "V1,30,35:V2,40,45:V3,50,55,K1:60" "Vx" ist jeweils das Ventil Nummer x mit den beiden Steuerzeiten in ms. "Kx" ist dann die entsprechende Kamera. Den Steuerstring musst Du dann auf dem Arduino in die entsprechende Werte zerlegen.
Vorteil dieser Lösung ist, das Du vom PC-Programm unabhängig bist. Denn wer am Ende den Steuerstring über die serielle Schnittstelle schickt ist egal (im einfachsten Fall kommen die Daten über den seriellen Monitor der IDE). Ein weiterer Vorteil ist, das Dein Timing exakter ist, weil es nicht von irgendeiner Kommunikation abhängt. Nachteil ist die größere Komplexität des Arduinoprogramms.

Mario.

@mkl0815: Ja, mann könnte die direkt an der Platinenunterseite abgreifen. Praktischer wäre es aber sie direkt am Vin auf ein shield zu bekommen, wenn, ja wenn das eh nur durchgeschleift wird. Da ist aber wohl noch eine Diode dazwischen (s. Link im nächsten Absatz):

So meinte ich das nicht. Sondern vielmehr so:
http://www.skonteo.de/product_info.php?products_id=71 Das ist einfacher und sauberer. 

Wie wäre es damit:
Relais-Shield
Dann hast Du noch ein Relais als Reserve, das Dingen ist nicht wirklich teuer und Du sparst Dir die Schaltung. Soweit ich das auf dem Bild erkennen kann, arbeitet das Dingen auch mit Optokopplern.
Mario.

Danke für den Schaltplan, aber ich habe ein UNO Board und da finde ich kein VIN ???

Schau mal auf die Bilder: http://arduino.cc/en/Main/ArduinoBoardUno
Untere Header-Reihe, der linke Header hat ganz rechts ein Pins "V_in".
Aber aufpassen. Soweit ich weiss, ist das Vin Pin HINTER der Diode die vor Verpolung schützen soll.

Hmm, bist Du sicher, das Du bei dem Wissensstand einen Arduino in einer produktiven Umgebung einsetzen willst? Was sagt denn die Versicherung dazu, wenn der erste Arbeiter zum Zinnsoldaten wird, weil die Steuerung einen Fehler hat.

Gibt es nicht auch für Steuersysteme Vorschriften welchen Anforderungen hinsichtlich Umgebung die erfüllen müssen?

Ansonsten  zu Deinen Fragen:

- Programmiert wird der Arduino in C und C++, nur die IDE ist in Java geschrieben
- Der Mega ist in SMD Technik gefertigt, der Uno hat einen Atmega328P als DIP28 Chip, den man leicht austauschen kann
- Wenn man aufpasst raucht der µC nicht ab. In der Regel gehen eher andere Bauteile kaputt, die man nicht so leicht tauschen kann
- Ja, der Mega hat deutlich mehr I/Os als der Uno.

Was sich mir als nächste Frage stellt, wie wird denn mit der Steuerung kommuniziert? Nur Sensoren reichen ja nicht, etwas mehr Info muss der Arduino ja schon bekommen.

Warum nicht die 12V VOR dem Arduino abgreifen? Dann brauchst Du nur ein Netzteil. Wenn der Arduino sonst nichts weiter treiben muss (also die Pins kaum  Strom liefern müssen), dann sollten auch 12V am Arduino nicht so kritisch sein.

Ja es ist schon erstaunlich, das die kleinen Elektronen immer wissen wo sie lang müssen.
Noch spannender wird es, wenn man bedenkt, das die technische Stromflussrichtung genau entgegengesetzt zur physikalischen Stromflussrichtung ist.
Da Elektronen negativ geladen sind, wandern die nämlich immer vom Minus (hohe Elektronendichte) zum Plus (niedrige Elektronendichte).

Schau mal hier:
http://www.ebay.de/itm/WS2811-LED-RGB-Lauflicht-Strip-60LED-m-Lange-Wahlbar-/330876638565?pt=DE_M%C3%B6bel_Wohnen_Lampen&var=&hash=item4d09c8d565
Da kann man auch einzelne LEDs bestellen. Damit wäre dann ein 2m Streifen mit 120 und ggf. ein Streifen mit 5 zusätzlichen LEDs möglich. Die 4 zusätzlichen kann man immer noch für andere Zwecke einsetzen, oder man läßt sie als Ersatz.