C Kleine Tischlampe bitte um Hilfestellung.

Nicole

Mitglied
03. Feb. 2014
61
0
6
Sprachen
  1. ANSI C
Hallo zusammen,

nach langer Pause möchte ich wieder ein kleines Projekt starten :dance3:

Wie Ihr wisst bin ich leider noch nicht der Profi in C ;)

Trotzdem möchte ich dieses mini Projekt versuchen.

Was will ich machen ?

Ich möchte über einen Taster einen Attiny13 anschalten.
Der Attiny13 soll wiederum eine LED Steuern 1x Taster Drücken LED an nochmals Taster Drücken LED aus.

Zusätzlich sollte der Attiny13 nach einer bestimmten Zeit die Lampe auch Automatisch ausschalten :help:

Das ganze soll eine kleine Nachttischlampe werden.

Habe bereits in meiner Testschaltung alles soweit aufgebaut.
Der Schalter zieht Masse und ist an PB4 angeschlossen.

Die LED bekomme ich auch zum leuchten.
Normal oder Wechselblinken funktioniert bestens.

Mein Problem ist nur wie steuer ich den Taster an?
Und wie schreibe ich am besten einen Timer der mir einfach z.B. 2 Minuten runterzählt ?

Ich würde mich sehr freuen wenn Ihr mir ein paar Tips bzw Beispiele geben könntet.

Vielen Dank mal wieder.
 
Das Bein mit den Taster schaltest Du über den internen Pullup auf high, der Taster zieht es bei Betätigung auf Gnd.
In der Hauptprogrammschleife pollst Du das entsprechende Bit im PIN-Register. Wenn es null ist, ist de Taster betätigt. Zwei Stolpersteine: erstens fragst Du das Bit eventuell zichtausendmal pro Sekunde ab, zweitens prellt der Taster beim betätigen und loslassen - mußt Du eventuell berücksichtigen.

Der Tn13 kann AFAIR intern mit 9,6 oder 4,8MHz betaktet werden, dieser Basistakt kann weiterhin über den MainClockPrescaler weiter runtergeteilt werden. (Abgesehen davon könnte auch der Watchdog-Oscillator als Taktquelle genutzt werden). Der Tiny besitzt ferner einen 8bit-Timer, der über einen eigenen Prascaler verfügt. Du Könntest also auch bei Betätigung des Tasters den Timer Starten, beim nächsten betätigen den Timer und die Lampe abschalten. Wird nicht abgeschaltet, läuft der Timer irgendwann über, worauf man mit 'nem Überlaufinterrupt reagieren kann.

Oder Du zählst die 2 min selbst mit Timerüberläufen, und nutzt den Timer nebenbei(!) als PWM-Dimmer...
 
Danke für deine schnelle Antwort.

Wie schon gesagt bin ich ganz am Anfang.
So wie Du mir das aufgelistet hast, kann ich es natürlich nicht 1 zu 1 Umsetzen.

Dazu fehlt mir einfach das Wissen.

Wäre es möglich das mir jemand von Euch unter die Arme greift ?
Ich möchte nicht, das Ihr für mich alles macht.

Nur ganz alleine sehe ich eher schwarz.

Vielen Dank mal wieder.
 
Hallo Nicole,

wie man so etwas in "C" programmiert ?
Bitte nicht falsch verstehen, ich will hier keine Diskussion über die "bessere" Programmiersparche starten, aber wenn du ohnehin noch am Anfang stehst, hast du dir mal LunaAVR angesehen?
Ich habe bisher in BASCOM programmiert, alle neuen Projekte realisiere ich aber mit LunaAVR. Hier gibt es jede Menge Beispiele.
Falls es Gründe für "C" gibt, dann vergiss meine Worte - sollte nur als Anregung gedacht sein - was es sonst noch so gibt.

- gp177 -
 
Hmm, auch wenn es ein kleines Projekt ist. Ich weiß nicht ob es auf dem ATtiny13 mit Bascom und LunaAVR umsetzbar ist. Der Chip ist ja recht klein, und der Code wird sehr schnell sehr groß. Mit Bascom bin ich vor einigen Jahren daran gescheitert. Kann gut sein dass das jetzt anders ist.

Mit C kann ich dir leider nicht helfen. Das ist einfach nicht meine Sprache und wird es auch nie werden.

Ich würde wohl den Timer initialisieren sodass der alle 10-100mS einen Intrerupt schmeißt (overflow).
Darin würde ich den Taster abfragen.
- wenn gedrückt und vorher nicht:
--- wenn licht an:
----- Licht aus
--- sonst:
----- Licht an
----- Zeit = 0
--- Taster Status sichern (um Änderung beim nächstem Durchlauf zu erkennen)
- wenn Licht an
--- wenn Zeit (2sec) erreicht:
----- Licht aus
- Zeit hochzählen
in der Main muss so nichts drin stehen. (nur die übliche Schleife, idealerweise mit Sleep)
Wenn der Taster nicht übermäßig prellt sollte das so schon funktionieren :)
Aber... Viele Wege führen nach Rom.
 
Naja, der Tn13 hat bereits 1k Flash, in der Größe gibts nur den 25/45/84 und den 24/44/84 mit mehr.
Für die Anwendung reicht der eine Timer aus, weitere interne Hardware wird nicht benötigt.
(Dafür reicht sogar der Tiny4 mit 0,5K)

Wie mehrfach angedeutet den Taster in regelmässigen Abständen pollen. Ich würde dazu eine Überlauffrequenz des Timers von ca 100Hz anstreben und die LED an einen möglichen PWM-Ausgang hängen. Dann kann man später problemlos Dimmen/ Hoch- und Runterfaden beim an und abschalten und so hinzufügen.

Im Prinzip ist das eines der Probleme, die sich in Assembler fast(!) einfacher und schneller umsetzen lassen als in 'ner Hochsprache - wenn man sich einmal mit der generellen Arbeitsweise der kleinen Controller beschäftigt hat.

In Assembler müßte man halt die Register alle schritt für Schritt über die Rechenregister beschreiben/auswerten,
Unter C fällt die unterste Ebene weg, man tut so als wenn man einfach direkt auf die Register zugreift,
Unter Bascom geht das auch, dort gibt es aber auch fertige ... Routinen, die das erledigen indem man zB so tut, als würde man den Timer direkt manipulieren.
Wie das unter Luna ist, weiß ich nicht - wahrscheinlich ähnlich wie in C nur mit'nem anderen Dialekt...

Letztlich muß sich aber der Programmierer 'n Kopf machen, was der Timer machen soll, was bei einem Überlauf etc. geschehen soll - wie Taster und LED angeschlossen sind und was bei Tasterbetätigung geschieht (und wie man das im Programm abfragen kann...
Mit welcher Sprache jetzt auch immer.
 
Guten Abend zusammen,

vielen Dank für Eure Antworten.

Ich bin mir nicht ganz sicher welche Sprache die richtige ist ?
Es ist auch nicht so einfach, da jeder etwas anderes sagt :confused:

Meiner Meinung nach sollte es relativ einfach zu lernen sein das wäre gut.
Ob es das natürlich gibt kann ich nicht sagen :girl_wacko:

Was würdet ihr an meiner Stelle machen ?

Ich bin um jeden Tip froh.

Vielen Dank
 
Einfach zu lernen ist so ein zweischneidiges Schwert.
Ich selbst habe mit Bascom angefangen, habe aber dann gemerkt dass, grade was Performance angeht, ich immer mehr auf Inline Assembler umgestiegen bin. Bis ich denn komplett umgestiegen war. Und gemerkt habe wie wenig ich eigentlich wusste was da unter der Haube wirklich abläuft. Kleine Projekte (wie das von dir) würde ich in Assembler machen. So lernt man auch die wirkliche Hardware kennen, was immer von Vorteil ist. Beispielsweise könnte Programmiersprache x bei einem simplen /2 komplette Fließkomma Routinen einbinden und das extrem umständlich und CPU-lastig ausrechnen. Andererseits könntest du aber auch 1x nach rechts schieben, erreichst das selbe. Ohne Libs und in 1-2 Takt Zyklen. Durch solche Kleinigkeiten kann man schnell mal über die Fähigkeiten eines ATtiny heraus kommen. Daher nutz ich auf den Tinys nur Assembler und bei größeren Projekten, insbesondere wo Fließkomma im Spiel ist LunaAVR (ist Bascom ähnlich).

Kurz um: Auch wenn Assembler vielleicht für das ein oder Andere graue Haar sorgen kann (der Einstieg ist schwerer) hilft es doch später gewaltig, auch wenn man sich dann für Bascom / C / LunaAVR entscheidet. Man kennt die Hardware einfach besser.
Und wenn es um Performance geht (kleiner und schneller Code) gibt es nichts besseres. Wobei dein Vorhaben jetzt nicht so kompliziert ist.
 
Vielen Dank für deine Infos.

Das keine Sprache einfach ist sollte klar sein.
Habe gedacht das es für den Anfang was bestimmtes gibt.

Über Assembler habe ich mich noch nicht schlau gemacht.
C oder Bascom dort habe ich mir Infos geholt bzw angeschaut.

In C benötigt man z.B. sehr viel mehr Code wie in Bascom für die gleiche Anwendung.

Deswegen habe ich mir gedacht ist vielleicht Bascom für Anfänger besser ?
Jetzt natürlich nach deinen Infos sieht das ganze wieder anders aus.

Leider alles nicht so einfach.

Vielen Dank mal wieder.
 
Es spiegelt jetzt auch nur meine Meinung wieder.

In Assembler brauchst du noch mehr Code(Zeilen) als in C oder Bascom oder LunaAVR.
Dafür lernst du die Hardware besser kennen, was dir später hilft.

In C / Bascom / LunaAVR kannst du in kürzester Zeit viel erreichen. Aber wenn es zu Performance geht, beispielsweise du willst 4 oder mehr 7 Segment Anzeigen ansteuern, ... Da hast du Einbußen. Oder auch - wie bei mir kürzlich geschehen - wenn der Compiler der Sprache Mist baut und man ewig im eigenem Code den Fehler sucht. Zugegeben sowas passiert sehr selten.

Ich kann dir gerne dabei helfen in ASM, ich habe nämlich ein nahezu identisches Projekt hier laufen. Ebenfalls mit Tiny13. Allerdings mit Dimmen der Helligkeit (33%, 66%, 100%, Aus) und ohne automatisches Abschalten. Lässt sich ja aber anpassen.
Bei mir wars noch dazu umschaltbar (Normal LED, HighPower LED, Beide). Mein Projekt ist hier zu finden:
http://avr-praxis.de/forum/showthread.php?2240-Akku-Recyclig-LED-Taschenlampe
 
Bascom (zu den anderen Hochsprachen kann ich nicht wirklich was sagen) nimmt Dir'n Haufen Arbeit ab, der Code erscheint kürzer. Du weißt dann aber einfach nicht, was der Controller da dann genau tut (und was er alles noch könnte). (vielleicht mußt Du es auch nicht immer genau wissen, aber manchmal ist es eben doch von Vorteil.)

Und dann gibt es manchmal auch Dinge die der Controller kann, die mit einfachen Mitteln der Hochsprache nicht zu bewerkstelligen sind, Sachen bei denen Dir die Hochsprache 'n Stinkefinger zeigt (frei nach Dino zitiert) - manchmal kann man dann trotzdem dasselbe direkt über die Register erreichen (AFAIR in Bascom zB "Config Timerx=PWM bla blub"... da ist fastPWM nicht vorgesehen - wenn man den nutzen will, muß man halt die Bits in den Controll und Steuerregistern selbst festlegen, die Config-Instruktion zaubert ja auch nicht...

Wenn Du schnelle Erfolgserlebnisse mit einfachen kurzen Programmen willst, ist Bascom (und sicher auch andere Hochsprachen) kein schlechter Einstieg, wenn Du dann aber mal wissen willst, was wirklich unter der Haube abgeht, und dich mit der Hardware und den Datenblättern auseinandersetzt, hast Du teilweise das Gefühl alles neu zu lernen (->Thomas), und wunderst Dich, warum einige Sachen unter Bascom so kompliziert sind.

Auf der anderen Seite werden aber mit einem Config didum komplexe Prozesse in Gang gesetzt, um die Du Dich dann nicht kümmern mußt, von denen Du nichts mitbekommst (Textausgabe über den UART zB, verwendest Du irgendwo im Code "Print "lustiger Text"", initialisiert Bascom für Dich den UART mit irgendwelchen defaults, kümmert sich um das Ablegen der Stringkonstante "lustiger Text", und jagt den String zeichenweise über den UART. In Assembler ist das bald 'n halber Bildschirm Code.

Hmm... eigentlich müßte man mal an Dinos Dampfmaschin-Thread anknüpfend weitere Fundamentalismen erläutern - wenn das nicht so'n Haufen Tipserei wäre...
 
Mein Problem ist nur wie steuer ich den Taster an?
Und wie schreibe ich am besten einen Timer der mir einfach z.B. 2 Minuten runterzählt ?

Ich würde mich sehr freuen wenn Ihr mir ein paar Tips bzw Beispiele geben könntet.

Hallo Nicole!

Ich habe einmal ein Beispiel geschrieben, dieses könnte dir weiter helfen und dich eventuell weiter auf Ideen bringen.


Hier eine kurze Erläuterung zum Programm:

In der Hauptschleife warte ich auf ein periodisches 10ms Signal, dann frage ich den Status des Tasters ab.

Ist der Taster gedrückt und die LED aus, wird die LED eingeschaltet und der Timer (2 Minuten, MeinTimer) wird aktiviert. Der Timer ist in der InterruptServiceRoutine realisiert, bei 0 wird die LED hier wieder ausgeschaltet.

Ist der Taster gedrückt und die LED an, wird die LED ausgeschaltet und der Timer (MeinTimer) wird deaktiviert.

Der Timer0 läuft immer und zwar im Mode CTC. Der CompareInterrupt wird etwa alle 10ms aufgerufen (bei fcpu=9,6MHz). Diese Zeit ergibt sich durch Prescaler und Comparewert.
(1ms sind genau zu erreichen, ich habe hier aber trotzdem 10ms verwendet)

Um auf den Comparewert und den Prescaler zu kommen, ist der TimerCalculator ggf. hilfreich:
http://www.avr-praxis.de/forum/entry.php?13-Meine-Softwaretools-(XP-Vista-Windows-7)

Die Portpins für Taster und LED musst du anpassen.
Näheres steht im Sourcecode. Die Programmgröße ist 256Bytes.

Der Sourcecode ist nicht getestet, ich hoffe ich habe nichts übersehen.

Frohes Fest :)
Dirk

[CCODE]/*
* Tischlampe.c
*
* Created: 21.12.2014 10:52:20
* Author: Dirk
*/


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


// Taster und LED definieren. Dies muss an die Anwendung angepasst werden
#define LEDPORT PORTB
#define LEDDIR DDRB
#define LED PINB0

#define KEYPORT PORTB
#define KEYDIR DDRB
#define KEYPIN PINB
#define KEY PINB1


// durch folgende Macros wird der Sourcecode etwas leserlicher
#define KEY_IS_PRESSED (!(KEYPIN & (1<<KEY)))
#define LED_IS_ON (!(LEDPORT & (1<<LED)))
#define LED_ON LEDPORT &= ~(1<<LED); // Pin low
#define LED_OFF LEDPORT |= 1<<LED; // Pin high
#define LED_TGL LEDPORT ^= 1<<LED; // Pin toggle


// Hier einige Variablen
volatile uint8_t TimerFlags = 0;
#define FLAG_10MS 0

volatile uint16_t MeinTimer = 0;

uint8_t KeyboardFlags = 0;
#define KFLAG_WAIT_KEY 0


// Dies ist die TimerISR. Diese wird alle 10ms aufgerufen.
ISR(TIM0_COMPA_vect)
{
// 10ms event

TimerFlags |= 1<<FLAG_10MS; // 10ms Signal für das Hauptprogramm

if (MeinTimer > 0)
{
MeinTimer--;
if (MeinTimer == 0) LED_OFF;
}


}


int main(void)
{

// Portpins initialisieren
LED_OFF
LEDDIR |= 1<<LED;

KEYPORT |= 1<<KEY; // Pullup Widerstand aktivieren
KEYDIR &= ~(1<<KEY); // Direction Input (muss man nach Reset nicht machen, da bereits alles Input ist.)


// Timer initialisieren
// CompareA Interrupt, CTC: Clear Timer on Compare Match
// fcpu=9,6MHz, Prescaler=1024, CompareValue=93 -> tisr= 10ms (10,027ms)
TCNT0 = 0;
OCR0A = 93;
TCCR0A = 1<<WGM01;
TCCR0B = (1<<CS02) | (1<<CS00); // Prescaler 1024, Timer Start
TIMSK0 = 1<<OCIE0A; // CompareA Interrupt

sei();

while(1)
{


if (TimerFlags & (1<<FLAG_10MS))
{
// 10ms event
cli();
TimerFlags &= ~(1<<FLAG_10MS); // Flag wieder zurücksetzen
sei();


if (KEY_IS_PRESSED)
{
// Taste ist gedrückt
if (!(KeyboardFlags & (1<<KFLAG_WAIT_KEY)))
{
KeyboardFlags |= 1<<KFLAG_WAIT_KEY;

if (LED_IS_ON)
{
// LED ausschalten und Timer deaktivieren
cli();
MeinTimer = 0;
sei();
LED_OFF

} else {
// LED einschalten und Timer aktivieren
cli();
MeinTimer = 12000; // 2 Minuten = 120 Sekunnden = 12000 x 10ms
LED_ON
sei();

}
}
} else {
// Taste ist nicht betätigt
KeyboardFlags &= ~(1<<KFLAG_WAIT_KEY);
} // if key pressed end

} // 10ms event end



}
} [/CCODE]
 
Hallo zusammen,

dirk vielen Dank für deine Hilfe und für deine Mühe.

Ich werde das ganze natürlich testen und berichten ob ich es hinbekommen habe oder auch nicht :stupid:

Jetzt mal eine generelle Frage an euch.
Ich möchte mir ein Buch kaufen wo ich wirklich von Null Anfange.

Das heißt schön langsam steigern mit verschiedenen Beispielen Übungen und der gleichen.

Könnt Ihr mir so ein Buch empfehlen ?

Was sagt Ihr zu diesem Buch ?

http://www.buecher.de/shop/c-c-und-c/c-programmieren-von-anfang-an/erlenkoetter-helmut/products_products/detail/prod_id/08230706/

Kennt das einer von euch ?

Soll ich mit C Anfangen oder doch lieber etwas anderes ?

Vielen Dank an alle.
 
Hi,
In etwa Dirks Weg hatte ich ja bereits in #2 vorgeschlagen: der Timer erzeugt 'ne Zeitbasis, die eine Zählvariable als Timeout decrementiert (wenn die Led an ist), im Hauptprogramm wird der Taster abgefragt und entsprechend die Led umgeschaltet (und das Timeout zurück-/gesetzt)
Ich denke, daß das dort beschriebene Computer-C nicht viel mit Mikrocontroller-C gemein haben wird.
In den Controller-Datenblättern finden sich zwar zu jeder Hardwarekomponente neben den Assembler- auch C-Codeschnipsel, aber die setzten natürlich C-Grundlagen vorraus. Mindestens.

Zu Assembler kam ja bereits der Link zu oldmax, ich hätte sonst auch noch'n Link auf'n gutes Tutorial...
Aber zu C (oder auch Bascom /Luna) werden Dir andere "Spezialisten" sicher auch gute Vorschläge geben können...
 
Danke für deine Antwort.

Mein Ziel ist es später mal IOS Anwendungen zu schreiben.

Die Betonung ist auf später ;)

Und C ist ja soviel ich weiß die Sprache mit der die Iphone/Ipad Anwendungen geschrieben werden oder?

Darum auch die Überlegung für C.

Versteht ihr was ich meine ?

Vielen Dank an alle.
 
Hallo Nicole,

Buchempfehlungen sind natürlich immer so eine Sache - geht es dir mehr um die Sprache oder auch um Mikrocontroller an sich?
Wenn dich die Grundlagen interessieren, könntest du dir z.B. das "AVR Mikrocontrollerlehrbuch" von Roland Walter ansehen. In diesem Buch werden alle grundlegenden Funktionen anhand eines ATMEGA8 sehr übersichtlich erläutert. Hier geht es aber um BASCOM. Zu diesem Buch gibt es bei SEGOR in Berlin auch einen Bauteilsatz, da kann man dann auch alle Beispiele leicht nachvollziehen.
Dieses Buch hatte ich mir zugelegt, als ich anfing mich mit MCs zu beschäftigen. Wenn du mit den Grundlagen bereits vertraut bist und du dich nicht mit BASCOM beschäftigen möchtest, wird dir dieses Buch natürlich nicht viel nutzen.
Zu LunaAVR gibt es soweit mir bekannt ist nur Online Dokumentationen. Diese Sprache ist dichter an "C" dran - wenn du mit den Grundlagen der Mikrokontroller noch nicht vertraut bist, wird das evtl. etwas kompliziert.

- gp177 -
 
Hi Nicole,

du mußt dir eins bewußt sein. C ist nicht gleich C. Du hast ziemliche Unterschiede zwischen einem PC/Handy/... und einem Mikrocontroller.

Bei einem PC/Handy/... besitzt du bereits ein lauffähiges System das die ganze Hardware steuert. Du programmierst lediglich eine Anwendung. Nicht mehr und nicht weniger. Die Anwendung wird gestartet und wenn du sie nicht mehr brauchst, dann beendest du sie wieder.

Bei einem Mikrocontroller besitzt du nichts. Es ist lediglich ein Stück Hardware das Strom verbraucht. Du mußt also die gesamte Ansteuerung der Hardware (BIOS/Treiber), deine Eingabe/Ausgabe (Tasten, Potis, Display, Schnittstellen), Benutzerinterface (Menüs,...) und dann natürlich auch deine Anwendung programmieren. Du startest hier nichts und du beendest auch nichts. Wenn du Strom dranlegst, dann fängt alles an zu leben. Wenn du Strom abschaltest, ist es wieder tot.

Auf einem Mikrocontroller programmierst du also wesentlich hardwarenäher. Du mußt dich hier um Timing und um Hardware kümmern, was bei einem PC oder einem Handy bereits alles für dich erledigt wurde. Aus dem Grund kannst du also mit einem x-beliebigem C-Buch bei einem Mikrocontroller wenig anfangen. Es lehrt dich lediglich die Sprachsyntax. Die Hardwarenähe wirst du in einem C-Buch für PCs definitiv nicht finden. Ohne die wirst du aber einen Mikrocontroller nicht zum Leben erwecken können.

Zusätzlich mußt du dich bei einem Mikrocontroller auch um die elektrischen Themen kümmern. Da wo du bei einem PC/Handy nur mal nen Kabel reinstecken mußt hast du es bei einem Mikrocontroller noch mit Spannungspegeln, Pinbelegungen, Pegelwandlern, Datentakt, usw zu tun.

Zusätzlich hast du auch noch verschiedene Entwicklungsumgebungen für die C-Programmierung. Je nachdem welche du verwendest, mußt du dich auch damit erstmal außeinandersetzen bevor du überhaupt eine einzige Zeile programmiert hast. Du mußt ein Projekt anlegen, usw.

Das wichtigste bei jeder Sprache ist erstmal die Denkweise beim Programmieren. Du mußt ein Problem/Aufgabe gedanklich zerlegen. Die Stücke die du bei der Zerlegung erhälst (die Befehle), wirst du in jeder Sprache auf ähnliche Weise wiederfinden. Eventuell heißen sie etwas anders aber sie werden irgendwo wiederzufinden sein. Manche Dialekte besitzen weniger und manche mehr Befehle. Wenn ein Befehl in einem Dialekt nicht existiert, dann mußt du ihn aus den existierenden nachbauen. So wie du in manchen menschlichen Sprachen etwas umschreiben mußt wenn es einen bestimmten Begriff nicht gibt.

Es ist also für das "Programmieren lernen" relativ egal mit welcher Hochsprache man anfängt. Lediglich Assembler fällt da ein wenig aus der Reihe. Es ist noch ein ganzes Stück "ursprünglicher". :cool:

Gruß
Dino
 
Aus dem Grund kannst du also mit einem x-beliebigem C-Buch bei einem Mikrocontroller wenig anfangen. Es lehrt dich lediglich die Sprachsyntax.

Hallo Nicole,

der Meinung bin ich auch. Wenn es rein um den Syntax geht, dann such mal im Internet nach "C Tutorial" oder "C Referenz", du musst dir hierfür nicht gleich ein Buch kaufen.

Wenn du C in Verbindung mit AVR-Mikrocontroller einsetzen möchtest, empfehle ich dir das AVR GCC Tutorial.

Um die Initialisierung der Hardwaremodule (wie im obigen Beispiel beim Timer0), musst du dich selber kümmern, es wäre also gut, wenn du mit den Datenblättern der Mikrocontroller zurecht kommst.

Ansonsten schau dir Beispielprogramme an und überleg dir kleine Projekte, dadurch lernst du automatisch. Bei Problemen gibt es ja Fachforen ;-)


Dirk :ciao:
 
Hallo Dino,

vielen dank für deine super Erklärung.

Da hast Du absolut recht.
Das ist mir soweit auch bewusst.

Ich möchte in erster Linie mit Mikrocontroller arbeiten.
Also wäre es besser ein Buch über AVR zu kaufen ?

Wenn ja welches sollte ich wählen?

Das mit der Sprache ist meiner Meinung nach nicht so einfach.
Es sollte eine Sprache sein wo ich nicht erst 2 Seiten Schreiben muss bis die LED leuchtet :D

Vielen Dank mal wieder.
 

Über uns

  • Makerconnect ist ein Forum, welches wir ausschließlich für einen Gedankenaustausch und als Diskussionsplattform für Interessierte bereitstellen, welche sich privat, durch das Studium oder beruflich mit Mikrocontroller- und Kleinstrechnersystemen beschäftigen wollen oder müssen ;-)
  • Dirk
  • Du bist noch kein Mitglied in unserer freundlichen Community? Werde Teil von uns und registriere dich in unserem Forum.
  •  Registriere dich

User Menu

 Kaffeezeit

  • Wir arbeiten hart daran sicherzustellen, dass unser Forum permanent online und schnell erreichbar ist, unsere Forensoftware auf dem aktuellsten Stand ist und der Server regelmäßig gewartet wird. Auch die Themen Datensicherheit und Datenschutz sind uns wichtig und hier sind wir auch ständig aktiv. Alles in allem, sorgen wir uns darum, dass alles Drumherum stimmt :-)

    Dir gefällt das Forum und unsere Arbeit und du möchtest uns unterstützen? Unterstütze uns durch deine Premium-Mitgliedschaft!
    Wir freuen uns auch über eine Spende für unsere Kaffeekasse :-)
    Vielen Dank! :ciao:


     Spende uns! (Paypal)