Der ATTiny2313 als Sub-Controller – GREETBoard I2C Slave

Ich komme gerade aus meinem Elektronik-Keller und habe das neue GREETBoard I2C Slave fertiggestellt und erfolgreich getestet. Dieses Modul ermöglicht die Erweiterung des GREETBoard-Systems um einen Sub-Controller, der alle möglichen Aufgaben erledigen kann, ohne dass sich das Hauptmodul, das GREETBoard ATMega128, darum kümmern muss. Angenommen, es sollen mehrere Motoren angesteuert werden, dann kann deren komplette Ansteuerung und eine mögliche Rückmeldung (Erfolg, Störung, etc) über den „Sklaven“ erfolgen, während das Hauptmodul lediglich die Schritte und die Richtung angibt. In der Zwischenzeit ist es dem ATMega128 möglich sich um andere Aufgaben zu kümmern. Die Kommunikation zwischen Haupt- und Slave-Modul wird, wie der Name des Moduls vermuten lässt, über den I²C-Bus gewährleistet.

Aufbau der Schaltung

Das zentrale Bauteil des GREETBoard I²C Salve ist ein ATTiny2313. Dies ist ein kleiner, 20-poliger Mikrocontroller, der über eine SPI-, UART- und I2C-Schnittstelle verfügt. Da der ATTiny über wenige Anschlüsse verfügt, sind SPI und I²C zusammengelegt, was sich USI – Universal Serial Interface – nennt. Diese Zusammenlegung scheint eine große programm- oder layouttechnische Herausforderung zu sein, aber in der Praxis ist dem (glücklicherweise) nicht so. Beide Schnittstellen werden wie gewohnt auf Wannensteckerleisten herausgeführt und können auch gleichzeitig angeschlossen sein. Ist das Modul mit anderen Bus-Teilnehmern verbunden, sollte es sicherheitshalber vom Bus getrennt werden, um Störungen/Defekte zu vermeiden.

Schaltplan

Der ATTiny ist mit einem 20MHz Quarz getaktet und verfügt über einen Reset-Taster. Zusätzlich dienen zwei Taster und drei Leuchtdioden für erste Programmierversuche ohne externe Beschaltung. Aber gerade die externe Beschaltung ist das Haupteinsatzgebiet dieses kleinen Moduls. Über die Pinleiste X3 sind alle nutzbaren Ein-/Ausgänge des ATTiny2313 herausgeführt, sodass das Modul z.B. auf ein sogenanntes Breadboard aufgesteckt werden kann. Dadurch stehen alle Pins für individuelle Experimente zur Verfügung.

GREETBoard I2C Slave - Schaltplan - V1.0

GREETBoard I2C Slave – Schaltplan – V1.0

Layout

Alle Bauteile passen auf ein sogenanntes 1/8-Modul und damit ist das GREETBoard I2C Slave ca. 50 x 40mm groß. Aufgrund der beiden Befestigungslöcher kann es auf jedes andere Modul des GREETBord Systems aufgesteckt werden. So befestigt, liegen die I²C-Buchsen der verbundenen Module exakt übereinander, was die Verbindung über kurze Flachbandkabel sehr einfach ermöglicht. Durch die gerade ausgeführte ISP-Buchse, kann an der oberen Kante ein weiteres Modul gestapelt werden (siehe Bild). Dies ist an der unteren Kante nicht möglich, da dort die Stiftleiste gewinkelt ausgeführt wurde, um das Modul für ein Breadboard steckbar zu gestallten. Auf dieser Stiftleiste sind alle verfügbaren Ein- und Ausgänge des ATTiny2313 herausgeführt (zusätzlich auch VCC und GND).

Gestapelte GREETBoard-Module

Gestapelte GREETBoard-Module

Das Module verfügt auch über stehend ausgeführte Pullup-Widerstände für den I²C-Bus. Diese sind jedoch erstmal nicht bestückt, da das GREETBoard ATMega128 im Normalfall die Pullup-Widerstände bereits aktiviert hat.

GREETBoard I2C Slave - Boardlayout - V1.0

GREETBoard I2C Slave – Boardlayout – V1.0

Ein- und Ausgabemöglichkeiten

Wie bereits weiter oben erwähnt, habe ich dem Modul zwei Taster und drei LEDs spendiert, die frei programmierbar sind. Die Taster liegen auf den Anschlüssen PD2 und PD3, die Leuchtdioden wiederum auf PB2, PB3 und PB4. Bei den LEDs ist auch zu erwähnen, dass es sich bei den Anschlüssen gleichzeitig auch um die „Output Compare Pins“ OC0A, OC1A und OC1B handelt. Diese sind sehr einfach, über die Timer des ATTiny2313, anzusprechen, was den Programmieraufwand für einfache Codes geringer macht. Die Taster liegen auf den Interrupt-Eingängen Int0 und Int1, die ebenfalls in den Code integriert werden können um schnell Funktionen auszulösen.

Die Anschlüsse PA0 und PA1 werden nicht herausgeführt, da diese für den externen Quarz verwendet werden. Ein ATTiny2313 läuft auch mit einem internen Taktgeber, der bis zu 8MHz ermöglicht. In dieser Betriebsart könnten die beiden Anschlüsse ebenfalls verwendet werden.

Einbindung in eigene Projekte

Ich habe mittlerweile mehrmals betont, dass dieses Modul hervorragend für die Einbindung in eigene Projekte verwendet werden kann. Vor allem, dass es möglich ist, es auf ein Breadboard zu stecken. Auf dem folgenden Bild ist das viel anschaulicher und bedarf weniger Worte.

Das GREETBoard I2c Slave auf einem Breadboard aufgesteckt

Das GREETBoard I2c Slave auf einem Breadboard aufgesteckt

In dieser beispielhaften Schaltung habe ich das GREETBoard I2C Slave auf das Breadboard gesteckt und an zwei Ausgängen je eine LED mit Vorwiderstand angeschlossen. Das Schöne am Breadboard ist halt, dass die Bauteile einfach in die kleinen Löcher gesteckt werden. Das ergibt zwar gerne einen unübersichtlich anmutenden Bauteilesalat, richtig gemacht, ist so aber sehr einfach und vor allem sehr schnell eine Testschaltung aufgebaut, für die man keine eigene Platine benötigt.

Eine solche Steckplatine (den deutschen Begriff habe ich tatsächlich erst bei der Suche nach dem Wikipedia-Link herausgefunden) ist aber keine Voraussetzung. In dem Fall, dass es bereits eine fertige Leiterplatte mit Stiftleisten für Signale gibt, ist es auch möglich, die Signale der beiden (oder mehr) Module durch flexible Drahtbrücken herzustellen. So wird Pin für Pin mit der „externen“ Schaltung verbunden.

Das Modul als „Stand-Alone“ Lösung

Während der Entwicklung dieses kleinen Moduls war mir zu Beginn nicht klar, dass es auch verwendet werden kann, ohne dass ein Hauptmodul Befehle über den I²C-Bus sendet. Es ist überhaupt kein Problem, den ATTiny2313 mit einem Programm zu versehen, das völlig alleine agiert und Steuerungsaufgaben übernimmt. Dafür ist lediglich eine Spannungsversorgung über die VCC- und GND-Pins nötig, mehr nicht. Der Anschluss an einen I²C-Bus ist weiterhin ohne weiteres möglich.

Damit ist diese Modul äußerst flexibel. Es kann als Sub-Controller für das Hauptmodul oder als Stand-Alone-Lösung verwendet werden. Es ist sehr einfach mit anderen GREETBoard Modulen kombinierbar oder als Teil von individuellen Schaltungen nutzbar. Es bieten sich also sehr viele Anwendungsmöglichkeiten. Ich bin gespannt, wo ich es noch überall einsetzen werde 🙂

Inbetriebnahme

Für einen ersten Test, habe ich ein kleines Programm geschrieben, dass die LED1 im Sekundentakt blinken lässt. Zusätzlich wird der Pin PB1 im gleichen Takt hin- und hergeschaltet, um dieses Signal an der Stiftleiste abgreifen zu können. Mit den Tasten lässt sich die Blinkfrequenz erhöhen und reduzieren.

Ich war echt froh, als die LED zu blinken begann und die Taster die Frequenz veränderten. Das Board ist somit erfolgreich gestartet. Weitere Versuche können nun beginnen! Super!!

/* ErsterTest_GREETBoard-I2C-Slave.c
 *
 * Created: 06.01.2015
 * Author: Timo Gruss (timogruss.de)
 *
 * Dieses Programm lässt die LED 1 blinken (Startfrequ. 1Hz)
 * Mit den Tasten S1 und S2 kann die Blinkfrequenz erhöht,
 * bzw. reduzziert werden.
 *
 * This code by Timo Gruß is licensed under a Creative Commons
 * Attribution-NonCommercial-ShareAlike 4.0 International License.
 */ 

#include <avr/io.h>
#include <avr/interrupt.h>

volatile uint8_t tcount;	// Globale Variable (volatile)
volatile uint16_t speed;		// Globale Variable (volatile)

ISR (TIMER1_OVF_vect)		// Timer Interrupt-Routine
{
  TCNT1 = speed;			// Reloadwert erneuern
  tcount++;				// tcount +1 pro Timer Interrupt (200ms)
}

int main(void)
{
  speed = 3036;						// Reloadwert in Variable ablegen

  //### AUSGÄNGE
  DDRB = (1 << DDB1);					// PB1 für externe Beschaltung
  DDRB = (1 << DDB2);					// PB2 als Ausgang für LED1

  //### EINGÄNGE
  DDRD &= ~(1 << DDD2);				// PD2 = Eingang
  DDRD &= ~(1 << DDD3);				// PD3 = Eingang
  PORTD |= _BV(2);					// Pull Up an PD2 aktivieren
  PORTD |= _BV(3);					// Pull Up an PD3 aktivieren

  //### TIMER
  TCNT1 = speed;						// Reloadwert für 200ms
  TCCR1B = (1<<CS10) | (1<<CS11);	// Prescaler auf 64
  TIMSK |= (1<<TOIE1);				// Interrupt für Timer aktiv.
  sei();								// Interrupts aktiv

  while(1)
  {
    if (tcount == 5)			// Wenn 5x Timer ausgelöst hat...
    {
      PORTB ^= (1 << PB2);    // LED umschalten
      tcount = 0;             // Zähler wieder auf 0 setzen
    }

    if (PIND & (1<<2)){			// Wenn Taste gedrückt...
      speed = speed - 200;		// Erhöhe die Blinkfrequenz
    }

    if (PIND & (1<<3)){			// Wenn Taste gedrückt...
      speed = speed + 200;		// Reduz. die Blinkfrequenz
    }
  }
}

Fazit

Das GREETBoard I2C Slave ist echt sehr flexibel einsetzbar, sogar noch flexibler als ich es mir zu Beginn gedacht habe. Ich stelle mir dabei die Frage, warum ich überhaupt ein PCF8574 für eine I2C Porterweiterung benutzen soll, wenn der ATTiny das gleiche und noch viel, viel mehr kann. Zumal der ATTiny in der DIP Version billiger ist, als der PCF. Selbst die SOIC Versionen sind gerade einmal 0,03€-0,32€ teurer. Solang keine Massenproduktion geplant ist, ist der Preisunterschied nicht dramatisch, die Vorteile jedoch eklatant!

Im nächsten Artikel werde ich näher auf die I2C-Slave-Funktion eingehen und zeigen, wie diese mit einer freien Bibliothek einfach realisiert wird.

Wie immer hoffe ich, dass ich dem Ein oder der Anderen behilflich sein konnte und bin auf euer Feedback gespannt. Vielleicht habt Ihr ja ein paar Anwendungsmöglichkeiten, für die das GREETBoard I2C Slave gut passen würde. In diesem Sinne wünsche ich Euch alles Gute,

Euer Timo

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.