Modulares Board

Wechseln zu: Navigation, Suche

Inhaltsverzeichnis

Modulares Board mit dem ATmega 1284p und ATtiny 2313

Board 1 1.jpeg

Das modulare Board 1 mit einem ATmega 1284p mit einer einheitlichen Höhe von 72 mm. Die Breite wird der Anwendung angepasst.

Warum ein neues Board?

Es gibt die verschiedensten Board. Jeder Hersteller hat sein eigenes Board. Der Unterschied liegt im Aufbau, verwendete Bauteile, Größe und Anschlüsse. Einige sind seit gefühlten 10 Jahren auf dem Markt. Entsprechend ist auch die Verwendung. Es passen die Anschlüsse nicht zusammen, die Belegung der Stecker ist unterschiedlich, es passen keine Erweiterungen dazu, die Beschreibungen fehlen total, passen nicht oder sind definitiv falsch. Das gleiche gilt für die Software. Für viele Sachen gibt es keine Beispiele oder kleine Anwendungen. Gerade für den Anfänger ergeben sich Riesenprobleme daraus und er verliert schnell die Lust daran. Es geht aber auch anders. Eine einheitliche Größe, alles passt zueinander und ist aufeinander Abgestimmt und reichlich Erklärung und Beispiele. Programmierung erfolgt durch ISP. Die Verbindung mit anderen Modulen kann mit dem I2C Bus erfolgen. Weitere Angaben, Codes, Tutorials oder Info könnt ihr von mir bekommen.

Das Board 1

  • Prozessor ATmega 1284p in einem 40 poligen Gehäuse mit einem Sockel (leicht austauschbar)
  • Quarz mit 16 MHz
  • Resettaster
  • 3 zusätzliche Taster
  • 2 LEDs
  • Lautsprecher
  • ISP Anschluss 6 polig
  • 2 x I2C Anschlüsse 10 polig
  • Anzeige +5V durch eine LED
  • Portanschluss A, B und D
  • alle Steckverbinder durch Wannenstecker, dadurch verpolungssicher
  • Belegung der Stecker nach RN-Standard
  • Größe 72x64 mm² (Platine P30)
  • Halterung für Hutschiene
  • zusätzliche Abblockung der Betriebsspannung
  • Taster haben durch Widerstände definierten Pegel
  • 2 Betriebsspannungen +5V / +12V am Stecker angeschlossen
  • einseitige Platine mit wenigen Brücken
  • keine SMD Bauteile
  • Bestückungsdruck
  • wunderbar geeignet für Anfänger
  • komplette Beschreibung und Aufbauanleitung (Tut)
  • Software in C zum Testen (Beispiele)
  • fertige Leerplatine erhältlich
  • erprobter Aufbau

Board 1 4.jpeg

Die bestückte Platine mit abgenommenem Prozessor. An der oberen Kante befinden sich die beiden I2C Buchsenstecker (2x5), oberhalb des Prozessors befindet sich der ISP-Stecker (2x3). An der linken bzw. rechten Seite befinden sich die Portstecker A,B und D (2x5). Innerhalb des Sockels habe ich einige Bauteile untergebracht.

Die Platine

Board 1 5.jpeg

Die Platine hat eine Größe von 72x64 mm², einseitig mit Bestückungsdruck. Der Preis für alles dürfte bei ca. 10 bis 12 Euro liegen.

Die Schaltung

Schaltung Board1.jpeg

Die Schaltung des Boards 1

Bauteile

  • L1–L3 - LED, 3 oder 5mm, 20 mA
  • 1 x Platine ca. 72 x 64 mm² (P30)
  • R1 - Widerstand 10 kOhm
  • R2–R4 - Widerstand 150 Ohm
  • R5–R7 - Widerstand 4,7 kOhm
  • R8–R10 - Widerstand 220 Ohm
  • C1, C2 - Kondensator 22pF
  • C3–C5 - Kondensator 100 nF
  • C6, C9 - Elko 100/16
  • C7–C10 - Kondensator 100 nF
  • Quarz 16 MHz
  • Lautsprecher RMP 14
  • 1 x Wannenstecker 2x3 (ISP) RM 2,54
  • 5 x Wannenstecker 2x5 (Port, I2C) RM 2,54
  • Taster 1-4 - Printtaster
  • IC ATmega 1284p
  • Sockel 40 polig
  • Halterung 3 teilig

Belegung Stecker

In diesen beiden Bilder habe ich die genaue Belegung der Steckbuchsen dargestellt. Die Belegung ist bei allen Boards gleich. Die Verbindung der einzelnen Platinen erfolgt durch 10 poliges Flachkabel mit unterschiedlichen Längen.

Stecker i2c.jpeg Stecker PortB.jpeg ISP 6 polg.jpeg

Pinbelegung

Port - Steckbuchse

  • PA0 - Port A / 1
  • PA1 - Port A / 2
  • PA2 - Port A / 3
  • PA3 - Port A / 4
  • PA4 - Port A / 5
  • PA5 - Port A / 6
  • PA6 - Port A / 7
  • PA7 - Port A / 8
  • PB0 - Port B / 1
  • PB1 - Port B / 2
  • PB2 - Port B / 3
  • PB3 - Port B / 4
  • PB4 - Port B / 5
  • PB5 - Port B / 6
  • PB6 - Port B / 7
  • PB7 - Port B / 8
  • PD0 - Port D / 1
  • PD1 - Port D / 2
  • PD2 - Port D / 3
  • PD3 - Port D / 4
  • PD4 - Port D / 5
  • PD5 - Port D / 6
  • PD6 - Port D / 7
  • PD7 - Port D / 8
  • PC2 - Taster 1
  • PC3 - Taster 2
  • PC4 - Taster 3
  • PC5 - LED 1
  • PC6 - LED 2
  • PC7 - Lautsprecher

Software

Ich nutze das AVR Studio 6.0 (6.2), programmiere in C und verwende die Dateien von Peter.

Mit diesem Programm testen wir als erstes eine LED auf dem Board. Wenn alles richtig bestückt wurde, muss eine LED blinken.

#define F_CPU 16000000UL	// Angabe der Quarzfrequenz, wichtig für die Zeit
#include <util/delay.h>		// Einbindung Datei Pause
#include <avr/io.h>		// Einbindung Datei Ausgänge

int main(void)
  {
    DDRC=0b00100000;		// Port C auf Ausgang schalten
    while(1)			// Programmschleife
      {
        PORTC &= ~(1<<PC5);	// Schaltet Pin aus
        _delay_ms(500);		// Pause 500 ms
        PORTC |= (1<<PC5);	// Schaltet Pin ein
        _delay_ms(500);		// Pause 500 ms
      }
  }

Mit diesem Programm testen wir die Funktion der Taster. Beim Betätigen der Taster sollen die LEDs entsprechend einschalten. Beim Betätigen des Tasters T3 schaltet der Lautsprecher ein.

# define F_CPU 16000000UL		        // Angabe der Quarzfrequenz, wichtig für die Zeit
# include <avr/io.h>				// Ausgänge
# include <util/delay.h>			// Zusätzlich Datei für Pause

int main (void)				        // Hauptprogramm
  {	
    DDRC  |= (1<<PC5) | (1<<PC6) | (1<<PC7);    // auf Ausgang schalten	
    while (1)					// Endlosschleife	
      {						// Beginn Programm	
        if ( PINC & (1<<PC2))			// Abfrage Taste 1
	  {
	    PORTC |=(1<<PC5);			// LED 1 ein
	  }
        else
	  {
	    PORTC &=~(1<<PC5);		        // LED 1 aus
	  }	
        if ( PINC & (1<<PC3) )			// Abfrage Taste 2
	  {
	    PORTC |=(1<<PC6);			// LED 2 ein
	  }
        else
	  {
	    PORTC &=~(1<<PC6);		        // LED 2 aus
	  }
        if (!( PINC & (1<<PC4)) )		// Abfrage Taste 3
	  {
	    PORTC |=(1<<PC7);			// Sound ein
	    _delay_us(500);
	    PORTC &=~(1<<PC7);		        // Sound aus
            _delay_us(500);
          }
        else
	  {
	    PORTC &=~(1<<PC7);		        // Sound aus
	  }
        }
    }

Das Board 2

PC172210 1.jpeg

Das bestückte Modul auf dem Träger in der Größe 72x42 mm

  • 2 Steckbuchsen für I2C Bus (2x5)
  • Steckbuchse für ISP (2x3)
  • Quarz mit 16MHz
  • Summer
  • 3 x Taster
  • 3 x LED
  • Anzeige Vcc mit LED
  • Resettaster
  • Master Slave bei I2C Bus möglich
  • Port B auf Buchse geführt (2x5)
  • erprobte Schaltung
  • einseitige Platine mit wenigen Brücken
  • keine SMD
  • Platine erhältlich

Die Platine

Platine 52 F.jpeg

Die Platine des Boards 2 mit dem ATtiny 2313

Die Schaltung

Board 2 Hardware.jpeg

Die Schaltung des Boards 2

Bauteile

  • L1 – L4 - LED, 3 oder 5mm, 20 mA
  • RN 1 - R-Netzwerk 5/4 220 Ohm
  • R1 - Widerstand 10 kOhm
  • R2 – R4 - Widerstand 4,7 kOhm
  • R5 – R7 - Widerstand 180 Ohm
  • R8 – R10 - Widerstand 220 Ohm
  • C1 – C3 – Kondensator 100 nF
  • C4 – C6 - Elko 100/16
  • C7, C8 - Kondensator 15 pF
  • C6, C9 - Elko 100/16
  • Q1 - Quarz 16 MHz
  • T1 – T4 - Taster
  • Summer - AL 60 SP 05
  • 1 x ATtiny 2313 (A) mit Sockel
  • 1 x Platine ca. 72 x 42 mm (P52)
  • 3 x Wannenstecker 2x5 (Port, I2C)
  • 1 x Wannenstecker 2x3
  • Halterung - 2 teilig

Belegung Stecker

Die Belegung der Stecker entspricht dem Board 1

Pinbelegung

  • PB 0 - Wannenstecker Pin 1
  • PB 1 - Wannenstecker Pin 2
  • PB 2 - Wannenstecker Pin 3
  • PB 3 - Wannenstecker Pin 4
  • PB 4 - Wannenstecker Pin 5
  • PB 5 - Wannenstecker Pin 6
  • PB 6 - Wannenstecker Pin 7
  • PB 7 - Wannenstecker Pin 8
  • GND - Wannenstecker Pin 9
  • Vcc - Wannenstecker Pin 10
  • PD 0 - Taster 2
  • PD 1 - Taster 3
  • PD 2 - Taster 4
  • PD 3 - LED 2
  • PD 4 - LED 3
  • PD 5 - LED 4
  • PD 6 - Summer
  • LED 1 – Anzeige Vcc
  • T 1 - Taster Reset

Software

#define F_CPU 16000000UL	// Angabe der Quarzfrequenz, wichtig für die Zeit
#include <util/delay.h>		// Einbindung Datei Pause
#include <avr/io.h>		// Einbindung Datei Ausgänge
int main(void)
  {
    DDRD=0b00111000;		// Port C auf Ausgang schalten
    while(1)			// Programmschleife
      {
        PORTD &= ~(1<<PD3);	// Schaltet Pin aus
        _delay_ms(500);		// Pause 500 ms
        PORTD |= (1<<PD3);	// Schaltet Pin ein
        _delay_ms(500);		// Pause 500 ms	

        PORTD &= ~(1<<PD4);	// Schaltet Pin aus
        _delay_ms(500);		// Pause 500 ms
        PORTD |= (1<<PD4);	// Schaltet Pin ein
        _delay_ms(500);		// Pause 500 ms
		
        PORTD &= ~(1<<PD5);	// Schaltet Pin aus
        _delay_ms(500);		// Pause 500 ms
        PORTD |= (1<<PD5);	// Schaltet Pin ein
        _delay_ms(500);		// Pause 500 ms		
      }
  }

Dieses Programm schaltet die LED 2 bis 4 nacheinander ein (Lauflicht)

# define F_CPU 16000000UL	// Angabe der Quarzfrequenz, wichtig für die Zeit
# include <avr/io.h>		// Ausgänge
# include <util/delay.h>	// Zusätzlich Datei für Pause
int main (void)			// Hauptprogramm
  {
    DDRD=0b00111000;		// Port D auf Ausgang schalten
    while (1)			// Endlosschleife
      {				// Beginn Programm
        if ( PIND & (1<<PD0) )	// Taster 2
	  {
	    PORTD |=(1<<PD3);	// LED 2 ein
	  }
        else
	  {
	    PORTD &=~(1<<PD3);	// LED 2 aus
	  }
        if ( PIND & (1<<PD1) )	// Taster 3
	  {
	    PORTD |=(1<<PD4);	// LED 3 ein
	  }
        else
	  {
	    PORTD &=~(1<<PD4);	// LED 3 aus
	  }
        if ( PIND & (1<<PD2) )	// Taster 4
	  {
	    PORTD |=(1<<PD5);	// LED 4 ein
	  }
        else
	  {
	    PORTD &=~(1<<PD5);	// LED 4 aus
	  }
        }	
  }

Bei diesem Programm schalten die Taster 2 bis 4 die LED 2 bis 4

Das Netzteil NT2 - +5V/+12V 3,5A

Für die Versorgung mit Spannung brauchen wir ein Netzteil. Habe dazu das Netzteil 2 gebaut. Es bringt bei +5V ca. 3,5A und bei +12V ca. 3,5A. Es wird aus einem alten Laptop-Netzteil von 19V/6A versorgt. Dadurch habe ich auf der Platine keine Netzspannung anliegen. Der Anschluss erfolgt mit einem Hohlstecker. Auf der Platine sind 2 Buchsenstecker 2x5 vorhanden. Dadurch kann ich das Netzteil zwischen 2 Module einbauen. Zusätzlich habe ich noch einen Anschluss für 12V vorgesehen. Die Belegung der Buchsenstecker erfolgt wieder nach RN-Standard. Zum Schutz des Netzteiles und der Schaltungen habe ich eine Diode in die Zuleitung eingebaut. Dadurch wird ein Falschpolen verhindert. Die Regelung erfolgt durch LM2576 mit Festspannung von +5V/+12V.

NT2 4.jpeg

Das Netzteil 2

Auch das Netzteil befindet sich auf einer einseitigen Platine. Es hat die Größe von 72x87 mm. Es passt damit ohne Probleme zu unserem Board 1. Auf der Platine befinden sich 2 Steckbuchsen 2x5. Diese sind nach RN-Standard belegt. Über diese beiden Buchsen erfolgt der Anschluss anderer Module. Das Netzteil liefert 2 Spannungen, +5V und +12V mit jeweils max. 3,5A. Den I2C Bus habe ich durchgeschleift und steht somit an beiden Seiten zur Verfügung.

NT2 1.jpeg

Die Platine

NT2 3.jpeg

Die Platine hat eine Größe von 72x87 mm, einseitig mit Bestückungsdruck

Die Schaltung

NT 2 Bild.jpeg

Die Schaltung des Netzteil mit +5V/3,5A und +12V/3,5a

Bauteile

  • IC 1 – LM 2576/12
  • IC 2 – LM 2576/5
  • C1 - Elko 1000/50V
  • C2,C5 - Elko 470/50V
  • C3,C6 - Elko 470/25V
  • C4,C7 - 100nF
  • R1 – 470 Ohm
  • R2 – 180 Ohm
  • D1 - P600A
  • D2,D3 - SB 590
  • D4,D5 - LED 3 mm 20mA
  • L1,L2 - Speicherdrossel 100µH 5A
  • L3,L4 - Störschutzdrossel 10µH
  • 2 x Schraubklemmen 5mm - 2 fach
  • 2 x Wannenstecker 10 (2x5) RM 2,54
  • KK1, KK2 – Kühlkörper SK29-25S
  • 1 x Hohlbuchse für Platine 5,5/2,5
  • S1, S2 - Sicherungshalter 5x20
  • Si1, Si2 - Sicherung 2,5A
  • 1 x Platine 72 x 87 einseitig
  • 1 x Netzteil ca. 19V / 6A (alt Laptop)

I2C- Bus - Das Display 1

PA061903 1.jpeg

Die Platine

Platine Foto D1 2.jpeg

Die Schaltung

Hardware Display 1 1.jpeg

Bauteile

  • R1, R2 – Widerstand 10 kOhm
  • R3 – Widerstand 4,7 kOhm
  • R4 – 220 Ohm
  • R6 – Widerstand 22 Ohm
  • R7 – Regler 100 Ohm
  • R8 – Regler 10 kOhm
  • C1, C3 – Kondensator 100nF
  • C2 – Elko 100/16
  • L1 – LED 3 mm grün 20 mA
  • Tr1 – Si PNP BC558
  • Steckerleiste 1x16
  • Buchsenleiste 1x16
  • 2 x Wannenstecker 2x5
  • Platine ca. 72 x 110 mm (D2)
  • Display – TC 1604 – 4x16 (TC 1602 2x16)

Widerstand R5 habe ich leider vergessen.

Belegung Stecker

Die Belegung der Steckbuchsen entspricht dem von Board 1. Die Belegung der Stecker des Displays entspricht dem Standart. Eventuell im Datenblatt kontrollieren.

Software

/* ATB_B1_Display_1.c Created: 11.10.2014 16:14:43 Author: AS */ 
#include <stdbool.h>
#include <avr/pgmspace.h>
#include "main.h"				// Aufruf „main“
#include "i2clcd.h"
#include "i2cmaster.h"
#include "avr/io.h"
#include <util/delay.h>

int main(void)
  {
    i2c_init();                			// Starte I2C Bus
    lcd_init();                			// Starte I2CLCD	
    lcd_light(0);				// 0=Licht an, 1=Licht aus 
	
    // Display Befehle
    lcd_command(LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKINGOFF);
    // Display ON/OFF / Cursor ON/OFF / Blinken ON/OFF
	
    lcd_command(LCD_CLEAR);    		        // Leere Display
    _delay_ms(2);				// warte 2ms
	
    lcd_printlc(1,6,"Boxtec"); 		        // Text Zeile 1
    lcd_printlc(2,2,"**************");	        // Text Zeile 2
    lcd_printlc(3,2,"Display Modul 1");	        // Text Zeile 3
    lcd_printlc(4,2,"(by achim S.)");		// Text Zeile 4
    _delay_ms(5000);		       		// Warte 5000ms
	
    while(1)					// while Schleife
      {						// Beginn Schleife
        lcd_command(LCD_CLEAR);        	        // Leere Display
        _delay_ms(1000);		      	// Warte 1s
		
        lcd_printlc(1,1,"Die 1. Zeile");		// Text Zeile 1
        _delay_ms(2000);			// warte 2s
		
        lcd_printlc(2,2,"Die 2. Zeile");	// Text Zeile 2
        _delay_ms(2000);			// warte 2s 
		
        lcd_printlc(3,3,"Die 3. Zeile");	// Text Zeile 3
        _delay_ms(2000);			// warte 2s
		
        lcd_printlc(4,4,"Die 4. Zeile");	// Text Zeile 4
        _delay_ms(5000);			// warte 5s
      }						// Ende Schleife
  }

Bilder / Ansichten

PA 061928 1.jpeg PA 121954 1.jpeg

I2C-Bus In / Out Board 1

IO 4.jpeg

Zur Ein- und Ausgabe im I2C Bus verwende ich sehr gern dieses Modul.

  • 2 Buchsen zum Anschluss an den Bus
  • PCF 8574 (A)
  • 4 x LED 5mm 20mA mit Vorwiderstände
  • 4 x Taster
  • 2 Buswiderstände an Vcc
  • 3 Adressstecker A0, A1, A2
  • Anzeige Vcc
  • Stecker Int
  • Sockel

Die Platine

IO 2.jpeg

Die Platine 72x54 mm

Die Schaltung

In Out 1 Schaltung.jpeg

Die Bauteile

  • C1 Elko 100/16
  • C2 100nF
  • LED 1 bis LED 5 LED 5mm, 20 mA
  • R1 bis R4, R7 220 Ohm
  • R5, R6 10 kOhm
  • 2 x Wannenstecker 10 polig (2x5)
  • 3 x Stiftleiste 3 polig (A0,A1,A2)
  • 2 x Stiftleiste 2 polig (J1, J2)
  • 1 x PCF8574 (A) mit Sockel 16 polig
  • 1 x Platine ( ca. 72x54 )

Die Bus Adressen des PCF 8574(A)

Bus Adressen 1.jpeg

#define F_CPU 16000000L				// definiere auf 16MHz
#include <util/delay.h>				// Einbinden der .h Datei
#include "i2cmaster.h"
 
unsigned char adr1_w = 0x40;			// Schreibadresse 40
unsigned char adr1_r = 0x41;			// Leseadresse
 
unsigned char adr2_w = 0x42;			// Schreibadresse 42
unsigned char adr2_r = 0x43;			// Leseadresse
 
unsigned char d;				// Taster
unsigned char e;				// LED
 
int main(void)
  {						// Hauptprogramm
    i2c_init ();
    i2c_start(adr1_w);				// Schreibbefehl für Device 1
    i2c_write(0xff);				// Alle Pins des PCF auf 0
 
    while(1)
      {						// Hauptschleife  
        i2c_write(0xff);			// Alle Pins des PCF auf 0
        i2c_start(adr1_r);			// Starte Lesezugriff
        d=i2c_readNak();			// Schreib Leseergebnis in d
 
        if (~d & 0x01)				// Abfrage T1
           {					// Wenn T1 gedrückt ist...
	      i2c_start(adr2_w);		// Schreibbefehl
	      e = 0x7e;				// Angabe LED Port0 7e
	      i2c_write(e);			// Schreibe e
	      e = 0xbd ;			// Angabe LED Port1 bd
	      i2c_write(e);			// Schreibe e
	      _delay_ms(100);			// 100ms warten
           }
         else
           {
	     e = 0xff;				// alle LED aus
	     i2c_start(adr2_w);			// Schreibbefehl
	     i2c_write(e);			// Schreibe e	
	   }
        }
    _delay_ms(100);
    i2c_stop();
  }

I2C-Bus Out Board 1

P7211663 1.jpeg

Die Platine

P4N F 1.jpeg

Die Platine in der Größe 72x42 mm

Die Schaltung

Schaltung Out1.jpeg

Bauteile

  • C1 - Elko 100/16
  • C2 - 100nF
  • LED 1 - LED 9 - LED 5mm, 20 mA
  • R1 - R8 - 180 Ohm
  • R9, R10 - 10 kOhm
  • 2 x Wannenstecker 10 polig (2x5)
  • 3 x Stiftleiste 3 polig (A0, A1, A2)
  • 1 x Stiftleiste 2 polig (J1)
  • 1 x PCF8574 (A) mit Sockel 16 polig
  • 1 x Platine ca. 72x42 mm

Belegung Stecker

Die Belegung der Steckbuchsen entspricht dem Board 1

Software

#define F_CPU 16000000L		        // definiere auf 16MHz
#include <util/delay.h>			// Einbinden der .h Datei
#include "i2cmaster.h"

unsigned char adr1_w = 0x40;		// Schreibadresse 40
unsigned char adr1_r = 0x41;		// Leseadresse
unsigned char adr2_w = 0x42;		// Schreibadresse 42
unsigned char adr2_r = 0x43;		// Leseadresse
unsigned char d;			// Taster
unsigned char e;			// LED

int main(void)
  {					// Hauptprogramm
    i2c_init ();	
    i2c_start(adr1_w);			// Schreibbefehl für Device 1
    i2c_write(0xff);			// Alle Pins des PCF auf 0
    while(1)
      {					// Hauptschleife
        i2c_write(0xff);		// Alle Pins des PCF auf 0
        i2c_start(adr1_r);		// Starte Lesezugriff
        d=i2c_readNak();		// Schreib Leseergebnis in d
        if (~d & 0x01)			// Abfrage Taster T1
          {				// Wenn T1 gedrückt ist...
            e = 0x49;			// Angabe LED nach Tabelle 			
	    i2c_start(adr2_w);		// Schreibbefehl
	    i2c_write(e);		// Schreibe e
	    _delay_ms(100);		// 100ms warten		
          }
      }
    _delay_ms(100); 			// 100ms warten
    i2c_stop();				// I2C Stop
  }

I2C-Bus Out Board 2

IOut 21.jpeg

Ansicht Modul mit 16 x LED. Der IC befindet sich auf der Unterseite und wurde direkt auf die Leiterzüge gelötet

Die Platine

IOut 22.jeg

Ansicht der Platine mit Bestückungsdruck

Die Schaltung

IOut 24.jpeg

Bauteile

  • RN1, RN2 - Widerstandsnetzwerk 220 Ohm 9/8
  • 2 x Wannenstecker 2x5
  • R1 – Widerstand 220 Ohm
  • 3 x Jumper
  • C1, C4 – Elko 100/16
  • C2, C3 – Kondensator 100 nF
  • Platine ca. 72 x 53 mm
  • 3 x Steckerleiste 3 polg.
  • L1 – LED 5 mm rot (20 mA)
  • 1 x PCF 8575 (Achtung SMD)
  • L00 – L07 – LED 3 mm grün 20 mA
  • L10 – L17 – LED 3 mm gelb 20 mA

Belegung Stecker

Die Belegung der Stecker entspricht dem Board 1

Software

/* ATB_I2C_Out2_5.c Created: 03.08.2014 18:23:29 Author: AS */ 
#define F_CPU 16000000L				// definiere auf 16MHz
#include <util/delay.h>				// Einbinden der .h Datei
#include "i2cmaster.h"

unsigned char adr1_w = 0x40;			// Schreibadresse
unsigned char adr1_r = 0x41;			// Leseadresse
unsigned char adr2_w = 0x42;			// Schreibadresse
unsigned char adr2_r = 0x43;			// Leseadresse

unsigned char d;				// Taster
unsigned char e;				// LED

int main(void)
  {						// Hauptprogramm
    i2c_init ();
    i2c_start(adr1_w);				// Schreibbefehl
    i2c_write(0xff);				// Alle Pins des PCF auf 0

    while(1)
      {						// Hauptschleife
        i2c_write(0xff);			// Alle Pins des PCF auf 0
        i2c_start(adr1_r);			// Starte Lesezugriff
        d=i2c_readNak();			// Schreib Leseergebnis in d
			
        if (~d & 0x01)				// Abfrage T1
	{					// Wenn T1 gedrückt ist...
	  i2c_start(adr2_w);			// Schreibbefehl
	  e = 0x7e;				// Angabe LED Port0 7e
	  i2c_write(e);				// Schreibe e
	  e = 0xbd;				// Angabe LED Port1 bd
	  i2c_write(e);				// Schreibe e
	  _delay_ms(100);			// 100ms warten
	}	
		
        if (~d & 0x02)					// Abfrage T2
	{						// Wenn T2 gedrückt ist...
	  i2c_start(adr2_w);				// Schreibbefehl
	  e = 0x5c;					// Angabe LED Port0
	  i2c_write(e);				// Schreibe e
	  e = 0x3a;					// Angabe LED Port1
	  i2c_write(e);				// Schreibe e
	  _delay_ms(100);				// 100ms warten
	}
		
        if (~d & 0x04)					// Abfrage T3
	{						// Wenn T3 gedrückt ist...
	  i2c_start(adr2_w);				// Schreibbefehl
	  e = 0x12;					// Angabe LED Port0
	  i2c_write(e);				// Schreibe e
	  e = 0x84;					// Angabe LED Port1
	  i2c_write(e);				// Schreibe e
	  _delay_ms(100);				// 100ms warten
	}

        if (~d & 0x08)					// Abfrage T4
	{						// Wenn T4 gedrückt ist...
	  i2c_start(adr2_w);				// Schreibbefehl
	  e = 0x00;					// Angabe LED Port0
	  i2c_write(e);				// Schreibe e
	  e = 0x00;					// Angabe LED Port1
	  i2c_write(e);				// Schreibe e
	  _delay_ms(100);				// 100ms warten
	}
        else
	{
	  e = 0xff;					// alle LED aus
	  i2c_start(adr2_w);				// Schreibbefehl
	  i2c_write(e);				// Schreibe e
	}
      }
    _delay_ms(100);
    i2c_stop();
  }

Graphik Modul mit KS0108 und Display TG12864

Foto1.jpeg

Ansicht des Graphik Moduls

Die Platine

Foto3.jpeg

Ansicht des Graphik Moduls

Die Schaltung

Foto2.jpeg

Bauteile

  • L1 - LED, 3 oder 5mm, 20 mA
  • P1 - Einstellregler 10 kOhm
  • R1 - Widerstand 220 Ohm
  • R2 - Widerstand 1,8 kOhm
  • R3 - Widerstand 10 kOhm
  • C1, C3 – Kondensator 100 nF
  • C2 - Elko 100/16
  • Graphikdisplay TG12864
  • Buchsenleiste 20 polig
  • Steckerleiste 20 polig
  • 1 x Platine ca. 72 x 121 mm (P35)
  • 4 x Wannenstecker 2x5 (Port, I2C)

Belegung Stecker

Die Belegung der Stecker entspricht Board 1

Software

Ansicht

Foto4.jpeg

So könnte das fertige Graphik Modul aussehen

Bilder

Mit dem KS0108 und einigen BMP kann man auch Bilder auf dem Display darstellen. Wie das genau geht, steht im PDF

PDF - Dateien

I2C-Bus WTMA (Schaltuhr mit I2C)

Fotow2.jpeg

Schaltuhr WTMA mit I2C Platine

Die Platine

Fotow1.jpeg

Ansicht der Platine

Die Schaltung

Fotow4.jpeg

Die Schaltung mit WTMA und Anbindung an den I2C Bus

Bauteile

  • L1 – L5 – LED 3 oder 5 mm, 20 mA (rot + grün)
  • R1 - Widerstand 220 Ohm
  • R2 - Widerstand 4,7 kOhm
  • R3, R4 – Widerstände 10 kOhm
  • R5, R6, R7 – Widerstand 220 Ohm
  • R8 - Widerstand 490 Ohm
  • C1, C4 – Elko 100/16
  • C2, C3 – Kondensator 100nF
  • 1 x WTMA 1 (Bausatz ELV)
  • 1 x PCA 9536 (SMD)
  • 2 x Wannenbuchsen 2x5 RM 2,54
  • 1 x Platine P22 (72x121 mm einseitig)
  • 1 x Jumper
  • 1 x Stecker zweipolig

Belegung Stecker

Die Belegung der Stecker entspricht Board 1

Belegung Ports/Pins

  • P0 – LED L2 (Ausgang)
  • P1 – LED L3 (Ausgang)
  • P2 – LED L4 (Ausgang)
  • P3 – Eingang (WTMA 1)

Software

#include "main.h"        		// Angabe der Adresse und Frequenz
#include "i2cmaster.h"      	        // Aufruf twimaster
#include <util/delay.h>
uint8_t da;
uint8_t db;
uint8_t var=0;
uint8_t mask;
uint8_t ret;

// adr1_w 0x82 P22 WTMA mit PCA9536    // Adressen müssen angepasst werden
// adr1_r 0x83
// adr2_w 0x40 P11 4xT + 4xLED
// adr2_r 0x41 P11

#define adr1_w 0x82
#define adr2_w 0x40
#define adr2_r 0x41
#define output_Reg 0x01
#define input_Reg 0x02
#define config_Reg 0x03

int8_t abfrage_Bus(uint8_t slave_adresse) 	 // Abfrage und Fehlermeldung
  {
    ret = i2c_start(slave_adresse);		 // Abfrage Slave vorhanden
    i2c_stop();
    if (ret == 0)
      {
        PORTC|=(1<<PC5);
      }
    else                			 // Fehlererkennung
      {
        PORTC &=~(1<<PC5);
   								                                       
      }
    }

int8_t PCA9536_Write(uint8_t slave_addresse, uint8_t cfg_Reg, uint8_t data)
  {
    i2c_start(slave_addresse);
    i2c_write(cfg_Reg);
    i2c_write(data);
    i2c_stop();
  }
  
int8_t PCF8574_Read(uint8_t slave_adresse1, uint8_t slave_adresse2)
  {
    i2c_start(slave_adresse1);      		 // Schreibbefehl für Device 2
    i2c_write(0xff);      			 // Alle Pins des PCF auf 0
    i2c_start(slave_adresse2);      		 // Starte Lesezugriff
    da=i2c_readNak();      			 // Schreib Leseergebnis in d
    i2c_stop();
  } 
   
int8_t PCA9536_Read(uint8_t slave_adresse)
  {
    i2c_start(slave_adresse);			 // Startbefehl für WTMA
    i2c_write(0x00);				 // setze Lesezugriff
    i2c_start(slave_adresse|0x01);		 // Starte Lesezugriff
    db=i2c_readNak();				 // Schreib Leseergebnis in d
    i2c_stop();
  }
   
int main(void)
  {
    i2c_init();                    		// Starte I2C Buss
    DDRC=0x20;        				// Anzeige LED am Prozessor
    abfrage_Bus(adr1_w);          		// Bus Adresse vorhanden
    abfrage_Bus(adr2_w);          		// Bus Adresse vorhanden
    PCA9536_Write(adr1_w, config_Reg, 0x08);    // PCA9536 auf OUTPUT MODUS umstellen
    while(1)
      {            				// Hauptschleife		
        PCF8574_Read(adr2_w, adr2_r);	        // Lesezugriff P11
        PCA9536_Read(adr1_w);			// Lesezugriff Abfrage WTMA
        if(~db & 0x08)				// Auswertung Lesezugriff
          {
             i2c_start(adr2_w);			// weckt Busteilnehmer auf
	 i2c_write(0x70);			// Index auf OUTPUT Data
	 i2c_stop();				// Stopt Bus
          }
        else
          {
	    i2c_start(adr2_w);			// weckt Busteilnehmer aus
	    i2c_write(0xf0);			// Index auf OUTPUT Data
	    i2c_stop();				// Stop Bus
          }
		
        var = 0;				// Abfrage Taste
        for(mask=0x01; mask < 0x07; mask<<=1)  
          {
            if (da & mask)
	  {              			// Taste prafen
	    var |=mask;        			// und kopieren
	  }
        }
			
        if (~da & 0x08)				// Taste 4
          {
            i2c_start(adr2_w);			// weckt Busteilnehmer auf
	    i2c_write(0xe0);			// Index auf OUTPUT Data stelen
	    i2c_stop();				// Stopt Bus
          }
        else
          {
	    i2c_start(adr2_w);			// weckt Busteilnehmer auf
	    i2c_write(0xf0);			// Index auf OUTPUT Data stellen
	    i2c_stop();				// Stopt Bus
          }
        PCA9536_Write(adr1_w, output_Reg, var);   // Aufruf Unterprogrann	
      }
  }

Ansicht der Platine

Fotow3.jpeg

PDF Dateien

Temperatur

Temperatur messen

PA191975 1.jpeg

Zur Temperaturmessung benutze ich den LM 75 (Achtung SMD). Den LM75 habe ich dazu auf eine kleine Platine extra aufgebaut. Dadurch kann ich den Anschluss verlängern.

Die Platinen

Platine 54 a 1.jpeg Platine 54 b 1.jpeg

Den Widestand und die LED über dem LM75 habe ich nicht eingebaut. Diese verurschen eine kleine Diffrenz in der Anzeige (Eigenwärme)

Die Schaltung

Bild Schaltung Temp1.jpeg

Bauteile

  • R1, R2 – Widerstand 220 Ohm
  • R3, R4 – Widerstand 10 kOhm
  • 2 x Wannenstecker 2 x 5 RM 2,54
  • Platine (Grund) ca. 72 x 31 mm
  • Platine (Fühler) ca. 23 x 27 mm
  • C1, C3 – Kondensator 100nF
  • C2 – Elko 100/16
  • L1, L2 – LED 3 mm grün 20 mA
  • IC1 – LM 75 – 5 (5V) SMD ! ! !
  • 3 x Stecker 3 polig
  • 1 x Stecker 2 polig
  • 4 x Jumper

Belegung Stecker

Die Belegung der Stecker entspricht Board 1. Die Belegung der Messplatine habe ich auf der Platine eingezeichnet.

Software

#include <stdbool.h>
#include <avr/pgmspace.h>
#include "main.h"
#include <util/delay.h>
#include "i2clcd.h"
#include "i2cmaster.h"
#include "avr/io.h"
#include "util/delay.h"
#include "avr/interrupt.h"

#define lm75_r 0x91     			// Leseadresse des LM75

uint8_t msb_temp;        			// Oberes Temperatur-Byte
uint8_t lsb_temp;        			// Unteres Temperatur-Byte
uint16_t temp_wrd;       			// Ganzes Temperatur-Wort
uint8_t ret;             			// Kontrollvariable für I2C Kommunik.
uint8_t x;               			// X-Position der Kommastelle
signed char temperatur;  		        // Variable m. Vorzeichen für die Temp.berechnung
char Buffer[20];         			// Umwandlungs-Variable für LCD Anzeige

void temperfassung(void) 			// Unterprogramm Temperaturerfassung
  {
    ret = i2c_start(lm75_r);      		// Start Lesen des LM75
    if (ret == 0)
      {               				// Wenn LM75 ein OK sendet...
        msb_temp = i2c_readAck();		//...speichere oberes Bit
        lsb_temp = i2c_readNak();		//...speichere unteres Bit
      }
    else                                	// Fehlererkennung
      {                        			// Wenn LM75 kein OK sendet
        lcd_command(LCD_CLEAR);		        // Leere Display
        lcd_printlc(1,13,"READ");		// "Lesevorgang"
        lcd_printlc(2,13,"NOK");		// "Nicht OK (NOK)"
      }
  }

int main(void)					// Start Hauptprogramm
  {
    cli();                     			// Interrupts deaktiviert
    i2c_init();                			// Starte I2C Bus
    lcd_init();                			// Starte I2CLCD
	
    // Display Befehle – Display ein, Cursor aus, Blinken aus
    lcd_command(LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKINGOFF);
    lcd_command(LCD_CLEAR);        	        // Leere Display
    _delay_ms(2);		      		// Warte 2ms    
    lcd_printlc(1,6,"Boxtec"); 		        // Zeile 1
    lcd_printlc(2,2,"Display Modul 1");	        // Zeile 2
    lcd_printlc(3,2,"und Temp-Modul");	        // Zeile 3
    lcd_printlc(4,2,"(achim S.+TG)");	        // Zeile 4
	
    _delay_ms(5000);		       		// Warte 5000ms
    lcd_command(LCD_CLEAR);    		        // Lösche Display
    _delay_ms(2);		      		// Warte 2ms
	
    while(1)					// Start while Schleife
      {
        temperfassung();                        // Unterprg Temp.auslesung
        temp_wrd = (msb_temp << 8 | lsb_temp);  // Zusammensetzung von o. & u. Byte
        temperatur = msb_temp;                  // Umwandlung in ein Signed Char
		
        // Nachkommastelle erkennen
        if      (temperatur <= -100) {x = 5;} 	// X-Pos. bei <= -100°C)	
        else if (temperatur <= -10)  {x = 4;} 	// X-Pos. bei <=  -10°C)
        else if (temperatur <= 9)    {x = 3;} 	// X-Pos. bei <=    9°C)
        else if (temperatur <= 99)   {x = 4;} 	// X-Pos. bei <=   99°C)
        else                         {x = 5;} 	// X-Pos. bei  >   99°C
        
        if (temp_wrd & (1<<7)) 
          {             			// Nachkommastelle erkennen
            lcd_printlc(3,x,",5");              // ,5 an Pos x schreiben
          }
        else 
          {
            lcd_printlc(3,x,",0");             	// ,0 an Pos x schreiben
          }
        if (temp_wrd & (1<<15)) 
          {            				// Wenn Minus-Grade angezeigt werden
            if (temp_wrd & (1<<7)) 
              {           			// Nachkommastelle erkennen
                temperatur = temperatur +1;
              }
            itoa(temperatur,Buffer, 10 );      	// Variable umwandeln...
            lcd_printlc(3,1,Buffer);		// ...und anzeigen
          }
        else 
          {
            lcd_printlc(3,1,"+");		// Ausgabe „ + „
            itoa(temperatur, Buffer, 10 );
            lcd_printlc(3,2,Buffer);
          }
        lcd_printlc(1,1,"Temperatur ist:"); 	// Ausgabe Text
        _delay_ms(100);			        // Pause
    }
  }

Die Software müsst ihr anpassen. Ich verwende die Dateien von Peter. Die Übertragung der Daten erfolgt mit dem I2C Bus und wird auf dem Display angezeigt. Bitte die Adressen der Hardware anpassen. Danke an Timo für seine Arbeit.

Temperatur schalten

Temp 21.jpeg

Ansicht der Platine Temp mit dem LM75 (Rückseite) und den beiden Versionen mit Relais und Transistor. Beide Ausgänge sind potentialfrei.

Die Platine

Temp 24.jpeg

Ansicht der Platine Die Platine ist für beide Versionen gleich. Die Bestückung ist unterschiedlich, entweder Relais oder Transistor

Die Schaltung

Temp 25.jpeg

Bauteile

(beide Optionen)

  • 2 x Wannenstecker 2 x 5 RM 2,54
  • Platine (Grund) ca. 72 x 31 mm
  • 4 x Jumper
  • Platine (Fühler) ca. 23 x 27 mm
  • R1, R2, R8 – Widerstand 220 Ohm
  • R3, R4, R7 – Widerstand 10 kOhm
  • R5 – 4,7 kOhm
  • R6 – 47 kOhm
  • Tr 1 – BC556 (Si-PNP)
  • Tr 2 – BD135 (Si NPN)
  • Rs 1 – SIL7271-D 5V ( Reedrelais mit Diode, 1 Schliesser, 5V )
  • C2 – Elko 100/16
  • C1, C3 – Kondensator 100nF
  • L1, L2, L3 – LED 3 mm grün 20 mA
  • IC1 – LM 75 – 5 (5V) SMD ! ! !
  • 3 x Stecker 3 polig
  • 1 x Stecker 2 polig
  • 1 x Stecker gew. 8 polig RM 2,54
  • C4 – 27pF (falls erforderlich)
  • 1 x Buchse 8 polig RM 2,54
  • 1 x Klemme 2 polig RM 5

Belegung Stecker

Die Belegung der Stecker entspricht Board 1

Software

/* ATB_B1_Temp3.c Created: 25.10.2014 19:44:17 Author: AS + FB*/ 
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include "main.h"
#include "i2clcd.h"
#include "i2cmaster.h"
#include "lm75.h"
#include <util/delay.h>

void startanzeige()						// Titelbild
  {
    lcd_command(LCD_CLEAR);
    _delay_ms(2);
    lcd_printlc(1,4,"Boxtec");
    lcd_printlc(2,2,"Display Modul 2");
    lcd_printlc(3,2,"und Temp-Modul");
    lcd_printlc(4,2,"(achim S.+FB)");
    _delay_ms(5000);
  }
int main(void)
  {
    char Buffer[20];
    int16_t temperatur, nachkomma;

    i2c_init();
    lcd_init();
	
    // Display Befehle
    lcd_command(LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKINGOFF);
    lcd_light(0);						// Licht an
	
    startanzeige();						// Unterprg startanzeige
    lcd_command(LCD_CLEAR);
    _delay_ms(2);

    lcd_printlc(1,1,"Temperatur");
	
    // Angabe der Schaltpunkte
    lm75_set_T_low(24*2 +1);				// 26°C
    lm75_set_T_high(26*2);				// 24,5°C
    while(1)
      {
        if (lm75_read_T(&temperatur) != 0) 
          {							// Fehlererkennung
            lcd_command(LCD_CLEAR);
	    _delay_ms(2);
	    lcd_printlc(2,6,"LM 75");
	    lcd_printlc(3,5,"Nicht OK");
	    _delay_ms(2000);
          }
	
        // Nachkommastellen bestimmen
        if (temperatur & 1) nachkomma=5; else nachkomma=0;
        temperatur >>=1;        					// auf ganze °C umrechnen

        // Anzeige
        sprintf_P(Buffer, PSTR("%+4d,%d"), temperatur, nachkomma);
        lcd_printlc(3,1,Buffer);
        _delay_ms(100);
      }
  }

Es müssen zusätzliche Dateien eingebunden und angepasst werden. Mein besonderer Dank für die Hilfe geht an Falk.

Ansichten

Temp 22.jpeg Temp 23.jpeg

Der HT 16 K 33

Der HT16K33 ist ein universeller IC zur Ansteuerung von LED Matrix Anzeigen und Siebensegmentanzeigen. Es können auch unterschiedliche LED Matrix angeschlossen werden. Nach Datenblatt z.B. 7x8, 8x8, 11x8, 12x8, 15x8, 16x8 und zusätzlich können auch Taster abgefragt werden.

Anzeige 1 mit dem HT16k33

Der HT16K33 auf der Platine

Anz 1 B1.jpeg

Mit dem HT16K33 kann ich mit dem I2C-Bus bis zu 8 Module zusammenschalten. Das ergibt bis zu 1024 LED die ich einzeln ansteuern kann.

Die Schaltung

Anz 1 B4.jpeg

Die Platine

Anz 1a FD.jpeg

Bauteile

  • L1 – LED, 20 mA, 3 oder 5 mm
  • R1 – Widerstand 220 Ohm
  • C1 – C3 - Kondensator 100 nF
  • C4 – Elko 100/16
  • 2 x Wannenstecker 2x5 RM 2,54
  • 1 x Breakout Modul mit HT16K33 mit 28 Pins
  • 2 x LED Matrix TA-11 SRWA (gemeinsame Kathode)
  • 1 x Platine P87 72x87 mm

Die LED brauchen keine Vorwiderstände

Belegung Stecker

Die Belegung der Stecker entspricht dem Board 1

Mögliche Adressen im Bus

Mit den Lötbrücken A0, A1 und A2 auf dem HT16K33 Modul sind diese Adressen möglich:

0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77

Die Auswahl erfolgt dabei durch dies Kombination: zum Beispiel:

  • 0x70 + A2 + A1 + A0 = 0x70 + 4 + 2 + 1 = 0x77
  • 0x70 + A2 + A0 = 0x70 + 4 + 1 = 0x75
  • 0x70 + A1 = 0x70 + 2 = 0x72

Diese Adressen sind nur für den HT16K33 mit 28 Pins gültig. Bei anderen Bauarten gelten andere Adressen.

Software

/* ATB_Anz1_Prg_1.c   Created: 29.04.2015 19:48:15 Author: AS */ 
#define F_CPU 16000000				// CPU clock in Hz
#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include "HT16K33.h"
#include "i2cmaster.h"      	
#include "util/delay.h"
int main (void)
  {
    i2c_init();
    HT16K33_modul1_addr = 0x70; 		// Address 0x70 ..0x77)
    HT16K33_Init();
    while(1)
      {		                                // 0 - linke Matrix, 1 - rechte Matrix
        HT16K33_WriteBild1(0);			// schreibt Bild1 auf Matrix 0
        _delay_ms(2000);			// Pause	
        HT16K33_ClearDisplay(0);		// löscht Matrix 0
        _delay_ms(2000);			// Pause
        HT16K33_WriteBild1Zeit(1);		// Schreibt Bild1 mit Zeit auf Matrix 1
        _delay_ms(2000);			// Pause
        HT16K33_ClearDisplay(1);		// löscht Matrix 1
        _delay_ms(2000);			// Pause
        HT16K33_WriteBild2(0);		        // schreibt Bild2 auf Matrix 0
        _delay_ms(2000);			// Pause
        HT16K33_WriteBild2(1);			// schreibt Bild1 auf Matrix 1
        _delay_ms(2000);			// Pause
        HT16K33_ClearDisplay(1);		// löscht Matrix 1
        _delay_ms(2000);			// Pause
        HT16K33_FillDisplay(0);			// füllt Matrix 0 einheitlich
        _delay_ms(2000);			// Pause
        HT16K33_FillDisplay(1);			// füllt Matrix 1 einheitlich
        _delay_ms(2000);			// Pause		
        HT16K33_WriteDisplay(0);		// Angabe schreiben mit adresse
        _delay_ms(2000);  			// Pause
        HT16K33_ClearDisplay(0);		// löscht Matrix 0-links, 1-rechts
        _delay_ms(2000);   			// Pause
        HT16K33_WriteDisplay(1);		// Angabe schreiben mit adresse
        _delay_ms(2000);			// Pause
        HT16K33_FillDisplay(0); 			// füllt Matrix 0 einheitlich
        _delay_ms(2000);   			// Pause
        HT16K33_FillDisplay(1); 			// füllt Matrix 1 einheitlich
        _delay_ms(2000);   			// Pause
        HT16K33_ClearDisplay(0);		// löscht Matrix 0
        HT16K33_ClearDisplay(1);		// löscht Matrix 1
        _delay_ms(2000);			// Pause	
      }
    return 0;
  }

Zum Betrieb sind noch andere Dateien notwendig.

Ansicht

Anz 1 B2.jpeg Anz 1 B3.jpeg

Anordnung der LED

Anz 1 B5.jpeg Anz 1 B6.jpeg

PDF-Datein

Anzeige 2 mit dem HT16K33

Der HT16K33 auf der Platine

Von anderen Herstellern wird der HT16K33 auf eine Platine zusammen mit einer LED Matrix vormontiert geliefert. Fertig zusammenlöten und man hat ein kleines Board zur Anzeige. Auf Grund der Bauart sind andere Ansteuerung zu beachten.

Die Schaltung

nnnnnnnn

Die Platine

nnnn

Bauteile

  • L1 – LED, 20 mA, 3 oder 5 mm
  • R1 – Widerstand 220 Ohm
  • C1 - Kondensator 100 nF
  • C2 – Elko 100/16
  • 2 x Wannenstecker 2x5 RM 2,54
  • 3 x Breakout Module mit HT16K33 mit je 24 Pins
  • 3 x LED Matrix 8x8 (gemeinsame Katode)
  • 1 x Platine P82 (72x64 mm)

Belegung Stecker

Die Belegung der Stecker entspricht Board 1

Mögliche Adressen in Bus

Mögliche Adressen im Bereich von

0x70, 0x71, 0x72, 0x73

Software

Ansicht

jjjjj

PDF-Datein

Anzeige 3 mit dem HT16K33

nnnnn

Der HT16K33 auf der Platine

nnnn

Die Schaltung

jgjg

Die Platine

bbbbbb

Bauteile

jghjhgj

Belegung der Stecker

Die Belegung der Stecker entspricht Board 1

Mögliche Adressen im Bus

kkj

Software

gjhgjhg

Ansichten

jgjgjgj

PDF-Datein

Extender

Mit diesen beiden Boards ist eine Übertragung des I2C Busses auf ca. 5-10 m möglich. Dazu muss der Bus umgesetzt werden werden. Dabei ist eine Platine der Sender und die andere Platine der Empfänger. Auf dem jeweiligen Board müssen jeweils 2 Jumper gesetzt werden. Der Sender ist das Board, was sich in Richtung Master befindet. Es wurden Entfernungen bis ca. 8 m getestet. Auf Grund der Leitungslänge und des Widerstandes bitte unbedingt die Betriebsspannung überprüfen.

Extender 1.jpeg

Ansicht der Platine. Es sind zur Funktion immer 2 Platinen erforderlich.

Die Platine

Extender 2.jpeg

Ansicht der Platine mit Bestückungsdruck

Die Schaltung

Extender 4.jpeg

Bauteile

  • C1, C3 - 100 nF
  • C2 - Elko 100/16
  • L1 LED - 5mm, 20 mA
  • R1, R2 - 4,7 kOhm
  • R3, R4 - 750 Ohm
  • IC1 - P 82 B 715
  • 1 x Sockel 8 polig
  • 4 x Stiftleisten 2 polig
  • Platine P9N 72mm x 41,5 mm
  • 2 x Jumper
  • 4 x (2x2) Klemmleiste RM 5mm
  • 2 x Wannenstecker 10 polig (2x5)

Belegung Stecker

Die Belegung der Busstecker entspricht Board 1

Software

Eine Software ist für diese Platine nicht nötig.

Bilder

Extender 3.jpeg

2 Extender Platinen mit ca 5m Kabel

Out 1

Out 11.jpeg Out 12.jpeg

Beim testen von Software oder Hardware habe ich immer ein Problem. Welchen Ausgang habe ich programmiert? Habe ich was verwechselt? Ist mein Verbindungskabel in Ordnung? Vielleicht ein Kurzschluss? Für solche Probleme habe ich mit diese kleine Platine gebaut. Damit kann ich ohne Probleme die korrekte Belegung testen, feststellen ob GND (Masse oder Vcc (+5V) korrekt anliegt.

Die Platine

Out 14.jpeg

Ansicht der Platine mit Bestückungsdruck

Die Schaltung

Out 13.jpeg

Ansicht der Schaltung. Bitte genau die Richtung der Widerstände beachten

Bauteile

  • L1–L9 - LED, 3 mm, 20 mA
  • 1 x Platine ca. 43 x 25 mm
  • R1 - Widerstand 220 Ohm
  • 2 x Wannenstecker 2x5
  • RN 1 - Netzwerkwiderstand, 8-fach, 220 Ohm (Einbaurichtung beachten)
  • R1 - Widerstand 180 Ohm
  • C1 - Kondensator 100 nF
  • C2 - Elko 100/16

Belegung Stecker

Die Belegung entspricht dem RN-Standard

Mögliche Fehler

Mögliche Fehler beim Test von Kabeln oder Ports mit der Platine

  • Keine Anzeige der Betriebsspannung mit der LED L9
  • Es leuchtet keine der LED 1 – 8
  • Es leuchten mehrere LED gleichzeitig
  • Einzelne LED leuchten nicht

Mögliche Ursachen

Sehen wir uns einmal die Belegung des 10 polg. Steckers an. Am Pin 9 liegt Masse (GND) an. Am Pin 10 liegt +5V (Vcc). Fehlt eine dieser Verbindungen, erfolgt keine Anzeige der Betriebsspannung. Die LED liegen über das RN (Widerstandnetzwerk) an +5V. Über die Pins 1 – 8 werden die einzelnen LED`s im Prozessor auf Masse gelegt. Leuchten einzelne PIN-LED auf und die L9 (Betriebsspannung) nicht, so könnte die Masse (GND) fehlen. Leuchten einzelne LED nicht, so könnte eine Unterbrechung an den Pins oder im Kabel vorliegen. Leuchten 2 oder mehr LED gleichzeitig könnte ein Kurzschluss zwischen einzelnen Pins oder am Kabel vorliegen. Bei einem verdrehen des ganzen Kabels (rote Ader auf der falschen Seite) besteht grosse Gefahr für den Prozessor. Da Masse an einem falschen Pin anliegt, könnte der Prozessor zerstört werden. Die im Programm eingestellte Zeit beträgt ca. 500 ms, das sind 0,5 Sekunden. Diese Zeit kann man einfach mitzählen. Wenn die LED deutlich schneller oder langsamer laufen, muss man die eingestellte Frequenz des Quarzes im Programm überprüfen. Wenn diese stimmt, (16MHz – 16 000 000) dann gibt es noch die Möglichkeit, dass der Prozessor noch auf dem internen Takt steht (Auslieferungszustand). Dieser könnte dann 1 MHz sein.

Software

/* ATB_B2_Prg_3.c Created: 02.09.2014 21:08:29 Author: AS */
// Lauflicht auf Port B
# define F_CPU 16000000UL	        // Angabe der Quarzfrequenz, wichtig für die Zeit
# include <avr/io.h>			// Ausgänge
# include <util/delay.h>		// Zusätzlich Datei für Pause
int main (void)			        // Hauptprogramm
  {
    DDRB = 0b11111111;		        // Konfiguration des Ausganges – DDR C 1=ein 0=aus
    while (1)				// Endlosschleife	
      {					// Beginn Programm
	PORTB = 0b11111110;		// PD 0 / nur LED 1 an, andere aus
	_delay_ms (150);		// Pause 1500 ms, 1=aus, 0=ein
		
	PORTB = 0b11111101;		// PD 1 / nur LED 2 an, andere aus
	_delay_ms (150);		// Pause 1500 ms
		
	PORTB = 0b11111011;		// PD 2 / nur LED 3 an, andere aus
	_delay_ms (150);		// Pause 1500 ms
		
	PORTB = 0b11110111;		// PD 3 / nur LED 4 an, andere aus
	_delay_ms (150);		// Pause 1500 ms
		
	PORTB = 0b11101111;		// PD 4 / nur LED 5 an, andere aus
	_delay_ms (150);		// Pause 1500 ms
		
	PORTB = 0b11011111;		// PD 5 / nur LED 6 an, andere aus
	_delay_ms (150);		// Pause 1500 ms
		
	PORTB = 0b10111111;		// PD 6 / nur LED 7 an, andere aus
	_delay_ms (100);		// Pause 1500 ms
		
	PORTB = 0b01111111;		// PD 7 / nur LED 8 an, andere aus
	_delay_ms (150);		// Pause 1500 ms
		
	PORTB = 0b11111111;		// PD 2 alle LED aus
	_delay_ms (50);		        // Pause 500 ms
      }
  }

Bitte achtet drauf, es ist für den Port B am ATi 2313 geschrieben. Die Angabe der Ports/Pins habe ich absichtlich so geschrieben. Dadurch ist der verwendete Pin sofort zu erkennen.

I2C Bus Isolator

Bei der Anwendung von höheren Spannungen besteht immer Gefahr für Leib und Leben. Durch die Einhaltung bestehender Schutzvorschriften ist eine Sicherheit möglich. Leider kann durch einen Kurzschluss zwischen unserer Technik und einer anderen Spannung unsere gesamte Technik zerstört werden. Im Netz habe ich einen "Isolator" gefunden. Dieser trennt unsere Elektronik komplett vom Netz und soll eine Spannungsfestigkeit > 1000V haben. Dabei werden die Bus-Leitungen, Spannungen und Bezugspotential vollständig getrennt.

Isolator 2.jpeg

Die Platine

Isolator 1a.jpeg

Ansicht der Platine

Die Schaltung

Schaltung Isolator.jpeg

Die Schaltung nach DL1DOW mit Erweiterungen

Bauteile

  • IC 1 – ADUM 1250
  • IC 2 – LTV 816
  • DC 1 – DC-DC Wandler 5V
  • DC 2 – DC-DC Wandler 12V
  • L1 – L4 - LED 3mm 20mA
  • R1 – R4 – 4,7 KOhm
  • R5 – 220 Ohm
  • R6 – 10 kOhm
  • R8, R9 – 220 Ohm
  • R7, R10 – 470 Ohm
  • C2, C3, C4, C6, C7, C8 – 100nF
  • C1, C5, C9, C10 – Elko 100/16
  • 2 x Wannenstecker 2x5 RM 2,54
  • 1 x Platine P23 72x42 mm
  • Stecker 2 polig mit Jumper

Belegung Stecker

Die Belegung der Stecker entspricht Board 1

Software

Eine Software ist nicht notwendig

Ansichten

Isolator 3.jpeg

Sicherheitshinweis

Die Benutzung erfolgt auf eigenes Risiko. Der Sicherheitsabstand zwischen den Leiterzügen entspricht nicht den VDE-Vorschriften. Die Sicherheitsvorschriften sind zu beachten.

Encoder / Drehgeber

Drehkodierer (Rotary Encoders) sind ähnlich im Einsatz wie Potentiometer, im Unterschied zu Potentiometern aber arbeiten die Encoder mit voller Drehung und ohne Beschränkung. Die Ausgabe erfolgt jedoch in Gray Codes welche Ausschluss über das Ausmass und die Richtung der Drehung geben können. Dieser Encoder ist speziell cool wegen der integrierten RGB LED (gemeinsame Anode). Ebenso verfügt der Encoder über einen Druckschalter. Zur Eingabe von Daten oder Bedienung sind Encoder sehr gut geeignet.

Encoder 1.jpeg

Die Platine

P 98 F.jpeg

Ansicht der Platine

Die Schaltung

Schaltung Encoder.jpeg

Die Schaltung Encoder

Bauteile

  • L1 – L3 - LED, 3 oder 5mm, 20 mA
  • 1 x Platine ca. 72 x 42 mm (P98)
  • R1 – R3 - Widerstand 220 Ohm
  • R4 – R7 - Widerstand 10 kOhm
  • R8 - Widerstand 10 kOhm
  • R9 - Widerstand 220 Ohm
  • R10 - Widerstand 180 Ohm (Rot)
  • R11 - Widerstand 100 Ohm (Grün)
  • R12 - Widerstand 100 Ohm (Blau)
  • 3 x Wannenstecker 2x5 (Port, I2C)
  • C1, C2 – Kondensator 100 nF
  • C3, C4 - Kondensator 10 nF
  • C5, C6 - Elko 100/16
  • Encoder mit LED RGB
  • Halterung - 2 teilig

Die genaue Typ-Angabe des Encoders ist mir nicht bekannt. Es können verschidene Typen verwendet werden. Die Umschaltung erfolgt durch die Software.

Belegung Portstecker

Schaltung Encoder 2.jpeg

Belegung des Port Steckers

Software

#define F_CPU 16000000			// CPU clock in Hz
#include "avr/io.h"
#include <avr/interrupt.h>

int8_t dreh = 8;			// Angabe der max Stellungen
int8_t val = 0;				// Startwert der Drehung

#define PHASE_A     (PINA & 1<<PA0)	// Eingang Encoder A  P98
#define PHASE_B     (PINA & 1<<PA1)	// Eingang Encoder B  P98	

volatile int8_t enc_delta;		// -128 ... 127
static int8_t last;

void encode_init( void )
  {
    int8_t new;
    new = 0;
    if( PHASE_A ) new = 3;	
    if( PHASE_B ) new ^= 1;		// convert gray to binary
    last = new;				// power on state
    enc_delta = 0;
  }

ISR( TIMER0_COMPA_vect )		// 1ms for manual movement
  {
    int8_t new, diff;
    new = 0;
    if( PHASE_A ) new = 3;
    if( PHASE_B ) new ^= 1;			// convert gray to binary
    diff = last - new;				// difference last - new
    if( diff & 1 ) 
      {						// bit 0 = value (1)
        last = new;				// store new as next last
        enc_delta += (diff & 2) - 1;		// bit 1 = direction (+/-)
      }
  }
int8_t encode_read1( void )			// einzel Schritt Encoder
  {
    int8_t val;
    cli();
    val = enc_delta;
    enc_delta = 0;
    sei();
    return val;                   
  }
int8_t encode_read2( void )			// zwei Schritt Encoder
  {
    int8_t val;
    cli();			                                                 
    val = enc_delta;
    enc_delta = val & 1;
    sei();
    return val >> 1;
  }
int8_t encode_read4( void )	                // vier Schritt Encoder
  {
    int8_t val;
    cli();
    val = enc_delta;
    enc_delta = val & 3;
    sei();
    return val >> 2;
  }
void timer_init()				// Timer 1ms
  {
    TCCR0A = (1<<WGM01);
    TCCR0B = (1<<CS01)|(1<<CS00);
    OCR0A = 249;
    TIMSK0 |=(1<<OCIE0A);
  } 
int main( void )		                // Hauptschleife
  {
    timer_init();  
    DDRA |= 0b11111100 ;			// LED auf Ausgang
    PORTA = 0b01111100;			        // LED auf aus bei 1
    encode_init();
    sei();
    while(1)
      {
        val += encode_read4();	                // Auswahl 1,2 oder 4 Schritt Encoder
        if (val>dreh)				// Begrenzung oben
          {
            val=0;
          }   
        if (val<0)		                // Begrenzung unten
          {
	    val=dreh;
          }			                // Beginn Auswertung
        if (val==1)			        // LED blau
          {
	    PORTA &= ~(1<<PA4);			// LED Blau ein
          }
        else
          {
	    PORTA |= (1<<PA4);			// LED Blau aus
          }	
        if (val==2)		                // LED grün
          {
	    PORTA &= ~(1<<PA3);                 // LED grün ein
          }
        else
          {
	    PORTA |= (1<<PA3);	                // LED grün aus
          }
        if (val==3)		                // LED rot
          {
	    PORTA &= ~(1<<PA2);	                // LED rot ein
          }
        else
          {
	    PORTA |= (1<<PA2);			// LED rot aus
          }
        if (val==5)
          {
	    PORTA &= ~(1<<PA3);			// LED grün ein
	    PORTA &= ~(1<<PA4);			// LED blau ein
          }
            if (val==6)
          {
	    PORTA &= ~(1<<PA2);			// LED rot ein
	    PORTA &= ~(1<<PA4);			// LED blau ein
          }
	    if (val==7)
          {
	    PORTA &= ~(1<<PA2);			// LED rot ein
	    PORTA &= ~(1<<PA3);			// LED grün ein
          }
            if (val==8)
          {
	    PORTA &= ~(1<<PA2);			// LED rot ein
	    PORTA &= ~(1<<PA3);			// LED grün ein
	    PORTA &= ~(1<<PA4);			// LED blau ein	
          }	
        }
      }

Multitasking

( Einfaches Multitasking )

  • Was ist eigentlich Multitasking?
  • Geht es mit meinen Prozessor?
  • Welche Programme brauche ich dazu?
  • Wie kann ich es einfach gestalten?
  • Gibt es Beispiele / Programme dazu?

Fragen über Fragen zum Thema. Dabei ist es relativ leicht zu machen. Ist einfach erstaunlich, was man damit machen kann.

Ein paar Beispile:

  • mehrere LED gleichzeitig mit verschiedenen Zeiten laufen lasen
  • fast gleichzeitig mehrere Taster abfragen und LED schalten
  • Tasterentprellung nach Peter
  • Taster - kurz/lang auswerten
  • Einknopfbedienung (mit einem Taster ein und aus)
  • Statemaschine
  • unabhängige Laufschrift
  • Menuesteuerung

Am besten mal ansehen:

Infos und Platinen

Wer mehr Infos, komplette Tuts oder Platinen haben möchte, kann mich direkt kontaktieren

myroboter@web.de

oder bei

http://www.platinencenter.de

nachsehen.

Geplante Themen:

I2C Bus Module :

  • Relais 4 fach
  • Relais 8 fach
  • Leistungsrelais
  • Storenrelais
  • Triax
  • Eingänge
  • Ausgänge
  • Ein- und Ausgänge 8 fach und 16 fach
  • Fernbedienung
  • IR-Melder
  • Servo
  • Verlängerung 10 m - Erledigt
  • Verlängerung 100 m
  • Anzeige
  • LED Ansteurung
  • Radio
  • Funkstrecke
  • Lauflicht
  • verschiedene Netzteile
  • Isolator - Erledigt
  • Uhr
  • LM75 - Erledigt
  • Drehgeber - Erledigt

... und mehr