7.1Verstärker mit 16X4LCD

[Meister Joda]

Hi liebe Community,

ich bin ein DIYler... aus dem euch vll. bekannten Forum, der DIY-Community

ich habe eine Ausbildung zum Mechatroniker genossen, aber leider wurden solche sachen wie PICs und Atmels nicht in meinem Lehrplan aufgenommen


Ich bin gerade dabei, einen 7.1Verstärker aus AB Stufen zusammen zu bauen. Soweit bekomme ich alles hin, ist nicht mein erster Verstärker. Habe mir aber für diesmal mehr vorgenommen:

Ich will mittels LM358 und 8Optokopplern die Pegel der Kanäle an einem 16x4 LCD ausgeben.

Über 8x KA2250 und 7Einstelltaster sollen folgende Einstellmöglichkeiten bestehen:
-Über ON/OFF soll der Haupttrafo ein- ausgeschaltet werden und ein Text wie "Wilkommen" angezeigt werden
-anschließend springen 4Relais an, welche das Einschaltknacken verhindern, jeweils mit 2Wechslern
-über 2Taster soll die Gesamtlautstärke verstellbar sein,was wieder am LCD zu sehen sein soll
-einzelne Kanäle jeweils 2dB stufenweise + oder - zum anpassen an den Raum, mit Anzeige des Kanals und der eingestellten Korrektur auf dem LCD
-Über eine Mute-Taste sollen die Relais wieder abfallen / anziehen

an Ein- Ausgängen brauche ich daher:
-7 für LCD Display
-8 für Optokoppler
-3 für alle 7Taster da 3Bit-Code (Volume +/-, Menu Up/Down, Enter, Mute, On/Off)
-1 für die Relais
-zusätzlich noch Ausgänge zum steuern der 8x KA2250

da ich bisher nicht mit PICs und Atmels zu tun hatte, gestaltet sich dieses Projekt etwas schwierig, aber ich gebe mich nicht so schnell auf... zu den Elektroniksachen fällt mir ne Menge ein, nur mit den PICs und Atmels hab ichs noch nicht so, desshalb hab ich auchschon auf "sprut" ne Menge gestöbert, bringt mich jetzt aber nicht wirklich praktisch weiter...

Für alle, die es interessiert ist hier der Link zu meinem Projekt,hab leider noch keine Homepage, kommt aber noch... Link (http://diy-community.de/showthread.php?t=20249)

Im grunde will ich wissen, was ich nehmen soll, Atmel oder PIC, wobei ich schon einen kleinen PIC Programmer von velleman besitze...

ich benötige ja eine Menge Ein/Ausgänge... außerdem benötige ich, naja, ich sag mal "Starthilfe"
=P~

Schöne Grüße, Florian 8-[

[PICture]

Hallo Meister Joda!

Als Starthilfe bei den PIC µC kann ich dir außer unserem "PIC Mikrocontroller" Forum folgendes empfehlen:

https://www.roboternetz.de/wissen/index.php/PIC_Assembler

Hoffentlich ist es für dich verständlicher als Sprut.:)

MfG

[Meister Joda]

ich kann mich ja mal einlesen...

aber ich weiss immernoch nicht ob PIC oder Atmel, was ist einfacher, was bietet mehr Möglichkeiten...

Greetz

[PICture]

Ich habe früher andere Prozessoren in ASM programmiert und bin auf PICs umgestiegen, weil ich sie einfacher zu programmieren finde. Die beide µC Familien bieten fast gleiche Möglichkeiten, jedoch für AVRs gibt es mehr fertige Programme (z.B. im Internet).

Die Entscheidung muß aber leider jeder selber treffen.:)

MfG

[niki1]

Angeblich sind Avr's leichter Handzuhaben, und generell gelten die als Hobby µC .
Ich selber habe Avr's rumliegen, nur hab ich keine Zeit sie in Betrieb zu nehemen.

[Meister Joda]

Wie ist das mit dem PIN-Support, ich benötige ja schon eine beträchtliche Anzahl...

und nicht alle PICs sind LCD kompatibel...

[PICture]

Ich habe nur schnell in einem Katalog nachgeschaut und die beide µC Familien sind fast gleich (AVR max.64 und PIC max. 68 ).

[Meister Joda]

das ist ja schön und gut, aber eine Empfehlung ist es nicht... :-(

[PICture]

Leider. Wenn ich dir PICs empfehle, dann bricht hier ein Krieg mit AVR-er aus und AVRs kann ich dir nicht empfehlen, weil ich sie nicht kenne...:(

[Meister Joda]

okay, wenn ich jetzt sage, ich würde gerne den 18F2550 nehmen, da ich ihn auch über USB 2.0 neu beschreiben kann, hätte ich gerne eine Meinung dazu ;-) am besten wären vll. auch Erfahrungen mit dem PIC und allgemein mit LCDs...

Grüße

[PICture]

Mit dem 18F2550 habe ich noch nichts gemacht, weil ich noch kein Bedarf für USB Anwendung hatte. So weit ich aber weiß alle PICs lassen sich per ICSP, also 3 Portpins programmieren, auch der 18F2550. Der 18F2550 kann per USB kommunizieren, aber nicht durch sein USB programmiert werden.

Als erstes habe ich mir bei eBay ein "Brenner" (Bausatz) gekauft, aus dem Internet ein kostenlosen Brennprogramm "icprog" runtergeladen und habe mein erstes Programm geschrieben, das nach einer weile auf einer selbstgebauter Lochrasterplatine sogar funktioniert hat. Das alles benutze ich bis heute.

Weil ich viel mit diversen PICs bastle, habe ich mir zuletzt eine universelle Entwicklungsplatine gebaut, die ich im Forum vorgestellt habe.

Ich habe mit verschiedene PICs schon fast alle mögliche LCD Displays programmiert (ohne Kontroller mit 3 Backplanes, Matrix, Grafik und Handy Display vom Nokia).

Du kannst dir das alles in unserem "PIC Mikrocontroller" Forum anschauen.

MfG

[wkrug]

Also werd ich hier mal eine Lanze für die ATMELS brechen.

Für dein Unterfangen sollte ein ATMEGA16 bzw. ATMEGA32 ausreichend sein.
Bei mir ist es umgekehrt wie bei PICture.
Ich hab mit den ATMELS angefangen und bin dabei geblieben.

Keiner der beiden Microcontroller Familien ist direkt LCD kompatibel.
Die nötige Hardware ( Ports ) ist vorhanden, einen eigenen LCD Treiber habe beide Controller nicht mit integriert.

Die benötigten LCD Routinen sind ein Softwareanteil auf deiner Entwicklungsumgebung ( AVR-GCC, CodeVision, BASCOM um nur ein paar zu nennen ).

Bei "BASCOM" gibt es direkt Befehle um ein LCD anzusteuern, bei Code Vision AVR eine Library, die man bei Bedarf aktivieren kann. Ausserdem gibt es unzählige LCD Librarys für fast jede Programmiersprache im Internet zu laden.

Das mit dem "Hobby" Microcontroller gilt für die ATMEL AVR Reihe ebenso gelten wie für die PIC Familie.

Bei den ATMEL Controllern gefällt mir der durchdachte Aufbau, die schnelle Befehlsabarbeitung ( RISC ) und das alle Controller der Familie den gleichen Prozessorkern haben. Kennst Du also einen, kennst Du schon mal das Herz aller AVR Controller.
Des weiteren ist die ISP ( In System Programming ) eine mehr als tolle Sache.
Ausserdem gibt es hier kein so großes Typengewirr wie bei den PIC's.

Nervig sind bei der AVR Controller Familie die Fuses.
Die sind fast bei jedem Typ etwas anders einzustellen und haben auch noch andere Liefereinstellungen. Ich denk aber mal bei den PIC's wird das nicht anders sein.

Meine Empfehlung ist immer sich erstmal mit der Hardware des gewünschten Controllers auseinanderzusetzen und das geht am Besten wenn man ein wenig in Assembler reinschnuppert.
Die dabe erworbenen Assembler Kenntnisse kann man auch nach dem Umstieg auf eine Hochsprache immer wieder gebrauchen.

Anschließend sollte man dann auf eine Hochsprache wechseln.
Mir selber hat BASCOM überhaupt nicht zugesagt ich bin dann direkt in "C" eingestiegen.
Die Syntax von "C" ist leider etwas gewöhnungsbedürftig - Wer kommt schon drauf ein Programm vom Ende her zu beginnen und fast alle Sonderzeichen die so eine PC Tastatur hergibt zu benutzen.
Allerdings kommt man mit "C" relativ schnell zu effektiv laufenden Programmen.
BASCOM scheint Anfangs einfacher zu sein, vor allem wenn man schon BASIC Kenntnisse hat. Wenn man allerdings etwas braucht das im Befehlsvorrat von BASCOM nicht enthalten ist wird es schnell kompliziert.

Wenn Du noch gar keine Erfahrung mit Microcontrollern hast, ist das was Du da Vorhast nur mit sehr viel Energie zu meistern.

Fang erstmal mit Programmen der Klasse "LED Blinkt" und "Hallo Welt" an.
Dabei lernst Du dann auch gleich wie man ein Display ansteuert.
Der nächste Schritt kann dann die Erfassung von Messwerten und die Ausgabe von Messwerten auf dem Display sein.
Dann kannst Du dich ein wenig in die Materie "Interrupt" einarbeiten.

Mit diesem Rüstzeug ist dann die Realisierung deines Vorhabens kein Problem mehr.

[PICture]

Hallo!

Ich habe alles, was der wkrug geschrieben hat, aufmerksam gelesen und kenne jetzt die AVRs besser. :) Bei der Wahl des µC Types sollte man sich ruhig Zeit lassen, weil meistens bei dem gewähltem µC bleibt man für sehr lange.

Mit der Programmiersprache hat der wkrug recht, wenn man Hochsprache benutzt ist man vom Prozessortyp unabhängig und geplantes Programm ist schnell fertig, sie kann aber nicht so schnell wie ASM laufen. Optimal ist eine Mischung aus beiden, die nach Bedarf eingesetzt werden können.

Ich glaube auch, wie der wkrug, dass dein Vorhaben für einen Anfänger zu kompliziert ist und dir mehr Frust als Freude bereiten wird.

MfG

[Meister Joda]

Hi,

ich denke, ich werde es so machen, wie wkrug gesagt hat und mit den einzelnen Baustellen anfangen und diese dann zusammen in ein großes Projekt fließen lassen...

Grüße

[Meister Joda]

Mensch... R. lässt sich wieder mal Zeit mit dem liefern :-(

[rideyourstyle]

Ich kenne ebenfalls nur die AVR's.
Aber ich denke, das mehr Leute (meine Annahme) hier im Forum mit AVR's arbeiten, wirst du im allgemeinen mehr Unterstützung bekommen, wenn du ein Problem hast...

[jwarta]

Vielleicht auch mal die Alternative MSP430 pruefen. Das Tool ist z.B. Eclipse kompatibel und kann daher gut erweitert werden. Der Prozessor selbst ist ein 16 bitter und vom Befehlssatz auf C/C++ optimiert.
http://focus.ti.com/mcu/docs/mcuprodoverview.tsp?sectionId=95&tabId=140&familyId=342

[tommelbommel]

TI MSP430 wuerde ich bei dieser Aufgabe aussen vor lassen. Staendiges Aergernis sind immer die nicht vorhandenen 5v toleranten I/O Pins. Vor allem weil so ziemlich alle LCDs 5v brauchen. Klar es gibt Pegelwandler aber eigentlich vermeidet man sowas wie die Pest.
AVR oder PIC ist eigentlich egal. Wuerfeln?

cu Tommelbommel

[Meister Joda]

Hi Leute,

ich bin seit meinem letzten Post etwas weitergekommen und zwar nutze ich jetzt den pic18f2550 vom Microchip und die Programmieroberfläche von Microchip (MPLAB IDE - cc18).

mein Problem ist nun, wie kann ich ein Bit aus einer "unsigned char" Variable abfragen? unsigned char bedeutet ja, dass ich einen Rahmen von 0 bis 255 habe... aber wie kann ich mir da das vierte von den 8Bit auskoppeln und dieses verknüpfen? Es geht um die Variable "value"...
Taster ist für den Integralgeber geschrieben und funktioniert soweit ganz gut!


#include <p18f2550.h>


//***************Variablen festlegen***************
char oldA, oldB, Power;
unsigned char value;

//***************Konfiguratioswort*****************
void config (void)
{
UCFG=0x08;
UCON=0x00;

TRISA=0b00000000;

TRISB=0b00000000;
#define SCKL_PGA PORTBbits.RB1

TRISC=0b00110100;
#define K1 PORTCbits.RC0
#define K2 PORTCbits.RC1
#define START PORTCbits.RC2
#define A PORTCbits.RC4
#define B PORTCbits.RC5
#define CS_PGA PORTCbits.RC6
#define SDI_PGA PORTCbits.RC7
}

//***************loop1*****************************
void loop1 (void)
{
int i;
for (i=0; i<118; i++);
}

//***************loop2*****************************
void loop2 (void)
{
unsigned short long i;
for (i=0; i<118909; i++);
}

//***************Start*****************************
void Start (void)
{
if (START && !K1 && !K2)
{
K1=1;
loop2();
loop2();
K2=1;
Power=1;
loop1();
while (START);
}
}

//***************Ende******************************
void Ende (void)
{
if (START && K1 && K2)
{
K2=0;
loop2();
loop2();
K1=0;
Power=0;
loop1();
while (START);
}
}

//***************Taster****************************
void Taster (void)
{
loop1(); //Verzögern
if (!((oldA==A)&&(oldB==B))) //nach Änderungen suchen
{
if (oldA&&!oldB&&A&&B&&(value<255)) //Regler nach rechts
{
value++; //lauter
loop1(); //Verzögern
while (B); //warten bis Signalende
}
if (oldB&&!oldA&&A&&B&&(value>0)) //Regler nach links
{
value--; //leiser
loop1(); //Verzögern
while (A); //warten bis Signalende
}
oldA=A; //Altdaten speichern
oldB=B; //Altdaten speichern
}
}

//***************LCD*******************************
void LCD (void)
{
}

//***************PGA*******************************
void PGA (void)
{
}



//***************main******************************
void main (void)
{
config(); //Konfigrautionswort aufrufen
oldA=0;
oldB=0;
value=0;
Power=0;
PORTA=0;
PORTB=0;
PORTC=0;


Sprungmarke:

if (!Power)
{
Start();
}

if (Power)
{
Taster();
Ende();
}

goto Sprungmarke;
}

Greetz

Edit von BASTIUniversal: Bitte, bitte, bitte die Code-Kästchen verwenden!!

[wkrug]

wie wärs mit:
// Binäre Und verknüpfung
if((value&0b00001000)>0)
{
// Das vierte Bit war 1 -> Aktion
}
else
{
// Das vierte Bit war 0 -> Aktion
};

[askazo]

Das ganze kann man sich sehr schön als Makro definieren:


#define IsBitSet(VAR,BIT) (((VAR) & (1<<BIT))?1:0)

//Aufruf
unsigned char test;
if(IsBitSet(test,4))
{
//Mache was
}
Vorsicht: Das Makro sieht das erste Bit als Bit 0.
Also wird hier im Beispiel das fünfte Bit abgefragt.

Gruß,
askazo