Mehrere Attinys verbinden

Wieviele Schalter hast du denn insgesamt?
Ich finde es etwas zu aufwändig (und teuer), für zwei Taster einen
kompletten Controller zu verdonnern.
Sowas kann man besser dadurch machen, dass man ein paar Schieberegister
an einen Controller hängt und diese periodisch abfragt. Dann kann man
auch gleich die Tasten entprellen und die Zeit messen.

60 Schalter sind es.

Leitungslänge max 5m.

Zudem  kostet ein Kontroller ATtiny2313 0,96ct/stk. Somit würde ich auf
kosten bei 60 Schalter von 31€ kommen.

Variante 1µC: Ist dieser defekt werden keine Schalter mehr überwacht.
Aber du hast mich wirklich auf eine einfache Lösung gebracht. Bei jedem
Schaltvorgang wird ein Interrupt ausgelöst und der Zustand des Ports
wird über RS232 an den PC übertragen. Dieser wertet dann wie lange ein
kurzer Schaltvorgang dauerte und erkennt ein Schaltvorgang >2sec als
ein ganzer.

"Variante 1µC: Ist dieser defekt werden keine Schalter mehr
überwacht."
Ist Dein Master kaputt passiert dann aber auch nix mehr :)

"Bei jedem Schaltvorgang wird ein Interrupt ausgelöst und der Zustand
des Ports wird über RS232 an den PC übertragen."
Versteh ich jetzt nicht ganz... Willst Du die Slaves mit RS232
betreiben? Das geht nicht - es sei denn Du hast 30 Serielle am PC.

Kommunikation zwischen Master und Slave:
I2C wirst Du von der Spezifikation her Probleme mit der Leitungslänge
bekommen (30x5m - wahrscheinlich als Sterntopologie) - es sei denn, Du
setzt I2C Hubs ein.

SPI könnte noch eine Möglichkeit sein, dann benötigst Du aber noch 5
Datenleitungen für das CS-Signal (oder weniger und Schieberegister).

Vielleicht kann man auch die Anzahl der Slaves ein wenig reduzieren
indem man Schaltergruppen zusammenfaßt. Immerhin hat der Tiny2313 18
I/O's (abzüglich Kommunikation). Theoretisch müßte man mit 4-5 Tinys
dann Deine 60 Schalter überwachen können. Wenn allerdings noch
Kommunikation zum PC dazu kommthast Du das Problem dass die Tinys nur
eine Hardwarekommunikationsschnittstelle drin haben. Entweder müßte der
Master dann ein Chip mit 2 Schnittstellen sein oder Du mußt eine
Softwaremäßig nachbilden.

Also ich dachte mir an einen µC mehrere Schalter zu hängen. Beispiel
Atmega64 könnten 5(Ports) x8 =40 Eingänge nutzen. Dann müsste man 2
AtMega64 nehemen und über zwei RS232 an den PC verbinden. PC(386 µPC
von Taskit) und Controller werden auf einer Baugruppe sein. Die
Schalter liegen im Umkreis von 3Meter.

"Du das Problem dass die Tinys nur eine
Hardwarekommunikationsschnittstelle drin haben"
-> Sind es nicht einzelne Blöcke USI und USART in einem ATtiny2313?
Denn wenn ich das Blockdiagramm anschaue erkenne ich 2 unabhängige
Blöcke, so dass ich 2 voneinader unabhänge Funktionsblöcke
interpretiere.
Oder sehe ich dass falsch?

Man nehme:
4x 75HCT165
1x Mega8 oder Tiny2313 (wegen RS232)
und verschalte es wie folgt:

VCC
 |
[1K-Netzwerk]
 |
[8 Schalter]
 |            +-----+
 |            |74HCT|
 +------------| 165 |-------[CLK]-------------------+
              |     |-------[SerialOut]-----------+ |
              +-----+                             | |
                  |                               | |
                  +---------[CLK enable]--------+ | |
VCC                                             | | |
 |                                              | | |
[1K-Netzwerk]                                   | | |
 |                                              | | |
[8 Schalter]                                    | | |
 |            +-----+                           | | |
 |            |74HCT|                           | | |
 +------------| 165 |-------[CLK]-------------------+
              |     |-------[SerialOut]-----------+ |
              +-----+                           | | |
                  |                             | | |
                  +---------[CLK enable]------+ | | |
VCC                                           | | | |
 |                                            | | | |
[1K-Netzwerk]                                 | | | |
 |                                            | | | |
[8 Schalter]                                  | | | |
 |            +-----+                         | | | |
 |            |74HCT|                         | | | |
 +------------| 165 |-------[CLK]-------------------+
              |     |-------[SerialOut]-----------+ |
              +-----+                         | | | |
                  |                           | | | |
                  +---------[CLK enable]----+ | | | |
VCC                                         | | | | |
 |                                          | | | | |
[1K-Netzwerk]                               | | | | |
 |                                          | | | | |
[8 Schalter]                                | | | | |
 |            +-----+                       | | | | |
 |            |74HCT|                       | | | | |
 +------------| 165 |-------[CLK]-------------------+
              |     |-------[SerialOut]-----------+ |
              +-----+                       | | | | |
                  |                         | | | | |
                  +---------[CLK enable]--+ | | | | |
                                          | | | | | |
                                          | | | | | [sck]
                                          | | | | [MOSI]
                                          | | | | | |
                                        +------------+
                                        |  Mega8  o. |
                                        | Tiny2313   |
                                        +------------+
                                         | |
                                       [RS232]

Obiges läßt sich beliebig erweitern, bis keine freien Pins mehr am µC
sind ;)
Abfrage ist trivial, einfach eine Schleife schreiben in der zyklisch
alle Schieberegister enabled werden und dann via SCK/MOSI die acht
Schalter auf einmal abfragen.
Obiges handelt 32 Inputs, bei acht Schieberegistern sind's 64 usw.
Wenn mans übertreiben will kann man auch z.B. mit 595er
Scheiberegistern alles über die SPI Schnittstelle abdecken.
Also ein 595er für acht 165er als Select-Baustein, dann geht's sogar
mit einem Tiny13 und Software UART ;)
Nur so als Idee ;)

Das Problem an dieser Lösung wird nur sein, dass die Ausgänge des '165
AFAIK nicht hochohmig zu schalten sind...

"Das Problem an dieser Lösung wird nur sein, dass die Ausgänge des
'165
AFAIK nicht hochohmig zu schalten sind..."

Wie das mit der konkreten Umsetzung aussieht hängt natürlich von der
Umgebung ab ;)
Aber da lassen sich sicherlich passende Gluelogiks finden ;)
Ein Optokoppler würde es doch schon tun ?

"Ich persönlich würde aber auch eher ein paar Tinys nehmen, da das
entprellen mit den 165ern nur spärlich geht."

Da gibt's zwei Varianten:
1. In Software öfter abfragen
2. http://www.ece.utep.edu/courses/web3376/concepts/debounce.html

Findet ich beides auch hier:
http://www.mikrocontroller.net/articles/Entprellung

4 mal tiny2313 mit jeweils 16 Schaltern. Softwareabfrage wie gesagt kein
Problem. Zur gewünschten Erhöhung der Ausfallsicherheit werden die vier
TX-Leitungen geUNDet (dazu reichen vier Dioden und ein Widerstand) auf
die vier RX und auf den 232-Treiber gegeben. Jeder tiny "hört" also
sich und die anderen vier senden.

Nun bekommt jeder noch eine Nummer und sendet seine Daten, wenn der
jeweilige Vorgänger fertig ist.

Was soll man daran noch vereinfachen?

Weitere INFOS.
Es sind immer 2 Schalter als eine Überwachungstelle zu sehen.
Zusätzlich werden noch Signal-LED(rot und grün) an einer
Überwachungsstelle sein.
-> Deswegen dachte ich mir, einen µC an einer Überwachungstelle
anzubringen.

Kann ich diese später über die USI/I2C gemeinsam (µC1||µC2||...||µCn)
über "Selfprogramming" updaten?
Die Adresse eines µC würde ich über Schalter(an jedem µC) einstellen.

So wird der PC an einen MASTERµC per RS232 eine Anfrage stellen - sag
mir mal Anzahl der Schaltkontakte>2sec und Gesamtdauer der
Schaltkontakte<2sec der Überwachungstelle 1-. Der Master holt sich die
Daten über USI/I2C an dem entsprechendem SLAVEµC und gibt die Infos per
RS232 zurück an den PC. So frägt er dann nacheinander die
Überwachungsstellen ab.

Zudem kann der PC enscheiden welche LED ansein soll und kann dies in
einem Entsprechendem Protokoll über den Master an den SLAVE
weiterleiten.

"Zusätzlich werden noch Signal-LED(rot und grün) an einer
Überwachungsstelle sein."
Soll der uC die LEDs steuern, abfragen oder ignorieren?

"Kann ich diese später über die USI/I2C gemeinsam
(µC1||µC2||...||µCn)
über "Selfprogramming" updaten?"
Ich habe schon Quelltext für einen I2C Bootloader im Netz gesehen
(Mega8 glaube ich). Damit sollte ein Neuprogrammieren über I2C möglich
sein (wenn der Speicher reicht).

Die Anwendung schreit irgendwie nach einem vernünftigen Bussystem (z.B.
CAN).

Der µCSLAVE soll die LED ansteuern(an bzw. ausschalten).
CAN ja schon davon gehört(werde mal in WIKI oder ähnlichem mich darüber
informieren), aber die Controller sollen bezahlbar bleiben.
Oder kann ich CAN auch mit USI in Tiny2313 nutzen?

Das ganze lässt sich auch als 1-Wire Bus realisieren, es gibt von
Dallas/Maxim entsprechende Devices für anzuschliessende Schalter.

DS2413: 2 I/O-Ports.
DS2408: 8 I/O-Ports.
Dürfte die technisch einfachste Lösung sein.

einfach mehrere 75HC573N an den ATTiny hängen. Ergibt 8
Schaltein/ausgänge pro Latch dann nochmal 3 Datenleitungen und das
reicht für 8x8=64 Schalter. Dadurch das du die Latchbausteine hochohmig
schalten kannst bleibt dein Port auch weiterhin für andere Aufgaben
nutzbar.