Modulares Board
Modulares Board mit dem ATmega 1284p und ATtiny 2313
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
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
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
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.
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
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
Die Platine des Boards 2 mit dem ATtiny 2313
Die Schaltung
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.
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.
Die Platine
Die Platine hat eine Größe von 72x87 mm, einseitig mit Bestückungsdruck
Die Schaltung
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
Die Platine
Die Schaltung
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
I2C-Bus In / Out Board 1
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
Die Platine 72x54 mm
Die Schaltung
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)
#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
Die Platine
Die Platine in der Größe 72x42 mm
Die Schaltung
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
Ansicht Modul mit 16 x LED. Der IC befindet sich auf der Unterseite und wurde direkt auf die Leiterzüge gelötet
Die Platine
Ansicht der Platine mit Bestückungsdruck
Die Schaltung
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
Ansicht des Graphik Moduls
Die Platine
Ansicht des Graphik Moduls
Die Schaltung
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
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)
Schaltuhr WTMA mit I2C Platine
Die Platine
Ansicht der Platine
Die Schaltung
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
PDF Dateien
Temperatur
Temperatur messen
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
Den Widestand und die LED über dem LM75 habe ich nicht eingebaut. Diese verurschen eine kleine Diffrenz in der Anzeige (Eigenwärme)
Die Schaltung
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
Ansicht der Platine Temp mit dem LM75 (Rückseite) und den beiden Versionen mit Relais und Transistor. Beide Ausgänge sind potentialfrei.
Die Platine
Ansicht der Platine Die Platine ist für beide Versionen gleich. Die Bestückung ist unterschiedlich, entweder Relais oder Transistor
Die Schaltung
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
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
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
Die Platine
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
Anordnung der LED
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
- Forumsbeitrag: Hinweise zur 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.
Ansicht der Platine. Es sind zur Funktion immer 2 Platinen erforderlich.
Die Platine
Ansicht der Platine mit Bestückungsdruck
Die Schaltung
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
2 Extender Platinen mit ca 5m Kabel
Out 1
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
Ansicht der Platine mit Bestückungsdruck
Die Schaltung
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.
Die Platine
Ansicht der Platine
Die Schaltung
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
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.
Die Platine
Ansicht der Platine
Die Schaltung
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
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:
- Multitasking Teil 1 (PDF)
- Multitasking Teil 2 (PDF)
- Multitasking Teil 3 (PDF)
- Multitasking Teil 4 (PDF)
- Multitasking Teil 5 (PDF)
Infos und Platinen
Wer mehr Infos, komplette Tuts oder Platinen haben möchte, kann mich direkt kontaktieren
myroboter@web.de
oder bei
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