mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik MSP430F2012 LED Blinken lassen


Autor: m. S. (marek)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi,

ich mal wider diesmal mit nem anderen Problem, ich arbiete mit nem 
Handbuch wo nicht wirklich beispiele drin sind deswegen probiere ich ein 
bischen rum aber komme gerade nicht weiter. Mein Problem ist folgendes 
hab ne LED an P1.2 die soll mithilfe des Timers Blinken ich hab mir was 
Überlegt aber das funktioniert nicht und ich weis nicht wiso. Vielleicht 
könnt ihr ja mal nen blick rauf werfen und mir unter die Arme greifen 
danke schon mal hier der Code:

#include <msp430x20x2.h>

int main()
{

  WDTCTL = WDTPW + WDTHOLD;
  TACTL = TASSEL1 + TACLR;    //  ????
  TACCR1 = 30000;  //obere grenze bis zu der hochgezählt werden  soll
  TACTL |= MC1;  // das hochgezählt werden soll
  TACCTL1 = OUTMOD_7;// stzen rücksetzen (mener meinung dann von 30000 
auf 0 ???)
  TACCR0 = 0;  // nuntere Grenze

  P1DIR &= 0x00;   //
  P1DIR |= 0x04;  //P1.2 Ausgang rest Eingang
  P1OUT &= 0x00;    //Ausgänge auf 0
  P1IN &= 0x00;    //Eingänge auf 0
  P1SEL &= 0x00;   //I/O funktion festgelegt
  P1REN |=0x02;  //Internen Widerstand zuschalten

  while(1){
  if(TACCR0 == 0){P1OUT = ~0x04;}  //LED an wenn 0
  else{
  if(TACCR1 == 30000){P1OUT = 0x04;}//LED aus wenn 30000
       }
        }

}

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Marek S. schrieb:
> int main()
> {
>
>   WDTCTL = WDTPW + WDTHOLD;
>   TACTL = TASSEL1 + TACLR;    //  ????
>   TACCR1 = 30000;  //obere grenze bis zu der hochgezählt werden  soll
>   TACTL |= MC1;  // das hochgezählt werden soll
>   TACCTL1 = OUTMOD_7;// stzen rücksetzen (mener meinung dann von 30000
> auf 0 ???)
>   TACCR0 = 0;  // nuntere Grenze
>
>   P1DIR &= 0x00;   //
>   P1DIR |= 0x04;  //P1.2 Ausgang rest Eingang
>   P1OUT &= 0x00;    //Ausgänge auf 0
>   P1IN &= 0x00;    //Eingänge auf 0
>   P1SEL &= 0x00;   //I/O funktion festgelegt
>   P1REN |=0x02;  //Internen Widerstand zuschalten
>
>   while(1){
>   if(TACCR0 == 0){P1OUT = ~0x04;}  //LED an wenn 0
>   else{
>   if(TACCR1 == 30000){P1OUT = 0x04;}//LED aus wenn 30000
>        }
>         }
>
> }

Also so geht das leider überhaupt nicht!
Du solltest mit den Beispielen von Ti üben, da ist zu jeder Anwendung 
etwas dabei.

Als Buch kann ich dir die "MSP430 Micrcontroller Basics" von John H. 
Davies sehr empfehlen. Es gibt noch ein anderes Buch von Matthias Sturm, 
aber das ist meiner Meinung nach nicht sehr gut gelungen, vor allem 
nicht, wenn man in C programmiert.

Das hier:
while(1)
{
  if (TACCR0 == 0)
  {
    P1OUT = ~0x04;}  //LED an wenn 0
  else
  {
    if(TACCR1 == 30000)
    {
      P1OUT = 0x04;
    } //LED aus wenn 30000
  }
}

TACCRx ist nicht zum vergleichen, der Wert wird sich nicht ändern, wenn 
du ihn einmal gesetzt hast. Du kannst das TAR-Register vergleichen, aber 
auch dafür ist der Timer nicht gedacht.

Wenn du mit CCR0 und CCR1 arbeitest, dann läuft deine Anwendung eher auf 
PWM hinaus, das hast du ja wahrscheinlich noch garnicht vor. Deswegen 
bleib bei einem CCR-Register. Und mach dir z.b. nen Interrupt, in dem du 
die LED togglest.
#include <msp430x20x2.h>

void main (void)
{

  WDTCTL = WDTPW + WDTHOLD;
  
  P1SEL  = 0x00;  // I/O funktion festgelegt
  P1DIR |= 0x04;  // P1.2 Ausgang, Rest Eingang
  P1REN |= 0x02;  // Internen Widerstand zuschalten
  P1OUT  = 0x00;  // Ausgänge auf 0

  TACTL = TASSEL_2 + ID_3 + MC_1;  // SMCLOCK + Teiler 8 + Up-Mode
  TACCTL0 |= CCIE;
  TACCR0 = 65000;  // obere grenze bis zu der hochgezählt werden  soll
  
  _BIS_SR (GIE);  // Globaler Interrupt aktiviert
  
  while (1) {}
}

#pragma vector=TIMERB0_VECTOR    // ISR Timer
__interrupt void seconds (void)
{
  P1OUT ^= 0x04;
}

Einen Wert an P1IN kannst du eh nicht schreiben, der soll ja von außen 
abgefragt werden.

Gruß, Dennis

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ups...:
#pragma vector=TIMERA0_VECTOR

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Naja und "seconds" muss deine ISR natürlich auch nicht heißen!

Autor: m. S. (marek)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke dafür schon mal aber es läuft nicht, es kommt aber auch keine 
Fehler meldung, auser das bei #pragma ien ausrufe zeichen vor steht bei 
ausführen. Auserdem würde es bei dir nicht auch nur ein mal blinken und 
nicht kontinuierlich da du ja bis 65000 hochzählst und dann wenn das 
erreicht wird solte es blinken un ddann nie wider, meinem veständnis 
nach.  werde mal rumprobieren hab mir auch gerade was überlegt mal 
schauen ob das klappen wird.

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Was steht denn bei dem Ausrufezeichen für ne Meldung?

Deine LED soll nur einmal kurz blinken? Jetzt in dem Quelltext wird sie 
ständig blinken, klar.

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das läuft so:

CCR0 ist mit 65000 belegt, also fängt der Controller an, mit jedem Takt 
einen hochzuzählen. Wenn die 65000 erreicht sind, dann wird ein 
Interrupt ausgelöst und in der ISR die LED getoggled. Also wenn die an 
war, geht sie jetzt aus und umgekehrt.

Nach der ISR ist der Zähler wieder auf 0 und beginnt von vorne.

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also der inter Zähler ist auf 0, nicht der CCR0, der bleibt die ganze 
Zeit auf 65000!

Zähler  CCR0

0       65000 -> loszählen
...
10540   65000 -> nicht gleich, weiterzählen...
...
49000   65000 -> nicht gleich, weiterzählen...
...
65000   65000 -> GLEICH!!! Interrupt -> LED togglen -> Zähler wieder auf 
0
...
0       65000 -> nicht gleich, weiterzählen...

USW.


Verstehst? : )

Gruß, Dennis

Autor: m. S. (marek)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also wenn ich auf das Ausrufe zeichen klike steht da so was
 in nem Fenster wo steht add Bookmark #pragma vector=TIMERA0_VECTOR 
// ISR Timer. Ne die soll schon öfters blinken aber das tut sie gerade 
nicht keine ahnung wiso nicht.

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ok, womit programmierst du ihn denn? Ich programmier mit IAR, weiß 
natürlich nicht, ob es überall gleich ist.

Autor: m. S. (marek)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das verstehe ich. Ich mach das mit Code Composer Essentials v2 da höhere 
versionen auf der ollen Win 2000 version auf den Rechner wo ich dran 
arbeite nicht laufen.

Autor: m. S. (marek)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich hab mir mal was neues einfallen lassen ich. Laufen tut es trotzdem 
nicht. Vielleicht weil ich den Timer falsch initialisiere aber wie das 
richtig geht weis ich nicht weil das User Manuell mach mich nicht gerade 
schlauer.
Hier kommt der code:

#include <msp430x20x2.h>

void main(void)
{
  WDTCTL = WDTPW + WDTHOLD;
  TACTL = TASSEL1 + TACLR;    //  ????
  TACTL |= MC_2;// das kontinuirlich gezählt werden soll von 0 bis
                      // ffff dann von 0 bis fffff usw.
  TACTL |= 0x02;  //interupt freigabe


  P1DIR &= 0x00;   //
  P1DIR |= 0x04;  //P1.2 Ausgang rest Eingang
  P1OUT &= 0x00;    //Ausgänge auf 0
  P1SEL &= 0x00;   //I/O funktion festgelegt

  while(1){
  if((TACTL & TAIFG)==1){P1OUT = ~0x04;}//TAIFG das überlauf  forhanden?
  else{P1OUT = 0x04;}
  }
}

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Dann mach es mit dem OUTMOD_7, dann brauchste aber halt noch den CCR1 
den legste dann auf den halben Wert von CCR0.

Musst aber dann gucken mit dem Pin, wo die LED dran ist, der muss 
natürlich zum Timer gehören und dann musste noch die Sonderfunktion mit 
P1SEL |=0x__ einstellen.

Guck mal ins Handbuch von dem Controller!

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Achja, ISR kannste dann natürlich löschen, die Interruptfreigabe auch 
und das CCIE ebenfalls.

Autor: m. S. (marek)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
So funst das auch aber ich weis noch nicht wiso muß ich mir mal 
überlegen und schauen wiso das geht. Hab das gerade kopiert aber 
verstehe das nicht wirklich schaue ich mir mal und lese mal weiter das 
Manuel aber danke für deine Hilfe.

#include <msp430x20x2.h>

void main (void)
{

  WDTCTL = WDTPW + WDTHOLD;
  TACTL = TASSEL_2 + TACLR + TAIE;  //SMCLK + Timer löschen

  CCTL0 = OUTMOD_4;      //up mode
  CCR0 = 0xFFFF;

  CCTL1 = OUTMOD_7;      //reset/set
  CCR1 = 0x7FFF;

  P1DIR |= 0x04;        //P1.2 ausgang
  P1SEL |= 0x04;        //P1.2 = TA1 ausgang

  TACTL |= MC1;        // up mode

  while(1);
}


mfg
Marek

Autor: Stefan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Marek S. schrieb:
> So funst das auch aber ich weis noch nicht wiso muß ich mir mal
> überlegen und schauen wiso das geht.

Ich würde Dir den User-Guide trotzdem nochmal eindringlich empfehlen!
Besonders das Thema "Basic Clocks" des MSP430.

Es macht nämlich einen entscheidenden Unterschied, ob der Timer mal mit 
ACLK oder mit SMCLK gespeist wird...

Autor: m. S. (marek)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Stefan(Gast)

Danke für den hinweis. Das hab ich die ganze Zeit vor mir aber, woher 
soll ich denn wissen wann ich welche zu benutzen habe wenn mir das 
keiner sagt und aus dem was da drinne steht wird man nicht so recht 
schlau. Ich beschäftige mich erst seit gestern damit zumindest mit dem 
mikrocontroller davor einen anderen gehabt der war komplexer. Da mußte 
ich aber auch nicht alleine dran sitzen und da wurde wir halb drauf 
gestoßen wo wir nachschauen sollen und jetzt sitzt du da hast keine 
Ahnung und hast ne idee und fängst einfach an weil du denkst das könnte 
gehen geht dann aber nicht und dann ist man verzweifelt warum das nicht 
geht. Woran kanst du denn erkennnen welcher Timer besser geeignet ist 
für die aufgabe die ich lösen sollte. Da ich das gerne verstehen würde 
wiso das so geht in dem von mir zuletzt eingefügten code. So in der 
schreib weise sehe ich das auch zum ertsen mal z.b.
 TACTL = TASSEL_2 + TACLR + TAIE; das steht da auch nirgends drinne das 
man das so machen soll. Ich danke dir schon jetzt für deine antwort.

mfg

marek

Autor: Stefan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Marek S. schrieb:
> Danke für den hinweis. Das hab ich die ganze Zeit vor mir aber, woher
> soll ich denn wissen wann ich welche zu benutzen habe wenn mir das
> keiner sagt
Das kann dir keiner sagen, weil die Anforderungen für jeden anders sind!
Deshalb mein Hinweis auf die "Basic Clocks" im User Guide. Man sollte 
verstehen, dass es verschiedene Clocks gibt, die man aus 
unterschiedlichen Quellen und mit unterschiedlichen Frequenzen takten 
kann!

> und aus dem was da drinne steht wird man nicht so recht
> schlau.
Aller Anfang ist schwer... aber ich finde den User Guide sooo schlecht 
nicht?!

> So in der
> schreib weise sehe ich das auch zum ertsen mal z.b.
>  TACTL = TASSEL_2 + TACLR + TAIE; das steht da auch nirgends drinne das
> man das so machen soll. Ich danke dir schon jetzt für deine antwort.
Nun, das ist lediglich das Setzen der einzelnen Bits im Register TACTL. 
Das ist aber alles genau im User Guide beschrieben!
Das einzig "ungewöhliche" ist die am Anfang vielleicht etwas verwirrende 
Schreibweise TASSEL_2 im Unterschied zu TASSEL1
Das eine sind die einzelnen Bits (TASSEL0 und TASSEL1), während TASSEL_x 
die Kombination beider Bits repräsentiert:
TASSEL_0 =     0
TASSEL_1 =     0   + TASSEL0
TASSEL_2 = TASSEL1 +    0
TASSEL_3 = TASSEL1 + TASSEL0

[... im Übrigen hättest Du somit schon erkennen können/müssen, dass ich 
oben Schmarrn geschrieben habe, denn Dein Timer wurde immer mit SMCLK 
betrieben, da TASSEL_2 = TASSEL1 ;-) ]

Autor: Stefan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Marek S. schrieb:
> Ich hab mir mal was neues einfallen lassen ich. Laufen tut es trotzdem
> nicht.
>
> #include <msp430x20x2.h>
>
> void main(void)
> {
>   WDTCTL = WDTPW + WDTHOLD;
>   TACTL = TASSEL1 + TACLR;    //  ????
>   TACTL |= MC_2;// das kontinuirlich gezählt werden soll von 0 bis
>                       // ffff dann von 0 bis fffff usw.
>   TACTL |= 0x02;  //interupt freigabe
>
>
>   P1DIR &= 0x00;   //
>   P1DIR |= 0x04;  //P1.2 Ausgang rest Eingang
>   P1OUT &= 0x00;    //Ausgänge auf 0
>   P1SEL &= 0x00;   //I/O funktion festgelegt
>
>   while(1){
>   if((TACTL & TAIFG)==1){P1OUT = ~0x04;}//TAIFG das überlauf  forhanden?
>   else{P1OUT = 0x04;}
>   }
> }

Das funzt nicht, weil:

1.) TACTL |= 0x02;  //interupt freigabe
Du gibst einen Interrupt frei, der auch eintreten wird.... ABER Du 
hast keine Interrupt-Service-Routine definiert... Dein Controller hängt 
sich auf!

2.) if((TACTL & TAIFG)==1)
TAIFG muss hier per Software zurückgesetzt werden.

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Zieh dir mal die Code-Examples von Ti, da sind ne Menge Anwendungen drin 
beschrieben.

Wir mussten uns während des Studiums das "ez430F2013"-Entwicklungs-Tool 
besorgen und ab da gabs leider keine große Hilfe mehr. Aber unsere 
Praktikumsaufgaben mussten wir auch abgeben. Und ne Klausur mit 
Programmieraufgabe kam dann natürlich auch noch. Vom Unterricht her 
keine wirkliche Hilfe zur Programmierung...:\ War ziemlich blöd.

Uns wurde angeraten, mit den Ti-Examples zu arbeiten, das waren unsere 
einzigen Hilfen dazu, aber da ist echt ne Menge dabei.

Wir sollten z.B. in einer Aufgabe ne PWM programmieren und haben einfach 
mal drauf losgelegt...vieeel zu umständlich - hier meine Aufgabenlösung, 
nur mal zur Veranschaulichung:
/*********************************************************
 * Embedded Systems: MSP430F2013 Education Tool          *
 *********************************************************
 * Dennis Eichmann (11049644) SS09                       *
 *                                                       *
 * Aufgabe 3.2: PWM / Analogausgabe                      *
 * --------------------------------                      *
 *                                                       *
 * Ausgabe eines stetig an- und absteigenden 8Bit        *
 * PWM-Signals am Port P1.0 (LED)                        *
 * Die LED soll damit gedimmt, bzw sanft ein- und aus-   *
 * geschaltet werden                                     *
 *                                                       *
 *********************************************************
 * Konfiguration des MSP430F2013:                        *
 * ------------------------------                        *
 *                                                       *
 * P1.0: LED gegen Masse                                 *
 * P1.1: Taster gegen Masse                              *
 * P1.4: Schleifer Potentiometer (3V3 / Masse)           *
 *       -> Bei Benutzung S1 schliessen!                 *
 * P1.5: Schalter gegen Masse                            *
 * P1.6: Draht zur freien Benutzung                      *
 *       -> Fuer Ausgang S1 oeffnen!                     *
 *                                                       *
 *********************************************************
 * Port-Verwendung:                                      *
 * ----------------                                      *
 *                                                       *
 * P1IN:  Auslesen gibt logischen Wert zurueck           *
 * P1OUT: Schreiben legt logischen Wert an               *
 * P1DIR: logische '0' setzt Pin auf Eingang (defaut)    *
 *        logische '1' setzt Pin auf Ausgang             *
 * P1REN: '1' aktiviert Widerstand (dafault: inaktiv)    *
 *        Bitmuster P1OUT: Pull- Up('1') / Down('0')     *
 * P1SEL: '0' fuer Standard I/O (default)                *
 *        '1' fuer alternative Funktionen                *
 * P1IE:  Interrupt bei Pegelwechsel; default '0' (aus)  *
 *        aktiv bei '1'                                  *
 * P1IES: Interrupt positive ('0') / negative ('1')      *
 *        Flanke                                         *
 * P1IFG: Interrupt-Flag-Bit - nach IRQ loeschen         *
 *        Auch fuer Software-Interrupt                   *
 *                                                       *
 * IRV: #pragma vector=PORT1_VECTOR                      *
 *                                                       *
 *********************************************************
 * Maskierungen von Bits:                                *
 * ----------------------                                *
 *                                                       *
 * OR:  Verknuepfung mit '0' laesst Wert unveraendert    *
 *      Verknuepfung mit '1' aendert Wert zu '1'         *
 *      P1OUT = P1OUT | BIT1 oder P1OUT |= BIT1          *
 * AND: Verknuepfung mit '1' laesst Wert unveraendert    *
 *      Verknuepfung mit '0' aendert Wert zu '0'         *
 *      P1OUT &= ~BIT1 -> '~' AND mit '0'                *
 * XOR: (TOGGLE) Wechsel von '0' nach '1' oder umgekehrt *
 *      P1OUT ^= BIT1                                    *
 *                                                       *
 *********************************************************
 * 16-Bit-Sigma-Delta-ADC Einstellungen:                 *
 * -------------------------------------                 *
 *                                                       *
 * SD16 INput ConTroL Register:                          *
 * SD16INCTL = SD16INCH_ 1 (Eingang des Multiplexers)    *
 *                       2 ... (6 fuer Temperatursensor) *
 *                                                       *
 * SD16 ConTroL Register:                                *
 * SD16CTL = SD16SSEL_ + SD16REFON (fuer interne 1V2)    *
 *                                                       *
 * SD16SSEL_0 MCLK  Master Clock                         *
 *          1 SMCLK Subsystem Master Clock               *
 *          2 ACLK  Auxiliary Clock                      *
 *          3 TACLK Externes Clock-Signal                *
 * (1,1MHz max)                                          *
 *                                                       *
 * SD16 Capture ConTroL Register:                        *
 * SD16CCTL0 = SD16IE + SD16SNGL + SD16UNI               *
 *             Interrupt Enable (Interrupt wenn fertig)  *
 *             Single Conversion (einfache Wandlung)     *
 *             Unipolar (Spannung gegen GND)             *
 *                                                       *
 * Wandlung starten mit: SD16CCTL0 |= SD16SC             *
 *                       SD16 Start Conversion           *
 *                                                       *
 * Ergebnis auslesen:    Variable = SD16MEM0             *
 *                       SD16 Memory 0                   *
 *                                                       *
 * IRV: #pragma vector=SD16_VECTOR                       *
 *                                                       *
 *********************************************************
 * 16-Bit-Timer Einstellungen:                           *
 * ---------------------------                           *
 *                                                       *
 * Timer A ConTroL-Register:                             *
 * TACTL = TASSEL_ + ID_ + MC_                           *
 *                                                       *
 * Timer A Source SELect:                                *
 * TASSEL_0 TACLK  Externes Clock-Signal                 *
 *        1 ACLK   Auxiliary Clock (externer Quarz)      *
 *        2 SMCLK  Subsystem Master Clock                *
 *        3 INCLK  Invertierter TACLK                    *
 *                                                       *
 * Input Divider:                                        *
 * ID_0 Teiler durch 1 (keine Teilung)                   *
 *    1 Teiler durch 2                                   *
 *    2 Teiler durch 4                                   *
 *    3 Teiler durch 8                                   *
 *                                                       *
 * Mode Control:                                         *
 * MC_0 Stop Mode (Timer haelt ohne Aenderung an)        *
 *    1 Up-Mode (Zaehlt bis zu angegebenen Wert CCR0)    *
 *    2 Continous Mode (Zaehlt immer wieder bis Maximum) *
 *    3 Up-/Down-Mode (Zaehlt bis CCR0, dann zurueck)    *
 *                                                       *
 * CCTL0 = CCIE: Interrupt durch Capture / Compare       *
 * IRV: #pragma vector=TIMAERA0_VECTOR                   *
 *                                                       *
 *********************************************************
 * Low-Power-Modi:                                       *
 * ---------------                                       *
 *                                                       *
 *        | LPM0  LPM1  LPM2  LPM3  LPM4                 *
 * -------------------------------------                 *
 * CPU    | aus   aus   aus   aus   aus                  *
 * MCLK   | aus   aus   aus   aus   aus                  *
 * SMCLK  | an    an    aus   aus   aus                  *
 * ACLK   | an    an    an    an    aus                  *
 * DCOdc  | an    aus   an    aus   aus                  *
 * DCOosc | an    an    aus   aus   aus                  *
 *                                                       *
 * Im LPM4 nurnoch Interrupts durch Portpins             *
 *                                                       *
 * Low-Power-Mode aktivieren: _BIS_SR(LPM0_bits + GIE)   *
 * Low Power Mode verlassen:  _BIC_SR_IRQ(LPM0_bits)     *
 *                                                       *
 *********************************************************
 * Globale Interrupts zulassen: _BIS_SR(GIE)             *
 *********************************************************
 * HEX - binaer:                                         *
 * -------------                                         *
 *                                                       *
 * 0x00 0000 0000     0x06 0000 0110     0x0C 0000 1100  *
 * 0x01 0000 0001     0x07 0000 0111     0x0D 0000 1101  *
 * 0x02 0000 0010     0x08 0000 1000     0x0E 0000 1110  *
 * 0x03 0000 0011     0x09 0000 1001     0x0F 0000 1111  *
 * 0x04 0000 0100     0x0A 0000 1010     0x10 0001 0000  *
 * 0x05 0000 0101     0x0B 0000 1011     0x11 0001 0001  *
 * ...                                                   *
 * 0x22 0010 0010     0xDD 1101 1101     0xFF 1111 1111  *
 *                                                       *
 *********************************************************/


#include "msp430x20x3.h"

int periodendauer = 255;                    // 8Bit Periodendauer
int pulsweite = 1;                          // Pulsweite wird in Schritten von 1 geaendert
int anaus = 0;                              // Variable zum Wechsel zwischen an- und aus-Zeit
int hochrunter = 0;                         // '0' fuer heller, '1' fuer dunkler


void aenderung (void)                       // Routine fuer heller / dunkler und Pulsweitenaenderung
{
  switch (hochrunter)                       // Abfrage ob heller oder dunkler werden
  {
    case 0:                                 // hochrunter ist '0' -> heller werden
    {
      pulsweite = pulsweite + 1;            // Pulsweite um 1 erhoehen -> laengere an- / kuerzere aus-Zeit
      
      if (pulsweite >= 255)                 // Wenn pulsweite 255 erreicht hat (an maximal / aus minimal)
      {
        hochrunter = 1;                     // hochrunter auf '1' -> ab jetzt dunkler werden
      }
      
      break;
    }

    case 1:                                 // hochrunter ist '1' -> dunkler werden
    {
      pulsweite = pulsweite - 1;            // Pulsweite um 1 verringern -> laengere aus- / kuerzere an-Zeit
      
      if (pulsweite <= 1)                   // Wenn pulsweite 1 erreicht hat (an minimal / aus maximal)
      {
        hochrunter = 0;                     // hochrunter auf '0' -> ab jetzt heller werden
      }
      
      break;
    }
    
    default: break;
  }
}


int main( void )
{
  WDTCTL = WDTPW + WDTHOLD;                 // Watchdog-Timer ausschalten

  P1DIR |= 0x01;                            // Setzt P1.0 auf Ausgang (LED)
  
  CCTL0 = CCIE;                             // Interrupt durch CCR0 moeglich
  CCR0 = periodendauer;                     // 
  TACTL = TASSEL_2 + ID_3 + MC_1;           // SMCLK + Teiler 8 + UpMode
  CCR0 = periodendauer;                     // Startet Capture-Compare und zaehlt bis 255 -> dann Interrupt
  
  _BIS_SR(LPM1_bits + GIE);                 // Low-Power-Mode 1 + Globaler Interrupt aktiviert
}  


#pragma vector=TIMERA0_VECTOR               // Interrupt-Service-Routine beim Erreichen von CCR0
__interrupt void timer (void)
{
  
  switch(anaus)                             // Abfrage: LED an oder aus
  {
    case 0:                                 // LED an-Zeit
    {
      CCR0 = pulsweite;                     // CCR0 bekommt Wert von pulsweite (steigt und faellt)
      P1OUT |= 0x01;                        // LED anschalten
      anaus = 1;                            // anaus jetzt '1' -> naechste Runde LED aus-Zeit
      break;
    }
    
    case 1:                                 // LED aus-Zeit
    {
      CCR0 = periodendauer - pulsweite;     // CCR0 bekommt Wert von periodendauer - pulsweite (steigt und faellt)
      P1OUT &= ~0x01;                       // LED ausschalten
      anaus = 0;                            // anaus jetzt '0' -> naechste Runde LED an-Zeit
      
      aenderung();                          // Aufruf der Routine zuer Aenderung der Richtung und der Pulsweite
      
      break;
    }
  
    default: break;
  }
}

So, der Anfang ist natürlich nur Kommentar, damit ich mir nicht immer 
alles wieder raussuchen musste, daher habe ich das in jede Aufgabe mit 
reinkopiert.

Aber guck dir mal den Teil für die PWM an, Horror! Mit dem "OUTMOD" 
kannste das ganze z.B. bequem in Hardware lösen und der Quelltext würde 
fast keine Zeile an Code mehr beeinhalten, außer die Konfiguration 
natürlich - nur die CCR-Register müsste man periodisch ändern. Aber die 
verbesserte Version finde ich grad nicht.

Nur worauf ich hinaus will: Wie man es am einfachsten macht, hat man 
dann in den Code-Examples gefunden - muss man halt nurmal reingucken :-)

Nichts desto trotz, vielleicht hilft dir ja auch mein Kommentar am 
Anfang des Codes, du fängst ja quasi auch gerade genau da an - dann 
musst du vorerst nicht immer für jede Info das Manual wälzen...aber das 
wirst du später noch oft genug :P Frohes Schaffen!


Gruß, Dennis

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Stefan schrieb:
> TACTL |= 0x02;  //interupt freigabe

Sowas ist eh ne Katastrophe! Du weisst vielleicht jetzt, dass das das 
Bit für TAIE ist, aber niemand anderes kann das im nachhinein 
nachvollziehen - ganz ehrlich ich weiß grad auch nicht, ob es das Bit 
ist, das müsste ich jetzt selber nachgucken...OK, ich hab grad 
nachgeguckt, es stimmt! Aber benutz doch die Synonyme, wenn es sie schon 
gibt, sonst wird da keiner mehr Lust haben, drüber zu gucken.

Autor: m. S. (marek)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ales klar ich danke euch für die Unterstützung ich beschäftige mich 
weiter hin damit vielleicht lege ich mir doch mal ein Buch für zu um 
dann einiges besser zu verstehen investitionen müßen halt auch mal getan 
werden aber viel dank für eure anregungen. Bei weiteren problem werde 
ich mich bestimmt noch mal melden. Werde mir jetzt noch mal das blinken 
zu gemüte führen wiso das funktioniert wie es funktioniert mann soll das 
ja auch verstehen können. Die beispiele von TI hab ich mir gestern 
runter geladen und werde mir die auch mal heute anschauen. Ansonsten 
genist die Sonne heut ebei 30°C sollen es in Berlin werden und ich hänge 
vor dem Rechner naaj es gibt schlimmeres. Bis denn.

mfg

MArek

Autor: Dennis (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Sei froh, ich muss nach der Arbeit noch meine Terrasse im Garten weiter 
bauen, da hoffe ich, dass es keine 30° gibt :)

Pass auf, ich lad dir noch mein anderen Praktikumsaufgaben hoch, 
vielleicht kannste da ja mal drauf gucken, immerhin haben wir ja genau 
da angefangen, wo du grad bist.

Die sind zwar für den 2013, aber du benutzt ja nen 2012, die sind ja 
nahezu gleich, nur dass der 2013 nen 16Bit AD hat.


Viel Spaß noch!


Dennis

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Sorry, ist ein bisschen groß, hab grad gesehen, dass in einer Aufgabe 
ein Video von der PWM drin war.

Autor: m. S. (marek)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Kein Problem ich werde das auch schon noch ihrgend wie hin kriegen ander 
haben das ja auch vor mir geschaft dann solt eich das auch ihrgend wie 
schafen. Dir auch noch viel spaß beim Bauen.

mfg

Autor: m. S. (marek)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich hab mich mal wider beschäftigt mit dem Blinken. Ich hab hir mal was 
zusammen geschrieben was meiner meinung nach gehen solte aber ich glaube 
er geht nicht in die interrupt service routine ich weis aber nicht wiso. 
Wenn wer kurz zeit hat mal nen blick drauf zu werfen und mir vielleicht 
nen hinweis geben kann oder sagen kann wo da der fehler ist würde mir 
helfen. Danke schon mal.

#include <msp430x20x2.h>

int main( void )
{
  WDTCTL = WDTPW + WDTHOLD;           // Watchdog-Timer ausschalten
  TACTL = TASSEL_2 + MC_1;           // SMCLK + UpMode

  P1DIR |= 0x04;                      // Setzt P1.2 auf Ausgang
  CCTL0 = CCIE;                      // Interrupt durch CCR0
  CCR0 = 0xFFFF; // Startet Capture-Compare und zählt bis FFFF
  _BIS_SR(GIE);                 // Globaler Interrupt enable
}
// Timer interrupt service routine
__interrupt void Timer(void)
{
   P1OUT ^= 0x04;                          // Toggle P1.2
}

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Marek S. schrieb:
> CCTL0 = CCIE;                      // Interrupt durch CCR0
>   CCR0 = 0xFFFF; // Startet Capture-Compare und zählt bis FFFF

Er geht da rein, weil du es so wolltest!

Autor: test (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
setz mal einen Breakpoint dann siehst du ob er da rein geht.

und InterruptFlag muss wieder gelöscht werden...

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Aso, sorry, hab das nicht überlesen.

Dir fehlt der Interrupt Vektor!

#pragma vector=timera0_vector

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
test schrieb:
> und InterruptFlag muss wieder gelöscht werden...

Das Flag löscht sich von selber in der ISR.

Autor: m. S. (marek)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das ist ne Tierisch schwere Geburt mit dem Ding. Ich hab das jetzt mal 
eingefügt den Vektor woher weis ich denn wie ich den Zu bennen habe nur 
mal so neben bei?
#include <msp430x20x2.h>

int main( void )
{
  WDTCTL = WDTPW + WDTHOLD;           // Watchdog-Timer ausschalten
  TACTL = TASSEL_2 + MC_1;           // SMCLK + UpMode

  P1DIR |= 0x04;                      // Setzt P1.2 auf Ausgang
  CCTL0 = CCIE;                      // Interrupt durch CCR0
  CCR0 = 0xFFFF; // Startet Capture-Compare und zählt bis FFFF
  _BIS_SR(GIE);                 // Globaler Interrupt enable
}
// Timer interrupt service routine
#pragma VECTOR=TIMERA0_VECTOR
__interrupt void Timer(void)
{
   P1OUT ^= 0x04;                          // Toggle P1.2
}

Funktionieren tut es trotzdem nicht. Im Datenblat steht an dem PIN1.2 
noch TA1 also dachte ich mal machste aus dem VECTOR=TIMERA0_VECTOR ein 
VECTOR=TIMERA1_VECTOR aber gehen tut es dann trotzdem nicht. Langsam 
gehen mir die ideen aus.

mfg

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Marek S. schrieb:
> #pragma VECTOR=TIMERA0_VECTOR

Das hat mit TA1 nichts zu tun - der TimerA0 bezieht sich auf CCR0!

Deine main() braucht noch eine
while (1) {}

Autor: Stefan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Dennis schrieb:
> Deine main() braucht noch einewhile (1) {}
Wäre ein "schöner" Programmierstil braucht's aber nicht, weil das der 
IAR automatisch macht.

Marek S. schrieb:
> Funktionieren tut es trotzdem nicht.
Was bedeutet das jetzt mal ganz genau?
Springt er in der IRQ oder nicht?
Nur mal so als Hinweis... Deine LED würde in deiner jetzigen 
Konfiguration mit ca. 7Hz blinken...

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Stefan schrieb:
> Wäre ein "schöner" Programmierstil braucht's aber nicht, weil das der
> IAR automatisch macht.

Besser wär noch ihn schlafen zu schicken, aber das is wohl erstmal nicht 
wichtig. Macht IAR das? Wusste ich garnicht, dachte er meckert dann mit 
"program exit reached" oder so ähnlich rum...nun ja, er benutzt aber eh 
CCE.

Stefan schrieb:
> Konfiguration mit ca. 7Hz blinken...

Das kommt hin, das sollte er noch sehen mit bloßem Auge. Ansonsten noch 
nen Divider rein.

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Marek S. schrieb:
> int main( void )

Meckert er eigentlich nicht, wegen fehlendem Rückgabewert?
#include <msp430x20x2.h>

void main (void )
{
  WDTCTL = WDTPW + WDTHOLD;          // Watchdog-Timer ausschalten
  P1SEL  = 0x00;                     // Port 1 komplett GPIO
  P1OUT  = 0x00;                     // Port 1 Ausgaenge auf 'low'
  P1DIR  = 0x04;                     // P1.2 Ausgang, Rest Eingang

  CCTL0 |= CCIE;                     // CCR0 kann Interrupt ausloesen
  CCR0   = 0xFFFF;                   // CCR0 laden

  TACTL = TASSEL_2 + MC_1;           // SMCLK + UpMode
  
  unsigned long int i;

  for (i=0; i<10000000; i++)         // Schleife zur LED-Kontrolle
  {
    P1OUT |= 0x04;                   // LED an
  }

  P1OUT &= ~0x04;                    // LED aus


  _BIS_SR (GIE);                     // Globale Interrupts aktiv

  while (1)                          // Nichts tun...
  {}
}

#pragma vector=timera0_vector
__interrupt void Timer(void)
{
   P1OUT ^= 0x04;                    // Toggle LED
}

Kopier das mal bitte in deinen Compiler! Und sag mal Bescheid, ob die 
LED am Anfang wenigstens kurz angeht.

Dennis

Autor: m. S. (marek)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also ich machen step bei step und das geht nur bis while(1) und bleibt 
dann da stehen ohne das ein step in die Routine rein geht. Ich weis auch 
nicht wiso, es kommt auch keine Fehlermeldung und ich hab keine ahnung 
wiso. Die LED funktioniert aber.

#include <msp430x20x2.h>

int main( void )
{
  WDTCTL = WDTPW + WDTHOLD;           // Watchdog-Timer ausschalten
  TACTL = TASSEL_2 + MC_1;           // SMCLK + UpMode

  P1DIR |= 0x04;                      // Setzt P1.2 auf Ausgang
  CCTL0 = CCIE;                      // Interrupt durch CCR0
  CCR0 = 0xFFFF; // Startet Capture-Compare und zählt bis FFFF
  _BIS_SR(GIE);                 // Globaler Interrupt enable
 while(1);
}
// Timer interrupt service routine
#pragma VECTOR=TIMERA0_VECTOR
__interrupt void Timer(void)
{
   P1OUT ^= 0x04;                          // Toggle P1.2
}

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Dennis schrieb:
> WDTCTL = WDTPW + WDTHOLD;          // Watchdog-Timer ausschalten

Mach daraus mal:
WDTCTL = (WDTPW | WDTHOLD);

und hier:

TACTL = TASSEL_2 + MC_1;
TACTL = (TASSEL_2 | MC_1);

Vielleicht ist das auch Compiler-abhängig...

Autor: m. S. (marek)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
So jetzt geht das ich hab rausgefunden woran das ligt schau dir mal den 
unteren teil an also da wo die ISR ist. So wie es da steht geht das 
jetzt. Aber viellen viellen dank trotzdem.

#include <msp430x20x2.h>

int main( void )
{
  WDTCTL = (WDTPW | WDTHOLD);           // Watchdog-Timer ausschalten
  TACTL = (TASSEL_2 | MC_1);           // SMCLK + UpMode

  P1DIR |= 0x04;                      // Setzt P1.2 auf Ausgang
  CCTL0 = CCIE;                      // Interrupt durch CCR0
  CCR0 = 0xFFFF; // Startet Capture-Compare und zählt bis FFFF
  _BIS_SR(GIE);                 // Globaler Interrupt enable
 while(1){}
}
// Timer interrupt service routine
__interrupt void Timer(void);
TIMERA0_ISR(Timer)
__interrupt void Timer(void)
{
   P1OUT ^= 0x04;                          // Toggle P1.2
}

mfg

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Marek S. schrieb:
> TIMERA0_ISR(Timer)

Also liegt es nur daran? Wegen dem CCE?

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Übrigens: Ich hoffe, du hast da nicht ne normale LED mit 20mA dran! Das 
tut dem MSP nicht so gut :) 2mA solltest du für den Dauerbetrieb nicht 
überschreiten.

Autor: m. S. (marek)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Jo ich denke mal ja da die Version so alt ist kennst der Debbuger und so 
das mit #pragma ... nicht aber auf dem rechner wo ich nun mal dranssitze 
läuft nichts besseres. Vielleicht holle ich mir mal so einen 
Programieradapter und nen microcontroller und werde mich zuhause damit 
gescheit beschäftigen.

mfg

Autor: Stefan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Marek S. schrieb:
> Jo ich denke mal ja da die Version so alt ist kennst der Debbuger und so
> das mit #pragma ... nicht

Nun ja, jede Toolchain hat da ihre eigene Art der Definition.
Bin allerdings (fälschlicherweise) die ganze Zeit davon ausgegangen, 
dass Du auch IAR benutzt... da hätte 'pragma... gepasst ;-)

Autor: m. S. (marek)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Na da bin ich mal wider. Ich hab gerade Probiert das blinken so zu 
steuern wenn ein Interrupt an P1.1 soll es blinken. Ich hab an P1.1 
einen Taster.
Es kommt keine Fehler meldung und es Blinkt auch fleisich aber die 
ganzezeit egal ob ich den Taster drücke oder nicht. Weil mit der do 
while schleife sage ich ihm doch blos das er den Interupt auslösen soll 
wenn ich den taster gedruckt habe oder verstehe ich da was falsch. Danke 
mal wider. Ist es sin voll das so zu machen ich hab auch an einen 
Interupt in der Interupt routine des Tasters gedacht von wo aus das dan 
getoggelt wird. Man hat mir aber davon abgeraten. Was meint ihr.


#include <msp430x20x2.h>

int main( void )
{
  WDTCTL = WDTPW + WDTHOLD;           // Watchdog-Timer ausschalten
  TACTL = TASSEL_2 + ID_3 + MC_1;    // SMCLK + Teiler durch 8  + UpMode

  P1DIR |= 0x04;  // Setzt P1.2 auf Ausgang

  P1IES = 0x02;    //P1.1 An dem der Taster hängt (L -> H wechsel)
  P1IE = 0x02;    // Interrupt enable für P1.1

  do{
  CCTL0 = CCIE;                  // Interrupt durch CCR0
  CCR0 = 0xFFFF; // Startet Capture-Compare und zählt bis FFFF
  _BIS_SR(GIE);}                // Globaler Interrupt enable
  while((P1IFG & 0x02)==1);
}

// Timer interrupt service routine
__interrupt void Timer(void);
TIMERA0_ISR(Timer)
__interrupt void Timer(void)
{
      P1OUT ^= 0x04;                          // Toggle P1.2
}

Autor: Stefan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Marek S. schrieb:
> wenn ein Interrupt an P1.1 soll es blinken.
Dein Polling des P1IFG-Flags kann man nicht wirklich als Interrupt 
bezeichnen ;-)  Wenn schon Interrupt, dann aktiviere ihn auch und 
schreibe eine Interrupt-Routine dazu.
ABER: Bei Tasten ist ein Interrupt keine gute Wahl!
Du musst den Taster entprellen!

> while schleife sage ich ihm doch blos das er den Interupt auslösen soll
> wenn ich den taster gedruckt habe oder verstehe ich da was falsch.
Ja, allerdings.
Zuerst musst Du Deine ganze Peripherie (hier der Timer)einmal 
initialisieren. Danach würde ich den Timer je nach Zustand des Tasters 
entweder aktivieren oder stoppen.
Deine do-while ist kompletter Murks!

> ich hab auch an einen
> Interupt in der Interupt routine des Tasters gedacht von wo aus das dan
> getoggelt wird. Man hat mir aber davon abgeraten. Was meint ihr.
Derjenige, der Dir abgeraten hat ist ein kluger Kopf!
Selbst sehr Erfahrene Programmierer meiden verschachtelte Interrupts so 
gut wie immer! Kann sehr unübersichtlich werden...

Autor: m. S. (marek)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Stefan schrieb:
> Zuerst musst Du Deine ganze Peripherie (hier der Timer)einmal
> initialisieren.

Hab ich das nicht schon damit gemacht Hab ich ihn nicht schon damit
TACTL = TASSEL_2 + ID_3 + MC_1;. Muß ich das dann noch mal machen in der 
while schleife?

Autor: Stefan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Marek S. schrieb:
> Muß ich das dann noch mal machen in der
> while schleife?
Na eben nicht!

In while() überprüfst Du nur noch, ob die Taste gedrückt ist oder 
nicht.

Hier eine Möglichkeit von zig tausend...:
volatile char  LED_Enable;

void main( void )
{
  WDTCTL = WDTPW + WDTHOLD;

  P1DIR |= 0x04;  

  CCTL0 = CCIE;   
  CCR0 = 0xFFFF;
  TACTL = TASSEL_2 + ID_3 + MC_1;

  LED_Enable = 0;

  _BIS_SR(GIE);

  while(1)
  {                     // (Tastenabfrage eventuell noch entprellen...)
    if (P1IN & 0x02)    // Taster abfragen (hier high-aktiv)
      LED_Enable = 1;   // Blinken aktivieren

    else
    {
      LED_Enable = 0;   // Blinken deaktivieren
      P1OUT &= ~0x04;   // LED aus 
    }
  }
}

// Timer interrupt service routine
__interrupt void Timer(void);
TIMERA0_ISR(Timer)
__interrupt void Timer(void)
{
  if(LED_Enable)
    P1OUT ^= 0x04;
}

Autor: m. S. (marek)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Dan war das mein Fehler dann hab ich deine Antwort falsch verstanden 
sorry, ich dachte das solt eich dann noch mal in der While schleife 
machen was mir aber komisch vorkam aber trotzdem danke.

mfg

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Stefan schrieb:
> while(1)
>   {                     // (Tastenabfrage eventuell noch entprellen...)
>     if (P1IN & 0x02)    // Taster abfragen (hier high-aktiv)
>       LED_Enable = 1;   // Blinken aktivieren
>
>     else
>     {
>       LED_Enable = 0;   // Blinken deaktivieren
>       P1OUT &= ~0x04;   // LED aus
>     }
>   }

Kannst auch:
while (1)
{
  if (P1IN & 0x02)
    TACTL0 |= CCIE;
  else
    TACTL0 &= ~CCIE;
}

Dann behält die LED ihren Status vor dem Tastendruck.
Wie schon gesagt wurde, es gibt zich Möglichkeiten.

Autor: m. S. (marek)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Dennis (Gast)

Du sagst ein Blick in das MSP430 Microcontroller Basiccs Buch lohnt 
sich. Kann man daraus gut was lernen und mit arbeiten? Dan würde ich mir 
das mal kaufen. Englisch solte ja nicht das Problem sein im notfall 
überstetzt man mal paar Wörter.

mfg

Autor: Dennis (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Marek S. schrieb:
> Du sagst ein Blick in das MSP430 Microcontroller Basiccs Buch lohnt
> sich.

Ja, also ich habe ein paar Bücher "durchgearbeitet" und meiner Meinung 
nach ist das das beste von allen über den MSP430. Es ist komplett in 
Englisch, klar, aber wer mit Elektronik zu tun hat, der kommt an 
englisch sowieso nicht vorbei. Da sind viele Programme drin, mit 
Anwendungen, wie man sie auch immer mal wieder braucht.

Von meiner Seite aus jedenfalls absolute Kaufempfehlung. Leider ist der 
MSP ja nicht so der gebräuchlichste Controller, das siehst du hier ja 
auch, die meisten programmieren auf Atmel. Das habe ich noch nie 
gemacht, kann daher nur vom MSP sprechen. Aber für den ist Davies Buch 
auf jedenfall die Investition wert.

Plus natürlich sie Code-Examples, da kann man ebenfalls ne Menge finden!


Gruß, Dennis

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.